arxo-codegen 0.4.0__py3-none-any.whl

arxo_codegen/plan.py

@@ -0,0 +1,4053 @@
+#!/usr/bin/env python3
+"""CLIR -> план исполнения, НЕ ЗАВИСЯЩИЙ от целевого языка.
+
+Здесь живёт вся семантика среза: какие таблицы завести, что перебирать, где
+соединение, где гард, какой терм посчитать, что отказать. Целевой язык об
+этом не знает: он получает готовый план и печатает синтаксис.
+
+Отказ — обязателен и громок. Незнакомое объявление, поле узла или форма
+терма дают не «меньше ответа», а ДРУГОЙ ответ, поэтому пропускать нельзя.
+"""
+import hashlib
+import json
+import re
+import unicodedata
+from fractions import Fraction
+if __package__:
+    from . import temporal
+else:
+    import temporal
+from pathlib import Path
+
+# Версия формата плана. Состав полей описан в README; его изменение меняет
+# версию, и эмиттер, не знающий версии, обязан отказать, а не печатать.
+PLAN_VERSION = "law-backend-plan/0.7"
+# План с возможностями поражаемого слоя (DECISION-0237): `capabilities`,
+# опоры обеих полярностей, страты и расписание фаз §111. План без
+# возможностей остаётся байтово прежним и носит PLAN_VERSION.
+PLAN_VERSION_L1 = "law-backend-plan/0.8"
+# План с агрегатами §59 в правилах и замыканиями §70 (DECISION-0239): подпланы
+# comprehension, порядок шагов тела, фаза closure с уровнями E-0113. План без
+# этих возможностей остаётся 0.8 либо 0.7 байтово.
+PLAN_VERSION_09 = "law-backend-plan/0.9"
+AGG_OPS = ("count", "sum", "min", "max", "only")
+# План с нормативными позициями L2 (DECISION-0242): норм-правила, позиции,
+# эффекты полномочий §127. План без возможности `norm` остаётся прежним.
+PLAN_VERSION_10 = "law-backend-plan/0.10"
+# План с календарными функциями §84–§86 (DECISION-0245): возможности функций,
+# политики `deadline_policy`, снимки `calendar_snapshot`, версия семантики.
+PLAN_VERSION_11 = "law-backend-plan/0.11"
+# План с Rational §35/§58 (DECISION-0252): возможность `value:rational`,
+# статические виды операндов арифметики, фоллибельные гарды `err` и сверка
+# вида головы `kindChecks`. План, где Rational не возникает, остаётся прежним.
+PLAN_VERSION_12 = "law-backend-plan/0.12"
+# План с Quantity §49 v1 и счётчиком-связывателем §86.1 (DECISION-0256):
+# возможность `value:quantity`, вид операнда `q`, терм `qtyvar`.
+PLAN_VERSION_13 = "law-backend-plan/0.13"
+# План с политикой округления §50 (DECISION-0259): возможности `value:round` и
+# `value:div_round`, статические виды аргументов вызова `ak`.
+PLAN_VERSION_14 = "law-backend-plan/0.14"
+# План с Boolean и Natural как значениями (DECISION-0266), границами месяца
+# §84.2 (DECISION-0267) и подстановочным `_` §98 (DECISION-0268):
+# возможности `value:boolean`, `value:natural`, `calendar:month_bound`,
+# `wildcard`. Модель они не меняют — план без них остаётся прежней версии
+# байтово; версия нужна эмиттеру, чтобы незнакомый литерал, вызов или
+# столбец атома не печатались молча.
+PLAN_VERSION_15 = "law-backend-plan/0.15"
+# План с датированными приоритетами §92.3 (DECISION-0269): возможность
+# `priority:dated`, поля `datedPriorities` и `datedNormPriorities` — пары
+# транзитивного замыкания с окнами `[start, end)` оси права; активное
+# множество рёбер модуль готовит один раз на дело (`prepare`, подготовленный
+# контекст). План без датированных рёбер остаётся прежней версии байтово.
+PLAN_VERSION_16 = "law-backend-plan/0.16"
+# План с вычисляемым аргументом атома тела и условным термом §56
+# (DECISION-0270, E-0180): возможности `term:body` и `term:if`; модель 0.9 —
+# ошибка значения аргумента есть issue правила, как у гардов; аргумент
+# считается до перебора таблицы (`pre`), генератор с таким аргументом берётся
+# только после связывания его переменных (`solver.solve`, pick).
+PLAN_VERSION_17 = "law-backend-plan/0.17"
+# План с функциями §46 «функция на функцию», параметрами A3 §A3.2, `let` и
+# `match` §55.1 (DECISION-0273): возможности `function`, `param:a3`,
+# `term:let`, `term:match`; модель 0.9. Функция печатается функцией цели по
+# позиционным параметрам; параметр A3 — окна `[start, end)` оси права со
+# значением, активное значение готовит `prepare` (подготовленный контекст),
+# разрыв — MISSING_PARAMETER_VALUE правила; `match` над перечислением с
+# вариантными образцами без полей и `_`, неполный — NON_EXHAUSTIVE_MATCH.
+PLAN_VERSION_18 = "law-backend-plan/0.18"
+# План с каналом суждения §47.3 (DECISION-0274): возможность `judgment` —
+# программа объявляет отношение суждения (`external judgment relation`).
+# Модель не меняется: запрос судье — обход по готовому состоянию модели
+# (порт `whynot.judgment_blockers` и соседей в рантайме цели), для него план
+# несёт `judgments` (орган и форма запроса), `backchain` с силой правил и
+# гардами, а модель L1 — применения дефитеров и поражённых кандидатов.
+PLAN_VERSION_19 = "law-backend-plan/0.19"
+FN_CAPS = {"function", "param:a3", "term:let", "term:match"}
+TERM_CAPS = {"term:body", "term:if"}
+A3_OK = "urn:law:a3#Result/Ok"
+A3_MISSING = "urn:law:a3#MissingParameterValue"
+A3_RESULT = "urn:law:std#Result"
+V15_CAPS = {"value:boolean", "value:natural", "calendar:month_bound", "wildcard"}
+# §84.2 (E-0084): границы месяца — чистые функции над Date; ни политика §86,
+# ни снимок §85 не читаются, ошибки значения над слотом Date нет.
+MONTH_FNS = {"urn:law:std#month_start_of": "month_start", "urn:law:std#month_end_of": "month_end"}
+# §84.1 (E-0028, E-0058, E-0185; W2 часть 2): физическая длительность между
+# мгновениями и шаг мгновения на длительность — чистые функции над Instant.
+# Не Instant у оракула всегда TYPE_ERROR — отказ плана; смешение мгновений со
+# смещением и без, не-ISO запись — TYPE_ERROR по значению, названный отказ
+# рантайма. Результат `add_duration` — Instant в UTC (`…Z`), дробные секунды
+# отбрасываются, как у оракула (`add_duration_value`).
+DUR_FNS = {"urn:law:std#hours_between": "hours_between", "urn:law:std#minutes_between": "minutes_between",
+           "urn:law:std#add_duration": "add_duration"}
+DURATION_UNITS = ("second", "minute", "hour", "day")
+INST = "urn:law:std#Instant"
+# Функции std календаря → (имя в плане, возможность). `days_between` чистая
+# и модели не меняет; остальные берут политику §86 и снимок §85 из
+# окружения и дают ошибку значения, поэтому требуют накопления выводов.
+CAL_FNS = {"urn:law:std#days_between": ("days_between", "calendar:days_between"),
+           "urn:law:std#add_calendar_period": ("add_calendar_period", "calendar:period"),
+           "urn:law:std#add_business_days": ("add_business_days", "calendar:business"),
+           "urn:law:std#add_legal_term": ("add_legal_term", None)}
+CAL_CAPS = {"calendar:days_between", "calendar:period", "calendar:business"}
+# Единицы счётчика (`values.py`): E-0029/E-0109 разводят операции по единице.
+DAY_UNITS = ("business_day", "calendar_day")
+CALENDAR_PERIOD_UNITS = ("calendar_day", "calendar_month", "calendar_year", "calendar_week")
+DEADLINE_UNITS = ("business_day", "calendar_day", "calendar_month", "calendar_year", "calendar_week")
+STD = "urn:law:std#"
+# §140: институциональные литералы, которые публикует жизненный цикл позиций,
+# с арностью; первый аргумент — позиция.
+STD_POSITION = {"created": 1, "instance_of": 2, "bearer_of": 2, "beneficiary_of": 2,
+                "pending": 1, "active": 1, "satisfied": 1, "violated": 1, "expired": 1,
+                "undetermined": 1, "invalidly_exercised": 1}
+POSITION_TYPE = "urn:law:backend#Position"
+MODALITIES = ("duty", "power", "immunity", "liberty")
+# Поля payload шаблона: читаемые оракулом и те, что оракул не читает вовсе
+# (политики §123, `completenessPolicy`, `over`, `subject`, `before`) — у
+# последних ответ от их значения не зависит, поэтому они принимаются.
+PAYLOAD_FIELDS = {
+    "duty": {"kind", "bearer", "holder", "beneficiary", "goal", "window", "allocationPolicy",
+             "dischargePolicy", "violationPolicy", "over", "subject"},
+    "power": {"kind", "holder", "bearer", "beneficiary", "window", "exercise", "effect", "validWhen",
+              "over", "subject"},
+    "immunity": {"kind", "holder", "bearer", "beneficiary", "window", "protectedEffect", "against",
+                 "over", "subject"},
+    "liberty": {"kind", "holder", "bearer", "beneficiary", "window", "action", "against", "over", "subject"},
+}
+GOAL_FIELDS = {"kind", "condition", "window", "action", "completenessPolicy", "termination"}
+TEMPLATE_FIELDS = {"id", "kind", "contentHash", "package", "name", "label", "labels", "provenance",
+                   "anchors", "sourceAnchors", "origin", "modality", "payload", "variables", "parameters"}
+NORM_REFUSAL = "обратная связь L2 вне среза генератора (DECISION-0242 п. 1)"
+# E-0116: пары агрегат/сравнение монотонного гарда и зеркало сравнения §206.
+MONOTONE_GUARD_OPS = {"count": ("ge", "gt"), "sum": ("ge", "gt"), "max": ("ge", "gt"), "min": ("le", "lt")}
+MIRROR_OP = {"ge": "le", "gt": "lt", "le": "ge", "lt": "gt"}
+CLOSURE_FIELDS = {"id", "kind", "contentHash", "package", "name", "label", "labels", "provenance",
+                  "anchors", "sourceAnchors", "origin", "predicate", "domain", "snapshot",
+                  "completeAsOf", "deriveExplicitNegative", "effective"}
+
+# Статусные тесты §65 в срезе L1 и сырые статусы §62 положительного атома,
+# при которых конъюнкт выполнен, по полярности литерала (§63 зеркалит
+# отрицательный). `supported` вычислительно тождествен `monotone` (E-0018),
+# различие — слой спецификации, поэтому возможности у них раздельные.
+STATUS_TESTS = ("established", "monotone", "supported", "not_known", "unknown", "refuted")
+GENERATING = ("established", "monotone", "supported")
+ACCEPT = {
+    ("established", "positive"): ["TRUE_ONLY"], ("established", "negative"): ["FALSE_ONLY"],
+    ("monotone", "positive"): ["TRUE_ONLY", "BOTH"], ("monotone", "negative"): ["FALSE_ONLY", "BOTH"],
+    ("supported", "positive"): ["TRUE_ONLY", "BOTH"], ("supported", "negative"): ["FALSE_ONLY", "BOTH"],
+    # §67/§113: not_known истинен без positive-опоры — при NEITHER и FALSE_ONLY.
+    ("not_known", "positive"): ["NEITHER", "FALSE_ONLY"], ("not_known", "negative"): ["NEITHER", "TRUE_ONLY"],
+    ("unknown", "positive"): ["NEITHER"], ("unknown", "negative"): ["NEITHER"],
+    ("refuted", "positive"): ["FALSE_ONLY"], ("refuted", "negative"): ["TRUE_ONLY"],
+}
+PRIORITY_FIELDS = {"id", "kind", "contentHash", "package", "name", "label", "labels", "provenance",
+                   "anchors", "sourceAnchors", "origin", "condition", "higher", "lower",
+                   "priorityKind", "reason"}
+TRUE_FORMULA = {"kind": "boolean", "value": True}
+UNSTRATIFIED = "программа не стратифицируема (§110, NON_EXECUTABLE_UNSTRATIFIED)"
+LATE = "поздний производитель (§111, LDC-E4103)"
+
+STD_FN = {"urn:law:std#round": "round", "urn:law:std#min": "min", "urn:law:std#max": "max",
+          "urn:law:std#abs": "abs", "urn:law:std#pow": "pow", "urn:law:std#div_round": "div_round"}
+TEXT_URN = "urn:law:std#Text"
+# §50 (DECISION-0259): режимы и предел точности `div_round` — порт `values`.
+ROUNDING_MODES = ("CEILING", "DOWN", "FLOOR", "HALF_DOWN", "HALF_EVEN", "HALF_UP", "UP")
+DIV_ROUND_MAX_PRECISION = 34
+BINOP = {"mul": "mul", "add": "add", "sub": "sub", "div": "div", "mod": "mod"}
+INT, DEC, MON = "urn:law:std#Integer", "urn:law:std#Decimal", "urn:law:std#Money"
+# DECISION-0266: Natural — неотрицательное целое; у оракула значение вида
+# `integer` (`values._TYPE_KINDS`), а тип-строка §189 своя: Natural не
+# подходит слоту Integer и наоборот (`facts._conforms`).
+NATURAL = "urn:law:std#Natural"
+BOOL = "urn:law:std#Boolean"
+# DECISION-0252: Rational §35 и динамический вид значение-зависимого частного
+# §58 (Decimal/Decimal, Money/Money) — Decimal либо Rational по значению.
+RAT, DYN = "urn:law:std#Rational", "urn:law:backend#DecimalOrRational"
+# DECISION-0256: Quantity §49 v1 — вид без тега; тег — свойство значения.
+QTY = "urn:law:std#Quantity"
+NUMERIC = {INT, DEC, MON, RAT, DYN, QTY, NATURAL}
+# Статический вид операнда в терме `bin` плана 0.12: рантайм не различает
+# Integer и Decimal по значению, и пара §58 решается видами.
+KIND_CODE = {INT: "i", DEC: "d", MON: "m", RAT: "r", DYN: "n", QTY: "q", NATURAL: "i"}
+
+
+def _num(urn):
+    """Вид арифметики §58 по типу слота: Natural считает как Integer
+    (DECISION-0266), тип-строка при этом остаётся своей для §189."""
+    return INT if urn == NATURAL else urn
+# §59 (errata E-0195): имена типов, у которых ВИД есть, — порт
+# `values._TYPE_KINDS` плюс `_OPAQUE_KINDS`. С видом элемента, объявленным
+# проекцией comprehension §52.1, сверяется вид политики пустой коллекции; имя
+# вне набора (сущность, перечисление, чужой символ) вида не предъявляет, и
+# сверка молчит: Unknown есть «утверждать нечего», а не «совместимо со всем».
+EMPTY_KIND_NAMES = frozenset({INT, NATURAL, DEC, MON, TEXT_URN, "urn:law:std#Date", BOOL, RAT, QTY,
+                              "urn:law:std#Instant", "urn:law:std#Magnitude", "urn:law:std#Bounds"})
+CMP = {"lt", "le", "gt", "ge", "eq", "ne"}
+
+TYPES = {
+    "urn:law:std#Money": "money",
+    "urn:law:std#Text": "text",
+    "urn:law:std#Decimal": "dec",
+    "urn:law:std#Integer": "dec",
+    "urn:law:std#Boolean": "bool",
+    # Natural (DECISION-0266): в ячейке — точное целое, как Integer.
+    "urn:law:std#Natural": "dec",
+    # Date §2.15: хранится и сравнивается по календарному дню; канон — ISO
+    # `YYYY-MM-DD`, поэтому порядок записи и есть порядок дня. Календарные
+    # функции §85 остаются вне среза.
+    "urn:law:std#Date": "date",
+    # Instant §2.15 (W2 часть 2): момент, а не запись (E-0048) — порядок и равенство
+    # по моменту, ключ атома по записи (E-0214); с Date не сравнивается (§57).
+    "urn:law:std#Instant": "inst",
+    # Rational §35 (DECISION-0252): несократимая дробь; ключ и сравнение — свои.
+    "urn:law:std#Rational": "rat",
+    # Quantity §49 v1 (DECISION-0256): число с тегом единицы.
+    "urn:law:std#Quantity": "qty",
+}
+
+#: §261 `law.std.actors` и корни событий §79–§80: сущности стандартной
+#: библиотеки — идентичности, как сущности пакета (`entity_ref` дела типа не
+#: несёт, §189 их не сверяет). Событие в слоте — ссылка `entity_ref` на
+#: закреплённый снимок (§79.1); конструктор-запись события в факте остаётся
+#: названным отказом раннера («аргумент вне среза раннера: record») до W7,
+#: где свёртка §161.1 читает его поля. Instant §2.15 — своё значение (W2, часть 2).
+#: `LegalContext`, `LegalRole` (§261) и `Jurisdiction` (§257, E-0039) — того же
+#: рода: у оракула нет ни вида значения (`values._TYPE_KINDS`), ни литерала,
+#: дело подаёт их `entity_ref`, и сверка §189 их не трогает (W2, релиз 0.1.5).
+STD_ENTITY_TYPES = frozenset(f"urn:law:std#{n}" for n in (
+    "Actor", "NaturalPerson", "LegalPerson", "Organization",
+    "PublicAuthority", "Official", "Court", "Collective", "Event", "Action",
+    "LegalContext", "LegalRole", "Jurisdiction"))
+#: `Interval<T>` §37 в слоте отношения — непрозрачная идентичность: литерала
+#: такого вида у оракула нет (`values.from_literal_term`), `entity_ref` в слоте
+#: §189 не сверяет, а интервальный терм дела раннер отвергает поимённо
+#: («аргумент вне среза раннера: interval»). Пакет, лишь объявляющий такое
+#: отношение (окно льготы `variance_granted` FNMA), получает план; дело с
+#: интервалом — названный отказ, а не иной ответ; литерал-интервал в теле
+#: правила — отказ плана («терм в аргументе тела вне среза»).
+STD_OPAQUE_SLOT_TYPES = frozenset({"urn:law:std#Interval"})
+
+RULE_META = {"id", "kind", "contentHash", "package", "name", "label", "labels",
+             "provenance", "anchors", "sourceAnchors", "variables"}
+RULE_FIELDS = RULE_META | {"strength", "head", "body", "effective"}
+RULE_EMPTY_OK = {"scope", "interpretations", "governs"}
+
+EXTERNAL_JUDGMENT_FIELDS = {"kind", "id", "package", "symbol", "effect", "authority", "capability",
+                            "requestType", "contentHash", "labels", "anchors"}
+FUNCTION_FIELDS = {"kind", "id", "package", "symbol", "parameters", "body", "effect", "anchors",
+                   "provenance", "contentHash", "labels", "visibility"}
+KNOWN_NODES = {("symbol_decl", "relation"), ("symbol_decl", "constant"),
+               ("type_decl", None), ("rule", None),
+               ("unit_decl", None), ("assertion", None),
+               # Объявление функции само по себе ничего не считает: вызов вне
+               # STD_FN отвергает `term`, ссылка через const_ref — `const_value`.
+               ("symbol_decl", "function"), ("function_decl", None)}
+ALWAYS = "urn:law:backend#always"
+
+# Инертные конструкции (CODEGEN-COVERAGE-PLAN §1.1, W1): присутствуют в пакете,
+# но на ответ поддержанных видов вопросов не влияют — план их ПРОПУСКАЕТ, а
+# не отвергает. Каждая строка манифеста `inert-nodes.json` держится парой
+# векторов «с конструкцией / без неё» с одним документом оракула; строку без
+# такого свидетеля роняют ворота check_conformance (модуль `inert`). Здесь
+# манифест только читается: план не решает, что инертно, — он исполняет
+# закреплённое.
+_INERT_MANIFEST = json.loads((Path(__file__).resolve().with_name("inert-nodes.json")).read_text(encoding="utf-8"))
+INERT_NODE_KINDS = frozenset(c.removeprefix("node:") for c in _INERT_MANIFEST["constructs"] if c.startswith("node:"))
+INERT_RULE_FIELDS = frozenset(c.removeprefix("rulefield:") for c in _INERT_MANIFEST["constructs"]
+                              if c.startswith("rulefield:"))
+
+
+class Refused(Exception):
+    """Отказ среза с названной причиной."""
+
+
+def _reject_withdrawn_language_version(ir: dict) -> None:
+    """Stage R accepts one exact semantic release and one IR schema."""
+    version, schema = ir.get("semanticVersion"), ir.get("schemaVersion")
+    if version != "0.2.11" or schema != "law.core.ir/0.7":
+        raise Refused("SEMANTIC_RELEASE_UNAVAILABLE: требуется law.core/0.2.11 "
+                      f"и law.core.ir/0.7; получено {version!r} / {schema!r}")
+
+
+def _reject_withdrawn_language_versions(ir: dict, world: list | None = None) -> None:
+    """Проверить корневой IR и каждый IR мира до их семантического связывания."""
+    _reject_withdrawn_language_version(ir)
+    for dependency in world or ():
+        _reject_withdrawn_language_version(dependency)
+
+
+# --- редакции §31/§92.3 (E-0095, DECISION-0236) --------------------------------
+# Порт `lawref.applicability.edition_state`: состояние редакции на момент —
+# последнее наступившее событие, чей extent покрывает момент. План не знает
+# даты права, поэтому считает состояние во всех точках излома (начала и
+# концы событий) и сворачивает применимость в интервалы; интервал — то же
+# окно `window`, что у `effective`, и эмиттеры о редакциях не знают.
+OPENING = ("in_force", "restored")
+SUSPENDING = ("suspended",)
+CLOSING = ("repealed", "expired", "invalidated")
+NORMATIVE_KINDS = ("assertion", "constraint", "norm_template", "priority_rule", "rule")
+T0 = "0000-01-01"
+NO_START = "\uffff"
+
+
+def _is_date(t) -> bool:
+    return isinstance(t, str) and len(t) == 10 and t[4] == "-" and t[7] == "-"
+
+
+def _event_start(extent):
+    if isinstance(extent, dict):
+        start = extent.get("start")
+        return None if start in (None, "-infinity") else str(start)
+    return None if extent is None else str(extent)
+
+
+def _ordered_events(edition: dict) -> list:
+    events = [e for e in edition.get("lifecycle") or [] if e.get("status")]
+    return [e for _, e in sorted(enumerate(events),
+                                 key=lambda pair: (_event_start(pair[1].get("extent")) or NO_START, pair[0]))]
+
+
+def _covers(extent, t: str) -> bool:
+    """Покрывает ли extent момент t; границы обязаны быть днями §2.15 —
+    иную гранулярность вызывающий отсеял до сюда."""
+    if isinstance(extent, dict):
+        start, end = extent.get("start"), extent.get("end")
+        if start not in (None, "-infinity"):
+            if not (start <= t if extent.get("startInclusive", True) else start < t):
+                return False
+        if end not in (None, "infinity"):
+            if not (t <= end if extent.get("endInclusive", False) else t < end):
+                return False
+        return True
+    return extent <= t
+
+
+def edition_applicable(edition: dict, t: str) -> bool:
+    if edition.get("applicability") == "timeless":
+        return True
+    state, closed = "not_yet", False
+    for event in _ordered_events(edition):
+        status = event["status"]
+        if status not in OPENING + SUSPENDING + CLOSING:
+            continue
+        extent = event.get("extent")
+        start = _event_start(extent)
+        if start is not None and start > t:
+            continue
+        if status in CLOSING:
+            closed, state = True, "closed"
+            continue
+        if closed:
+            continue
+        covers = _covers(extent, t)
+        if status in SUSPENDING:
+            state = "suspended" if covers else "applicable"
+        else:
+            state = "applicable" if covers else "closed"
+    return state == "applicable"
+
+
+def edition_intervals(edition: dict):
+    """Применимость редакции как список окон `[start, end)`; строка —
+    причина, по которой окно не вычислимо (граница не дневной гранулярности:
+    оракул такую редакцию читает как вне датировки с предупреждением).
+    Редакция без событий применимости §31 и без `timeless` — пустой список:
+    по §27.2 она `not_yet` на любую дату и узел датирует (§92 усл. 3,
+    errata E-0350, шаг 2)."""
+    if edition.get("applicability") == "timeless":
+        return [(None, None)]
+    events = [e for e in edition.get("lifecycle") or []
+              if e.get("status") in OPENING + SUSPENDING + CLOSING]
+    if not events:
+        return []
+    points = set()
+    for e in events:
+        extent = e.get("extent")
+        bounds = [extent.get("start"), extent.get("end")] if isinstance(extent, dict) else [extent]
+        for b in bounds:
+            if b in (None, "-infinity", "infinity"):
+                continue
+            if not _is_date(b):
+                return f"граница lifecycle не дневной гранулярности: {b}"
+            points.add(str(b))
+    marks = [T0] + sorted(points)
+    out, cur = [], None
+    for i, m in enumerate(marks):
+        on = edition_applicable(edition, m)
+        if on and cur is None:
+            cur = None if m == T0 else m
+            cur = (cur,)
+        elif not on and cur is not None:
+            out.append((cur[0], m))
+            cur = None
+    if cur is not None:
+        out.append((cur[0], None))
+    return out
+
+
+def _intersect(a, b):
+    """Пересечение двух окон `[start, end)`; None — пусто."""
+    start = a[0] if b[0] is None else (b[0] if a[0] is None else max(a[0], b[0]))
+    end = a[1] if b[1] is None else (b[1] if a[1] is None else min(a[1], b[1]))
+    if start is not None and end is not None and start >= end:
+        return None
+    return (start, end)
+
+
+def _contains(window, seg) -> bool:
+    """Лежит ли отрезок `seg` целиком в окне `window` (`None` — бесконечность)."""
+    s, e = window
+    a, b = seg
+    return (s is None or (a is not None and s <= a)) and (e is None or (b is not None and b <= e))
+
+
+def _union(intervals: list) -> list:
+    """Объединение окон в непересекающиеся, по возрастанию."""
+    items = sorted(intervals, key=lambda w: (w[0] is not None, w[0] or ""))
+    out: list = []
+    for w in items:
+        if out and (out[-1][1] is None or (w[0] is not None and w[0] <= out[-1][1])):
+            last = out.pop()
+            end = None if last[1] is None or w[1] is None else max(last[1], w[1])
+            out.append((last[0], end))
+        else:
+            out.append(w)
+    return out
+
+
+def _payload_vars(value, out: list | None = None) -> list:
+    """Все переменные payload шаблона — порт `norms._payload_vars`: payload не
+    формула, и `_free` по видам формул его узлов не видит."""
+    out = [] if out is None else out
+    if isinstance(value, dict):
+        if value.get("kind") == "var":
+            if value["var"] not in out:
+                out.append(value["var"])
+        else:
+            for item in value.values():
+                _payload_vars(item, out)
+    elif isinstance(value, list):
+        for item in value:
+            _payload_vars(item, out)
+    return out
+
+
+def _next_day(day: str) -> str:
+    """Следующий календарный день ISO §2.15 — граница полуинтервала."""
+    import datetime
+    return (datetime.date.fromisoformat(day) + datetime.timedelta(days=1)).isoformat()
+
+
+class _Excluded(Exception):
+    """Узел исключён проекцией §92.3 на всей оси: в плане его нет."""
+
+
+def _slug(urn: str) -> str:
+    """Внутреннее имя порождённого кода из StableId (таблица, функция, правило).
+
+    ASCII-локальная часть — с заменой символов вне `[A-Za-z0-9_]` на `_`, как
+    прежде. Замена букв вне ASCII (кириллица и другие письменности) стирала
+    различие имён: у отношений одного пакета получалось одно имя таблицы.
+    Такому слагу добавляются 8 знаков SHA-256 локальной части — имя остаётся
+    ASCII для всех целей и различимым (DECISION-0423 §7)."""
+    local = urn.split("#")[-1]
+    slug = re.sub(r"[^A-Za-z0-9_]", "_", local)
+    if local.isascii():
+        return slug
+    digest = hashlib.sha256(local.encode("utf-8")).hexdigest()[:8]
+    compact = re.sub(r"_+", "_", slug).strip("_")
+    return f"{compact}_{digest}" if compact else f"u_{digest}"
+
+
+def _api_slug(urn: str) -> str:
+    """Нейтральное имя вопроса или входа API из StableId (DECISION-0423 §2.7).
+
+    ASCII-имя совпадает с `_slug`. Имя с буквами вне ASCII их сохраняет (NFC):
+    знаки, не являющиеся буквой, цифрой или `_`, сворачиваются в `_`. Слова и
+    регистр по языку (snake_case, camelCase, PascalCase) выводит эмиттер цели."""
+    local = urn.split("#")[-1]
+    if local.isascii():
+        return re.sub(r"[^A-Za-z0-9_]", "_", local)
+    name = re.sub(r"[^\w]+|_+", "_", unicodedata.normalize("NFC", local)).strip("_")
+    return name or "u_" + hashlib.sha256(local.encode("utf-8")).hexdigest()[:8]
+
+
+LABEL_ORDER = {"official": 0, "plain": 1, "unofficial": 2, "translation": 3}
+
+
+def _labels(node: dict) -> list:
+    """Метки §218 узла для комментариев API: официальная первой, затем
+    прочие и переводы; текст и язык — как в CLIR, без правки."""
+    out = [{"language": l.get("language"), "status": l.get("status"), "text": l.get("text")}
+           for l in (node.get("labels") or []) if l.get("text")]
+    return sorted(out, key=lambda l: (LABEL_ORDER.get(l["status"], 9), l["language"] or ""))
+
+
+def _sccs(vertices: list, edges: list) -> dict:
+    """Компоненты сильной связности (Тарьян, итеративно): вершина → номер."""
+    succ: dict = {v: [] for v in vertices}
+    for a, b in edges:
+        succ.setdefault(a, []).append(b)
+        succ.setdefault(b, [])
+    index, low, comp, stack, on = {}, {}, {}, [], set()
+    counter = [0]
+    for root in sorted(succ):
+        if root in index:
+            continue
+        work = [(root, 0)]
+        while work:
+            v, i = work.pop()
+            if i == 0:
+                index[v] = low[v] = counter[0]
+                counter[0] += 1
+                stack.append(v)
+                on.add(v)
+            recurse = False
+            for j in range(i, len(succ[v])):
+                w = succ[v][j]
+                if w not in index:
+                    work.append((v, j + 1))
+                    work.append((w, 0))
+                    recurse = True
+                    break
+                if w in on:
+                    low[v] = min(low[v], index[w])
+            if recurse:
+                continue
+            if low[v] == index[v]:
+                while True:
+                    w = stack.pop()
+                    on.discard(w)
+                    comp[w] = index[v]
+                    if w == v:
+                        break
+            if work:
+                parent = work[-1][0]
+                low[parent] = min(low[parent], low[v])
+    return comp
+
+
+def _covered(inner, outer: list) -> bool:
+    """Покрывает ли объединение окон `outer` окно `inner` (`None` — вся ось)."""
+    need = [(None, None)] if inner is None else inner
+    # `_union` сливает пересекающиеся и смежные окна, поэтому окно внутри
+    # объединения лежит целиком в одном его окне.
+    have = [(None, None)] if outer is None else _union(outer)
+    return all(any((h[0] is None or (w[0] is not None and h[0] <= w[0]))
+                   and (h[1] is None or (w[1] is not None and w[1] <= h[1])) for h in have)
+               for w in need)
+
+
+def _admit_current_slice(ir, world):
+    _reject_withdrawn_language_versions(ir, world)
+    for document in [ir, *(world or [])]:
+        temporal.validate_ir(document, Refused)
+        if any(n.get("kind") == "norm_template" or
+               (n.get("head") or {}).get("kind") == "norm_template_ref"
+               for n in document.get("nodes") or []):
+            raise Refused("NORM_RANKS_UNAVAILABLE: norm runtime requires current ranks (W6)")
+
+
+class Builder:
+    def __init__(self, ir: dict, world: list | None = None, want: set | None = None,
+                 resources: dict | None = None):
+        """`world` — CLIR зависимостей (замыкание импортов). Мир собирается
+        как у `resolver.link_world`: корень, затем зависимости по имени;
+        узел с уже занятым StableId пропускается, если его contentHash тот же
+        (копии фактов `facts pkg::Group` у потребителя), иначе — отказ.
+
+        `want` — возможности, которых требует не программа, а её вызывающий:
+        `negation` для дела с отрицательными фактами (DECISION-0237)."""
+        _admit_current_slice(ir, world)
+        self.linked = world is not None
+        self.world_passport = []
+        self.dated_facts: list = []
+        if world:
+            ir = self._link(ir, world)
+        self.ir = ir
+        self.consts: dict = {}
+        self.entities: set = set()
+        self.aliases: dict = {}
+        self.types: dict = {}
+        self.want = set(want or ())
+        self.caps: set = set()
+        self.l1 = False
+        self._meta: dict = {}
+        self._prio: list = []
+        self.v09 = False
+        self.v10 = False
+        self.v11 = False
+        self.v12 = False
+        self.v13 = False
+        self.v14 = False
+        self.v15 = False
+        self.v16 = False
+        self.v17 = False
+        self.v18 = False
+        # DECISION-0274: отношения суждения §47.3 объявлены.
+        self.v19 = False
+        self.judgments: dict = {}
+        # DECISION-0273: функции §46, параметры A3, `let`, `match` встретились.
+        self._function_seen = False
+        self._a3_seen = False
+        self._let_seen = False
+        self._match_seen = False
+        self._fn_plan: dict = {}
+        self._fn_stack: list = []
+        self._a3params: dict = {}
+        self._let_n = 0
+        # DECISION-0270: вычисляемый аргумент тела и условный терм встретились.
+        self._body_term_seen = False
+        self._if_seen = False
+        # DECISION-0269: датированное ребро приоритета встретилось при разборе.
+        self._dated_prio_seen = False
+        # DECISION-0266–0268: Boolean, Natural, границы месяца и `_` встретились
+        # при компиляции — `build_plan` строит план заново с возможностями.
+        self._boolean_seen = False
+        self._natural_seen = False
+        self._month_seen = False
+        self._wildcard_seen = False
+        # DECISION-0259 п. 1: `round` с политикой для рантайма и `div_round`.
+        self._round_seen = False
+        self._div_round_seen = False
+        # DECISION-0256 п. 1: Quantity первым классом встретилась при компиляции.
+        self._quantity_seen = False
+        # W2 часть 2: Instant первым классом встретилась при компиляции.
+        self._instant_seen = False
+        # DECISION-0252 п. 1: Rational либо значение-зависимое частное встретились
+        # при компиляции — `build_plan` строит план заново с `value:rational`.
+        self._rational_seen = False
+        # DECISION-0252 п. 4: правила с ошибкой значения над незавершённым входом —
+        # ошибку не ловят, она становится названным отказом раннера.
+        self._value_refuse: set = set()
+        # Байты ресурсов по `resourceUri` (снимки §85, DECISION-0245); без
+        # записи — явный MISSING_CALENDAR; исходное дерево не читается.
+        self.resources = dict(resources or {})
+        # Explicit maps (including an empty map) never read repository resources.
+        # Standalone planning never discovers a source checkout.
+        self.repository_resources = False
+        self._norms: list = []
+        self._norm_meta: dict = {}
+        self._atoms: list = []
+        self._aggs: list = []
+        self._agg_cache: dict = {}
+        # E-0105: в плане есть агрегат с ошибкой значения — нужен `backchain`.
+        self._agg_fallible = False
+        self._agg_reads: list = []
+        self._agg_inner: list = []
+        self._closures: list = []
+
+    def _link(self, root: dict, world: list) -> dict:
+        nodes, owner = [], {}
+        parts = [((root.get("package") or {}).get("name", "<root>"), root)]
+        parts += sorted(((d.get("package") or {}).get("name", "?"), d) for d in world)
+        for name, ir in parts:
+            for n in ir.get("nodes", []):
+                nid = n.get("id", "")
+                prev = owner.get(nid)
+                if prev is not None:
+                    if prev.get("contentHash") != n.get("contentHash"):
+                        raise Refused(f"коллизия StableId между пакетами мира с разным содержимым: {nid}")
+                    continue
+                owner[nid] = n
+                nodes.append(n)
+            if ir is not root:
+                self.world_passport.append({"name": name, "namespace": (ir.get("package") or {}).get("namespace"),
+                                            "version": (ir.get("package") or {}).get("version")})
+        return dict(root, nodes=nodes, imports=[])
+
+    def _foreign_type_aliases(self, ir: dict, rels: list) -> None:
+        """Чужой тип в форме `имя.пакета#Тип` (так понижается
+        `algo.description::Algorithm`, lawc `lower/decls.rs`): вид слота
+        берётся у объявления `namespace#Тип`, где namespace — пакета мира с
+        ТОЧНО этим именем. Строка типа в сигнатурах, константах и
+        наследовании не меняется: сверка §189 у оракула (`facts._conforms`)
+        сравнивает строки, и нормализация приняла бы то, что он отвергает.
+        Имя без пакета в мире или без объявления остаётся вне среза."""
+        names = {(ir.get("package") or {}).get("name"): (ir.get("package") or {}).get("namespace")}
+        names.update({w["name"]: w["namespace"] for w in self.world_passport})
+        raw = {t for r in rels for t in self.types[r["id"]] if t}
+        raw |= {c["type"] for c in self.consts.values() if c["type"]}
+        raw |= {b for b in self.bases.values() if b}
+        for name in sorted(raw):
+            if name.startswith("urn:") or name.count("#") != 1:
+                continue
+            package, local = name.split("#")
+            ns = names.get(package)
+            if not ns:
+                continue
+            # Цель сама бывает алиасом §40 (`kz.corpus.osms#Person` →
+            # `kz.corpus.civilcode#Person`): вид берётся за цепочкой, строка
+            # ссылки при этом не меняется (W2, часть 1).
+            urn = self._t(f"{ns}#{local}")
+            if urn in self.entities:
+                self.entities.add(name)
+            elif urn in self.enums:
+                self.enums[name] = self.enums[urn]
+
+    def _t(self, name):
+        """Имя типа за цепочкой алиасов §40 (E-0097/E-0098) — как
+        `facts._unalias` оракула: обе стороны сверки §189 берутся за цепочкой,
+        цикл обрывается на повторе. `None` проходит как есть."""
+        seen: set = set()
+        current = name
+        while current is not None and current not in seen:
+            seen.add(current)
+            nxt = self.aliases.get(current)
+            if nxt is None:
+                break
+            current = nxt
+        return current
+
+    def ts(self, name):
+        name = self._t(name)
+        if name == "urn:law:std#Number":
+            raise Refused("NUMBER_UNAVAILABLE: exact Number and slot narrowing (E-0316/E-0319/E-0334) are outside this slice")
+        if name == RAT:
+            self._rational_seen = True
+        if name == QTY:
+            self._quantity_seen = True
+        if name == INST:
+            self._instant_seen = True
+        if name == BOOL:
+            self._boolean_seen = True
+        if name == NATURAL:
+            self._natural_seen = True
+        if name in TYPES:
+            return TYPES[name]
+        if name in self.entities:
+            return "text"
+        if name in self.enums:
+            return "enum"
+        raise Refused(f"тип аргумента вне среза генератора: {name}")
+
+    def term(self, node: dict, binds: dict) -> dict:
+        k = node["kind"]
+        if k == "var":
+            if node["var"] not in binds:
+                raise Refused(f"несвязанная переменная в голове: {node['var']}")
+            bind = binds[node["var"]]
+            if bind[0] == "p":
+                # Параметр подплана агрегата: значение внешней переменной (§52.1).
+                return {"k": "param", "i": bind[1], "t": bind[2]}
+            if bind[0] == "f":
+                # DECISION-0273: параметр функции §46 — позиционный аргумент.
+                return {"k": "fvar", "i": bind[1], "t": bind[2]}
+            if bind[0] == "l":
+                # DECISION-0273: переменная `let` — локальное связывание.
+                return {"k": "lvar", "i": bind[1], "t": bind[2]}
+            i, j, t = bind
+            return {"k": "var", "row": i, "col": j, "t": t}
+        if k == "aggregate" and self.v09:
+            return self._aggregate(node, binds)[0]
+        if k == "let":
+            return self._let_term(node, binds)
+        if k == "match":
+            return self._match_term(node, binds)
+        if k == "value":
+            t = (node.get("type") or {}).get("name", "")
+            if t == "urn:law:std#Number":
+                raise Refused("NUMBER_UNAVAILABLE: exact Number and slot narrowing (E-0316/E-0319/E-0334) are outside this slice")
+            if t == "urn:law:std#Money":
+                return {"k": "lit", "t": "money", "v": str(node["value"]), "cur": node["currency"]}
+            if t in ("urn:law:std#Decimal", "urn:law:std#Integer"):
+                return {"k": "lit", "t": "dec", "v": str(node["value"])}
+            if t == "urn:law:std#Text":
+                return {"k": "lit", "t": "text", "v": node["value"]}
+            if t == "urn:law:std#Date":
+                if not temporal.date_valid(node.get("value")):
+                    raise Refused("TEMPORAL_VALUE_INVALID: Date requires ASCII Gregorian YYYY-MM-DD")
+                return {"k": "lit", "t": "date", "v": str(node["value"])}
+            if t == INST:
+                if not temporal.instant_valid(node.get("value")):
+                    raise Refused("TEMPORAL_VALUE_INVALID: Instant requires an explicit valid offset")
+                # Запись мгновения — идентичность (E-0214), сравнение — по моменту (E-0048).
+                self._instant_seen = True
+                return {"k": "lit", "t": "inst", "v": str(node["value"])}
+            if t == RAT:
+                # §35 (E-0005): запись литерала бывает сократимой (`5/100` в датасете
+                # A3), оракул её сокращает (`from_literal_term`); рантайм цели принимает
+                # только канон §168.1 — сокращаем здесь. Не `n/d` с целыми, ноль в
+                # знаменателе — у оракула TYPE_ERROR/DIVISION_BY_ZERO всегда: отказ.
+                #
+                # Errata E-0213 сокращение НЕ отменяет, и это замер, а не осторожность.
+                # Канон §208 теперь печатает несократимую дробь, и порождаемый CLIR
+                # корпуса после перевыпуска несократим весь (0 из 1 281 снимка), — но
+                # план читает CLIR КАК ЗАПИСАН, а не канонизирует его: сократимая
+                # запись остаётся ЗАКОННЫМ входом (§208, раздел лексики E-0203),
+                # схема `LiteralTerm.value` намеренно не сужена, и рукописный либо
+                # чужой CLIR вправе прийти с `5/100`. Правило здесь то же самое:
+                # `Fraction` даёт взаимно простую пару с положительным знаменателем —
+                # ровно канон `canonical_rational`, — и `5/1` остаётся дробью.
+                raw = str(node["value"])
+                try:
+                    num, den = (int(x) for x in raw.split("/"))
+                except ValueError as exc:
+                    raise Refused(f"литерал Rational не 'n/d' вне среза генератора (§35): {raw}") from exc
+                if den == 0:
+                    raise Refused("литерал Rational со знаменателем 0 вне среза генератора (§35)")
+                frac = Fraction(num, den)
+                self._rational_seen = True
+                return {"k": "lit", "t": "rat", "v": f"{frac.numerator}/{frac.denominator}"}
+            if t == QTY and node.get("unit"):
+                self._quantity_seen = True
+                return {"k": "lit", "t": "qty", "v": str(node["value"]), "unit": node["unit"]}
+            if t == BOOL:
+                # DECISION-0266: литерал обязан быть JSON-булевым — иное у
+                # оракула всегда TYPE_ERROR (`values.from_literal_term`).
+                if not isinstance(node.get("value"), bool):
+                    raise Refused("литерал Boolean не true/false вне среза генератора (§48)")
+                self._boolean_seen = True
+                return {"k": "lit", "t": "bool", "v": node["value"]}
+            if t == NATURAL:
+                # DECISION-0266: неотрицательное целое; иное у оракула всегда TYPE_ERROR.
+                v = node.get("value")
+                if isinstance(v, bool) or not isinstance(v, int) or v < 0:
+                    raise Refused("литерал Natural не неотрицательное целое вне среза генератора (§48)")
+                self._natural_seen = True
+                return {"k": "lit", "t": "dec", "v": str(v)}
+            raise Refused(f"тип значения вне среза генератора: {t}")
+        if k == "entity_ref":
+            return {"k": "lit", "t": "text", "v": node["id"]}
+        if k == "const_ref":
+            if self.is_member(node["id"]):
+                return {"k": "lit", "t": "enum", "v": node["id"]}
+            if self._is_a3(node["id"]):
+                return self._a3_term(node["id"])
+            return self.term(self.const_value(node["id"]), binds)
+        if k == "binary":
+            op = BINOP.get(node["op"])
+            if op is None:
+                raise Refused(f"операция вне среза генератора: {node['op']}")
+            out = {"k": "bin", "op": op, "l": self.term(node["left"], binds),
+                   "r": self.term(node["right"], binds)}
+            self.static_type(node, binds)          # таблицы видов §58 — статически
+            # Current arithmetic always carries operand kinds (i64 boundary included).
+            # DECISION-0252 п. 3: статические виды операндов для `arith` рантайма
+            # (DECISION-0270: и у планов с вычисляемыми аргументами — код ошибки).
+            out["lk"] = KIND_CODE[self.static_type(node["left"], binds)]
+            out["rk"] = KIND_CODE[self.static_type(node["right"], binds)]
+            return out
+        if k == "call" and node.get("function") in CAL_FNS:
+            return self._calendar_call(node, binds)
+        if k == "call" and node.get("function") in MONTH_FNS:
+            return self._month_call(node, binds)
+        if k == "call" and node.get("function") in DUR_FNS:
+            return self._duration_call(node, binds)
+        if k == "if":
+            return self._if_term(node, binds)
+        if k == "call" and node.get("function") in self.fdecls:
+            return self._fcall(node, binds)
+        if k == "call":
+            fn = STD_FN.get(node["function"])
+            if fn is None:
+                raise Refused(f"функция вне среза генератора: {node['function']}")
+            out = {"k": "call", "fn": fn, "args": [self.term(a, binds) for a in node["args"]]}
+            self.static_type(node, binds)
+            if fn in ("round", "div_round"):
+                ak = self._policy(node, binds)
+                if self.v14:
+                    # DECISION-0259 п. 2: вид аргумента — из плана, не из значения.
+                    out["ak"] = ak
+            return out
+        raise Refused(f"узел терма вне среза генератора: {k}")
+
+    # --- DECISION-0273: функции §46, параметры A3, let, match -----------------
+
+    def _is_a3(self, cid: str) -> bool:
+        """Функция объявлена параметром-датасетом A3 (`calendar.is_a3_parameter`)."""
+        decl = self.fdecls.get(cid)
+        return decl is not None and any((e.get("attributes") or {}).get("a3Kind") == "parameter-dataset"
+                                        for e in decl.get("provenance") or [])
+
+    def _a3_range(self, cond: dict) -> tuple:
+        """Условие строки параметра (`a3._range_condition`): `true`, `v0 >= start`,
+        `v0 < end` либо их конъюнкция; иная форма — отказ."""
+        k = (cond or {}).get("kind")
+        if k == "boolean" and cond.get("value") is True:
+            return None, None
+        if k == "and":
+            items = cond.get("items") or []
+            if len(items) == 2:
+                s1, e1 = self._a3_range(items[0])
+                s2, e2 = self._a3_range(items[1])
+                if s1 is not None and e1 is None and s2 is None and e2 is not None:
+                    return s1, e2
+            raise Refused("форма параметра A3 вне среза генератора (DECISION-0273)")
+        if k == "comparison" and (cond.get("left") or {}).get("kind") == "var" \
+                and (cond.get("right") or {}).get("kind") == "value" \
+                and ((cond["right"].get("type") or {}).get("name") == "urn:law:std#Date"):
+            if cond.get("op") == "ge":
+                return str(cond["right"]["value"]), None
+            if cond.get("op") == "lt":
+                return None, str(cond["right"]["value"])
+        raise Refused("форма параметра A3 вне среза генератора (DECISION-0273)")
+
+    def _a3_term(self, cid: str) -> dict:
+        """Параметр A3 §A3.2 через `const_ref`: оракул вызывает функцию датасета на
+        `legalTime` (`values.eval_term`), строки — окна `[start, end)` на оси
+        права (`a3.lower_parameter`). План разбирает тело структурно: цепочка
+        `if` по окнам → вызов функции строки → `Result/Ok [литерал]`, хвост —
+        `MissingParameterValue`. Значение готовит `prepare` один раз на дело;
+        разрыв — MISSING_PARAMETER_VALUE правила (молчание права, статус
+        NEITHER/COMPUTED, обход E-0105 код пропускает). Ось Instant — отказ."""
+        if cid in self._a3params:
+            p = self._a3params[cid]
+            return {"k": "a3", "id": cid, "t": p["kind"]}
+        decl, sym = self.fdecls[cid], self.fsyms.get(cid)
+        if sym is None:
+            raise Refused(f"параметр A3 без объявления символа: {cid}")
+        params = decl.get("parameters") or []
+        if len(params) != 1 or self._t((params[0].get("type") or {}).get("name")) != "urn:law:std#Date":
+            raise Refused("параметр A3 по оси Instant вне среза генератора (DECISION-0273)")
+        rt = sym.get("returnType") or {}
+        if rt.get("name") != A3_RESULT or not rt.get("args"):
+            raise Refused("форма параметра A3 вне среза генератора (DECISION-0273)")
+        vt = self._t((rt["args"][0] or {}).get("name"))
+        kind = self.ts(vt)
+        windows, body = [], decl.get("body") or {}
+        while True:
+            if body.get("kind") == "variant_value" and body.get("constructor") == A3_MISSING:
+                break
+            if body.get("kind") != "if":
+                raise Refused("форма параметра A3 вне среза генератора (DECISION-0273)")
+            start, end = self._a3_range(body.get("condition"))
+            then = body.get("then") or {}
+            row = self.fdecls.get(then.get("function")) if then.get("kind") == "call" and not then.get("args") else None
+            rb = (row or {}).get("body") or {}
+            if rb.get("kind") != "variant_value" or rb.get("constructor") != A3_OK or len(rb.get("fields") or []) != 1:
+                raise Refused("форма параметра A3 вне среза генератора (DECISION-0273)")
+            lit = rb["fields"][0]
+            if self.static_type(lit, {}) != vt:
+                raise Refused("тип строки параметра A3 не совпадает с типом значения (DECISION-0273)")
+            windows.append([start, end, self.term(lit, {})])
+            body = body.get("else") or {}
+        if not windows:
+            raise Refused("параметр A3 без строк вне среза генератора (DECISION-0273)")
+        self._a3params[cid] = {"id": cid, "type": vt, "kind": kind, "windows": windows}
+        self._a3_seen = True
+        return {"k": "a3", "id": cid, "t": kind}
+
+    def _fn_sig(self, fn: str) -> dict:
+        """Скомпилированная функция §46: тело по позиционным параметрам,
+        статический тип результата против объявленного (`_require_type`
+        оракула), фоллибельность тела. Рекурсия у оракула —
+        NON_EXECUTABLE_FUNCTION_RECURSION всегда: отказ плана."""
+        if fn in self._fn_plan:
+            return self._fn_plan[fn]
+        if fn in self._fn_stack:
+            raise Refused(f"рекурсия функции §46 (NON_EXECUTABLE_FUNCTION_RECURSION) вне среза генератора: {fn}")
+        if self._is_a3(fn):
+            raise Refused(f"вызов параметра A3 как функции вне среза генератора: {fn}")
+        decl, sym = self.fdecls[fn], self.fsyms.get(fn)
+        if sym is None:
+            raise Refused(f"функция без объявления символа: {fn}")
+        for f in sorted(set(decl) - FUNCTION_FIELDS):
+            raise Refused(f"поле функции вне среза генератора: {f}")
+        params = decl.get("parameters") or []
+        urns = [self._t((p.get("type") or {}).get("name")) for p in params]
+        kinds = [self.ts(u) for u in urns]
+        binds = {p["id"]: ("f", i, kinds[i], urns[i]) for i, p in enumerate(params)}
+        declared = self._t((sym.get("returnType") or {}).get("name"))
+        returns = self.ts(declared)
+        name = _slug(fn)
+        if any(v["name"] == name for v in self._fn_plan.values()):
+            raise Refused(f"совпадающие имена функций в мире вне среза генератора: {name}")
+        self._fn_stack.append(fn)
+        try:
+            body = self.term(decl["body"], binds)
+            actual = self.static_type(decl["body"], binds)
+            if actual != declared:
+                raise Refused("тип результата функции §46 не совпадает с объявленным вне среза генератора (DECISION-0273)")
+            fallible = self._fallible_value(decl["body"], binds)
+        finally:
+            self._fn_stack.pop()
+        out = {"name": name, "id": fn, "params": kinds, "paramTypes": urns, "returns": returns,
+               "returnType": declared, "body": body}
+        if fallible:
+            out["fallible"] = True
+        self._fn_plan[fn] = out
+        self._function_seen = True
+        return out
+
+    def _fcall(self, node: dict, binds: dict) -> dict:
+        """Вызов функции §46: арность и типы аргументов статически (у оракула —
+        TYPE_ERROR при исполнении, здесь отказ плана)."""
+        sig = self._fn_sig(node["function"])
+        self._function_seen = True
+        args = node.get("args") or []
+        if len(args) != len(sig["params"]):
+            raise Refused("арность вызова функции §46 не совпадает с объявлением вне среза генератора")
+        for a, want in zip(args, sig["paramTypes"]):
+            actual = self.static_type(a, binds)
+            if actual != want:
+                raise Refused("тип аргумента функции §46 не совпадает с параметром вне среза генератора (DECISION-0273)")
+        return {"k": "fcall", "fn": sig["name"], "args": [self.term(a, binds) for a in args]}
+
+    def _let_binds(self, node: dict, binds: dict, i: int) -> dict:
+        var = node.get("variable") or {}
+        vt = self._t((var.get("type") or {}).get("name"))
+        kind = self.ts(vt)
+        actual = self.static_type(node.get("value") or {}, binds)
+        if actual != vt:
+            raise Refused("тип значения `let` не совпадает с объявленным вне среза генератора (DECISION-0273)")
+        out = dict(binds)
+        out[str(var.get("id"))] = ("l", i, kind, vt)
+        return out
+
+    def _let_term(self, node: dict, binds: dict) -> dict:
+        """`let` §55: значение вычисляется один раз, тело — с локальным связыванием;
+        тип значения обязан совпасть с объявленным (`_require_type`)."""
+        i = self._let_n
+        self._let_n += 1
+        inner = self._let_binds(node, binds, i)
+        self._let_seen = True
+        return {"k": "let", "i": i, "v": self.term(node["value"], binds), "b": self.term(node["body"], inner)}
+
+    def _match_arms(self, node: dict, binds: dict) -> tuple:
+        """Образцы `match` §55.1 над перечислением: вариант без полей —
+        идентичность члена (`_match_pattern`, E-0067), `_` — любой; иные образцы
+        и не-перечисление — отказ. Возвращает (enum, [(член|None, значение)],
+        исчерпывающий ли)."""
+        st = self.static_type(node.get("subject") or {}, binds)
+        if st not in self.enums:
+            raise Refused("match §55.1 над не-перечислением вне среза генератора (DECISION-0273)")
+        members = self.enums[st]
+        arms, covered, wild = [], set(), False
+        for arm in node.get("arms") or []:
+            p = arm.get("pattern") or {}
+            if p.get("kind") == "wildcard":
+                m, wild = None, True
+            elif p.get("kind") == "variant":
+                if p.get("fields"):
+                    raise Refused("вариантный образец с полями над перечислением вне среза генератора (§38)")
+                enum_urn, _, member = str(p.get("constructor")).rpartition("/")
+                if enum_urn != st:
+                    raise Refused("образец match другого перечисления вне среза генератора (DECISION-0273)")
+                m = next((x for x in members if x.rsplit("#", 1)[-1] == member), None)
+                if m is None:
+                    raise Refused(f"член перечисления в образце не объявлен: {p.get('constructor')}")
+                covered.add(m)
+            else:
+                raise Refused(f"образец match вне среза генератора: {p.get('kind')}")
+            arms.append((m, arm.get("value") or {}))
+        if not arms:
+            raise Refused("match без ветвей вне среза генератора")
+        return st, arms, wild or covered >= set(members)
+
+    def _match_type(self, node: dict, binds: dict) -> str | None:
+        _st, arms, _ex = self._match_arms(node, binds)
+        kinds = {self.static_type(v, binds) for _m, v in arms}
+        if len(kinds) != 1:
+            raise Refused("ветви match §55.1 разных видов вне среза генератора (DECISION-0273)")
+        return kinds.pop()
+
+    def _match_term(self, node: dict, binds: dict) -> dict:
+        self._match_type(node, binds)
+        _st, arms, exhaustive = self._match_arms(node, binds)
+        self._match_seen = True
+        out = {"k": "match", "s": self.term(node["subject"], binds),
+               "arms": [{"m": m, "v": self.term(v, binds)} for m, v in arms]}
+        if not exhaustive:
+            # §55.1: ни один образец не совпал — NON_EXHAUSTIVE_MATCH по подстановке.
+            out["x"] = False
+        return out
+
+    def _if_term(self, node: dict, binds: dict) -> dict:
+        """Условный терм §56 (E-0180, DECISION-0270): условие — чистое
+        data-условие (`values.is_data_condition`: boolean, comparison, and,
+        or); статусный тест в условии читает опору, не данные — отказ. Ветви
+        одного статического вида; иное — отказ (у оракула вид по значению
+        ветви, срез видами ветвей расходился бы с ключом атома). Ветвь
+        вычисляется лениво — только выбранная (`select_conditionals`)."""
+        cond = self._data_cond(node.get("condition"), binds)
+        kt = self.static_type(node.get("then") or {}, binds)
+        ke = self.static_type(node.get("else") or {}, binds)
+        if kt != ke:
+            raise Refused("ветви условного терма §56 разных видов вне среза генератора (DECISION-0270)")
+        self._if_seen = True
+        return {"k": "if", "c": cond, "t": self.term(node["then"], binds), "e": self.term(node["else"], binds)}
+
+    def _data_cond(self, f: dict, binds: dict) -> dict:
+        k = (f or {}).get("kind")
+        if k == "boolean":
+            return {"k": "bool", "v": bool(f.get("value"))}
+        if k == "comparison":
+            if f.get("op") not in CMP:
+                raise Refused(f"сравнение вне среза генератора: {f.get('op')}")
+            self.guard_enums(f, binds)
+            self.guard_kinds(f, binds)
+            self.guard_instant(f, binds)
+            return {"k": "cmp", "op": f["op"], "l": self.term(f["left"], binds), "r": self.term(f["right"], binds)}
+        if k in ("and", "or"):
+            items = f.get("items") or []
+            if not items:
+                raise Refused("пустое условие терма §56 вне среза генератора")
+            return {"k": k, "items": [self._data_cond(x, binds) for x in items]}
+        raise Refused(f"условие терма §56 вне data-условия вне среза генератора (DECISION-0270): {k}")
+
+    def _body_arg(self, ai: int, j: int, t: str, arg: dict, expected: str, binds: dict) -> dict:
+        """Фильтр атома тела по аргументу. Константа — как прежде (`body_const`);
+        вычисляемый терм (E-0180, DECISION-0270) — тип обязан совпасть с типом
+        слота статически (оракул сопоставляет канонические байты, значение И
+        тип), значение считается ДО перебора таблицы (`pre`), ошибка значения —
+        issue правила (`err`), как у гарда."""
+        if arg["kind"] in ("value", "entity_ref", "const_ref"):
+            return {"row": ai, "col": j, "t": t, "term": self.body_const(arg, expected)}
+        if arg["kind"] not in ("binary", "call", "if", "let", "match"):
+            raise Refused(f"терм в аргументе тела вне среза генератора: {arg['kind']}")
+        missing = sorted(set(self._free(arg)) - set(binds))
+        if missing:
+            raise Refused(f"переменная без позитивного генератора (§190/§113): {', '.join(missing)}")
+        actual = self.static_type(arg, binds)
+        if actual != expected and (expected in TYPES or expected in self.enums):
+            raise Refused("тип аргумента тела не совпадает с параметром §189")
+        self._body_term_seen = True
+        out = {"row": ai, "col": j, "t": t, "term": self.term(arg, binds), "pre": True}
+        if self._fallible_calendar(arg) or self._fallible_value(arg, binds):
+            out["err"] = True
+        return out
+
+    def _month_call(self, node: dict, binds: dict) -> dict:
+        """§84.2 (E-0084, DECISION-0267): граница месяца — чистая функция над
+        Date. Не Date у оракула всегда TYPE_ERROR — отказ плана; над слотом
+        Date ошибки значения нет, поэтому вызов не фоллибелен и модели не
+        меняет (как `days_between`, DECISION-0245 п. 1)."""
+        name = MONTH_FNS[node["function"]]
+        args = node.get("args") or []
+        if len(args) != 1:
+            raise Refused(f"{name}: арность вне среза генератора (§84.2)")
+        out = self.term(args[0], binds)
+        if self.static_type(args[0], binds) != "urn:law:std#Date":
+            raise Refused(f"{name}: аргумент не Date вне среза генератора (§57/§2.15)")
+        self._month_seen = True
+        return {"k": "call", "fn": name, "args": [out]}
+
+    def _duration_call(self, node: dict, binds: dict) -> dict:
+        """§84.1 (W2 часть 2): `hours_between`/`minutes_between` — полных единиц
+        между мгновениями со знаком; `add_duration` — мгновение через целую
+        Quantity секунд/минут/часов/суток, канон UTC. Виды аргументов
+        проверяются статически, как `values` при исполнении: не Instant, не
+        Quantity, чужая единица, дробный счётчик — TYPE_ERROR оракула всегда,
+        здесь отказ плана. Смешение записи со смещением и без — отказ рантайма."""
+        name = DUR_FNS[node["function"]]
+        args = node.get("args") or []
+
+        def moment(a):
+            out = self.term(a, binds)
+            if self.static_type(a, binds) != INST:
+                raise Refused(f"{name}: аргумент не Instant вне среза генератора (§84.1/§2.15)")
+            return out
+
+        self._instant_seen = True
+        if name != "add_duration":
+            if len(args) != 2:
+                raise Refused(f"{name}: арность вне среза генератора (§84.1)")
+            return {"k": "call", "fn": name, "args": [moment(args[0]), moment(args[1])]}
+        if len(args) != 2:
+            raise Refused("add_duration: арность вне среза генератора (§84.1)")
+        count = args[1]
+        if count.get("kind") != "value" or (count.get("type") or {}).get("name") != QTY:
+            raise Refused("add_duration: длительность не литерал Quantity вне среза генератора (§84.1)")
+        unit = count.get("unit")
+        if unit not in DURATION_UNITS:
+            raise Refused(f"add_duration: единица {unit} вне среза генератора (§84.1)")
+        try:
+            value = float(str(count.get("value")))
+        except ValueError:
+            raise Refused("add_duration: длительность не число вне среза генератора (§84.1)")
+        if value != int(value):
+            raise Refused("add_duration: дробная длительность вне среза генератора (§84.1)")
+        return {"k": "call", "fn": "add_duration", "args": [moment(args[0]), {"k": "qty", "v": int(value), "unit": unit}]}
+
+    def _calendar_call(self, node: dict, binds: dict) -> dict:
+        """Календарная функция §84–§86 (DECISION-0245). Аргументы проверяются
+        статически так, как `values` проверяет их при исполнении: то, что у
+        оракула всегда TYPE_ERROR (не Date, чужая единица, дробный счётчик),
+        здесь отказ плана; ошибки политики и снимка — исполнения."""
+        name = CAL_FNS[node["function"]][0]
+        args = node.get("args") or []
+        date = "urn:law:std#Date"
+
+        def dated(a):
+            out = self.term(a, binds)
+            if self.static_type(a, binds) != date:
+                raise Refused(f"{name}: аргумент не Date вне среза генератора (§57/§2.15)")
+            return out
+
+        if name == "days_between":
+            if len(args) != 2:
+                raise Refused("days_between: арность вне среза генератора (§84.4)")
+            return {"k": "call", "fn": name, "args": [dated(args[0]), dated(args[1])]}
+        if len(args) not in (2, 3) or (len(args) == 3 and name != "add_business_days"):
+            raise Refused(f"{name}: арность вне среза генератора (§86)")
+        count = args[1]
+        if count.get("kind") != "value" and self.static_type(count, binds) == QTY:
+            # DECISION-0256 п. 6: связыватель Quantity — вид, единица и целочисленность
+            # на деле (`counter` рантайма); у `add_legal_term` ветвь выбирает единица.
+            self._quantity_seen = True
+            out = {"k": "call", "fn": name,
+                   "args": [dated(args[0]), {"k": "qtyvar", "fn": name, "term": self.term(count, binds)}]}
+            if len(args) == 3:
+                if self.static_type(args[2], binds) != "urn:law:std#Text":
+                    raise Refused("add_business_days: after_time не Text вне среза генератора (§86 cutoff)")
+                out["args"].append(self.term(args[2], binds))
+            return out
+        if count.get("kind") != "value" or (count.get("type") or {}).get("name") != "urn:law:std#Quantity":
+            raise Refused(f"{name}: счётчик не литерал Quantity вне среза генератора (DECISION-0245 п. 2)")
+        unit = count.get("unit")
+        allowed = {"add_calendar_period": CALENDAR_PERIOD_UNITS, "add_business_days": DAY_UNITS,
+                   "add_legal_term": DEADLINE_UNITS}[name]
+        if unit not in allowed:
+            raise Refused(f"{name}: единица счётчика {unit} вне среза генератора (E-0029/E-0109)")
+        try:
+            value = float(str(count.get("value")))
+        except ValueError:
+            raise Refused(f"{name}: счётчик не число вне среза генератора (§84)")
+        if value != int(value):
+            raise Refused(f"{name}: дробный счётчик вне среза генератора (§84)")
+        if name == "add_legal_term":
+            # §86.1: единица выбирает одну из двух нормативных операций.
+            name = "add_business_days" if unit in DAY_UNITS else "add_calendar_period"
+        out = {"k": "call", "fn": name, "args": [dated(args[0]), {"k": "qty", "v": int(value), "unit": unit}]}
+        if len(args) == 3:
+            if self.static_type(args[2], binds) != "urn:law:std#Text":
+                raise Refused("add_business_days: after_time не Text вне среза генератора (§86 cutoff)")
+            out["args"].append(self.term(args[2], binds))
+        return out
+
+    @staticmethod
+    def _fallible_calendar(node) -> bool:
+        """Терм содержит календарную функцию с ошибкой значения (§86)."""
+        stack = [node]
+        while stack:
+            x = stack.pop()
+            if isinstance(x, list):
+                stack.extend(x)
+            elif isinstance(x, dict):
+                if x.get("kind") == "call" and x.get("function") in CAL_FNS \
+                        and x["function"] != "urn:law:std#days_between":
+                    return True
+                stack.extend(v for v in x.values() if isinstance(v, (dict, list)))
+        return False
+
+    def static_type(self, node: dict, binds: dict) -> str | None:
+        """Тип терма головы, известный статически: URN типа `std` либо None,
+        если проверять нечего (сущность — у `entity_ref` носителя типа нет)."""
+        k = node["kind"]
+        if k == "var":
+            if node["var"] not in binds:
+                raise Refused(f"несвязанная переменная в голове: {node['var']}")
+            bind = binds[node["var"]]
+            if bind[0] in ("p", "f", "l"):
+                urn = bind[3]
+                return urn if urn in TYPES or urn in self.enums else None
+            pred = self._atoms[bind[0]]["predicate"]
+            return self._slot_type(pred, self._var_col(node["var"], binds))
+        if k == "value":
+            return (node.get("type") or {}).get("name")
+        if k == "const_ref":
+            if self.is_member(node["id"]):
+                return self.members[node["id"]]
+            if self._is_a3(node["id"]):
+                return self._a3params[node["id"]]["type"] if node["id"] in self._a3params \
+                    else self._a3params[self._a3_term(node["id"])["id"]]["type"]
+            return self.static_type(self.const_value(node["id"]), binds)
+        if k == "let":
+            return self.static_type(node.get("body") or {}, self._let_binds(node, binds, -1))
+        if k == "match":
+            return self._match_type(node, binds)
+        if k == "call" and node.get("function") in self.fdecls:
+            return self._fn_sig(node["function"])["returnType"]
+        if k == "binary":
+            return self.arith_kind(node["op"], self.static_type(node["left"], binds),
+                                   self.static_type(node["right"], binds))
+        if k == "call" and node.get("function") in CAL_FNS:
+            return INT if node["function"] == "urn:law:std#days_between" else "urn:law:std#Date"
+        if k == "call" and node.get("function") in MONTH_FNS:
+            return "urn:law:std#Date"
+        if k == "call" and node.get("function") in DUR_FNS:
+            return INST if DUR_FNS[node["function"]] == "add_duration" else INT
+        if k == "if":
+            kt = self.static_type(node.get("then") or {}, binds)
+            ke = self.static_type(node.get("else") or {}, binds)
+            if kt != ke:
+                raise Refused("ветви условного терма §56 разных видов вне среза генератора (DECISION-0270)")
+            return kt
+        if k == "call":
+            return self.call_kind(node["function"], [self.static_type(a, binds) for a in node["args"]])
+        if k == "aggregate" and self.v09:
+            return self._aggregate(node, binds)[1]
+        return None
+
+    def arith_kind(self, op: str, l: str | None, r: str | None) -> str | None:
+        """Таблицы видов §58 для среза (Integer, Decimal, Money; Rational и
+        динамический Decimal|Rational — DECISION-0252). Пара вне таблицы —
+        отказ плана, как TYPE_ERROR у оракула; вид, зависящий от значения,
+        план несёт динамическим, а ошибку решает рантайм (`arith`, issue
+        модели 0.12). Операция вне BINOP сюда не доходит."""
+        if op not in BINOP:
+            return None
+        l, r = _num(l), _num(r)
+        if l not in NUMERIC or r not in NUMERIC:
+            raise Refused(f"арифметика вне среза (§58): не числовой операнд {op}")
+        if RAT in (l, r) or DYN in (l, r) or QTY in (l, r):
+            if QTY in (l, r):
+                self._quantity_seen = True
+            kind = self._arith_rational(op, l, r)
+            if RAT in (l, r) or DYN in (l, r) or kind in (RAT, DYN):
+                self._rational_seen = True
+            return kind
+        pair = {l, r}
+        if op in ("add", "sub"):
+            if l != r:
+                raise Refused(f"арифметика вне среза (§58): виды операндов не совпадают у {op}")
+            return l
+        if op == "mul":
+            if pair == {MON}:
+                raise Refused("арифметика вне среза (§58): произведение двух размерных величин не определено")
+            if INT in pair:
+                return l if r == INT else r          # скаляр §49 не меняет вида
+            return MON if MON in pair else DEC
+        if op == "div":
+            if (l, r) == (DEC, DEC) or (l, r) == (MON, MON):
+                # E-0005/E-0083: вид частного зависит от значения (DECISION-0252 п. 2).
+                self._rational_seen = True
+                return DYN
+            if (l, r) == (MON, DEC):
+                return MON
+            if (l, r) == (INT, INT):
+                # E-0020: единственный источник Rational из целых.
+                self._rational_seen = True
+                return RAT
+            raise Refused("арифметика вне среза (§58): пара вне таблицы делимых")
+        if op == "mod":
+            if (l, r) != (INT, INT):
+                raise Refused("арифметика вне среза (§58): остаток только Integer mod Integer")
+            return INT
+        return None
+
+    def call_kind(self, fn: str, kinds: list) -> str | None:
+        name = STD_FN.get(fn)
+        kinds = [_num(k) for k in kinds]
+        if name in ("min", "max"):
+            if len(kinds) == 2 and (RAT in kinds or DYN in kinds or QTY in kinds):
+                # DECISION-0252/0256: выбор операнда требует совпадения видов, как
+                # сложение; динамический операнд совпадает своим исходом.
+                if QTY in kinds:
+                    self._quantity_seen = True
+                if RAT in kinds or DYN in kinds:
+                    self._rational_seen = True
+                return self._arith_rational("add", kinds[0], kinds[1])
+            if len(kinds) != 2 or kinds[0] not in NUMERIC or kinds[0] != kinds[1]:
+                raise Refused(f"арифметика вне среза (§58): виды операндов не совпадают у {name}")
+            return kinds[0]
+        if name == "abs":
+            if len(kinds) != 1 or kinds[0] not in NUMERIC:
+                raise Refused("арифметика вне среза (§58): abs над нечисловым видом")
+            if kinds[0] in (RAT, DYN):
+                self._rational_seen = True
+            if kinds[0] == QTY:
+                self._quantity_seen = True
+            return kinds[0]
+        if name == "pow":
+            if kinds != [INT, INT]:
+                raise Refused("арифметика вне среза (§58): pow только Integer pow Integer")
+            return INT
+        if name == "round":
+            # §50, E-0110: над Integer при precision >= 0 — тождество того же вида.
+            if kinds and kinds[0] == RAT:
+                self._rational_seen = True
+                raise Refused("round над Rational вне среза генератора (§50: round не берёт Rational)")
+            if kinds and kinds[0] == QTY:
+                self._quantity_seen = True          # §50: round сохраняет тег (DECISION-0256)
+            if kinds and kinds[0] == DYN:
+                # DECISION-0259 п. 3: Rational по значению — TYPE_ERROR рантайма.
+                self._rational_seen = self._round_seen = True
+            elif not kinds or kinds[0] not in (MON, DEC, INT, QTY):
+                raise Refused("round вне среза генератора: вид операнда не числовой (§50)")
+            self._policy_kinds("round", kinds[1:])
+            return DEC if kinds[0] == DYN else kinds[0]
+        if name == "div_round":
+            # §50/§58 (E-0036, E-0170, DECISION-0259 п. 3): четыре пары; иная —
+            # у оракула всегда TYPE_ERROR, отказ плана.
+            if len(kinds) != 4:
+                raise Refused("div_round вне среза генератора: ожидаются делимое, делитель, точность и режим (§50)")
+            self._div_round_seen = True
+            if RAT in kinds[:2]:
+                self._rational_seen = True
+                raise Refused("div_round над Rational вне среза генератора (§50/§58, E-0036)")
+            if DYN in kinds[:2]:
+                self._rational_seen = True
+            if QTY in kinds[:2]:
+                self._quantity_seen = True
+            pair = tuple(DEC if k == DYN else k for k in kinds[:2])
+            if pair not in ((MON, DEC), (QTY, DEC), (DEC, DEC), (MON, MON)):
+                raise Refused("div_round вне среза генератора: пара видов вне E-0036/E-0170 (§50/§58)")
+            self._policy_kinds("div_round", kinds[2:])
+            return {(MON, DEC): MON, (QTY, DEC): QTY}.get(pair, DEC)
+        return None
+
+    @staticmethod
+    def _policy_kinds(fn: str, kinds: list) -> None:
+        """§50: точность — Integer либо Decimal, режим — Text; иной вид у оракула
+        всегда TYPE_ERROR (DECISION-0259 п. 3)."""
+        if len(kinds) != 2:
+            raise Refused(f"{fn} вне среза генератора: ожидаются точность и режим (§50)")
+        if kinds[0] not in (INT, DEC):
+            raise Refused(f"{fn} вне среза генератора: точность не Integer и не Decimal (§50)")
+        if kinds[1] != TEXT_URN:
+            raise Refused(f"{fn} вне среза генератора: режим не Text (§50)")
+
+    @staticmethod
+    def _pair_kinds(op: str, a: str, b: str) -> set:
+        """Виды исхода конкретной пары §58 — порт `values.binary`; пустое
+        множество — у оракула TYPE_ERROR. Decimal/Decimal и Money/Money дают
+        Decimal либо Rational по значению (E-0005, E-0083)."""
+        if op in ("add", "sub"):
+            return {a} if a == b else set()
+        if op == "mul":
+            if a == b == INT:
+                return {INT}
+            if INT in (a, b) and {a, b} & {MON, DEC, QTY}:
+                return {a, b} - {INT}
+            if {a, b} == {INT, RAT} or a == b == RAT:
+                return {RAT}
+            if {a, b} == {MON, RAT}:
+                return {MON}                     # E-0085: доля масштабирует деньги
+            if RAT in (a, b) or a == b == MON or QTY in (a, b) and {a, b} != {QTY, DEC}:
+                return set()                     # Q×Q, Q×Money, Q×Rational — TYPE_ERROR
+            return {QTY} if QTY in (a, b) else {MON} if MON in (a, b) else {DEC}
+        if op == "div":
+            if a == b == RAT or a == b == INT:
+                return {RAT}
+            if RAT in (a, b):
+                return set()
+            if (a, b) in ((DEC, DEC), (MON, MON), (QTY, QTY)):
+                return {DEC, RAT}                # E-0068: частное одной единицы безразмерно
+            return {MON} if (a, b) == (MON, DEC) else {QTY} if (a, b) == (QTY, DEC) else set()
+        if op == "mod":
+            return {INT} if a == b == INT else set()
+        return set()
+
+    def _arith_rational(self, op: str, l: str, r: str) -> str:
+        """Пара §58 с Rational либо динамическим операндом (DECISION-0252 п. 2):
+        вид — у исходов, которые не ошибка; пара без таких исходов у оракула
+        всегда TYPE_ERROR и отвергается планом."""
+        outcomes = set()
+        for a in ((DEC, RAT) if l == DYN else (l,)):
+            for b in ((DEC, RAT) if r == DYN else (r,)):
+                outcomes |= self._pair_kinds(op, a, b)
+        if not outcomes:
+            raise Refused(f"арифметика вне среза (§58): {l.split('#')[-1]} {op} {r.split('#')[-1]} "
+                          "у оракула всегда TYPE_ERROR")
+        if outcomes == {DEC, RAT}:
+            return DYN
+        if len(outcomes) != 1:
+            raise Refused(f"арифметика вне среза (§58): вид исхода {op} не определён статически")
+        return outcomes.pop()
+
+    def _lit(self, node: dict) -> dict | None:
+        """Литерал за ссылками на константы §54 либо None."""
+        while node.get("kind") == "const_ref" and not self.is_member(node["id"]):
+            node = self.const_value(node["id"])
+        return node if node.get("kind") == "value" else None
+
+    def _policy(self, node: dict, binds: dict) -> list:
+        """DECISION-0259 п. 1–3: политика `round`/`div_round`. Литеральная
+        точность либо режим, у оракула всегда TYPE_ERROR, — отказ плана.
+        `value:div_round` — любой `div_round`; `value:round` — `round` с
+        нелитеральной политикой, режимом не HALF_UP либо динамическим видом.
+        Результат — статические виды аргументов `ak` (`t` — Text)."""
+        fn = STD_FN[node["function"]]
+        args = node["args"]
+        kinds = [self.static_type(a, binds) for a in args]
+        prec, mode = self._lit(args[-2]), self._lit(args[-1])
+        if prec is not None:
+            raw = str(prec["value"])
+            if "." in raw or "e" in raw.lower():
+                raise Refused(f"{fn} вне среза генератора: точность не целое (§50)")
+            scale = int(raw)
+            if scale < 0 or (fn == "div_round" and scale > DIV_ROUND_MAX_PRECISION):
+                raise Refused(f"{fn} вне среза генератора: точность вне диапазона (§50, E-0036)")
+        if mode is not None and mode.get("value") not in ROUNDING_MODES:
+            raise Refused(f"{fn} вне среза генератора: режим вне семи (§50)")
+        if fn == "div_round":
+            self._div_round_seen = True
+        elif prec is None or mode is None or mode["value"] != "HALF_UP" or kinds[0] == DYN:
+            self._round_seen = True
+        return [KIND_CODE.get(k, "t") for k in kinds]
+
+    def _policy_fallible(self, node: dict, binds: dict) -> bool:
+        """DECISION-0259 п. 5: вызов может дать ошибку значения. `round` — при
+        нелитеральной политике либо динамическом виде; `div_round` — кроме
+        ненулевого литерального делителя при литеральной политике и паре не
+        Money/Money."""
+        args = node["args"]
+        if self._lit(args[-2]) is None or self._lit(args[-1]) is None:
+            return True
+        kinds = [self.static_type(a, binds) for a in args[:-2]]
+        if DYN in kinds:
+            return True
+        if STD_FN[node["function"]] == "round":
+            return False
+        divisor = self._lit(args[1])
+        return divisor is None or kinds == [MON, MON] or \
+            not any(ch in "123456789" for ch in str(divisor["value"]))
+
+    def kind_checks(self, head: dict, binds: dict) -> list:
+        """Позиции головы с динамическим видом в слоте Decimal либо Rational —
+        сверка E-0077 рантаймом по значению (DECISION-0252 п. 5)."""
+        params = self.types.get(head["predicate"]) or []
+        return [[pos, KIND_CODE[expected]]
+                for pos, (expected, arg) in enumerate(zip(params, head["args"]))
+                if expected in (DEC, RAT) and self.static_type(arg, binds) == DYN]
+
+    def _fallible_value(self, node, binds: dict, gens: list | None = None) -> bool:
+        """Терм может дать ошибку значения §58 (DECISION-0252 п. 4): деление и
+        остаток (ноль, неточность), арифметика над Rational и динамическим
+        видом, сравнение с динамическим видом. Расхождение валют у денег сюда
+        не входит: как и до плана 0.12, это названный отказ рантайма. Внутрь
+        агрегата обход не спускается: его ошибки — G3."""
+        saved = self._atoms
+        if gens is not None:
+            self._atoms = gens
+        try:
+            stack = [node]
+            while stack:
+                x = stack.pop()
+                if isinstance(x, list):
+                    stack.extend(x)
+                    continue
+                if not isinstance(x, dict) or x.get("kind") in ("aggregate", "comprehension"):
+                    continue
+                if x.get("kind") == "let":
+                    # DECISION-0273: тело — с локальным связыванием.
+                    if self._fallible_value(x.get("value"), binds) \
+                            or self._fallible_value(x.get("body"), self._let_binds(x, binds, -1)):
+                        return True
+                    continue
+                if x.get("kind") == "match":
+                    _st, arms, exhaustive = self._match_arms(x, binds)
+                    if not exhaustive:
+                        return True              # NON_EXHAUSTIVE_MATCH по подстановке
+                    stack.append(x.get("subject"))
+                    stack.extend(v for _m, v in arms)
+                    continue
+                if x.get("kind") == "const_ref" and self._is_a3(x["id"]):
+                    return True                  # MISSING_PARAMETER_VALUE на разрыве датасета
+                if x.get("kind") == "call" and x.get("function") in self.fdecls \
+                        and self._fn_sig(x["function"]).get("fallible"):
+                    return True                  # ошибка значения в теле функции §46
+                if x.get("kind") in ("binary", "comparison"):
+                    kinds = {self.static_type(x["left"], binds), self.static_type(x["right"], binds)}
+                    if x["kind"] == "binary" and (x.get("op") in ("div", "mod") or kinds & {RAT, DYN, QTY}):
+                        return True
+                    if x["kind"] == "comparison" and (DYN in kinds or kinds == {QTY}):
+                        return True              # DECISION-0256 п. 4: разные единицы
+                if x.get("kind") == "call" and STD_FN.get(x.get("function")) in ("round", "div_round") \
+                        and self._policy_fallible(x, binds):
+                    return True                  # DECISION-0259 п. 5
+                stack.extend(v for v in x.values() if isinstance(v, (dict, list)))
+            return False
+        finally:
+            self._atoms = saved
+
+    def guard_instant(self, g: dict, binds: dict) -> None:
+        """§57/§2.15 (W2 часть 2): Instant сравнивается только с Instant; с Date у
+        оракула DATE_INSTANT_MISMATCH, с прочими видами TYPE_ERROR — всегда,
+        поэтому отказ плана. Стоит отдельно от `guard_kinds`: L0-путь строгих
+        правил её не звал, и расширять там сверку Rational значило бы менять
+        закреплённые исходы."""
+        kinds = []
+        for side in ("left", "right"):
+            try:
+                kinds.append(self.static_type(g[side], binds))
+            except Refused:
+                return
+        for x, y in ((kinds[0], kinds[1]), (kinds[1], kinds[0])):
+            if x == INST and y is not None and y != INST:
+                raise Refused("сравнение Instant с иным видом вне среза генератора (§57/§2.15)")
+
+    def guard_kinds(self, g: dict, binds: dict) -> None:
+        """§57/§48 (DECISION-0252 п. 2): Rational сравнивается только с Rational;
+        сравнение, которое у оракула всегда TYPE_ERROR, — отказ плана."""
+        kinds = []
+        for side in ("left", "right"):
+            try:
+                kinds.append(_num(self.static_type(g[side], binds)))
+            except Refused:
+                return
+        for x, y in ((kinds[0], kinds[1]), (kinds[1], kinds[0])):
+            if (x == RAT and y in (INT, DEC, MON)) or (x == DYN and y in (INT, MON, QTY)) \
+                    or (x == QTY and y in (INT, DEC, MON, RAT)):
+                raise Refused("сравнение Rational с иным видом вне среза генератора (§57/§48)")
+
+    def _var_col(self, name: str, binds: dict) -> int:
+        return binds[name][1]
+
+    def _slot_type(self, pred: str, col: int) -> str | None:
+        t = self.types[pred][col]
+        return t if t in TYPES or t in self.enums else None
+
+    def head_types(self, head: dict, binds: dict) -> None:
+        """Типы аргументов ВЫВЕДЕННОЙ головы против сигнатуры §189 (E-0077).
+
+        Оракул отвергает вывод с Integer в Decimal-слоте при исполнении
+        (`check_derived_types`), а рантайм среза сравнивает числа по величине
+        и ответил бы TRUE_ONLY там, где оракул даёт NEITHER. Здесь это отказ
+        плана: сущности не проверяются (у `entity_ref` типа нет — как у
+        оракула), остальное обязано совпасть с объявленным типом слота."""
+        params = self.types.get(head["predicate"])
+        if params is None:
+            raise Refused(f"предикат головы не объявлен в пакете: {head['predicate']}")
+        if len(params) != len(head["args"]):
+            raise Refused("арность головы правила не совпадает с сигнатурой §189")
+        for arg in head["args"]:
+            if arg.get("kind") == "const_ref" and self._is_a3(arg["id"]):
+                # DECISION-0273: голый параметр в голове — позиция идентичности у оракула
+                # (`a3_runner`: «голый const_ref в голове … не вычисляется»).
+                raise Refused("голый `const_ref` параметра A3 в позиции идентичности (голова, аргумент атома) вне среза генератора: у оракула он не вычисляется, читайте вызовом (DECISION-0273)")
+        for expected, arg in zip(params, head["args"]):
+            actual = self.static_type(arg, binds)
+            if actual is None or (expected not in TYPES and expected not in self.enums):
+                continue
+            if actual == DYN and expected in (DEC, RAT):
+                continue                    # DECISION-0252 п. 5: сверка рантаймом (`kindChecks`)
+            if actual != expected:
+                raise Refused("тип аргумента головы не совпадает с параметром §189 (E-0077)")
+
+    def guard_enums(self, g: dict, binds: dict) -> None:
+        """§57/E-0067 для гарда: порядок над перечислением не определён, члены
+        разных перечислений несравнимы — у оракула это TYPE_ERROR при
+        исполнении, рантайм среза ответил бы false. Здесь — отказ плана.
+        То же для Boolean (DECISION-0266): `values.binary` сравнивает виды
+        (`_check_same_kind`), а порядок над `boolean` — TYPE_ERROR."""
+        kinds = []
+        for side in ("left", "right"):
+            try:
+                kinds.append(self.static_type(g[side], binds))
+            except Refused:
+                kinds.append(None)
+        if BOOL in kinds:
+            if kinds[0] != kinds[1]:
+                raise Refused("сравнение Boolean с иным видом вне среза генератора (§57/§48)")
+            if g["op"] not in ("eq", "ne"):
+                raise Refused("порядок над Boolean не определён §57 вне среза генератора")
+        enum_sides = [t for t in kinds if t in self.enums]
+        if not enum_sides:
+            return
+        if g["op"] not in ("eq", "ne"):
+            raise Refused("порядок над перечислением не определён §57 (E-0067)")
+        if len(set(enum_sides)) > 1:
+            raise Refused("члены разных перечислений несравнимы §57 (E-0067)")
+
+    def is_member(self, cid: str) -> bool:
+        """`const_ref` — член перечисления §38, если это не объявленная константа
+        со значением: таблица разыменования §54 знает объявленные константы и
+        применяется первой, а одно имя бывает и константой, и членом
+        перечисления того же пакета (`kz.corpus.mortgage`,
+        `ObrashchenieVSobstvennost`)."""
+        c = self.consts.get(cid)
+        return cid in self.members and not (c is not None and c.get("value") is not None)
+
+    def const_value(self, cid: str) -> dict:
+        """Значение константы §54; ссылка на функцию или параметр A3 через
+        `const_ref` — отдельный отказ: обзор корпуса иначе читал их как
+        «константа не найдена» и обещал дешёвый рычаг, которого нет."""
+        c = self.consts.get(cid)
+        if c is not None and c.get("value") is not None:
+            return c["value"]
+        if cid in self.functions:
+            raise Refused(f"ссылка на функцию или параметр через const_ref вне среза генератора: {cid}")
+        if c is not None:
+            raise Refused(f"константа без значения вне среза генератора: {cid}")
+        raise Refused(f"константа не найдена в CLIR: {cid}")
+
+    def body_const(self, arg: dict, expected: str) -> dict:
+        """Константа в аргументе атома тела: оракул сопоставляет её с ground-
+        атомом по каноническим байтам терма (`solver.solve`), то есть по
+        значению И типу. Рантайм сравнивает `eq` — по значению, поэтому тип
+        литерала обязан совпасть с объявленным типом слота статически: литерал
+        Integer в Decimal-слоте у оракула не совпадает ни с одной строкой, а
+        рантайм по величине ответил бы иначе. Сущности типа не несут, как у
+        оракула. Подстановочный `_` §98 и терм с вычислением — отказ."""
+        k = arg["kind"]
+        if k == "wildcard":
+            raise Refused("подстановочный аргумент `_` §98 вне среза генератора")
+        if k in ("binary", "call", "if", "let", "match"):
+            # DECISION-0270: вычисляемый аргумент требует модели 0.9 — признак
+            # для второго прохода `build_plan`, план строится заново с `term:body`.
+            self._body_term_seen = True
+        if k not in ("value", "entity_ref", "const_ref"):
+            raise Refused(f"терм в аргументе тела вне среза генератора: {k}")
+        if k == "const_ref" and self._is_a3(arg["id"]):
+            # DECISION-0273: голый параметр в атоме — идентичность у оракула (как член
+            # перечисления), не значение; корпус читает параметр вызовом (`round(MRP, …)`).
+            raise Refused("голый `const_ref` параметра A3 в позиции идентичности (голова, аргумент атома) вне среза генератора: у оракула он не вычисляется, читайте вызовом (DECISION-0273)")
+        if k == "const_ref" and self.is_member(arg["id"]):
+            # Член перечисления — идентичность `{namespace}#{Член}` (§38); одно
+            # имя члена бывает у нескольких перечислений пакета, поэтому
+            # проверяется принадлежность слоту, а не «тип члена».
+            if expected not in self.enums or arg["id"] not in self.enums[expected]:
+                raise Refused("тип аргумента тела не совпадает с параметром §189")
+            return self.term(arg, {})
+        actual = self.static_type(arg, {})
+        if actual is not None and (expected in TYPES or expected in self.enums) and actual != expected:
+            raise Refused("тип аргумента тела не совпадает с параметром §189")
+        return self.term(arg, {})
+
+    def parts(self, body: dict, atoms: list, guards: list) -> None:
+        k = body.get("kind")
+        if k == "status":
+            if body.get("status") != "established":
+                raise Refused(f"статусный тест вне L0-среза: {body.get('status')}")
+            atoms.append(body["formula"])
+        elif k == "literal":
+            atoms.append(body)
+        elif k == "comparison":
+            if body["op"] not in CMP:
+                raise Refused(f"сравнение вне среза генератора: {body['op']}")
+            guards.append(body)
+        elif k in ("and", "conjunction"):
+            subs = body.get("items") or body.get("args") or body.get("operands")
+            if not subs:
+                raise Refused("конъюнкция без членов в CLIR")
+            for s in subs:
+                self.parts(s, atoms, guards)
+        else:
+            raise Refused(f"форма тела вне среза генератора: {k}")
+
+    # --- Единицы проверки. `build` останавливается на первом отказе, `survey`
+    # проходит все единицы и собирает КАЖДЫЙ отказ: карта причин по корпусу
+    # нужна для выбора следующего шага среза, а первая причина скрывает
+    # остальные. Внутри одной единицы (правило, факт) отказ по-прежнему первый.
+
+    def _node(self, n: dict) -> None:
+        sig = (n.get("kind"), n.get("symbolKind"))
+        if sig == ("source_edition", None):
+            # Жизненный цикл редакции §31/§92.3 решает, участвует ли
+            # заякоренное правило в вычислении: это НЕ провенанс. План
+            # сворачивает применимость в окно по дате права (`_dating`).
+            return
+        if sig in (("source_publication", None), ("publication", None), ("fragment", None)):
+            # Провенанс §194: закреплённый текст, его хэши и адрес. На
+            # вычисление не влияет ни в одной реализации — как source_work.
+            return
+        if sig == ("norm_template", None) and self.v10:
+            # Шаблон нормы §122 разбирает `_norm_v10` у ссылающегося правила.
+            for f in sorted(set(n) - TEMPLATE_FIELDS):
+                raise Refused(f"поле шаблона нормы вне среза генератора: {f}")
+            return
+        if sig in (("deadline_policy", None), ("calendar_snapshot", None)) and self.v11:
+            # Политика §86 и снимок §85 выбираются делом (DECISION-0245).
+            return
+        if sig == ("closure_policy", None) and self.v09:
+            # Замыкание §70 разбирает `_closure` (DECISION-0239 G4).
+            return
+        if sig == ("external_decl", None) and n.get("effect") == "judgment":
+            # DECISION-0274: носитель органа канала суждения §47.3 — читается
+            # в `judgments` (`queries.judgment_declarations`).
+            for f in sorted(set(n) - EXTERNAL_JUDGMENT_FIELDS):
+                raise Refused(f"поле external_decl канала суждения вне среза генератора: {f}")
+            return
+        if sig == ("priority_rule", None) and self.l1:
+            # Приоритет §106 разбирает `_priority`: в срезе только безусловное
+            # недатированное ребро между правилами (DECISION-0237 F4).
+            return
+        if sig[1] is None and sig[0] in INERT_NODE_KINDS:
+            # Инертное объявление: свидетель — пара векторов манифеста
+            # `inert-nodes.json` (source_work §28, anchor §33, revision §32,
+            # entrenchment §92.3, factor_vocabulary/precedent_decl §201,
+            # counterfactual_decl §186).
+            return
+        if sig not in KNOWN_NODES:
+            raise Refused(f"объявление вне среза генератора: {n.get('kind')}/{n.get('symbolKind')}")
+        if n.get("kind") == "rule":
+            for f in sorted(set(n) - RULE_FIELDS):
+                if f in RULE_EMPTY_OK and not n[f]:
+                    continue
+                if f in INERT_RULE_FIELDS:
+                    # Инертное поле правила (`visibility` §23.2, DECISION-0386):
+                    # свидетель — пара манифеста инертности.
+                    continue
+                if f == "scope" and n[f] == {"kind": "boolean", "value": True}:
+                    continue
+                raise Refused(f"поле правила вне среза генератора: {f}")
+
+    def _index(self) -> list[dict]:
+        ir = self.ir
+        rels = [n for n in ir["nodes"] if n.get("symbolKind") == "relation"]
+        self.root_ns = (ir.get("package") or {}).get("namespace", "")
+        by_id = {n["id"]: n for n in ir["nodes"] if "id" in n}
+        self.editions = {n["id"]: edition_intervals(n) for n in ir["nodes"] if n.get("kind") == "source_edition"}
+        self.frag_edition = {n["id"]: n.get("edition") for n in ir["nodes"] if n.get("kind") == "fragment"}
+        self.by_id = by_id
+        self.entities = {n["id"] for n in ir["nodes"] if n.get("typeKind") == "entity"}
+        self.consts = {n["id"]: {"type": (n.get("returnType") or {}).get("name"),
+                                 "value": n.get("value") if isinstance(n.get("value"), dict) else None}
+                       for n in ir["nodes"] if n.get("symbolKind") in ("constant", "const")}
+        self.functions = {n["id"] for n in ir["nodes"] if n.get("symbolKind") == "function"}
+        # DECISION-0273: тела функций §46 по символу и их объявления.
+        self.fdecls = {n["symbol"]: n for n in ir["nodes"] if n.get("kind") == "function_decl" and n.get("symbol")}
+        self.fsyms = {n["id"]: n for n in ir["nodes"] if n.get("symbolKind") == "function"}
+        # Перечисления §38: член — значение со stable qualified identity
+        # `{namespace}#{Член}`; узла у члена нет, ссылка на него — `const_ref`,
+        # который оракул оставляет в ключе атома как есть (§54: таблица
+        # разыменования знает только объявленные константы).
+        # Пространство имён члена — пакет-владелец перечисления (в мире
+        # импортов узлы разных пакетов лежат рядом; `package` узла — его URN).
+        ns = (ir.get("package") or {}).get("namespace", "")
+        self.enums = {n["id"]: [f"{n.get('package') or ns}#{v}" for v in (n.get("variants") or [])]
+                      for n in ir["nodes"] if n.get("kind") == "type_decl" and n.get("typeKind") == "enum"}
+        self.members = {m: e for e, ms in self.enums.items() for m in ms}
+        # Наследование сущностей (`entity A : B`): константа подтипа
+        # подходит параметру базового типа — как у оракула (`_conforms`).
+        self.bases = {n["id"]: (n.get("base") or {}).get("name") for n in ir["nodes"]
+                      if n.get("kind") == "type_decl" and (n.get("base") or {}).get("name")}
+        self.types = {r["id"]: [(p.get("type") or {}).get("name") for p in r["parameters"]] for r in rels}
+        # §40 (E-0097/E-0098): алиас типа прозрачен на исполнении — как у оракула
+        # (`facts._unalias`: обе стороны сверки §189 берутся за цепочкой алиасов).
+        # Цель алиаса компилятор пишет в форме `имя.пакета#Тип`; вид слота берётся
+        # у объявления пакета мира с ТОЧНО этим именем. Имя без пакета в мире
+        # остаётся строкой цели и уходит в отказ с этим именем (CODEGEN-COVERAGE-PLAN W2).
+        # Нормализуются ТОЛЬКО ссылки на объявленные алиасы: сырые строки
+        # `имя.пакета#Тип` в сигнатурах оракул сравнивает как есть, их не трогает
+        # и `_foreign_type_aliases` ниже.
+        names = {(ir.get("package") or {}).get("name"): ns}
+        names.update({w["name"]: w["namespace"] for w in self.world_passport})
+        self.aliases = {}
+        for n in ir["nodes"]:
+            if n.get("kind") != "type_decl" or n.get("typeKind") != "alias":
+                continue
+            target = (n.get("target") or {}).get("name")
+            if not target:
+                continue
+            if not target.startswith("urn:") and target.count("#") == 1:
+                package, local = target.split("#")
+                if names.get(package):
+                    target = f"{names[package]}#{local}"
+            self.aliases[n["id"]] = target
+        if self.aliases:
+            self.types = {r: [self._t(t) for t in ts] for r, ts in self.types.items()}
+            for c in self.consts.values():
+                c["type"] = self._t(c["type"])
+            self.bases = {k: self._t(v) for k, v in self.bases.items()}
+        # §261: сущности стандартной библиотеки — идентичности, как сущности пакета;
+        # слот `Interval<T>` — непрозрачная идентичность (релиз 0.1.5).
+        self.entities |= STD_ENTITY_TYPES | STD_OPAQUE_SLOT_TYPES
+        self._foreign_type_aliases(ir, rels)
+        self.public = {r["id"] for r in rels if r.get("visibility") == "public"}
+        self.rel_kind = {r["id"]: r.get("relationKind") for r in rels}
+        # DECISION-0274: отношения суждения §47.3 — орган и форма запроса
+        # (`queries.judgment_declarations`): `external_decl` перекрывает
+        # исторический объект `judgment` символа; без обоих орган — сам символ.
+        self.judgments = {}
+        for r in rels:
+            if r.get("relationKind") == "judgment":
+                legacy = r.get("judgment") or {}
+                self.judgments[r["id"]] = {"authority": legacy.get("authority", r["id"])}
+                if legacy.get("requestSchema") is not None:
+                    self.judgments[r["id"]]["requestSchema"] = legacy["requestSchema"]
+        for n in ir["nodes"]:
+            if n.get("kind") == "external_decl" and n.get("effect") == "judgment" and n.get("symbol") in self.judgments:
+                d = self.judgments[n["symbol"]]
+                authority = (n.get("authority") or {}).get("id")
+                if authority:
+                    d["authority"] = authority
+                if "requestType" in n:
+                    d["requestSchema"] = n["requestType"]
+        if self.judgments:
+            influenced = set(self.judgments)
+            dependencies = []
+            for rule in self.ir["nodes"]:
+                if rule.get("kind") != "rule":
+                    continue
+                body = rule.get("body") or {}
+                stack, reads, variables = [body], set(), set()
+                while stack:
+                    part = stack.pop()
+                    if isinstance(part, list): stack.extend(part)
+                    elif isinstance(part, dict):
+                        if part.get("kind") == "literal": reads.add(part.get("predicate"))
+                        if part.get("kind") == "var": variables.add(part["var"])
+                        stack.extend(v for v in part.values() if isinstance(v, (dict, list)))
+                head = rule.get("head") or {}
+                headvars = {a["var"] for a in head.get("args") or [] if a.get("kind") == "var"}
+                dependencies.append((head.get("predicate"), reads, variables - headvars))
+            while True:
+                more = {head for head, reads, _ in dependencies if reads & influenced}
+                if more <= influenced: break
+                influenced |= more
+            if any(hidden and reads & influenced for _, reads, hidden in dependencies):
+                raise Refused("JUDGMENT_WITNESS_UNAVAILABLE: witness-bound backchaining requires E-0189")
+        if self.judgments and "aggregate" in self.caps:
+            raise Refused("AGGREGATE_JUDGMENT_UNAVAILABLE: open aggregate members require E-0357")
+        self.rel_labels = {r["id"]: _labels(r) for r in rels}
+        # Провенанс для комментариев API: фрагмент → локатор и редакция §194.
+        editions = {n["id"]: _labels(n) for n in ir["nodes"] if n.get("kind") == "source_edition"}
+        self.fragments = {n["id"]: {"locator": n.get("locator"),
+                                    "edition": (editions.get(n.get("edition")) or [{}])[0].get("text")}
+                          for n in ir["nodes"] if n.get("kind") == "fragment"}
+        self.rule_nodes = {n["id"]: n for n in ir["nodes"] if n.get("kind") == "rule"}
+        return rels
+
+    def table_name(self, pred: str) -> str:
+        """Имя таблицы в порождённом коде: локальное имя; при коллизии между
+        пакетами мира — с префиксом пространства имён."""
+        if not hasattr(self, "_names"):
+            self._names = {}
+        name = _slug(pred)
+        if self._names.get(name, pred) != pred:
+            name = _slug(pred.split("#")[0]) + "__" + name
+        if self._names.get(name, pred) != pred:
+            # Два отношения с одним именем таблицы и после префикса — иначе
+            # порождённый код молча свёл бы их в одну таблицу.
+            raise Refused(f"совпадающие имена таблиц в мире вне среза генератора: {name}")
+        self._names[name] = pred
+        return name
+
+    def _table(self, r: dict) -> dict:
+        # Тип КАЖДОГО параметра каждого отношения проверяется здесь, а не только
+        # у атомов правил: таблица с параметром вне среза (Rational, Instant,
+        # Date) не может хранить значения дела, и отказ обязан жить в плане, а
+        # не всплывать в раннере одной из целей (T151/T155 до этой проверки).
+        # Объявленные типы уезжают в план: раннер сверяет с ними аргументы
+        # дела по §189/§48 (errata E-0046) так же, как оракул.
+        # §45.1: ключевая проекция. Два различных accepted-кортежа при одной
+        # проекции на ключ — KEY_CONFLICT (§196); evaluator ничего не выбирает
+        # и не удаляет, ответ от этого не меняется. Ключи уезжают в план
+        # как позиции столбцов: раннер считает конфликты после насыщения —
+        # у оракула в счёт идут и утверждения, и strict-выводы.
+        arity = len(r["parameters"])
+        keys = []
+        for key in r.get("keys") or []:
+            if not key or any(not isinstance(i, int) or i < 0 or i >= arity for i in key):
+                raise Refused("ключ отношения §45.1 вне арности")
+            keys.append(list(key))
+        for t in self.types[r["id"]]:
+            self.ts(t)
+        return {"pred": r["id"], "name": self.table_name(r["id"]), "arity": arity,
+                "params": list(self.types[r["id"]]), "keys": keys,
+                "kinds": [self.ts(t) for t in self.types[r["id"]]]}
+
+    def _dating(self, node: dict):
+        """Окна применимости узла по его якорям (§92.3): `None` — узел вне
+        датировки (якорь не разрешается), иначе объединение окон датирующих
+        редакций. Редакция без событий применимости даёт пустое окно (§27.2,
+        errata E-0350): узел, все якоря которого ведут на такие редакции,
+        снят на всей оси. Достаточно одной применимой редакции; граница не
+        дневной гранулярности читается как вне датировки — как у оракула
+        (узел остаётся, предупреждение)."""
+        windows, dated = [], False
+        for anchor in node.get("anchors") or []:
+            target = self.by_id.get(anchor)
+            eid = anchor if target is not None and target.get("kind") == "source_edition" \
+                else self.frag_edition.get(anchor)
+            iv = self.editions.get(eid) if eid else None
+            if iv is None or isinstance(iv, str):
+                return None
+            dated = True
+            windows += iv
+        return _union(windows) if dated else None
+
+    def _rule(self, i: int, rule: dict) -> dict:
+        if rule.get("strength") not in (None, "strict"):
+            raise Refused(f"сила правила вне L0-среза: {rule.get('strength')}")
+        atoms, guards = [], []
+        self.parts(rule["body"], atoms, guards)
+        if not atoms:
+            raise Refused("тело без перебираемых атомов вне среза генератора")
+        binds, joins, filters, plan_atoms = {}, [], [], []
+        self._atoms = atoms
+        for ai, atom in enumerate(atoms):
+            if atom.get("polarity") != "positive":
+                raise Refused("отрицательный литерал в теле вне L0-среза")
+            params = self.types.get(atom["predicate"])
+            if params is None:
+                raise Refused(f"предикат тела не объявлен в пакете: {atom['predicate']}")
+            if len(params) != len(atom["args"]):
+                raise Refused("арность атома тела не совпадает с сигнатурой §189")
+            plan_atoms.append({"pred": atom["predicate"]})
+            for j, arg in enumerate(atom["args"]):
+                t = self.ts(params[j])
+                if self._wild(plan_atoms[-1], arg, j, len(params)):
+                    continue
+                if arg["kind"] != "var":
+                    filters.append({"row": ai, "col": j, "t": t, "term": self.body_const(arg, params[j])})
+                    continue
+                cell = (ai, j, t)
+                prev = binds.get(arg["var"])
+                if prev is None:
+                    binds[arg["var"]] = cell
+                else:
+                    joins.append([list(prev), list(cell)])
+        head = rule["head"]
+        if head.get("polarity") != "positive":
+            raise Refused("отрицательная голова правила вне L0-среза")
+        self.head_types(head, binds)
+        window, dating = self._window(rule)
+        for g in guards:
+            self.guard_enums(g, binds)
+            self.guard_instant(g, binds)
+        out = {
+            "name": f"{i}_{_slug(rule['id'])}", "id": rule["id"], "window": window,
+            "atoms": plan_atoms, "joins": joins, "filters": filters,
+            "guards": [{"op": g["op"], "l": self.term(g["left"], binds), "r": self.term(g["right"], binds)}
+                       for g in guards],
+            "head": {"pred": head["predicate"], "args": [self.term(a, binds) for a in head["args"]]},
+        }
+        self._remember(out, rule, "strict", [("established", a["predicate"], "positive") for a in atoms], dating)
+        return out
+
+    def _wild(self, atom: dict, arg: dict, j: int, arity: int) -> bool:
+        """§98 (E-0165, DECISION-0268): `_` в аргументе положительного литерала
+        тела — существование: позиция совпадает с любым значением, ничего не
+        связывает, и строки, различающиеся только в ней, дают ОДНУ
+        подстановку (`solver.solve`: дедупликация по остальным столбцам).
+        План отмечает у атома столбцы `wild` и `keep`; эмиттер печатает
+        дедупликацию по проекции на `keep`. Свидетель у оракула — наименьший
+        по ключу — влияет только на proof, которого срез не несёт."""
+        if arg.get("kind") != "wildcard":
+            return False
+        self._wildcard_seen = True
+        atom.setdefault("wild", []).append(j)
+        atom["keep"] = [c for c in range(arity) if c not in atom["wild"]]
+        return True
+
+    @staticmethod
+    def _has_wild(lit: dict) -> bool:
+        return any(isinstance(a, dict) and a.get("kind") == "wildcard" for a in lit.get("args") or [])
+
+    def _window(self, rule: dict):
+        """Окно действия §31 правила и окна датирующих редакций §92.3."""
+        eff = rule.get("effective")
+        window = None
+        if eff:
+            if eff.get("axis") != "legal_time":
+                raise Refused(f"ось окна effective вне среза генератора: {eff.get('axis')}")
+            if eff.get("startInclusive") is False or eff.get("endInclusive") is True:
+                raise Refused("полузакрытость окна effective вне среза генератора")
+            window = {"start": eff.get("start"), "end": eff.get("end")}
+        # Редакции §92.3: окно правила — пересечение `effective` с
+        # применимостью датирующих редакций. Несколько окон в одном языке
+        # не выразимы прежним планом — названный отказ; пустое окно — правило
+        # исключено (у оракула — issue `EDITION_NOT_APPLICABLE`, ответ тот же).
+        dating = self._dating(rule)
+        if dating is not None:
+            base = (window or {}).get("start"), (window or {}).get("end")
+            cut = [w for w in (_intersect(base, d) for d in dating) if w is not None]
+            if not cut:
+                raise _Excluded(rule["id"])
+            if len(cut) > 1:
+                raise Refused("прерывистая применимость редакции §92.3 вне среза генератора")
+            window = {"start": cut[0][0], "end": cut[0][1]}
+        return window, dating
+
+    def _remember(self, out: dict, rule: dict, strength: str, reads: list, dating) -> None:
+        """Сведения о правиле для структурного анализа (не входят в план):
+        сила, голова, чтения `(статус, предикат, полярность)` и датировка
+        редакцией — у оракула проекция §92.3 снимает узел до подготовки слоёв."""
+        self._meta[out["name"]] = {
+            "name": out["name"], "id": rule["id"], "strength": strength,
+            "head": out["head"]["pred"], "polarity": out["head"].get("polarity", "positive"),
+            "reads": reads, "dating": dating,
+            "computed": any(a["k"] in ("bin", "call") for a in out["head"]["args"])}
+
+    # --- поражаемый слой L1 (DECISION-0237) ------------------------------------
+
+    def _capabilities(self) -> set:
+        """Возможности, которых требует программа: сила правила §104,
+        отрицательные головы, литералы и факты §99/§113, приоритеты §106,
+        статусные тесты §65 кроме `established`. Пустое множество — L0-план."""
+        caps = set(self.want)
+
+        def walk(f) -> None:
+            if not isinstance(f, dict):
+                return
+            k = f.get("kind")
+            if k == "literal" and f.get("polarity") == "negative":
+                caps.add("negation")
+            if k == "status":
+                if f.get("status") in STATUS_TESTS and f.get("status") != "established":
+                    caps.add(f"status:{f['status']}")
+                walk(f.get("formula"))
+            for s in f.get("items") or f.get("args") or f.get("operands") or []:
+                if isinstance(s, dict) and s.get("kind") in ("literal", "status", "and", "conjunction"):
+                    walk(s)
+
+        for n in self.ir["nodes"]:
+            k = n.get("kind")
+            if k == "rule":
+                if n.get("strength") in ("defeasible", "defeater"):
+                    caps.add("defeasible")
+                if (n.get("head") or {}).get("polarity") == "negative":
+                    caps.add("negation")
+                walk(n.get("body"))
+            elif k == "priority_rule":
+                caps.add("priority")
+            elif k == "closure_policy":
+                caps.add("closure")
+            elif k == "norm_template":
+                caps.add("norm")
+            elif k == "symbol_decl" and n.get("relationKind") == "judgment":
+                # DECISION-0274: объявленное отношение суждения — запрос судье
+                # возможен из любого носителя канала (E-0100), не только тела.
+                caps.add("judgment")
+            if k == "rule" and (n.get("head") or {}).get("kind") == "norm_template_ref":
+                caps.add("norm")
+            elif k == "assertion" and (n.get("literal") or {}).get("polarity") == "negative":
+                caps.add("negation")
+            if k in ("rule", "norm_template"):
+                # DECISION-0245: календарные функции в термах правил и в
+                # границах окон шаблонов позиций.
+                stack = [n.get("body"), n.get("head"), n.get("payload")]
+                while stack:
+                    x = stack.pop()
+                    if isinstance(x, list):
+                        stack.extend(x)
+                    elif isinstance(x, dict):
+                        if x.get("kind") == "call" and x.get("function") in CAL_FNS:
+                            caps |= self._cal_caps(x)
+                        stack.extend(v for v in x.values() if isinstance(v, (dict, list)))
+            if k == "rule":
+                # DECISION-0239: агрегат §59 в теле или голове; генератор его
+                # comprehension несёт свои статусы и отрицания.
+                stack = [n.get("body"), n.get("head")]
+                while stack:
+                    x = stack.pop()
+                    if isinstance(x, list):
+                        stack.extend(x)
+                    elif isinstance(x, dict):
+                        if x.get("kind") == "aggregate":
+                            caps.add("aggregate")
+                            walk((x.get("input") or {}).get("generator"))
+                        stack.extend(v for v in x.values() if isinstance(v, (dict, list)))
+        return caps
+
+    @staticmethod
+    def _cal_caps(node: dict) -> set:
+        """Возможность вызова календарной функции; `add_legal_term` §86.1 —
+        по единице литерала счётчика (иначе отказ плана при разборе терма)."""
+        name, cap = CAL_FNS[node["function"]]
+        if cap is not None:
+            return {cap}
+        args = node.get("args") or []
+        if len(args) > 1 and isinstance(args[1], dict) and args[1].get("kind") != "value":
+            # DECISION-0256 п. 6: единица связывателя известна лишь на деле — обе ветви.
+            return {"calendar:period", "calendar:business"}
+        unit = args[1].get("unit") if len(args) > 1 and isinstance(args[1], dict) else None
+        return {"calendar:business"} if unit in DAY_UNITS else {"calendar:period"}
+
+    def parts_l1(self, body: dict, out: list) -> None:
+        """Тело правила L1 → конъюнкты `(статус, литерал)` и гарды `("guard", …)`."""
+        k = body.get("kind")
+        if k == "status":
+            status = body.get("status")
+            if status not in STATUS_TESTS:
+                # conflicted/opposed оракул не исполняет (`flatten_body`):
+                # правило у него пропускается с NON_EXECUTABLE_RULE.
+                raise Refused(f"статусный тест вне среза генератора: {status}")
+            if (body.get("formula") or {}).get("kind") != "literal":
+                raise Refused("статусный тест над нелитералом вне среза генератора")
+            out.append((status, body["formula"]))
+        elif k == "literal":
+            out.append(("established", body))
+        elif k == "comparison":
+            if body["op"] not in CMP:
+                raise Refused(f"сравнение вне среза генератора: {body['op']}")
+            out.append(("guard", body))
+        elif k in ("and", "conjunction"):
+            subs = body.get("items") or body.get("args") or body.get("operands")
+            if not subs:
+                raise Refused("конъюнкция без членов в CLIR")
+            for s in subs:
+                self.parts_l1(s, out)
+        elif k == "boolean" and body.get("value") is True:
+            return
+        else:
+            raise Refused(f"форма тела вне среза генератора: {k}")
+
+    def _rule_l1(self, i: int, rule: dict) -> dict:
+        """Правило L1: генераторы — положительные `established`/`monotone`
+        литералы в порядке тела; прочие литералы и статусные тесты —
+        проверки над уже связанными переменными (§190: отсутствие не
+        связывает, §113); ground-тело без генератора допускается."""
+        strength = rule.get("strength") or "strict"
+        if strength not in ("strict", "defeasible", "defeater"):
+            raise Refused(f"сила правила вне среза генератора: {strength}")
+        conj: list = []
+        self.parts_l1(rule["body"], conj)
+        gens = [lit for st, lit in conj if st in GENERATING and lit.get("polarity") == "positive"]
+        binds, joins, filters, plan_atoms = {}, [], [], []
+        self._atoms = gens
+        for ai, atom in enumerate(gens):
+            params = self.types.get(atom["predicate"])
+            if params is None:
+                raise Refused(f"предикат тела не объявлен в пакете: {atom['predicate']}")
+            if len(params) != len(atom["args"]):
+                raise Refused("арность атома тела не совпадает с сигнатурой §189")
+            status = next(st for st, lit in conj if lit is atom)
+            plan_atoms.append({"pred": atom["predicate"], "accept": ACCEPT[(status, "positive")]})
+            for j, arg in enumerate(atom["args"]):
+                t = self.ts(params[j])
+                if self._wild(plan_atoms[-1], arg, j, len(params)):
+                    continue
+                if arg["kind"] != "var":
+                    filters.append({"row": ai, "col": j, "t": t, "term": self.body_const(arg, params[j])})
+                    continue
+                cell = (ai, j, t)
+                prev = binds.get(arg["var"])
+                if prev is None:
+                    binds[arg["var"]] = cell
+                else:
+                    joins.append([list(prev), list(cell)])
+        checks, reads = [], []
+        for st, lit in conj:
+            if st == "guard":
+                continue
+            pol = lit.get("polarity")
+            if pol not in ("positive", "negative"):
+                raise Refused("полярность литерала тела вне среза генератора")
+            reads.append((st, lit["predicate"], pol))
+            if any(lit is g for g in gens):
+                continue
+            if self._has_wild(lit):
+                # §98/E-0041: `_` законно только в положительном литерале тела;
+                # под отрицанием и в статусном тесте компилятор его отвергает (LDC-E0207).
+                raise Refused("подстановочный аргумент `_` §98 вне положительного литерала тела вне среза генератора")
+            params = self.types.get(lit["predicate"])
+            if params is None:
+                raise Refused(f"предикат тела не объявлен в пакете: {lit['predicate']}")
+            if len(params) != len(lit["args"]):
+                raise Refused("арность атома тела не совпадает с сигнатурой §189")
+            args = []
+            for j, arg in enumerate(lit["args"]):
+                if arg["kind"] == "var":
+                    if arg["var"] not in binds:
+                        raise Refused(f"переменная без позитивного генератора (§190/§113): {arg['var']}")
+                    args.append(self.term(arg, binds))
+                else:
+                    args.append(self.body_const(arg, params[j]))
+            checks.append({"pred": lit["predicate"], "accept": ACCEPT[(st, pol)], "args": args})
+        head = rule["head"]
+        if (head or {}).get("kind") != "literal":
+            raise Refused(f"голова правила вне среза генератора: {(head or {}).get('kind')}")
+        if head.get("polarity") not in ("positive", "negative"):
+            raise Refused("полярность головы правила вне среза генератора")
+        self.head_types(head, binds)
+        window, dating = self._window(rule)
+        guards = [g for st, g in conj if st == "guard"]
+        for g in guards:
+            self.guard_enums(g, binds)
+            self.guard_instant(g, binds)
+        out = {
+            "name": f"{i}_{_slug(rule['id'])}", "id": rule["id"], "strength": strength, "window": window,
+            "atoms": plan_atoms, "joins": joins, "filters": filters, "checks": checks,
+            "guards": [{"op": g["op"], "l": self.term(g["left"], binds), "r": self.term(g["right"], binds)}
+                       for g in guards],
+            "head": {"pred": head["predicate"], "polarity": head["polarity"],
+                     "args": [self.term(a, binds) for a in head["args"]]},
+            # Идентичность применения (DECISION-0237 п. 8): StableId правила
+            # плюс типизированная подстановка — значения всех переменных тела.
+            "subst": [self.term({"kind": "var", "var": v}, binds) for v in binds],
+        }
+        self._remember(out, rule, strength, reads, dating)
+        return out
+
+    # --- агрегаты §59 и замыкания §70 (DECISION-0239) ---------------------------
+
+    @staticmethod
+    def _free(item, out: list | None = None) -> list:
+        """Свободные переменные терма или формулы в порядке встречи — порт
+        `solver._term_vars`/`_formula_vars` для форм среза: у comprehension
+        свои переменная и связки не свободны."""
+        out = [] if out is None else out
+        if isinstance(item, list):
+            for x in item:
+                Builder._free(x, out)
+            return out
+        if not isinstance(item, dict):
+            return out
+        k = item.get("kind")
+        if k == "var":
+            if item["var"] not in out:
+                out.append(item["var"])
+        elif k == "comprehension":
+            inner = Builder._free([item.get("element"), item.get("generator")])
+            bound = {(item.get("variable") or {}).get("id")}
+            bound |= {b.get("id") for b in item.get("binders") or [] if b.get("id")}
+            for v in inner:
+                if v not in bound and v not in out:
+                    out.append(v)
+        elif k == "aggregate":
+            Builder._free(item.get("input"), out)
+        elif k in ("literal",):
+            Builder._free(item.get("args"), out)
+        elif k == "status":
+            Builder._free(item.get("formula"), out)
+        elif k in ("and", "conjunction"):
+            Builder._free(item.get("items") or item.get("args") or item.get("operands"), out)
+        elif k in ("binary", "comparison"):
+            Builder._free([item.get("left"), item.get("right")], out)
+        elif k == "call":
+            Builder._free(item.get("args"), out)
+        elif k == "if":
+            # §56: переменные условия и ОБЕИХ ветвей (`solver._term_vars`).
+            Builder._free([item.get("condition"), item.get("then"), item.get("else")], out)
+        elif k == "or":
+            Builder._free(item.get("items"), out)
+        elif k == "let":
+            # DECISION-0273: переменная `let` связана в теле.
+            Builder._free(item.get("value"), out)
+            inner = Builder._free(item.get("body"))
+            bound = str((item.get("variable") or {}).get("id"))
+            for v in inner:
+                if v != bound and v not in out:
+                    out.append(v)
+        elif k == "match":
+            Builder._free([item.get("subject")] + [a.get("value") for a in item.get("arms") or []], out)
+        return out
+
+    def _body09(self, formula: dict, outer: dict) -> dict:
+        """Тело правила или генератор comprehension в порядке выбора
+        `solver.solve`: сначала первый полностью связанный конъюнкт (гард или
+        проверка статуса), иначе первый позитивный генератор. От порядка
+        зависит, вычислится ли гард с ошибкой агрегата (DECISION-0239 п. 4)."""
+        conj: list = []
+        self.parts_l1(formula, conj)
+        binds = dict(outer)
+        atoms, joins, filters, checks, guards, steps, reads, gens = [], [], [], [], [], [], [], []
+        saved = self._atoms
+        self._atoms = gens
+        remaining = list(conj)
+        try:
+            while remaining:
+                idx = next((n for n, (_st, it) in enumerate(remaining)
+                            if set(self._free(it)) <= set(binds)), None)
+                if idx is not None and self._has_wild(remaining[idx][1]):
+                    # §98 (DECISION-0268): полностью связанный литерал с `_` у
+                    # оракула — свидетель существования на том же месте; в
+                    # плане это генератор с дедупликацией, все столбцы которого
+                    # соединения либо фильтры, и он берётся на своём шаге.
+                    st, it = remaining[idx]
+                    if st not in GENERATING or it.get("polarity") != "positive":
+                        raise Refused("подстановочный аргумент `_` §98 вне положительного литерала тела вне среза генератора")
+                    remaining.pop(idx)
+                    remaining.insert(0, (st, it))
+                    idx = None
+                if idx is not None:
+                    st, it = remaining.pop(idx)
+                    if st == "guard":
+                        self.guard_enums(it, binds)
+                        self.guard_kinds(it, binds)
+                        self.guard_instant(it, binds)
+                        steps.append({"guard": len(guards)})
+                        guards.append({"op": it["op"], "l": self.term(it["left"], binds),
+                                       "r": self.term(it["right"], binds), "_node": it})
+                        continue
+                    pol = it.get("polarity")
+                    if pol not in ("positive", "negative"):
+                        raise Refused("полярность литерала тела вне среза генератора")
+                    reads.append((st, it["predicate"], pol))
+                    params = self.types.get(it["predicate"])
+                    if params is None:
+                        raise Refused(f"предикат тела не объявлен в пакете: {it['predicate']}")
+                    if len(params) != len(it["args"]):
+                        raise Refused("арность атома тела не совпадает с сигнатурой §189")
+                    args, err = [], False
+                    for j, a in enumerate(it["args"]):
+                        if a["kind"] == "var":
+                            args.append(self.term(a, binds))
+                        elif a["kind"] in ("binary", "call", "if", "let", "match"):
+                            # DECISION-0270: вычисляемый аргумент проверки статуса —
+                            # значение считается до проверки; ошибка значения — issue
+                            # правила по подстановкам, как у гарда (`err`).
+                            f = self._body_arg(0, j, self.ts(params[j]), a, params[j], binds)
+                            err = err or bool(f.get("err"))
+                            args.append(f["term"])
+                        else:
+                            args.append(self.body_const(a, params[j]))
+                    steps.append({"check": len(checks)})
+                    check = {"pred": it["predicate"], "accept": ACCEPT[(st, pol)], "args": args}
+                    if err:
+                        check["err"] = True
+                    checks.append(check)
+                    continue
+                # `solver.solve` (pick): генератор с вычисляемым аргументом
+                # берётся, лишь когда переменные аргумента связаны (E-0180).
+                idx = next((n for n, (st, it) in enumerate(remaining)
+                            if st in GENERATING and it.get("polarity") == "positive"
+                            and all(a.get("kind") in ("var", "wildcard") or set(self._free(a)) <= set(binds)
+                                    for a in it.get("args") or [])), None)
+                if idx is None:
+                    missing = sorted(set(self._free(remaining[0][1])) - set(binds))
+                    raise Refused(f"переменная без позитивного генератора (§190/§113): {', '.join(missing)}")
+                st, atom = remaining.pop(idx)
+                reads.append((st, atom["predicate"], "positive"))
+                params = self.types.get(atom["predicate"])
+                if params is None:
+                    raise Refused(f"предикат тела не объявлен в пакете: {atom['predicate']}")
+                if len(params) != len(atom["args"]):
+                    raise Refused("арность атома тела не совпадает с сигнатурой §189")
+                ai = len(atoms)
+                gens.append(atom)
+                atoms.append({"pred": atom["predicate"], "accept": ACCEPT[(st, "positive")]})
+                steps.append({"gen": ai})
+                for j, arg in enumerate(atom["args"]):
+                    t = self.ts(params[j])
+                    if self._wild(atoms[-1], arg, j, len(params)):
+                        continue
+                    if arg["kind"] != "var":
+                        filters.append(self._body_arg(ai, j, t, arg, params[j], binds))
+                        continue
+                    prev = binds.get(arg["var"])
+                    if prev is None:
+                        binds[arg["var"]] = (ai, j, t)
+                    elif prev[0] == "p":
+                        filters.append({"row": ai, "col": j, "t": t,
+                                        "term": {"k": "param", "i": prev[1], "t": prev[2]}})
+                    else:
+                        joins.append([list(prev), [ai, j, t]])
+        finally:
+            self._atoms = saved
+        return {"atoms": atoms, "joins": joins, "filters": filters, "checks": checks, "guards": guards,
+                "steps": steps, "reads": reads, "binds": binds, "gens": gens}
+
+    def _aggregate(self, node: dict, binds: dict) -> tuple:
+        """Агрегат §59 → подплан comprehension §52.1 с параметрами — внешними
+        переменными. Возвращает (терм, URN вида результата, фоллибелен ли)."""
+        key = id(node)
+        if key in self._agg_cache:
+            return self._agg_cache[key]
+        op = node.get("op")
+        if op not in AGG_OPS:
+            raise Refused(f"агрегат вне среза генератора: {op}")
+        if op == "only" and node.get("options"):
+            # §51 (errata E-0256): у функционального lookup политики нет, и
+            # оракул отвечает на `options` TYPE_ERROR — другой ответ, а не меньший.
+            raise Refused("агрегат only с options вне среза генератора (§51, errata E-0256)")
+        comp = node.get("input") or {}
+        if comp.get("kind") != "comprehension" or "distinct" not in comp:
+            raise Refused("вход агрегата не comprehension §52.1 вне среза генератора")
+        free = self._free(comp)
+        outer, ptypes = {}, []
+        for n, v in enumerate(free):
+            if v not in binds:
+                raise Refused(f"несвязанная переменная в голове: {v}")
+            b = binds[v]
+            if b[0] == "p":
+                urn, t = b[3], b[2]
+            else:
+                urn = self.types[self._atoms[b[0]]["predicate"]][b[1]]
+                t = b[2]
+            outer[v] = ("p", n, t, urn)
+            ptypes.append(t)
+        args = [self.term({"kind": "var", "var": v}, binds) for v in free]
+        body = self._body09(comp["generator"], outer)
+        if not body["atoms"]:
+            raise Refused("comprehension без перебираемых атомов вне среза генератора")
+        if any(f.get("err") for f in body["filters"]) or any(c.get("err") for c in body["checks"]):
+            # DECISION-0270: у подплана агрегата нет кодов по подстановкам (G3 —
+            # ошибка агрегата целиком); ошибка аргумента атома comprehension — отказ.
+            raise Refused("ошибка значения в аргументе атома comprehension вне среза генератора (DECISION-0270)")
+        element = comp.get("element") or {}
+        saved = self._atoms
+        self._atoms = body["gens"]
+        try:
+            if element.get("kind") not in ("var", "value", "entity_ref", "const_ref"):
+                raise Refused("вычисляемый элемент comprehension вне среза генератора (§52.1)")
+            el = self.term(element, body["binds"])
+            kind = self.static_type(element, body["binds"])
+        finally:
+            self._atoms = saved
+        if op != "count" and kind not in NUMERIC:
+            raise Refused(f"агрегат {op} над нечисловым элементом вне среза генератора (§59)")
+        # DECISION-0266: сумма и выбор над Natural у оракула — Integer (`Typed integer`).
+        result = INT if op == "count" else _num(kind)
+        empty = (node.get("options") or {}).get("empty")
+        empty_term = None
+        if empty is not None and op != "count":
+            policy = _num(self.static_type(empty, {}))
+            # errata E-0195: у оракула вид политики сверяется с видом элемента
+            # ПУСТОЙ коллекции, а его несёт ОБЪЯВЛЕННЫЙ тип проекции §52.1
+            # (`values.aggregate_element_type`), а не вид, выведенный планом из
+            # терма элемента: в законной программе они совпадают, в рукописном
+            # CLIR — нет, и там оракул даёт TYPE_ERROR. Сверяются ОБА носителя:
+            # расхождение любого — отказ, потому что ответ у оракула другой,
+            # а не меньший.
+            declared = self._t(((comp.get("variable") or {}).get("type") or {}).get("name"))
+            if policy != result or (declared in EMPTY_KIND_NAMES and policy != _num(declared)):
+                raise Refused("вид empty-политики агрегата не совпадает с видом элемента коллекции "
+                              "(§59, errata E-0195)")
+            empty_term = self.term(empty, {})
+        name = f"agg_{len(self._aggs)}"
+        for g in body["guards"]:
+            g.pop("_node", None)
+        self._aggs.append({"name": name, "op": op, "params": ptypes, "atoms": body["atoms"],
+                           "joins": body["joins"], "filters": body["filters"], "checks": body["checks"],
+                           "guards": body["guards"], "steps": body["steps"], "element": el,
+                           "distinct": bool(comp["distinct"]), "empty": empty_term})
+        # E-0112: перечисление — ребро completion над всеми чтениями генератора.
+        self._agg_reads += [("completion", pred, pol) for _st, pred, pol in body["reads"]]
+        self._agg_inner += body["reads"]
+        out = ({"k": "agg", "fn": name, "args": args, "t": TYPES[result]}, result,
+               op != "count" and empty_term is None)
+        if out[2]:
+            # E-0105: ошибка агрегата правила-кандидата доезжает до статуса
+            # вопроса `truth` — раннеру нужен обход от цели (`backchain`).
+            self._agg_fallible = True
+        self._agg_cache[key] = out
+        return out
+
+    def _monotone_guard(self, g: dict):
+        """Агрегат монотонного гарда E-0116 либо None — порт
+        `rules._monotone_guard_aggregate` с `_monotone_generator`."""
+        op = g.get("op")
+        for agg, threshold, effective in ((g.get("left") or {}, g.get("right") or {}, op),
+                                          (g.get("right") or {}, g.get("left") or {}, MIRROR_OP.get(op))):
+            if agg.get("kind") != "aggregate":
+                continue
+            if effective not in MONOTONE_GUARD_OPS.get(agg.get("op"), ()):
+                return None
+            comp = agg.get("input") or {}
+            if comp.get("kind") != "comprehension" or '"comprehension"' in json.dumps(threshold):
+                return None
+            conj: list = []
+            try:
+                self.parts_l1(comp.get("generator") or {}, conj)
+            except Refused:
+                return None
+            for st, lit in conj:
+                if st == "guard" or st in ("monotone", "supported"):
+                    continue
+                if st != "established" or lit.get("polarity") == "negative" \
+                        or lit.get("predicate") in self._derived:
+                    return None
+            return agg
+        return None
+
+    def _rule_v09(self, i: int, rule: dict) -> dict:
+        """Правило плана 0.9: шаги тела в порядке `solve`, агрегаты подпланами."""
+        strength = rule.get("strength") or "strict"
+        if strength not in ("strict", "defeasible", "defeater"):
+            raise Refused(f"сила правила вне среза генератора: {strength}")
+        body, fallible, addends, first_agg = self._rule_body09(rule)
+        binds = body["binds"]
+        head = rule["head"]
+        if (head or {}).get("kind") != "literal":
+            raise Refused(f"голова правила вне среза генератора: {(head or {}).get('kind')}")
+        if head.get("polarity") not in ("positive", "negative"):
+            raise Refused("полярность головы правила вне среза генератора")
+        saved = self._atoms
+        self._atoms = body["gens"]
+        try:
+            self.head_types(head, binds)
+            kind_checks = self.kind_checks(head, binds) if self.v12 or self.v13 or self.v14 or self.v17 or self.v18 else []
+            head_args = [self.term(a, binds) for a in head["args"]]
+            subst = [self.term({"kind": "var", "var": v}, binds) for v in binds]
+            head_value = (self.v12 or self.v13 or self.v14 or self.v17 or self.v18) and self._fallible_value(head["args"], binds)
+        finally:
+            self._atoms = saved
+        # W5 (errata E-0265): агрегат `sum`/`min`/`max`/`only` без политики `empty`
+        # в голове снимает только свою подстановку — issue одна на (правило, код),
+        # остальные подстановки применяются. До errata ответ оракула зависел от
+        # порядка подстановок, и здесь стоял отказ плана (DECISION-0239 п. 4).
+        head_agg = any(self._agg_cache.get(id(x), (None, None, False))[2] for x in self._walk(head))
+        head_fallible = self._fallible_calendar(head) or head_value or head_agg
+        window, dating = self._window(rule)
+        out = {
+            "name": f"{i}_{_slug(rule['id'])}", "id": rule["id"], "strength": strength, "window": window,
+            "atoms": body["atoms"], "joins": body["joins"], "filters": body["filters"], "checks": body["checks"],
+            "guards": body["guards"], "steps": body["steps"],
+            "head": {"pred": head["predicate"], "polarity": head["polarity"], "args": head_args},
+            "subst": subst, "fallible": fallible, "addends": addends,
+        }
+        if head_fallible:
+            # §175 (errata E-0265): ошибка головы снимает только свою подстановку;
+            # issue — по каждому коду однажды, прошедшие подстановки применяются.
+            out["headFallible"] = True
+        if head_agg:
+            # Ошибка агрегата головы (EMPTY_AGGREGATE, CARDINALITY_CONFLICT) ловится
+            # на подстановке, а не всем правилом, как ошибка гарда (G3).
+            out["headAgg"] = True
+        if kind_checks:
+            # DECISION-0252 п. 5: вид значения в слоте Decimal/Rational — E-0077.
+            out["kindChecks"] = kind_checks
+        self._remember(out, rule, strength, body["reads"] + self._agg_reads, dating)
+        self._meta[out["name"]]["fallible"] = fallible or head_fallible
+        if self._fallible_calendar(head) or any(g.get("cal") for g in body["guards"]):
+            self._meta[out["name"]]["calendar"] = True
+        if head_value or any(g.get("err") for g in body["guards"]) \
+                or any(f.get("err") for f in body["filters"]) or any(c.get("err") for c in body["checks"]):
+            self._meta[out["name"]]["value"] = True
+        # Статусы чтений внутри генераторов: для замыкания важно, читает ли
+        # перечисление негатив (§70/E-0113), а не сам факт перечисления.
+        self._meta[out["name"]]["inner"] = list(self._agg_inner)
+        self._meta[out["name"]]["aggregates"] = [a["name"] for a in self._aggs[first_agg:]]
+        self._meta[out["name"]]["closure_reads"] = self._closure_reads(rule)
+        return out
+
+    def _rule_body09(self, rule: dict) -> tuple:
+        """Тело правила плана 0.9: шаги `solve`, гарды E-0116 и фоллибельность —
+        общее у правил с литеральной головой и у норм-правил (DECISION-0242)."""
+        self._agg_reads = []
+        self._agg_inner = []
+        first_agg = len(self._aggs)
+        body = self._body09(rule["body"], {})
+        addends, fallible = [], False
+        # DECISION-0270: ошибка значения вычисляемого аргумента атома (до перебора
+        # таблицы) либо проверки статуса — та же механика кодов, что у гарда.
+        if any(f.get("err") for f in body["filters"]) or any(c.get("err") for c in body["checks"]):
+            fallible = True
+        for g in body["guards"]:
+            node = g.pop("_node")
+            if self._fallible_calendar(node):
+                # DECISION-0245 п. 6: ошибка календаря в гарде — issue и снятие
+                # правила на проход; коды ловятся по подстановкам.
+                g["cal"] = True
+                fallible = True
+            elif (self.v12 or self.v13 or self.v14 or self.v17 or self.v18) and self._fallible_value(node, body["binds"], body["gens"]):
+                # DECISION-0252 п. 4: ошибка значения §58 в гарде — та же механика.
+                g["err"] = True
+                fallible = True
+            mono = self._monotone_guard(node)
+            if mono is not None:
+                conj: list = []
+                self.parts_l1(mono["input"]["generator"], conj)
+                derived = sorted({lit["predicate"] for st, lit in conj
+                                  if st != "guard" and lit["predicate"] in self._derived})
+                if derived:
+                    raise Refused("монотонный агрегатный гард (E-0116) над выводимым предикатом "
+                                  f"вне среза генератора (DECISION-0239 G2): {', '.join(derived)}")
+                if mono.get("op") == "sum":
+                    # E-0116: знак слагаемых проверяется на исполнении гарда.
+                    addends.append(self._agg_cache[id(mono)][0])
+            for side in (node.get("left") or {}, node.get("right") or {}):
+                stack = [side]
+                while stack:
+                    x = stack.pop()
+                    if isinstance(x, dict):
+                        if x.get("kind") == "aggregate" and id(x) in self._agg_cache and self._agg_cache[id(x)][2]:
+                            fallible = True
+                        stack.extend(v for v in x.values() if isinstance(v, (dict, list)))
+                    elif isinstance(x, list):
+                        stack.extend(x)
+        return body, fallible, addends, first_agg
+
+    def _closure_reads(self, rule: dict) -> list:
+        """Чтения правила для ожидания замыкания §70 (E-0174) —
+        `(статус, предикат, полярность, перечисление)`: порт разбора
+        `rules.closure_waits`. Литералы тела; генераторы монотонного гарда
+        E-0116 — не перечисление; генераторы прочих агрегатов тела и головы —
+        перечисление (`_split_generator_literals`)."""
+        conj: list = []
+        self.parts_l1(rule["body"], conj)
+        reads: list = []
+        for st, item in conj:
+            if st == "guard":
+                mono = self._monotone_guard(item)
+                if mono is not None:
+                    reads += [(s, lit, False) for s, lit in self._generator_literals(mono["input"])]
+                    continue
+            else:
+                reads.append((st, item, False))
+            reads += [(s, lit, True) for s, lit in self._generator_literals(item)]
+        reads += [(s, lit, True) for s, lit in self._generator_literals(rule["head"])]
+        return [(s, lit["predicate"], lit.get("polarity", "positive"), enum) for s, lit, enum in reads]
+
+    def _generator_literals(self, formula) -> list:
+        """Порт `rules._aggregate_generator_literals`: литералы генераторов
+        comprehension со статусом; внутрь генератора обход не спускается."""
+        out: list = []
+        stack = [formula]
+        while stack:
+            x = stack.pop(0)
+            if isinstance(x, list):
+                stack[:0] = x
+            elif isinstance(x, dict):
+                if x.get("kind") == "comprehension":
+                    conj: list = []
+                    self.parts_l1(x.get("generator") or {}, conj)
+                    out += [(st, lit) for st, lit in conj if st != "guard" and lit.get("predicate")]
+                    continue
+                stack[:0] = [v for v in x.values() if isinstance(v, (dict, list))]
+        return out
+
+    @staticmethod
+    def _walk(x):
+        stack = [x]
+        while stack:
+            y = stack.pop()
+            if isinstance(y, dict):
+                yield y
+                stack.extend(v for v in y.values() if isinstance(v, (dict, list)))
+            elif isinstance(y, list):
+                stack.extend(y)
+
+    def _closure(self, n: dict) -> None:
+        """Замыкание §70 (E-0087, E-0104): негатив члену домена без
+        strict/asserted positive-опоры. Неисполнимое у оракула замыкание
+        (`NON_EXECUTABLE_CLOSURE`) — отказ среза."""
+        for f in sorted(set(n) - CLOSURE_FIELDS):
+            raise Refused(f"поле замыкания вне среза генератора: {f}")
+        if not n.get("deriveExplicitNegative"):
+            return          # оракул такое замыкание пропускает молча
+        pred, domain = n.get("predicate"), n.get("domain") or {}
+        width = len(self.types.get(pred) or [])
+        if not width or domain.get("kind") != "const_ref" or domain.get("id") not in self.types \
+                or self.types[domain["id"]] != self.types[pred]:
+            raise Refused(f"замыкание §70 вне среза генератора (NON_EXECUTABLE_CLOSURE): {n.get('id')}")
+        eff = n.get("effective")
+        window = None
+        if eff:
+            if eff.get("axis") != "legal_time":
+                raise Refused(f"ось окна effective вне среза генератора: {eff.get('axis')}")
+            start, end = eff.get("start"), eff.get("end")
+            start = None if start in (None, "-infinity") else start
+            end = None if end in (None, "infinity") else end
+            # E-0087: окно замыкания проверяется `within_effective` с флагами
+            # включения. Граница-день §2.15 переводится в полуинтервал
+            # `[start, end)` сдвигом на следующий день; иная гранулярность — отказ.
+            for bound, inclusive, shift in ((start, eff.get("startInclusive", True), False),
+                                            (end, eff.get("endInclusive", False), True)):
+                if bound is not None and not _is_date(bound) and inclusive is shift:
+                    raise Refused("полузакрытость окна effective вне среза генератора")
+            if start is not None and eff.get("startInclusive") is False:
+                start = _next_day(start)
+            if end is not None and eff.get("endInclusive") is True:
+                end = _next_day(end)
+            window = {"start": start, "end": end}
+        self._closures.append({"name": f"closure_{len(self._closures)}_{_slug(n['id'])}", "id": n["id"],
+                               "pred": pred, "domain": domain["id"], "window": window})
+
+    # --- нормативные позиции L2 (DECISION-0242) ---------------------------------
+
+    def _std_tables(self) -> list:
+        """Таблицы литералов §140, которые публикует жизненный цикл позиций.
+        Позиция — сущность вида `urn:position:…`; шаблон во втором аргументе
+        `instance_of` — `const_ref` (идентичность). Объявленный пакетом
+        std-предикат остаётся объявлением пакета."""
+        out = []
+        self.entities |= {POSITION_TYPE, "urn:law:backend#Template"}
+        for name, arity in STD_POSITION.items():
+            pred = STD + name
+            if pred in self.types:
+                continue
+            params = [POSITION_TYPE] + (["urn:law:backend#Template" if name == "instance_of" else POSITION_TYPE]
+                                        if arity == 2 else [])
+            if name in ("bearer_of", "beneficiary_of"):
+                params[1] = POSITION_TYPE
+            self.types[pred] = params
+            out.append({"pred": pred, "name": self.table_name(pred), "arity": arity, "params": params,
+                        "keys": [], "kinds": ["text"] * arity})
+        return out
+
+    def _deref(self, value):
+        """Разыменование констант §54 в payload шаблона — оракул делает его над
+        программой до исполнения; члены перечислений остаются `const_ref`."""
+        if isinstance(value, list):
+            return [self._deref(v) for v in value]
+        if not isinstance(value, dict):
+            return value
+        if value.get("kind") == "const_ref" and not self.is_member(value.get("id", "")):
+            c = self.consts.get(value.get("id"))
+            if c is not None and c.get("value") is not None:
+                return c["value"]
+        return {k: self._deref(v) for k, v in value.items()}
+
+    def _norm_v10(self, i: int, rule: dict) -> dict:
+        """Норм-правило §135 с шаблоном §122: подстановки тела создают позиции,
+        статус §134 — лестница оракула (`norms._summary_at`), эффект power —
+        `effects.materialize_effects`. Всё, что оракул исполняет иначе или
+        не исполняет, — названный отказ."""
+        strength = rule.get("strength") or "strict"
+        if strength == "defeater":
+            raise Refused("дефитер норм-правила вне среза генератора (DECISION-0242 K6)")
+        if strength not in ("strict", "defeasible"):
+            raise Refused(f"сила правила вне среза генератора: {strength}")
+        tid = (rule.get("head") or {}).get("id")
+        tpl = self.by_id.get(tid)
+        if tpl is None or tpl.get("kind") != "norm_template":
+            raise Refused(f"шаблон нормы не разрешается (§135): {tid}")
+        # §92.3: проекция редакции снимает у оракула шаблон на дату права, и
+        # ссылающееся правило позиций не создаёт (NON_EXECUTABLE_RULE — issue
+        # вне сверки среза). То же даёт окно правила, пересечённое с окнами
+        # шаблона; несколько окон — названный отказ, как у правил.
+        rule_window, _dating = self._window(rule)
+        tdating = self._dating(tpl)
+        if tdating is not None and tdating != [(None, None)]:
+            base = (rule_window or {}).get("start"), (rule_window or {}).get("end")
+            cut = [w for w in (_intersect(base, d) for d in tdating) if w is not None]
+            if not cut:
+                raise _Excluded(rule["id"])
+            if len(cut) > 1:
+                raise Refused("прерывистая применимость редакции §92.3 вне среза генератора")
+            rule_window = {"start": cut[0][0], "end": cut[0][1]}
+        modality = tpl.get("modality")
+        payload = self._deref(tpl.get("payload") or {})
+        if modality not in MODALITIES or payload.get("kind") != modality:
+            raise Refused(f"модальность шаблона вне среза генератора: {modality}")
+        for f in sorted(set(payload) - PAYLOAD_FIELDS[modality]):
+            raise Refused(f"поле payload шаблона вне среза генератора (DECISION-0242 п. 4): {f}")
+        body, fallible, addends, first_agg = self._rule_body09(rule)
+        if any(g.get("cal") for g in body["guards"]):
+            raise Refused("календарная функция с ошибкой значения в теле норм-правила вне среза генератора "
+                          "(DECISION-0245)")
+        if any(g.get("err") for g in body["guards"]):
+            raise Refused("терм с ошибкой значения §58 в теле норм-правила вне среза генератора (DECISION-0252)")
+        binds = body["binds"]
+        free = set(_payload_vars(payload))
+        if not free <= set(binds):
+            raise Refused(f"переменная payload не связана телом норм-правила (DECISION-0242 п. 3): "
+                          f"{', '.join(sorted(free - set(binds)))}")
+        saved = self._atoms
+        self._atoms = body["gens"]
+        reads_extra: list = []
+        try:
+            def literal(node, what):
+                if node is None:
+                    return None
+                if node.get("kind") == "status" and what in ("условие цели", "validWhen"):
+                    if what == "условие цели" and node.get("status") != "established":
+                        raise Refused(f"{what} §124 в форме status:{node.get('status')} вне среза генератора")
+                    node = node.get("formula") or {}
+                if node.get("kind") == "call" and what == "exercise":
+                    node = {"kind": "literal", "polarity": "positive", "predicate": node.get("function"),
+                            "args": node.get("args") or []}
+                if node.get("kind") != "literal" or node.get("polarity") not in ("positive", "negative"):
+                    raise Refused(f"{what} вне среза генератора (DECISION-0242 п. 4): {node.get('kind')}")
+                params = self.types.get(node["predicate"])
+                if params is None or len(params) != len(node.get("args") or []):
+                    raise Refused(f"{what}: предикат не объявлен либо арность не совпадает (§189)")
+                reads_extra.append((what, node["predicate"]))
+                return {"pred": node["predicate"], "polarity": node["polarity"],
+                        "args": [self.term(a, binds) for a in node["args"]]}
+
+            def actor(term):
+                if term is None:
+                    return None
+                k = term.get("kind")
+                if k in ("entity_ref", "const_ref"):
+                    return {"k": "lit", "t": "text" if k == "entity_ref" else "enum", "v": term["id"]}
+                if k == "var":
+                    t = self.term(term, binds)
+                    return t if t["t"] in ("text", "enum") else {"k": "fallback"}
+                return {"k": "fallback"}
+
+            def bound(term):
+                if term is None:
+                    return None
+                if term.get("kind") == "value":
+                    tname = (term.get("type") or {}).get("name")
+                    if tname == "urn:law:std#Text" and term.get("value") in ("infinity", "+infinity", "-infinity"):
+                        return {"k": "inf", "v": term["value"]}
+                    if tname == "urn:law:std#Date":
+                        return {"k": "lit", "t": "date", "v": str(term["value"])}
+                if term.get("kind") == "var":
+                    t = self.term(term, binds)
+                    if t["t"] == "date":
+                        return t
+                if term.get("kind") == "call" and term.get("function") in CAL_FNS:
+                    # DECISION-0245 п. 8: граница — календарный терм над
+                    # переменными тела; ошибка — issue и граница «нет». Не
+                    # Date (`days_between`) — у оракула TYPE_ERROR на каждой
+                    # позиции (`norms._window_bounds`).
+                    compiled = self.term(term, binds)
+                    if self.static_type(term, binds) != "urn:law:std#Date":
+                        return {"k": "calbound", "error": "TYPE_ERROR"}
+                    return {"k": "calbound", "term": compiled}
+                raise Refused("граница окна позиции вне среза генератора (DECISION-0242 п. 2): "
+                              f"{term.get('kind')}")
+
+            def window(w):
+                if w is None:
+                    return None
+                if w.get("kind") != "interval":
+                    raise Refused(f"окно позиции вне среза генератора: {w.get('kind')}")
+                return {"start": bound(w.get("start")), "end": bound(w.get("end")),
+                        "startInclusive": bool(w.get("startInclusive", True)),
+                        "endInclusive": bool(w.get("endInclusive", True))}
+
+            goal = payload.get("goal")
+            goal_kind, condition, goal_window, completeness = None, None, None, []
+            if modality == "duty":
+                if not isinstance(goal, dict) or goal.get("kind") not in ("achievement", "maintenance", "forbearance"):
+                    raise Refused("вид цели §124 вне среза генератора: "
+                                  f"{(goal or {}).get('kind') if isinstance(goal, dict) else goal}")
+                for f in sorted(set(goal) - GOAL_FIELDS):
+                    raise Refused(f"поле цели §124 вне среза генератора: {f}")
+                goal_kind = goal["kind"]
+                goal_window = window(goal.get("window"))
+                if goal_kind == "forbearance":
+                    action = goal.get("action") or {}
+                    if action.get("kind") != "call":
+                        raise Refused("действие цели §124.3 вне среза генератора: требуется вызов отношения")
+                    condition = literal({"kind": "literal", "polarity": "negative",
+                        "predicate": action.get("function"), "args": action.get("args") or []},
+                        "условие цели")
+                else:
+                    if goal.get("condition") is None:
+                        raise Refused("условие цели §124 отсутствует (NON_EXECUTABLE_GOAL)")
+                    condition = literal(goal.get("condition"), "условие цели")
+                if goal_kind in ("maintenance", "forbearance"):
+                    for c in sorted((n for n in self.ir["nodes"] if n.get("kind") == "closure_policy"
+                                     and n.get("deriveExplicitNegative") and n.get("predicate") == condition["pred"]),
+                                    key=lambda n: n["id"]):
+                        dom = (c.get("domain") or {})
+                        if dom.get("kind") == "const_ref" and dom.get("id") in self.types:
+                            completeness.append({"domain": dom["id"],
+                                                 "completeAsOf": str(c.get("completeAsOf", ""))[:10]})
+            elif goal is not None:
+                raise Refused(f"цель у модальности {modality} вне среза генератора")
+            holder_term = payload.get("bearer") if payload.get("bearer") is not None else payload.get("holder")
+            out = {
+                "name": f"{i}_{_slug(rule['id'])}", "id": rule["id"], "strength": strength,
+                "window": rule_window, "template": tid, "modality": modality,
+                "atoms": body["atoms"], "joins": body["joins"], "filters": body["filters"],
+                "checks": body["checks"], "guards": body["guards"], "steps": body["steps"],
+                "fallible": fallible, "addends": addends,
+                "subst": [self.term({"kind": "var", "var": v}, binds) for v in binds],
+                "holder": actor(holder_term),
+                "beneficiary": actor(payload.get("beneficiary")),
+                "goalKind": goal_kind, "condition": condition, "goalWindow": goal_window,
+                "payloadWindow": window(payload.get("window")), "completeness": completeness,
+                "payload": payload,
+                "payloadVars": [{"var": v, "term": self.term({"kind": "var", "var": v}, binds),
+                                 "pred": body["gens"][binds[v][0]]["predicate"], "col": binds[v][1]}
+                                for v in sorted(free)],
+            }
+            if modality == "power":
+                effect = payload.get("effect") or {}
+                if effect.get("kind") != "create" or not isinstance(effect.get("after"), dict):
+                    raise Refused("эффект полномочия §127 вне среза генератора: только create")
+                out.update({"exercise": literal(payload.get("exercise"), "exercise"),
+                            "validWhen": literal(payload.get("validWhen"), "validWhen"),
+                            "effect": literal(effect["after"], "эффект"),
+                            "powerHolder": actor(payload.get("holder"))})
+                if out["exercise"] is None:
+                    raise Refused("exercise полномочия §127 отсутствует")
+            if modality == "immunity":
+                protected = (payload.get("protectedEffect") or {}).get("after")
+                out.update({"protected": literal(protected, "защищённый эффект") if protected else None,
+                            "against": actor(payload.get("against"))})
+        finally:
+            self._atoms = saved
+        self._norm_meta[out["name"]] = {
+            "id": rule["id"], "name": out["name"], "reads": body["reads"] + self._agg_reads,
+            "extra": reads_extra, "modality": modality, "goal": goal_kind, "template": tid,
+            "action": json.dumps((goal or {}).get("action") if modality == "duty" else payload.get("action"),
+                                 sort_keys=True),
+            "condition": (condition or {}).get("pred"),
+            "effect": (out.get("effect") or {}).get("pred"), "aggregates": [a["name"] for a in self._aggs[first_agg:]]}
+        return out
+
+    def _structure10(self, metas: list, strict: list, drules: list, reach: dict) -> dict:
+        """Отказы DECISION-0242: обратная связь L2 (п. 1), конфликт позиций
+        §105.1 (K5); приоритеты норм-правил для power/immunity (п. 5)."""
+        if "urn:law:std#incompatible" in json.dumps(self.ir["nodes"]):
+            raise Refused("конфликт позиций §105.1 (incompatible) вне среза генератора (DECISION-0242 K5)")
+        norms = list(self._norm_meta.values())
+        libs = {n["action"] for n in norms if n["modality"] == "liberty" and n["action"] != "null"}
+        forb = {n["action"] for n in norms if n["goal"] == "forbearance" and n["action"] != "null"}
+        if libs & forb:
+            raise Refused("конфликт позиций §105.1 (forbearance/liberty) вне среза генератора (DECISION-0242 K5)")
+        keyed = sorted({n["condition"] for n in norms if n["goal"] in ("achievement", "maintenance")
+                        and n["condition"] and (self.by_id.get(n["condition"]) or {}).get("keys")})
+        if keyed:
+            raise Refused("конфликт позиций §105.1 по ключу §45.1 вне среза генератора "
+                          f"(DECISION-0242 K5, POSSIBLE_NORM_CONFLICT): {', '.join(keyed)}")
+        # п. 1: выходы L2 и их strict-следствия.
+        out = {STD + s for s in STD_POSITION} | {n["effect"] for n in norms if n["effect"]}
+        changed = True
+        while changed:
+            changed = False
+            for m in strict:
+                if m["head"] not in out and any(pred in out for _st, pred, _p in m["reads"]):
+                    out.add(m["head"])
+                    changed = True
+        for n in norms:
+            hit = sorted({pred for _st, pred, _p in n["reads"] if pred in out}
+                         # Эффект и защищённый эффект — образцы, а не чтения хранилища.
+                         | {pred for _w, pred in n["extra"] if pred in out and _w not in ("эффект", "защищённый эффект")})
+            if hit:
+                raise Refused(f"{NORM_REFUSAL}: норм-правило {n['id']} читает {', '.join(hit)}")
+        for m in drules:
+            if m["head"] in out or any(pred in out for _st, pred, _p in m["reads"]):
+                raise Refused(f"{NORM_REFUSAL}: поражаемое правило {m['id']} над выходом L2")
+        for c in self._closures:
+            if c["pred"] in out or c["domain"] in out:
+                raise Refused(f"{NORM_REFUSAL}: замыкание {c['id']} над выходом L2")
+        negative_heads = {m["head"] for m in strict if m["polarity"] == "negative"}
+        for m in strict:
+            for st, pred, pol in m["reads"] + m.get("inner", []):
+                if pred not in out:
+                    continue
+                if st not in ("established", "monotone", "supported") or pol == "negative" \
+                        or (st == "established" and pred in negative_heads):
+                    raise Refused(f"{NORM_REFUSAL}: strict-правило {m['id']} читает {st} {pred} "
+                                  "до исполнения L2")
+        names = {n["id"]: n["name"] for n in norms}
+        return {"normPriorities": sorted([names[a], names[b]] for a in reach for b in reach[a]
+                                         if a in names and b in names)}
+
+    def _priority(self, n: dict) -> None:
+        """Приоритет §106 в срезе: безусловное (`condition == true`)
+        недатированное ребро между правилами. Условный §117/§118,
+        датированный редакцией и неизвестные поля — названный отказ."""
+        if n.get("condition") not in (None, TRUE_FORMULA) or n.get("priorityKind") not in (None, "direct"):
+            raise Refused(f"условный приоритет (§117/§118) вне среза генератора: {n.get('id')}")
+        for f in sorted(set(n) - PRIORITY_FIELDS):
+            raise Refused(f"поле приоритета вне среза генератора: {f}")
+        higher, lower = n.get("higher") or {}, n.get("lower") or {}
+        if higher.get("kind") != "const_ref" or lower.get("kind") != "const_ref":
+            raise Refused(f"сторона приоритета не правило (§106) вне среза генератора: {n.get('id')}")
+        dating = self._dating(n)
+        window = None
+        if dating is not None and dating != [(None, None)]:
+            if not dating:
+                return          # §92.3: узел снят проекцией на всей оси
+            if len(dating) != 1:
+                # DECISION-0269 п. 3: прерывистое окно исходного ребра — отказ первого среза.
+                raise Refused(f"прерывистое окно приоритета (§92.3) вне среза генератора: {n.get('id')}")
+            self._dated_prio_seen = True
+            window = dating[0]
+        self._prio.append((higher["id"], lower["id"], n["id"], window))
+
+    def _fact_l1(self, a: dict) -> dict:
+        lit = a.get("literal") or {}
+        pol = lit.get("polarity")
+        if pol not in ("positive", "negative"):
+            raise Refused("полярность собственного факта вне среза генератора")
+        dating = self._dating(a)
+        if dating is not None and dating != [(None, None)]:
+            if not dating:
+                raise _Excluded(a["id"])
+            if len(dating) > 1:
+                raise Refused("прерывистая применимость редакции §92.3 вне среза генератора")
+            self.dated_facts.append({
+                "name": f"dated_{len(self.dated_facts)}_{_slug(a['id'])}", "id": a["id"], "strength": "strict",
+                "window": {"start": dating[0][0], "end": dating[0][1]},
+                "atoms": [{"pred": ALWAYS, "accept": ["TRUE_ONLY"]}], "joins": [], "filters": [], "checks": [],
+                "guards": [], "subst": [],
+                "head": {"pred": lit["predicate"], "polarity": pol, "args": [self.term(x, {}) for x in lit["args"]]}})
+            raise _Excluded(None)
+        return {"pred": lit["predicate"], "polarity": pol, "args": [self.term(x, {}) for x in lit["args"]]}
+
+    def _structure(self, rules: list) -> dict:
+        """Структурный анализ программы: циклы §110, завершимость, а у L1 —
+        барьер полноты §110 п. 5, приоритеты §106, ранги обоих слоёв, поздние
+        производители §111 и расписание фаз. Всё за срезом — названный отказ."""
+        metas = sorted((self._meta[r["name"]] for r in rules if r["name"] in self._meta),
+                       key=lambda m: m["id"])
+        # §110 п. 1–2: цикл допускает только монотонные рёбра. Единственное
+        # поражаемое правило, читающее свою голову, — тоже цикл: до errata
+        # E-0173 оракул исполнял его одним проходом, теперь оба оценщика
+        # отвечают NON_EXECUTABLE_UNSTRATIFIED, и срез отказывает с ними.
+        edges = []
+        for m in metas:
+            for st, pred, _pol in m["reads"]:
+                if st == "completion":
+                    kind = "completion"
+                elif st in ("not_known", "unknown"):
+                    kind = "default"
+                elif m["strength"] != "strict":
+                    kind = "defeasible"
+                elif st in ("monotone", "supported"):
+                    kind = "monotone"
+                else:
+                    kind = "status"
+                edges.append((m["head"], pred, kind))
+        # E-0113: замыкание — вершина `producers(P ∪ domain) → closure(P) →
+        # readers(¬P)`; все его рёбра немонотонны.
+        closed: dict = {}
+        for c in self._closures:
+            closed.setdefault(c["pred"], []).append(c)
+            edges += [(c["id"], c["pred"], "closure"), (c["id"], c["domain"], "closure")]
+        for m in metas:
+            for st, pred, pol in m["reads"] + m.get("inner", []):
+                if pred in closed and st != "completion" and (pol == "negative" or st in ("refuted", "not_known", "unknown")):
+                    edges += [(m["head"], c["id"], "closure") for c in closed[pred]]
+        # §47.3 (DECISION-0274): чтение отношения суждения — обычное чтение
+        # таблицы; запрос судье строит обход раннера по `backchain`.
+        comp = _sccs(sorted({e[0] for e in edges} | {e[1] for e in edges}), [(a, b) for a, b, _ in edges])
+        for a, b, kind in edges:
+            if kind != "monotone" and comp[a] == comp[b]:
+                raise Refused(f"{UNSTRATIFIED}: цикл через {a} → {b} с ребром [{kind}]")
+        # DECISION-0237 п. 11: рекурсия, порождающая значения арифметикой, не
+        # обязана завершиться, а частичный результат не выдаётся как ответ.
+        for m in metas:
+            if m["computed"] and any(comp.get(m["head"]) == comp.get(pred) for _st, pred, _p in m["reads"]):
+                raise Refused(f"рекурсия с порождением значений арифметикой (DECISION-0237 п. 11) "
+                              f"вне среза генератора: {m['head']}")
+        if not self.l1:
+            return {}
+        strict =[m for m in metas if m["strength"] == "strict"]
+        drules = [m for m in metas if m["strength"] != "strict"]
+        # §110 п. 5, §107.3: дефитер действует только при обычном кандидате
+        # той же головы и полярности; у оракула набор узлов проецирован на
+        # дату права §92.3, поэтому окна производителей обязаны покрыть окно
+        # дефитера — иначе в непокрытую дату оракул гасит документ.
+        # Считается по узлам CLIR, а не по скомпилированным правилам: обзор
+        # продолжает после отказа правила, и производитель, отвергнутый своей
+        # причиной, иначе делал бы дефитер «сиротой».
+        heads = []
+        for n in self.ir["nodes"]:
+            head = n.get("head") or {}
+            if n.get("kind") != "rule" or n.get("strength") not in ("defeasible", "defeater") \
+                    or head.get("kind") != "literal":
+                continue
+            dating = self._dating(n)
+            if dating == []:
+                continue        # §92.3: узел снят проекцией на всей оси
+            heads.append({"id": n["id"], "strength": n["strength"], "head": head.get("predicate"),
+                          "polarity": head.get("polarity"),
+                          "dating": None if dating == [(None, None)] else dating})
+        for d in heads:
+            if d["strength"] != "defeater":
+                continue
+            prods = [m for m in heads if m["strength"] == "defeasible"
+                     and (m["head"], m["polarity"]) == (d["head"], d["polarity"])]
+            outer = None if any(m["dating"] is None for m in prods) else [w for m in prods for w in m["dating"]]
+            if not prods or not _covered(d["dating"], outer):
+                raise Refused("дефитер без обычного кандидата той же полярности "
+                              f"(§110 п. 5, NON_EXECUTABLE_STRATUM_BARRIER): {d['id']}")
+        # §106: транзитивное замыкание безусловных рёбер; цикл — отказ среза
+        # (у оракула PRIORITY_CONFLICT группы, DECISION-0237 п. 13).
+        # DECISION-0269: у оракула проекция §92.3 сначала снимает неприменимые
+        # узлы приоритета, потом строится замыкание (`editions.project_editions`,
+        # `defeasible._priority_closure`), поэтому окно ребра участвует в
+        # замыкании: по отрезкам оси между границами окон — пересечение вдоль
+        # пути, объединение между путями; цикл на отрезке — отказ.
+        pairs = self._priority_windows()
+        reach: dict = {}
+        for (a, b), ws in pairs.items():
+            if ws == [(None, None)]:
+                reach.setdefault(a, set()).add(b)
+        dnames = {m["id"]: m["name"] for m in drules}
+        priorities = sorted([dnames[a], dnames[b]] for a in reach for b in reach[a]
+                            if a in dnames and b in dnames)
+        dated_priorities = sorted([dnames[a], dnames[b], [list(w) for w in ws]]
+                                  for (a, b), ws in pairs.items()
+                                  if ws != [(None, None)] and a in dnames and b in dnames)
+        srank = self._strict_ranks(strict)
+        drank = self._defeasible_ranks(drules)
+        late = self._late(strict, drules, drank)
+        levels_09, wait_level = (self._structure09(metas, strict, drules, srank, late, closed, edges)
+                                 if self.v09 else ([], {}))
+        strict_strata = [[m["name"] for m in strict if srank[m["id"]] == k]
+                         for k in sorted(set(srank.values()))]
+        if self.dated_facts:
+            # Датированный факт у оракула — вход, а не правило: его голова
+            # полна до любого вывода, поэтому страта печатается первой.
+            strict_strata.insert(0, [r["name"] for r in self.dated_facts])
+        levels = sorted(set(drank.values()))
+        dstrata = [[m["name"] for m in drules if drank[m["id"]] == k] for k in levels]
+
+        def strict_phase(done: int) -> dict:
+            # E-0174: `waiting` — правила, чьи замыкания ещё не пройдены после
+            # `done` уровней; strict-проход их не исполняет. Поле печатается
+            # только непустым: у прочих планов расписание байтово прежнее.
+            waiting = sorted(name for name, k in wait_level.items() if k > done)
+            return {"phase": "strict", "waiting": waiting} if waiting else {"phase": "strict"}
+
+        schedule = [strict_phase(0)]
+        if levels_09:
+            for done, names in enumerate(levels_09, start=1):
+                schedule += [{"phase": "closure", "policies": names}, strict_phase(done)]
+        else:
+            schedule.append({"phase": "closure", "policies": []})
+        for k, names in zip(levels, dstrata):
+            schedule += [{"phase": "candidates", "stratum": k, "rules": names},
+                         {"phase": "defeat", "stratum": k},
+                         {"phase": "surviving", "stratum": k},
+                         {"phase": "strict"},
+                         {"phase": "status", "stratum": k}]
+        result = {"strata": {"strict": [s for s in strict_strata if s], "defeasible": dstrata},
+                  "priorities": priorities, "schedule": schedule}
+        if self.v16:
+            result["datedPriorities"] = dated_priorities
+        if self.v10:
+            # DECISION-0242 K3: один проход L2 после поражаемого слоя —
+            # позиции §135, эффекты полномочий §127, strict-замыкание.
+            result.update(self._structure10(metas, strict, drules, reach))
+            if self.v16:
+                names = {n["id"]: n["name"] for n in self._norm_meta.values()}
+                result["datedNormPriorities"] = sorted(
+                    [names[a], names[b], [list(w) for w in ws]] for (a, b), ws in pairs.items()
+                    if ws != [(None, None)] and a in names and b in names)
+            schedule += [{"phase": "norms"}, {"phase": "effects"}, {"phase": "strict"}]
+        return result
+
+    def _priority_windows(self) -> dict:
+        """Транзитивное замыкание приоритетов §106 с окнами §92.3
+        (DECISION-0269): пара «выше, ниже» → объединение окон `[start, end)`,
+        на которых она достижима; `[(None, None)]` — вся ось (недатированная
+        пара, как прежде). Отрезки оси — между границами окон датированных
+        рёбер; на каждом отрезке замыкание Уоршелла по активным рёбрам, цикл
+        на отрезке — названный отказ (у оракула PRIORITY_CONFLICT на дату)."""
+        edges = [(hi, lo, w) for hi, lo, _pid, w in self._prio]
+        bounds = sorted({b for _hi, _lo, w in edges if w is not None for b in w if b is not None})
+        segments = []
+        prev = None
+        for b in bounds:
+            segments.append((prev, b))
+            prev = b
+        segments.append((prev, None))
+        pairs: dict = {}
+        for seg in segments:
+            active = [(hi, lo) for hi, lo, w in edges if w is None or _contains(w, seg)]
+            reach: dict = {}
+            for hi, lo in active:
+                reach.setdefault(hi, set()).add(lo)
+            changed = True
+            while changed:
+                changed = False
+                for a in sorted(reach):
+                    for b in sorted(reach[a]):
+                        extra = reach.get(b, set()) - reach[a]
+                        if extra:
+                            reach[a] |= extra
+                            changed = True
+            cyc = sorted(a for a in reach if a in reach[a])
+            if cyc:
+                if seg == (None, None):
+                    raise Refused(f"цикл приоритетов (§106, PRIORITY_CONFLICT) вне среза генератора: {', '.join(cyc)}")
+                raise Refused("цикл приоритетов (§106, PRIORITY_CONFLICT) на отрезке "
+                              f"[{seg[0] or '-∞'}, {seg[1] or '∞'}) вне среза генератора (DECISION-0269): {', '.join(cyc)}")
+            for a in reach:
+                for b in reach[a]:
+                    pairs.setdefault((a, b), []).append(seg)
+        return {pair: _union(segs) for pair, segs in pairs.items()}
+
+    def _structure09(self, metas, strict, drules, srank, late, closed, edges) -> list:
+        """Структура плана 0.9: отказы DECISION-0239 и уровни замыканий E-0113."""
+        dp = {m["head"] for m in drules}
+        # п. 8 (G5): замыкание над предикатом или доменом, чей производитель
+        # поражаем либо поздний через строгую цепочку, — отказ: оракул
+        # материализует замыкания до поражаемого слоя, проза §70 — после
+        # производителей.
+        for c in self._closures:
+            for pred in (c["pred"], c["domain"]):
+                if pred in dp or late.get(pred):
+                    raise Refused(f"замыкание §70 над поражаемым производителем вне среза генератора "
+                                  f"(DECISION-0239 G5): {c['id']}")
+        # п. 7 (errata E-0174): strict-читатель, чей тест опровергается
+        # негативом замыкания, ждёт замыкание — подъём над вершиной, а не отказ.
+        waits = _closure_waits(strict, closed)
+        # п. 4: фоллибельный гард strict-правила обязан читать только
+        # завершённое ниже его страты — иначе момент ошибки зависел бы от хода
+        # фикспойнта.
+        producers: dict = {}
+        for m in strict:
+            producers.setdefault(m["head"], []).append(m)
+        for m in strict:
+            if not m.get("fallible"):
+                continue
+            cal = m.get("calendar")
+            value = m.get("value")
+            for _st, pred, _pol in m["reads"]:
+                if pred in dp or late.get(pred) or pred in closed or any(
+                        srank[p["id"]] >= srank[m["id"]] for p in producers.get(pred, [])
+                        if p["id"] != m["id"] or cal or value):
+                    if cal:
+                        raise Refused("календарная функция с ошибкой значения над незавершённым входом вне "
+                                      f"среза генератора (DECISION-0245 п. 7): {m['id']} читает {pred}")
+                    if value:
+                        # DECISION-0252 п. 4: момент ошибки значения зависел бы от хода
+                        # фикспойнта — правило ошибку не ловит, и она становится
+                        # названным отказом раннера, а не issue и не отказом плана.
+                        self._value_refuse.add(m["name"])
+                        break
+                    raise Refused("агрегат с ошибкой значения над незавершённым входом вне среза генератора "
+                                  f"(DECISION-0239 п. 4): {m['id']} читает {pred}")
+        if not self._closures:
+            return [], {}
+        # E-0113: уровень замыкания — на единицу выше уровней замыканий,
+        # достижимых из его вершины по зависимостям.
+        adj: dict = {}
+        for a, b, _k in edges:
+            adj.setdefault(a, set()).add(b)
+        ids = [c["id"] for c in self._closures]
+        deps = {}
+        for cid in ids:
+            seen, stack = {cid}, [cid]
+            while stack:
+                for nxt in adj.get(stack.pop(), ()):
+                    if nxt not in seen:
+                        seen.add(nxt)
+                        stack.append(nxt)
+            deps[cid] = [o for o in ids if o != cid and o in seen]
+        level: dict = {}
+        for _ in range(len(ids) + 1):
+            changed = False
+            for cid in ids:
+                need = 1 + max((level.get(o, 1) for o in deps[cid]), default=0)
+                if need > level.get(cid, 0):
+                    level[cid] = need
+                    changed = True
+            if not changed:
+                break
+        else:
+            raise Refused(f"{UNSTRATIFIED}: цикл между замыканиями")
+        groups = [[c["name"] for c in sorted(self._closures, key=lambda c: c["id"]) if level[c["id"]] == k]
+                  for k in sorted(set(level.values()))]
+        # Ждущее правило исполняется в strict-проходе после уровня своего
+        # старшего замыкания: замыкания материализуются по уровням.
+        ranks = sorted(set(level.values()))
+        wait_level = {m["name"]: 1 + ranks.index(max(level[c] for c in waits[m["id"]]))
+                      for m in strict if waits.get(m["id"])}
+        return groups, wait_level
+
+    def _strict_ranks(self, strict: list) -> dict:
+        """Порт `strict.strict_ranks`: ранги §110 строгого слоя (DECISION-0088)."""
+        rank = {m["id"]: 0 for m in strict}
+        heads = {m["head"] for m in strict}
+        needs = any(m["polarity"] == "negative" or any(st in ("not_known", "unknown", "refuted")
+                                                       or (st == "completion" and p in heads)
+                                                       for st, p, _q in m["reads"]) for m in strict)
+        if not needs:
+            return rank
+        producers: dict = {}
+        for m in strict:
+            producers.setdefault(m["head"], []).append(m["id"])
+        for _ in range(len(strict) + 1):
+            changed = False
+            for m in strict:
+                need = 0
+                for st, pred, _pol in m["reads"]:
+                    bump = 0 if st in ("supported", "monotone") else 1
+                    for pid in producers.get(pred, []):
+                        if pid != m["id"]:
+                            need = max(need, rank[pid] + bump)
+                if need > rank[m["id"]]:
+                    rank[m["id"]] = need
+                    changed = True
+            head_max: dict = {}
+            for m in strict:
+                head_max[m["head"]] = max(head_max.get(m["head"], 0), rank[m["id"]])
+            for m in strict:
+                if head_max[m["head"]] > rank[m["id"]]:
+                    rank[m["id"]] = head_max[m["head"]]
+                    changed = True
+            if not changed:
+                return rank
+        raise Refused(f"{UNSTRATIFIED}: ранги строгого слоя не сходятся")
+
+    def _defeasible_ranks(self, drules: list) -> dict:
+        """Порт `defeasible.stratify`: ранг §110 поражаемого правила — глубина
+        через поражаемые головы; правила одной головы обеих полярностей и
+        дефитеры — в одной страте (E-0078/E-0080)."""
+        heads: dict = {}
+        for m in drules:
+            heads.setdefault(m["head"], []).append(m)
+        rank = {m["id"]: 0 for m in drules}
+        for _ in range(len(drules) + 1):
+            changed = False
+            for m in drules:
+                deps = [(pred, 1) for _st, pred, _pol in m["reads"]]
+                if m["strength"] == "defeater":
+                    deps.append((m["head"], 1))
+                need = 0
+                for pred, bump in deps:
+                    same = m["strength"] == "defeater" and pred == m["head"]
+                    for p in heads.get(pred, []):
+                        if p["id"] != m["id"]:
+                            need = max(need, rank[p["id"]] + (0 if same else bump))
+                if need > rank[m["id"]]:
+                    rank[m["id"]] = need
+                    changed = True
+            head_max: dict = {}
+            for m in drules:
+                head_max[m["head"]] = max(head_max.get(m["head"], 0), rank[m["id"]])
+            for m in drules:
+                if head_max[m["head"]] > rank[m["id"]]:
+                    rank[m["id"]] = head_max[m["head"]]
+                    changed = True
+            if not changed:
+                return rank
+        raise Refused(f"{UNSTRATIFIED}: цикл через поражаемые зависимости")
+
+    def _late(self, strict: list, drules: list, drank: dict) -> None:
+        """Поздние производители §111 (LDC-E4103). Strict-замыкание повторяется
+        после каждой поражаемой страты, поэтому предикат со строгим
+        производителем, читающим поражаемый вывод, полон только после страты
+        этого вывода. С errata E-0172 оба оценщика поднимают поражаемого
+        читателя цепочки рангом, а строгого status-sensitive читателя
+        пропускают (lawc — E4103); срез печатает страты без этого подъёма и
+        потому по-прежнему отказывает — снятие отказа есть расширение среза."""
+        dp = {m["head"] for m in drules}
+        level = {}
+        for m in drules:
+            level[m["head"]] = max(level.get(m["head"], 0), drank[m["id"]])
+        late: dict = {m["head"]: set() for m in strict}
+        per_rule: dict = {}
+        changed = True
+        while changed:
+            changed = False
+            for m in strict:
+                acc = set()
+                for _st, pred, _pol in m["reads"]:
+                    if pred in dp:
+                        acc.add(pred)
+                    acc |= late.get(pred, set())
+                per_rule[m["id"]] = acc
+                if not acc <= late[m["head"]]:
+                    late[m["head"]] |= acc
+                    changed = True
+        for m in strict:
+            for st, pred, pol in m["reads"]:
+                if st in ("monotone", "supported"):
+                    continue
+                if pred in dp:
+                    raise Refused(f"{LATE}: strict-правило {m['id']} читает {st} {pred} "
+                                  "с поражаемым производителем")
+                if not late.get(pred):
+                    continue
+                opposite = [s for s in strict if s["head"] == pred and s["polarity"] != pol and per_rule[s["id"]]]
+                if st != "established" or opposite:
+                    raise Refused(f"{LATE}: strict-правило {m['id']} читает {st} {pred}, "
+                                  "производимый строгой цепочкой над поражаемым выводом")
+        for m in drules:
+            for pred in [p for _st, p, _pol in m["reads"]] + [m["head"]]:
+                if late.get(pred) and max(level[q] for q in late[pred]) >= drank[m["id"]]:
+                    raise Refused(f"{LATE}: правило {m['id']} страты {drank[m['id']]} читает {pred}, "
+                                  "полный лишь после страты своего поражаемого источника")
+        return {pred: qs | ({pred} if pred in dp else set()) for pred, qs in late.items()} | \
+            {pred: {pred} for pred in dp if pred not in late}
+
+    def _api(self, rels: list, rules: list) -> dict:
+        """Поверхность API §api (DECISION-0234): вопросы и входы модуля.
+
+        Правила те же, что у `@arxo/law-forms`, и пакет их не объявляет:
+        ВОПРОС — `pub`-отношение, у которого есть производящее правило,
+        читающее в теле ДРУГОЙ предикат (самозамыкание вроде симметрии
+        вопросом не делает); ВХОД — предикат, достижимый из вопросов по
+        телам правил и либо эмпирический, либо без производителя. Печатается
+        только это; остальные отношения остаются таблицами модели."""
+        # DECISION-0237 п. 9: дефитер опоры не создаёт и производителем
+        # вопроса не становится, но его входы и входы отрицательных и
+        # статусных чтений (`checks`) — входы вопроса.
+        producers: dict = {}
+        reads: dict = {}
+        for r in rules:
+            body = {a["pred"] for a in r["atoms"]} | {c["pred"] for c in r.get("checks", [])}
+            if self.v09 and r["name"] in self._meta:
+                # DECISION-0239: входы генераторов агрегатов — входы вопроса.
+                body |= {pred for _st, pred, _pol in self._meta[r["name"]]["reads"]}
+            reads.setdefault(r["head"]["pred"], set()).update(body)
+            if r.get("strength") != "defeater":
+                producers.setdefault(r["head"]["pred"], set()).update(body)
+        questions = sorted(p for p in self.public
+                           if (self.by_id.get(p) or {}).get("package", self.root_ns) == self.root_ns
+                           and any(q != p for q in producers.get(p, ())))
+        reach: set = set()
+        stack = list(questions)
+        while stack:
+            p = stack.pop()
+            for q in reads.get(p, ()):
+                if q not in reach:
+                    reach.add(q)
+                    stack.append(q)
+        inputs = sorted(p for p in reach
+                        if p != ALWAYS and (p not in producers or self.rel_kind.get(p) == "empirical"))
+        names: dict = {}
+
+        def unique(pred: str) -> str:
+            base = _api_slug(pred)
+            name, n = base, 1
+            while name in names and names[name] != pred:
+                n += 1
+                name = f"{base}_{n}"
+            names[name] = pred
+            return name
+
+        # Источники вопроса: производящие правила с их метками и якорями
+        # §194 — то, что печатается комментарием над функцией.
+        by_head: dict = {}
+        for r in rules:
+            if r.get("strength") != "defeater":
+                by_head.setdefault(r["head"]["pred"], []).append(r["id"])
+
+        def sources(pred: str) -> list:
+            out = []
+            for rid in by_head.get(pred, []):
+                node = self.rule_nodes.get(rid, {})
+                anchors = [dict(self.fragments.get(a) or {"locator": None, "edition": None}, id=a)
+                           for a in (node.get("anchors") or [])]
+                out.append({"rule": _slug(rid), "labels": _labels(node), "anchors": anchors})
+            return out
+
+        return {"questions": [{"pred": p, "name": unique(p), "params": list(self.types[p]),
+                               "kinds": [self.ts(t) for t in self.types[p]],
+                               "labels": self.rel_labels.get(p, []),
+                               "inputs": sorted(q for q in inputs if q in self._deps(p, reads)),
+                               "sources": sources(p)}
+                              for p in questions],
+                "inputs": [{"pred": p, "name": unique(p), "params": list(self.types[p]),
+                            "kinds": [self.ts(t) for t in self.types[p]],
+                            "labels": self.rel_labels.get(p, [])} for p in inputs]}
+
+    @staticmethod
+    def _deps(pred: str, producers: dict) -> set:
+        out: set = set()
+        stack = [pred]
+        while stack:
+            p = stack.pop()
+            for q in producers.get(p, ()):
+                if q not in out:
+                    out.add(q)
+                    stack.append(q)
+        return out
+
+    def _fact(self, a: dict) -> dict:
+        lit = a.get("literal") or {}
+        if lit.get("polarity") != "positive":
+            raise Refused("отрицательный собственный факт вне L0-среза")
+        dating = self._dating(a)
+        if dating is not None and dating != [(None, None)]:
+            if not dating:
+                raise _Excluded(a["id"])
+            if len(dating) > 1:
+                raise Refused("прерывистая применимость редакции §92.3 вне среза генератора")
+            # Датированный факт печатается правилом с окном над служебной
+            # таблицей `always` (одна строка): та же механика окна §31, что у
+            # правил, и ни один эмиттер не узнаёт о редакциях.
+            self.dated_facts.append({
+                "name": f"dated_{len(self.dated_facts)}_{_slug(a['id'])}", "id": a["id"],
+                "window": {"start": dating[0][0], "end": dating[0][1]},
+                "atoms": [{"pred": ALWAYS}], "joins": [], "filters": [], "guards": [],
+                "head": {"pred": lit["predicate"], "args": [self.term(x, {}) for x in lit["args"]]}})
+            raise _Excluded(None)
+        return {"pred": lit["predicate"], "args": [self.term(x, {}) for x in lit["args"]]}
+
+    def _setup(self) -> None:
+        self.caps = self._capabilities()
+        # DECISION-0245: `days_between` модели не меняет; фоллибельные
+        # календарные функции требуют накопления выводов модели 0.9.
+        self.l1 = bool(self.caps - {"calendar:days_between", "judgment"} - V15_CAPS)
+        self.v10 = "norm" in self.caps
+        self.v09 = bool(self.caps & {"aggregate", "closure", "norm", "calendar:period", "calendar:business",
+                                     "value:rational", "value:quantity", "value:round", "value:div_round"}
+                        or self.caps & TERM_CAPS or self.caps & FN_CAPS)
+        self.v11 = bool(self.caps & CAL_CAPS)
+        # DECISION-0252 п. 1: ошибка значения §58 требует накопления выводов 0.9.
+        self.v12 = "value:rational" in self.caps
+        self.v13 = "value:quantity" in self.caps
+        # DECISION-0259 п. 1: политика округления для рантайма.
+        self.v14 = bool(self.caps & {"value:round", "value:div_round"})
+        # DECISION-0266–0268: значения и формы, не меняющие модель.
+        self.v15 = bool(self.caps & V15_CAPS)
+        # DECISION-0269: датированные приоритеты §92.3.
+        self.v16 = "priority:dated" in self.caps
+        # DECISION-0270: вычисляемые аргументы тела и условные термы.
+        self.v17 = bool(self.caps & TERM_CAPS)
+        # DECISION-0273: функции, параметры A3, `let`, `match`.
+        self.v18 = bool(self.caps & FN_CAPS)
+        # DECISION-0274: канал суждения §47.3.
+        self.v19 = "judgment" in self.caps
+        self._derived = {(n.get("head") or {}).get("predicate") for n in self.ir["nodes"]
+                         if n.get("kind") == "rule" and (n.get("head") or {}).get("kind") == "literal"}
+
+    def build(self) -> dict:
+        ir = self.ir
+        if ir.get("imports") and not self.linked:
+            raise Refused("импорт чужого пакета без мира зависимостей вне среза генератора")
+        self._setup()
+        for n in ir["nodes"]:
+            self._node(n)
+        rels = self._index()
+        self._export_functions()
+        tables = [self._table(r) for r in rels]
+        if self.v10:
+            tables += self._std_tables()
+        rules, excluded = [], []
+        compile_rule = self._rule_v09 if self.v09 else self._rule_l1 if self.l1 else self._rule
+        for i, rule in enumerate([n for n in ir["nodes"] if n.get("kind") == "rule"]):
+            try:
+                if self.v10 and (rule.get("head") or {}).get("kind") == "norm_template_ref":
+                    self._norms.append(self._norm_v10(i, rule))
+                else:
+                    rules.append(compile_rule(i, rule))
+            except _Excluded as exc:
+                excluded.append(str(exc))
+        if self.l1:
+            for n in ir["nodes"]:
+                if n.get("kind") == "priority_rule":
+                    self._priority(n)
+                if n.get("kind") == "closure_policy" and self.v09:
+                    self._closure(n)
+        facts = []
+        compile_fact = self._fact_l1 if self.l1 else self._fact
+        for a in ir["nodes"]:
+            if a.get("kind") != "assertion":
+                continue
+            try:
+                facts.append(compile_fact(a))
+            except _Excluded as exc:
+                if str(exc) != "None":
+                    excluded.append(str(exc))
+        structure = self._structure(rules)
+        for r in rules:
+            if r["name"] in self._value_refuse:
+                if r.get("headAgg"):
+                    # Без перехвата ошибка агрегата головы ушла бы в обработчик G3
+                    # и сняла правило целиком — иной ответ, чем у оракула.
+                    raise Refused("агрегат в голове с ошибкой значения над незавершённым входом "
+                                  "вне среза генератора (DECISION-0252 п. 4)")
+                # DECISION-0252 п. 4: без перехвата ошибка значения — отказ раннера.
+                r.pop("headFallible", None)
+                for g in r["guards"]:
+                    g.pop("err", None)
+        if self.dated_facts:
+            tables.append({"pred": ALWAYS, "name": "always", "arity": 1, "params": ["urn:law:std#Text"],
+                           "keys": [], "kinds": ["text"]})
+            always = {"pred": ALWAYS, "args": [{"k": "lit", "t": "text", "v": "on"}]}
+            facts.append(dict(always, polarity="positive") if self.l1 else always)
+            rules += self.dated_facts
+        plan = {"planVersion": PLAN_VERSION, "package": ir.get("package"),
+                "world": self.world_passport,
+                "tables": tables, "rules": rules, "facts": facts,
+                "excluded": sorted(excluded),
+                "consts": self._consts(), "bases": dict(sorted(self.bases.items())),
+                "api": self._api(rels, rules)}
+        if not self.l1:
+            if self.v11 or self.v15 or self._fn_plan or self.v19:
+                # DECISION-0245 п. 1: `days_between` в модели L0; DECISION-0266–0268
+                # тоже не меняют модели — версия 0.15 и возможности при тех же полях.
+                # DECISION-0273: функции §46 для вопросов `term` — модель L0 версии 0.18.
+                out = dict({"planVersion": PLAN_VERSION_19 if self.v19 else PLAN_VERSION_18 if self._fn_plan
+                            else PLAN_VERSION_15 if self.v15 else PLAN_VERSION_11,
+                            "capabilities": sorted(self.caps)},
+                           **{k: v for k, v in plan.items() if k != "planVersion"})
+                if self.v11:
+                    out.update(self._calendar_env())
+                if self._fn_plan:
+                    out["functions"] = [self._fn_plan[k] for k in sorted(self._fn_plan)]
+                if self.v19:
+                    # DECISION-0274: канал суждения у модели L0 — обход раннера
+                    # по правилам с силой и гардами, органы по отношению.
+                    out["judgments"] = dict(sorted(self.judgments.items()))
+                    out["backchain"] = self._backchain(rules)
+                    out["backchainConsts"] = {cid: c["value"] for cid, c in sorted(self.consts.items())
+                                              if c["value"] is not None}
+                return out
+            return plan
+        if self.v09:
+            structure = dict(structure, aggregates=self._aggs, closures=self._closures)
+        if self.v10:
+            structure = dict(structure, norms=self._norms)
+        if self.v18 or self._fn_plan or self._a3params:
+            # DECISION-0273: функции §46 и параметры A3 в порядке идентификаторов.
+            structure = dict(structure, functions=[self._fn_plan[k] for k in sorted(self._fn_plan)])
+            if self._a3params:
+                structure["a3Params"] = [self._a3params[k] for k in sorted(self._a3params)]
+            self.v18 = True
+        if self.v11:
+            structure = dict(structure, **self._calendar_env())
+        if self.v19:
+            structure = dict(structure, judgments=dict(sorted(self.judgments.items())))
+        if self.caps & {"calendar:period", "calendar:business"} or self.v12 or self.v13 or self.v14 or self.v17 \
+                or self.v18 or self.v19 or self._agg_fallible:
+            # E-0105: обход ошибок терма от цели вопроса (DECISION-0245, 0252, 0270);
+            # DECISION-0274: тот же обход — запрос судье §47.3.
+            structure["backchain"] = self._backchain(rules)
+            # Разыменование констант §54 аргументов вопроса для обхода.
+            structure["backchainConsts"] = {cid: c["value"] for cid, c in sorted(self.consts.items())
+                                            if c["value"] is not None}
+        return dict({"planVersion": PLAN_VERSION_19 if self.v19 else PLAN_VERSION_18 if self.v18
+                     else PLAN_VERSION_17 if self.v17 else PLAN_VERSION_16 if self.v16
+                     else PLAN_VERSION_15 if self.v15
+                     else PLAN_VERSION_14 if self.v14
+                     else PLAN_VERSION_13 if self.v13
+                     else PLAN_VERSION_12 if self.v12
+                     else PLAN_VERSION_11 if self.v11
+                     else PLAN_VERSION_10 if self.v10 else PLAN_VERSION_09 if self.v09 else PLAN_VERSION_L1,
+                     "capabilities": sorted(self.caps)},
+                    **{k: v for k, v in plan.items() if k != "planVersion"}, **structure)
+
+    def _export_functions(self) -> None:
+        """DECISION-0273: функции §46 модуля доступны вопросу `term` раннера и
+        без правил (T071), поэтому компилируются заранее. Функция вне среза
+        (запись, список, рекурсия) пакету не отказывает, пока её не читает
+        правило: она не попадает в план, вопрос к ней — названный отказ
+        раннера. Признаки значений неиспользуемой функции не двигают версию."""
+        flags = ("_rational_seen", "_quantity_seen", "_round_seen", "_div_round_seen", "_boolean_seen",
+                 "_natural_seen", "_month_seen", "_wildcard_seen", "_if_seen", "_let_seen", "_match_seen",
+                 "_body_term_seen", "_function_seen")
+        saved = {f: getattr(self, f) for f in flags}
+        for fn in sorted(self.fdecls):
+            if self._is_a3(fn):
+                continue
+            try:
+                self._fn_sig(fn)
+            except Refused:
+                continue
+        for f, v in saved.items():
+            setattr(self, f, v)
+
+    def _backchain(self, rules: list) -> list:
+        """Обход ошибок терма E-0105 (`whynot.term_error_blockers`): правила
+        с литеральной головой по id — окно, голова и литеральные конъюнкты
+        тела с разыменованными константами §54, как их видит оракул. Раннер
+        по нему называет статусом NEITHER, за которым стоит ошибка терма."""
+        compiled = {r["id"]: r for r in rules if "id" in r}
+        out = []
+        for n in sorted((n for n in self.ir["nodes"] if n.get("kind") == "rule"
+                         and (n.get("head") or {}).get("kind") == "literal" and n["id"] in compiled),
+                        key=lambda n: n["id"]):
+            conj: list = []
+
+            def walk(f):
+                k = f.get("kind") if isinstance(f, dict) else None
+                if k == "status" and (f.get("formula") or {}).get("kind") == "literal":
+                    conj.append([f.get("status"), self._deref(f["formula"])])
+                elif k == "literal":
+                    conj.append(["established", self._deref(f)])
+                elif k == "comparison":
+                    # DECISION-0274: гард §57–§58 — живость правила на пути
+                    # запроса судье (E-0101, `_rule_is_dead`).
+                    conj.append(["guard", self._deref(f)])
+                elif k in ("and", "conjunction"):
+                    for x in f.get("items") or f.get("args") or f.get("operands") or []:
+                        walk(x)
+
+            walk(n.get("body") or {})
+            r = compiled[n["id"]]
+            out.append({"id": n["id"], "name": r["name"], "window": r["window"],
+                        "strength": n.get("strength") or "strict",
+                        "head": self._deref(n["head"]), "body": conj})
+        return out
+
+    def _calendar_env(self) -> dict:
+        """Окружение календаря для раннера (DECISION-0245 п. 3): версия
+        семантики CLIR (у 0.1 политика — объект контекста), политики
+        `deadline_policy` по id и снимки `calendar_snapshot` с датасетом либо
+        кодом ошибки загрузки — порт `calendar.load_calendar`."""
+        import hashlib
+        from pathlib import Path
+        policies, calendars = {}, []
+        for n in self.ir["nodes"]:
+            if n.get("kind") == "deadline_policy" and isinstance(n.get("policy"), dict):
+                policies[n["id"]] = n["policy"]
+            if n.get("kind") != "calendar_snapshot":
+                continue
+            uri = str(n.get("resourceUri", ""))
+            data = self.resources.get(uri)
+            entry = {"id": n["id"]}
+            if data is None:
+                entry["error"] = "MISSING_CALENDAR"
+            elif "sha256:" + hashlib.sha256(data).hexdigest() != n.get("datasetHash", ""):
+                entry["error"] = "CALENDAR_DATASET_HASH_MISMATCH"
+            else:
+                entry.update(_calendar_dataset(data))
+            calendars.append(entry)
+        return {"semanticVersion": self.ir["semanticVersion"],
+                "deadlinePolicies": dict(sorted(policies.items())),
+                "calendars": sorted(calendars, key=lambda c: c["id"])}
+
+    def _consts(self) -> dict:
+        """Константы со значением для раннера: разыменование §54 аргументов
+        дела и запроса и тип константы для проверки §189. Константа с типом
+        вне среза не отказывает пакету, пока на неё никто не ссылается:
+        она просто не попадает в план."""
+        out = {}
+        for cid, c in sorted(self.consts.items()):
+            if c["value"] is None:
+                continue
+            if c["type"] == RAT and not self.v12:
+                continue            # DECISION-0252: значение Rational несёт только план 0.12
+            if c["type"] == QTY and not self.v13:
+                continue            # DECISION-0256: значение Quantity несёт только план 0.13
+            try:
+                out[cid] = {"type": c["type"], "term": self.term(c["value"], {})}
+            except Refused:
+                continue
+        return out
+
+    def survey(self) -> list[str]:
+        """Все отказы пакета по единицам проверки; пустой список — план строится."""
+        ir = self.ir
+        out: list[str] = []
+
+        def attempt(fn, *args) -> None:
+            try:
+                fn(*args)
+            except Refused as exc:
+                out.append(str(exc))
+            except _Excluded:
+                pass
+
+        if ir.get("imports") and not self.linked:
+            out.append("импорт чужого пакета без мира зависимостей вне среза генератора")
+        self._setup()
+        for n in ir["nodes"]:
+            attempt(self._node, n)
+        rels = self._index()
+        for r in rels:
+            attempt(self._table, r)
+        if self.v10:
+            attempt(self._std_tables)
+        rules: list = []
+        compile_rule = self._rule_v09 if self.v09 else self._rule_l1 if self.l1 else self._rule
+        for i, rule in enumerate([n for n in ir["nodes"] if n.get("kind") == "rule"]):
+            if self.v10 and (rule.get("head") or {}).get("kind") == "norm_template_ref":
+                attempt(lambda i=i, rule=rule: self._norms.append(self._norm_v10(i, rule)))
+            else:
+                attempt(lambda i=i, rule=rule: rules.append(compile_rule(i, rule)))
+        if self.l1:
+            for n in ir["nodes"]:
+                if n.get("kind") == "priority_rule":
+                    attempt(self._priority, n)
+                if n.get("kind") == "closure_policy" and self.v09:
+                    attempt(self._closure, n)
+        for a in [n for n in ir["nodes"] if n.get("kind") == "assertion"]:
+            attempt(self._fact_l1 if self.l1 else self._fact, a)
+        # Структура — одна единица над правилами, прошедшими свою проверку:
+        # цикл или поздний производитель — свойство программы, не правила.
+        attempt(self._structure, rules)
+        return out
+
+    def capabilities(self) -> list[str]:
+        """Возможности программы без построения плана (для обзора)."""
+        return sorted(self._capabilities())
+
+
+def _closure_read_dependencies(status: str, predicate: str, polarity: str, enumeration: bool) -> tuple:
+    """Порт `rules._closure_read_dependencies` (E-0174): зависимости одного
+    чтения — (монотонные, немонотонные). Элемент `("rule", P, полярность)` —
+    опоры строгих производителей головы `P`, `("closure", P)` — негативы
+    замыкания над `P`. `established` опровергает противоположная опора,
+    `not_known` и `refuted` — опора той же полярности, `unknown` — любая;
+    перечисление немонотонно по всему, от чего зависит его тест."""
+    negative = polarity == "negative"
+    same = ("rule", predicate, polarity)
+    other = ("rule", predicate, "positive" if negative else "negative")
+    closure = ("closure", predicate)
+    if status in ("supported", "monotone"):
+        monotone, non_monotone = [same] + ([closure] if negative else []), []
+    elif status == "not_known":
+        monotone, non_monotone = [], [same] + ([closure] if negative else [])
+    elif status == "refuted":
+        monotone, non_monotone = [other] + ([] if negative else [closure]), [same]
+    elif status == "unknown":
+        monotone, non_monotone = [], [same, other, closure]
+    else:
+        monotone, non_monotone = [same] + ([closure] if negative else []), [other]
+    if enumeration:
+        return [], monotone + non_monotone
+    return monotone, non_monotone
+
+
+def _closure_waits(strict: list, closed: dict) -> dict:
+    """Порт `rules.closure_waits` (errata E-0174): id strict-правила →
+    id замыканий, до материализации которых оно не исполняется. Ожидание
+    транзитивно через строгих производителей: производитель завершён, когда
+    завершены все его чтения. Пустой словарь — прежнее расписание."""
+    if not closed:
+        return {}
+    reads_of = []
+    for m in strict:
+        monotone, non_monotone = [], []
+        for st, pred, pol, enumeration in m.get("closure_reads", []):
+            mono, non = _closure_read_dependencies(st, pred, pol, enumeration)
+            monotone += mono
+            non_monotone += non
+        reads_of.append((m["id"], (m["head"], m["polarity"]), monotone, non_monotone))
+    ready: dict = {}
+
+    def value(dep: tuple) -> frozenset:
+        if dep[0] == "closure":
+            return frozenset(c["id"] for c in closed.get(dep[1], []))
+        return ready.get((dep[1], dep[2]), frozenset())
+
+    waits = {rule_id: frozenset() for rule_id, *_ in reads_of}
+    changed = True
+    while changed:
+        changed = False
+        for rule_id, head, monotone, non_monotone in reads_of:
+            wait = frozenset().union(*(value(d) for d in non_monotone))
+            complete = wait.union(*(value(d) for d in monotone))
+            if wait != waits[rule_id]:
+                waits[rule_id] = wait
+                changed = True
+            if not complete <= ready.get(head, frozenset()):
+                ready[head] = ready.get(head, frozenset()) | complete
+                changed = True
+    return {rule_id: wait for rule_id, wait in waits.items() if wait}
+
+
+def build_plan(ir: dict, world: list | None = None, want: set | None = None,
+               resources: dict | None = None) -> dict:
+    """План программы. Rational §35 и значение-зависимое частное §58 видны
+    только при компиляции термов, а возможность `value:rational` меняет модель
+    (DECISION-0252 п. 1): встретив их, план строится заново с возможностью.
+    Отказ первого прохода проверяется обзором: он доходит до всех правил."""
+    _admit_current_slice(ir, world)
+    builder = Builder(ir, world, want, resources)
+    try:
+        plan = builder.build()
+        needed = value_caps(builder) - builder.caps
+    except Refused:
+        probe = Builder(ir, world, want, resources)
+        probe.survey()
+        needed = value_caps(probe) - probe.caps
+        if not needed:
+            raise
+    want = set(want or ())
+    # DECISION-0273: параметр A3, функция, `let`, `match` внутри вычисляемого
+    # аргумента тела видны только проходу с `term:body` — возможности
+    # добираются до неподвижной точки (каждый проход добавляет хотя бы одну).
+    while needed:
+        want |= needed
+        builder = Builder(ir, world, want, resources)
+        plan = builder.build()
+        needed = value_caps(builder) - builder.caps
+    return dict(plan, planVersion="law-backend-plan/0.20", basePlanVersion=plan["planVersion"],
+                capabilities=sorted(set(plan.get("capabilities") or []) | {"admission:current"}),
+                admission={"reservedAssertionIds": sorted({n["id"] for document in [ir, *(world or [])]
+                           for n in document.get("nodes") or [] if n.get("id") and n.get("kind") != "assertion"})})
+
+
+def value_caps(builder: Builder) -> set:
+    """Возможности значений, встреченные проходом компиляции: Rational
+    (DECISION-0252), Quantity (DECISION-0256), политика округления
+    (DECISION-0259). Признаки отмечаются и без возможности, поэтому второго
+    прохода достаточно."""
+    return ({"value:rational"} if builder._rational_seen else set()) | \
+        ({"value:quantity"} if builder._quantity_seen else set()) | \
+        ({"value:instant"} if builder._instant_seen else set()) | \
+        ({"value:round"} if builder._round_seen else set()) | \
+        ({"value:div_round"} if builder._div_round_seen else set()) | \
+        ({"value:boolean"} if builder._boolean_seen else set()) | \
+        ({"value:natural"} if builder._natural_seen else set()) | \
+        ({"calendar:month_bound"} if builder._month_seen else set()) | \
+        ({"wildcard"} if builder._wildcard_seen else set()) | \
+        ({"priority:dated"} if builder._dated_prio_seen else set()) | \
+        ({"term:body"} if builder._body_term_seen else set()) | \
+        ({"term:if"} if builder._if_seen else set()) | \
+        ({"function"} if builder._function_seen else set()) | \
+        ({"param:a3"} if builder._a3_seen else set()) | \
+        ({"term:let"} if builder._let_seen else set()) | \
+        ({"term:match"} if builder._match_seen else set())
+
+
+def survey_plan(ir: dict, world: list | None = None) -> list[str]:
+    _admit_current_slice(ir, world)
+    builder = Builder(ir, world)
+    reasons = builder.survey()
+    needed = value_caps(builder) - builder.caps
+    if needed:
+        return Builder(ir, world, needed).survey()
+    return reasons
+
+
+WEEKDAYS = ("monday", "tuesday", "wednesday", "thursday", "friday", "saturday", "sunday")
+
+
+def _calendar_dataset(data: bytes) -> dict:
+    """Датасет снимка §85 для модуля: покрытие, недельный график, исключения —
+    инварианты `calendar.load_calendar`; нарушение — код ошибки загрузки,
+    который оракул выпускает при первом обращении к календарю."""
+    import datetime
+    from pathlib import Path
+    import jsonschema
+    invalid = {"error": "CALENDAR_DATASET_INVALID"}
+    try:
+        dataset = json.loads(data.decode("utf-8"))
+        # Схема датасета §85 — та же, что у `schemas.validate("calendar-dataset")`.
+        from core_support import calendar_schema
+        schema = calendar_schema()
+        if any(True for _ in jsonschema.Draft202012Validator(schema).iter_errors(dataset)):
+            return invalid
+        valid = dataset["valid"]
+        start = datetime.date.fromisoformat(valid["start"])
+        end = datetime.date.fromisoformat(valid["endExclusive"])
+        weekly = {e["day"]: bool(e["working"]) for e in dataset["weeklySchedule"]}
+        if any(d not in weekly for d in WEEKDAYS):
+            return invalid
+        overrides = {}
+        for e in dataset.get("overrides", []):
+            day = datetime.date.fromisoformat(e["date"])
+            if not (start <= day < end):
+                return invalid
+            overrides[day.isoformat()] = bool(e["working"])
+    except (ValueError, KeyError, TypeError, AttributeError):
+        return invalid
+    return {"start": start.isoformat(), "endExclusive": end.isoformat(),
+            "weekly": [weekly[d] for d in WEEKDAYS], "overrides": dict(sorted(overrides.items()))}
+
+
+# --- мир зависимостей ---------------------------------------------------------
+
+def world_index(root) -> dict:
+    """Снимки CLIR по имени пакета: `corpus/clir` и собственные снимки
+    `packs/**/clir` (без `deps/` и `.build/` — копий чужих)."""
+    from pathlib import Path
+    root = Path(root)
+    index = {}
+    paths = sorted((root / "corpus" / "clir").glob("*.lawir.json"))
+    for p in sorted((root / "packs").rglob("*.lawir.json")):
+        if "deps" in p.parts or ".build" in p.parts:
+            continue
+        paths.append(p)
+    for p in paths:
+        try:
+            ir = json.loads(p.read_text(encoding="utf-8"))
+        except (OSError, ValueError):
+            continue
+        name = (ir.get("package") or {}).get("name")
+        if name and name not in index:
+            index[name] = p
+    return index
+
+
+def resolve_world(ir: dict, index: dict, extra: list | None = None) -> list:
+    """Замыкание импортов корня по индексу снимков; `extra` — CLIR, поданные
+    явно (зависимости вектора). Импорт без снимка — отказ плана."""
+    from pathlib import Path
+    from inputs import dependency_index
+    have = dependency_index(extra or [])
+    out, queue = [], [i.get("package", {}).get("name") for i in ir.get("imports") or []]
+    seen = set()
+    while queue:
+        name = queue.pop(0)
+        if not name or name in seen:
+            continue
+        seen.add(name)
+        dep = have.get(name)
+        if dep is None:
+            path = index.get(name)
+            if path is None:
+                raise Refused(f"импорт без снимка CLIR в мире: {name}")
+            dep = json.loads(Path(path).read_text(encoding="utf-8"))
+        out.append(dep)
+        queue += [i.get("package", {}).get("name") for i in dep.get("imports") or []]
+    return out
+
+
+if __name__ == "__main__":
+    import sys
+    from pathlib import Path
+    plan = build_plan(json.loads(Path(sys.argv[1]).read_text(encoding="utf-8")))
+    out = sys.argv[2] if len(sys.argv) > 2 else "-"
+    text = json.dumps(plan, ensure_ascii=False, indent=1)
+    print(text) if out == "-" else Path(out).write_text(text, encoding="utf-8")