arxo-codegen 0.4.0__py3-none-any.whl

arxo_codegen/targets/py/evaluate.py

@@ -0,0 +1,980 @@
+"""Единый вычислительный вход Python-цели (DECISION-0423 §2.2).
+
+Дело и вопрос приходят в канонической форме (§168, §172) — той же, что у
+векторов и оракула, — и `evaluate` возвращает ответ исполняемого профиля.
+Раннер и API вызывают только его, поэтому сверка аргументов §189, разворот
+контекста, насыщение и лестница статусов §175 у них одни.
+
+Состояние — на вызов (§2.3): таблицы модели строит `model.new_model()`,
+контекст рантайма (правовое время, политика срока, снимок календаря) живёт в
+`contextvars`, сопутствующие множества — в замыкании `_evaluate`. Между
+вызовами ничего не живёт; параллельные вызовы из потоков не делят состояния.
+
+Названный отказ среза — `RT.Refused`; ошибка значения вне вопроса `term` и
+вне правил модели становится тем же отказом (раннер печатает его с кодом 3).
+"""
+import contextvars
+import json
+
+import runtime as RT
+import model as _MODEL
+
+Refused = RT.Refused
+
+VALUE_TYPES = {"urn:law:std#Money", "urn:law:std#Decimal", "urn:law:std#Integer", "urn:law:std#Text"}
+MIRROR = {"TRUE_ONLY": "FALSE_ONLY", "FALSE_ONLY": "TRUE_ONLY", "BOTH": "BOTH", "NEITHER": "NEITHER"}
+
+# --- вопросы term §57–§59 и collect §52.1 -----------------------------------
+# Срез раннера: comprehension по установленным атомам таблиц с гардами,
+# элемент — ячейка или литерал; агрегаты count/sum/min/max; арифметика §58 и
+# функции рантайма над результатом. Вид результата выводится статически по
+# тем же таблицам §58, что у плана: у оракула вид — часть значения (Integer 5
+# и Decimal 5 — разные байты), у рантайма — нет.
+INT, DEC, MON = "urn:law:std#Integer", "urn:law:std#Decimal", "urn:law:std#Money"
+TEXT, DATE, RAT = "urn:law:std#Text", "urn:law:std#Date", "urn:law:std#Rational"
+INSTANT = "urn:law:std#Instant"
+QTY, BOOL = "urn:law:std#Quantity", "urn:law:std#Boolean"
+NAT = "urn:law:std#Natural"
+NUM = {INT, DEC, MON, RAT, QTY, NAT}
+CMP_OPS = ("lt", "le", "gt", "ge", "eq", "ne")
+# DECISION-0252 п. 3: вид операнда для `arith` рантайма. У вопроса вид каждого
+# значения известен точно — из литерала, слота или исхода операции.
+KIND_CODE = {INT: "i", DEC: "d", MON: "m", RAT: "r", QTY: "q", NAT: "i"}
+# Имя функции рантайма по имени std-функции вопроса (DECISION-0267).
+RT_NAME = {"month_start_of": "month_start", "month_end_of": "month_end"}
+# Виды вопросов протокола раннера; `rows` — внутренний вид API (DECISION-0423 §2.1).
+QUERY_KINDS = ("truth", "term", "collect")
+
+
+def norm(t: str) -> str:
+    """DECISION-0266: Natural считает как Integer (`values._TYPE_KINDS`), тип-строка своя."""
+    return INT if t == NAT else t
+
+
+# §59 (errata E-0195): вид элемента ПУСТОЙ коллекции несёт ОБЪЯВЛЕННЫЙ тип
+# проекции comprehension §52.1 (`variable.type.name`) — единственный носитель
+# вида, не зависящий от числа решений generator-а (порт
+# `values.aggregate_element_type`). Таблица — порт `values._TYPE_KINDS` плюс
+# `_OPAQUE_KINDS`: Natural и Integer у оракула один вид `integer`. Имя вне
+# таблицы (сущность, перечисление, чужой символ) вида не предъявляет, и сверка
+# МОЛЧИТ: Unknown есть «утверждать нечего», а не «совместимо со всем».
+EMPTY_ELEMENT_KINDS = {INT: INT, NAT: INT, DEC: DEC, MON: MON, TEXT: TEXT, DATE: DATE,
+                       BOOL: BOOL, RAT: RAT, QTY: QTY,
+                       "urn:law:std#Instant": "urn:law:std#Instant",
+                       "urn:law:std#Magnitude": "urn:law:std#Magnitude",
+                       "urn:law:std#Bounds": "urn:law:std#Bounds"}
+# §175: коды ошибки значения вопроса со статусом TYPE_ERROR (`queries.query_calc`).
+TYPE_ERROR_CODES = ("TYPE_ERROR", "CURRENCY_MISMATCH", "DIMENSION_MISMATCH", "DATE_INSTANT_MISMATCH")
+
+#: E-0105: код ошибки терма → статус результата (`whynot.TERM_ERROR_STATUS`);
+#: код вне таблицы — RUNTIME_ERROR; старшинство — `TERM_ERROR_PRECEDENCE`.
+TERM_ERROR_STATUS = {"MISSING_POLICY": "MISSING_POLICY", "DEADLINE_POLICY_INVALID": "MISSING_POLICY",
+                     "MISSING_CALENDAR": "MISSING_INPUT", "CALENDAR_DATASET_INVALID": "MISSING_INPUT",
+                     "CALENDAR_DATASET_HASH_MISMATCH": "MISSING_INPUT", "CALENDAR_OUT_OF_RANGE": "MISSING_INPUT",
+                     "TYPE_ERROR": "TYPE_ERROR", "CURRENCY_MISMATCH": "TYPE_ERROR",
+                     "DIMENSION_MISMATCH": "TYPE_ERROR", "DATE_INSTANT_MISMATCH": "TYPE_ERROR", "RESOURCE_LIMIT": "RESOURCE_LIMIT",
+                     "OPAQUE_NON_EXECUTABLE": "NON_EXECUTABLE", "NON_EXHAUSTIVE_MATCH": "NON_EXECUTABLE",
+                     "UNKNOWN_FUNCTION": "NON_EXECUTABLE", "NON_EXECUTABLE_FUNCTION_RECURSION": "NON_EXECUTABLE"}
+TERM_ERROR_PRECEDENCE = ("MISSING_INPUT", "MISSING_POLICY", "NON_EXECUTABLE", "EXTERNAL_UNAVAILABLE",
+                         "TYPE_ERROR", "RUNTIME_ERROR", "RESOURCE_LIMIT")
+#: §175/§181.2 (errata E-0265): код из списка остаётся статусом итога, прочие — NON_EXECUTABLE.
+OUTCOME_CODES = {"PRIORITY_CONFLICT", "INTERPRETATION_REQUIRED", "TYPE_ERROR",
+                 "RESOURCE_LIMIT", "CONFLICTED_INPUTS", "SOURCE_RESOLUTION_FAILED"}
+
+
+def arith_kind(op: str, l: str, r: str) -> str:
+    l, r = norm(l), norm(r)
+    if l not in NUM or r not in NUM:
+        raise RT.Refused(f"арифметика вне среза (§58): не числовой операнд {op}")
+    if op in ("add", "sub"):
+        if l != r:
+            raise RT.Refused(f"арифметика вне среза (§58): виды операндов не совпадают у {op}")
+        return l
+    if op == "mul":
+        if l == MON and r == MON:
+            raise RT.Refused("арифметика вне среза (§58): произведение двух размерных величин не определено")
+        if INT in (l, r):
+            return r if l == INT else l
+        return MON if MON in (l, r) else DEC
+    if op == "div":
+        if (l, r) in ((DEC, DEC), (MON, MON)):
+            return DEC
+        if (l, r) == (MON, DEC):
+            return MON
+        if (l, r) == (INT, INT):
+            raise RT.Refused("арифметика вне среза (§58): частное Integer/Integer — Rational")
+        raise RT.Refused("арифметика вне среза (§58): пара вне таблицы делимых")
+    if op == "mod":
+        if (l, r) != (INT, INT):
+            raise RT.Refused("арифметика вне среза (§58): остаток только Integer mod Integer")
+        return INT
+    raise RT.Refused("операция вне среза раннера: " + op)
+
+
+def call_kind(fn: str, ks: list) -> str:
+    if fn in ("min", "max"):
+        if len(ks) != 2 or ks[0] not in NUM or ks[0] != ks[1]:
+            raise RT.Refused(f"арифметика вне среза (§58): виды операндов не совпадают у {fn}")
+        return ks[0]
+    if fn == "abs":
+        if len(ks) != 1 or ks[0] not in NUM:
+            raise RT.Refused("арифметика вне среза (§58): abs над нечисловым видом")
+        return ks[0]
+    if fn == "pow":
+        if ks != [INT, INT]:
+            raise RT.Refused("арифметика вне среза (§58): pow только Integer pow Integer")
+        return INT
+    if fn == "round":
+        if len(ks) != 3:
+            raise RT.Refused("round вне среза раннера: ожидаются значение, разряды и режим (§50)")
+        if ks[0] == RAT:
+            raise RT.Refused("round над Rational вне среза генератора (§50: round не берёт Rational)")
+        if ks[0] not in NUM:
+            raise RT.Refused("round вне среза генератора: вид операнда не числовой (§50)")
+        _policy_kinds("round", ks[1:])
+        return ks[0]
+    if fn == "div_round":
+        # §50/§58 (E-0036, E-0170; DECISION-0259 п. 3): четыре пары видов.
+        if len(ks) != 4:
+            raise RT.Refused("div_round вне среза генератора: ожидаются делимое, делитель, точность и режим (§50)")
+        if RAT in ks[:2]:
+            raise RT.Refused("div_round над Rational вне среза генератора (§50/§58, E-0036)")
+        pair = tuple(ks[:2])
+        if pair not in ((MON, DEC), (QTY, DEC), (DEC, DEC), (MON, MON)):
+            raise RT.Refused("div_round вне среза генератора: пара видов вне E-0036/E-0170 (§50/§58)")
+        _policy_kinds("div_round", ks[2:])
+        return {(MON, DEC): MON, (QTY, DEC): QTY}.get(pair, DEC)
+    if fn in ("month_start_of", "month_end_of"):
+        # §84.2 (E-0084, DECISION-0267): арность и вид — TYPE_ERROR оракула (`month_bound_value`).
+        if len(ks) != 1 or ks[0] != DATE:
+            raise RT.TermError("TYPE_ERROR")
+        return DATE
+    if fn in ("hours_between", "minutes_between"):
+        # §84.1 (E-0028/E-0058; W2 часть 2): оба аргумента — Instant, иначе TYPE_ERROR оракула.
+        if len(ks) != 2 or ks[0] != INSTANT or ks[1] != INSTANT:
+            raise RT.TermError("TYPE_ERROR")
+        return INT
+    if fn == "add_duration":
+        raise RT.Refused("add_duration в вопросе вне среза раннера (§84.1)")
+    raise RT.Refused("функция вне среза раннера: " + fn)
+
+
+def _policy_kinds(fn: str, ks: list) -> None:
+    """§50: точность — Integer либо Decimal, режим — Text (DECISION-0259 п. 3)."""
+    if ks[0] not in (INT, DEC):
+        raise RT.Refused(f"{fn} вне среза генератора: точность не Integer и не Decimal (§50)")
+    if ks[1] != TEXT:
+        raise RT.Refused(f"{fn} вне среза генератора: режим не Text (§50)")
+
+
+def flatten(body: dict, atoms: list, guards: list) -> None:
+    k = (body or {}).get("kind")
+    if k == "status":
+        if body.get("status") != "established":
+            raise RT.Refused("статусный тест вне L0-среза: " + str(body.get("status")))
+        atoms.append(body["formula"])
+    elif k == "literal":
+        atoms.append(body)
+    elif k == "comparison":
+        guards.append(body)
+    elif k in ("and", "conjunction"):
+        for sub in body.get("items") or body.get("args") or body.get("operands") or []:
+            flatten(sub, atoms, guards)
+    else:
+        raise RT.Refused("форма тела вне среза генератора: " + str(k))
+
+
+def canon_dec(d) -> str:
+    """Каноническая десятичная запись §18/§208: без хвостовых нулей и minus-zero."""
+    u, s = d.u, d.s
+    if u == 0:
+        return "0"
+    while s > 0 and u % 10 == 0:
+        u //= 10
+        s -= 1
+    neg = u < 0
+    body = str(-u if neg else u).rjust(s + 1, "0")
+    text = body if s == 0 else body[:len(body) - s] + "." + body[len(body) - s:]
+    return ("-" if neg and u != 0 else "") + text
+
+
+def literal(x: tuple) -> dict:
+    """Литерал-терм §53 из typed-значения — ровно то, что печатает оракул.
+    Целое — число языка (JSON-число), а не строка."""
+    v, t = x
+    if t == "entity":
+        return {"kind": "entity_ref", "id": v}
+    if t == "enum":
+        return {"kind": "const_ref", "id": v.id}
+    if t == TEXT:
+        return {"kind": "value", "type": {"name": TEXT}, "value": v}
+    if t == DATE:
+        return {"kind": "value", "type": {"name": DATE}, "value": v.v}
+    if t == INSTANT:
+        return {"kind": "value", "type": {"name": INSTANT}, "value": v.v}
+    if t == MON:
+        return {"kind": "value", "type": {"name": MON}, "currency": v.cur, "value": canon_dec(v)}
+    if t == DEC:
+        return {"kind": "value", "type": {"name": DEC}, "value": canon_dec(v)}
+    if t == RAT:
+        return {"kind": "value", "type": {"name": RAT}, "value": f"{v.n}/{v.d}"}
+    if t == BOOL:
+        return {"kind": "value", "type": {"name": BOOL}, "value": bool(v)}
+    if t == NAT:
+        # DECISION-0266: запись дела хранит тип Natural; вычисленное целое — всегда Integer.
+        return {"kind": "value", "type": {"name": NAT}, "value": v.u // (10 ** v.s)}
+    if t == QTY:
+        return {"kind": "value", "type": {"name": QTY}, "unit": v.unit, "value": canon_dec(v)}
+    if t == INT:
+        if v.u % (10 ** v.s) != 0:
+            raise RT.Refused("Integer с дробной частью в результате")
+        return {"kind": "value", "type": {"name": INT}, "value": v.u // (10 ** v.s)}
+    raise RT.Refused("вид результата вне среза раннера: " + str(t))
+
+
+def canon(v) -> str:
+    """Канонические байты §208 значения: ключи по порядку, без пробелов, целое — цифрами."""
+    if v is None:
+        return "null"
+    if v is True or v is False:
+        return "true" if v else "false"
+    if isinstance(v, int):
+        return str(v)
+    if isinstance(v, str):
+        return json.dumps(v, ensure_ascii=False)
+    if isinstance(v, list):
+        return "[" + ",".join(canon(x) for x in v) + "]"
+    return "{" + ",".join(json.dumps(k, ensure_ascii=False) + ":" + canon(v[k]) for k in sorted(v)) + "}"
+
+
+def _ground(value, subst: dict):
+    """Заземление payload шаблона подстановкой — порт `norms._ground_payload`."""
+    if isinstance(value, dict):
+        if value.get("kind") == "var":
+            return subst.get(value["var"], value)
+        return {k: _ground(v, subst) for k, v in value.items()}
+    if isinstance(value, list):
+        return [_ground(v, subst) for v in value]
+    return value
+
+
+def _canon_json(v) -> str:
+    return json.dumps(v, ensure_ascii=False, sort_keys=True)
+
+
+def effective_context(case: dict) -> dict:
+    """Порт `context.expand` без дозаполнения: профили §89.1 от корня к листу,
+    затем поля дела."""
+    raw = dict(case.get("context") or {})
+    profiles = case.get("contextProfiles") or {}
+    parent = raw.pop("extends", None)
+    chain, seen, current = [], set(), parent
+    while current is not None:
+        if current in seen:
+            raise RT.Refused("CONTEXT_PROFILE_CYCLE: цикл наследования профилей (§89.1)")
+        if current not in profiles:
+            raise RT.Refused("CONTEXT_PROFILE_MISSING: профиль не определён (§89.1)")
+        seen.add(current)
+        chain.append(current)
+        current = profiles[current].get("extends")
+    effective = {}
+    for name in reversed(chain):
+        effective.update(profiles[name].get("fields") or {})
+    effective.update(raw)
+    return effective
+
+
+def evaluate(case: dict, query: dict, stats: dict | None = None, *, api: bool = False) -> dict:
+    """Ответ исполняемого профиля на вопрос `query` по делу `case`.
+
+    Каждый вызов — в собственном контексте `contextvars` с новой моделью.
+    `stats`, если передан, получает замер модели L1 (в протокол ответа не
+    входит, DECISION-0237 этап 6). `api` разрешает внутренний вид `rows`,
+    которого протокол раннера не знает."""
+    if query.get("kind") == "positions":
+        raise RT.Refused("POSITIONS_UNAVAILABLE: positions requires current norm ranks (W6)")
+    RT.validate_temporal_case(case)
+    return contextvars.copy_context().run(_evaluate, case, query, stats, api)
+
+
+def _evaluate(case: dict, query: dict, stats: dict | None, api: bool) -> dict:
+    RT.begin_context()
+    M = _MODEL.new_model()
+    for assertion in case.get("assertions") or []:
+        if assertion.get("id") in M.NODE_IDS:
+            raise RT.Refused("LDC-E1382: case assertion id collides with a program node")
+    RT.admit_numeric_inputs(case, query, bool(M.JUDGMENTS))
+
+    # Слой модели: L1-модель хранит опоры обеих полярностей (DECISION-0237).
+    LAYER = getattr(M, "LAYER", "L0")
+    ISSUES: list = []
+    TYPE_ERROR_PREDICATES: set = set()
+    # Запись строки, поданная делом как сущность и как Text, — в рантайме одно
+    # значение, у оракула — разные атомы. Для печати результата вид берётся по
+    # тому, как запись подана; одна запись в обеих ролях — названный отказ.
+    ENTITIES: set = set()
+    TEXTS: set = set()
+    LAST_TERM_CODES: set = set()
+
+    def arg(a: dict):
+        kind = a.get("kind")
+        if kind == "entity_ref":
+            ENTITIES.add(a["id"])
+            return a["id"]
+        if kind == "const_ref":
+            # §54: разыменование предшествует исполнению; ниже ссылок нет.
+            c = M.CONSTS.get(a.get("id"))
+            if c is None:
+                # Член перечисления §38 либо имя без объявления: оракул оставляет
+                # такой const_ref в ключе атома как есть — значение есть идентичность.
+                return RT.sym(str(a.get("id")))
+            return c[1]
+        if kind != "value":
+            raise RT.Refused("аргумент вне среза раннера: " + str(kind))
+        t = (a.get("type") or {}).get("name")
+        # §208/§48 (errata E-0197, E-0202, E-0203): сырое поле литерала читается по
+        # грамматике §208, а не средствами Python. `str(a["value"])` приводил к
+        # строке ЛЮБОЙ JSON, а отсутствие поля роняло KeyError — крахом вместо
+        # правовой диагностики.
+        raw = a.get("value")
+        if t == "urn:law:std#Money":
+            return RT.lit_money(raw, a.get("currency"))
+        if t == "urn:law:std#Decimal":
+            return RT.lit_dec(raw)
+        if t == "urn:law:std#Integer":
+            return RT.lit_int(raw)
+        if t == "urn:law:std#Text":
+            text = RT.lit_text(raw)
+            TEXTS.add(text)
+            return text
+        if t == "urn:law:std#Date":
+            return RT.date(RT.lit_text(raw))
+        if t == "urn:law:std#Instant":
+            return RT.instant(RT.lit_text(raw))
+        if t == "urn:law:std#Rational":
+            # §168.1 (DECISION-0252 п. 8): только каноническая запись, иная — отказ.
+            return RT.rat(raw)
+        if t == "urn:law:std#Quantity" and a.get("unit"):
+            # §49 v1 (DECISION-0256 п. 7): значение и тег единицы как записаны.
+            return RT.lit_qty(raw, a.get("unit"))
+        if t == "urn:law:std#Boolean":
+            # DECISION-0266: только JSON-булево; иная запись у оракула — TYPE_ERROR при чтении значения.
+            if not isinstance(raw, bool):
+                raise RT.Refused("значение Boolean не true/false вне среза раннера (§48)")
+            return raw
+        if t == "urn:law:std#Natural":
+            # DECISION-0266: неотрицательное целое; иное у оракула — TYPE_ERROR при чтении значения.
+            if isinstance(raw, bool) or not isinstance(raw, int) or raw < 0:
+                raise RT.Refused("значение Natural не неотрицательное целое вне среза раннера (§48)")
+            # Диапазон i64 §208 — общей воронкой (errata E-0202).
+            return RT.lit_int(raw)
+        raise RT.Refused("аргумент вне среза раннера: " + str(t))
+
+    def arg_type(a: dict):
+        """Тип аргумента, если он известен: у `value` — из узла, у `const_ref` —
+        из объявления константы; `entity_ref` типа не несёт (как у оракула).
+        Оракул разыменовывает константы §54 ДО сверки (`engine.evaluate`):
+        константа-сущность становится `entity_ref`, член перечисления — ссылкой
+        вне таблицы констант, и обе не сверяются. Поэтому тип берётся только у
+        константы std-типа."""
+        if a.get("kind") == "value":
+            return (a.get("type") or {}).get("name")
+        if a.get("kind") == "const_ref":
+            c = M.CONSTS.get(a.get("id"))
+            return c[0] if c and str(c[0]).startswith("urn:law:std#") else None
+        return None
+
+    def conforms(actual: str, expected: str) -> bool:
+        """Совпадение типа с наследованием сущностей вверх от фактического."""
+        seen = set()
+        cur = actual
+        while cur is not None and cur not in seen:
+            if cur == expected:
+                return True
+            seen.add(cur)
+            cur = M.BASES.get(cur)
+        return False
+
+    def well_typed(lit: dict) -> bool:
+        """Арность и типы аргументов утверждения против сигнатуры §189 (E-0046).
+
+        Зеркало `check_argument_types` оракула: несогласованное утверждение не
+        принимается, причина названа кодом TYPE_ERROR; `entity_ref` типа не несёт
+        и не проверяется; предикат без сигнатуры принимается (его никто не читает).
+        Проверка идёт ДО преобразования значений: тип вне среза в чужом слоте —
+        это TYPE_ERROR, а не отказ раннера."""
+        params = M.PARAMS.get(lit["predicate"])
+        if params is None:
+            return True
+        args = lit.get("args") or []
+        if len(args) != len(params):
+            ISSUES.append("TYPE_ERROR"); TYPE_ERROR_PREDICATES.add(lit["predicate"])
+            return False
+        for expected, a in zip(params, args):
+            actual = arg_type(a)
+            if actual is not None and not conforms(actual, expected):
+                ISSUES.append("TYPE_ERROR"); TYPE_ERROR_PREDICATES.add(lit["predicate"])
+                return False
+        return True
+
+    def query_typed(lit: dict) -> bool:
+        params = M.PARAMS.get(lit["predicate"])
+        if params is None:
+            return False
+        args = lit.get("args") or []
+        if len(args) != len(params):
+            return False
+        return all(arg_type(a) is None or conforms(arg_type(a), expected)
+                   for expected, a in zip(params, args))
+
+    def typed_arg(a: dict) -> tuple:
+        """Литерал-терм §53 как (значение, тип); тип сущности у entity_ref — "entity"."""
+        k = a.get("kind")
+        if k == "entity_ref":
+            return a["id"], "entity"
+        if k == "const_ref":
+            # DECISION-0273: параметр A3 в вопросе `term` — за срезом раннера (значение на legal_time дела).
+            if a.get("id") in M.A3_TYPES:
+                raise RT.Refused("параметр A3 в вопросе вне среза раннера: " + str(a.get("id")))
+            c = M.CONSTS.get(a.get("id"))
+            if c is None:
+                return RT.sym(str(a.get("id"))), "enum"
+            return c[1], c[0]
+        if k == "value":
+            t = (a.get("type") or {}).get("name")
+            if t in (MON, DEC, INT, TEXT, DATE, RAT, QTY, BOOL, NAT, INSTANT):
+                return arg(a), t
+            raise RT.Refused("аргумент вне среза раннера: " + str(t))
+        raise RT.Refused("узел терма вне среза раннера: " + str(k))
+
+    def slot_typed(pred: str, col: int, v) -> tuple:
+        t = M.PARAMS[pred][col]
+        if isinstance(v, str):
+            ent, txt = v in ENTITIES, v in TEXTS
+            if ent and txt:
+                raise RT.Refused("одна запись подана делом и сущностью, и Text: вид результата не определён в срезе")
+            if ent:
+                return v, "entity"
+            if txt:
+                return v, TEXT
+            return v, (TEXT if t == TEXT else "entity")
+        if isinstance(v, bool):
+            return v, BOOL
+        if t in (MON, DEC, INT, DATE, RAT, QTY, NAT, INSTANT):
+            return v, t
+        return v, ("enum" if isinstance(v, RT.Sym) else "entity")
+
+    def eval_term(node: dict, env: dict) -> tuple:
+        k = node.get("kind")
+        if k == "var":
+            if node["var"] not in env:
+                raise RT.Refused("несвязанная переменная терма: " + str(node["var"]))
+            return env[node["var"]]
+        if k == "value" and (node.get("type") or {}).get("name") == RAT:
+            # ERR-E0005: операнд вычисления разбирается как у оракула — сократимая
+            # запись нормализуется; каноничность §168.1 — у записей, не у операнда.
+            return RT.lit_rat_term(node.get("value")), RAT
+        if k in ("value", "entity_ref", "const_ref"):
+            return typed_arg(node)
+        if k == "binary":
+            lv, lt = eval_term(node["left"], env)
+            rv, rt = eval_term(node["right"], env)
+            op = node["op"]
+            if op in CMP_OPS:
+                # §57 (`values.binary`, `_check_same_kind`): валюта, единица, затем вид.
+                if lt == rt == MON and lv.cur != rv.cur:
+                    raise RT.TermError("CURRENCY_MISMATCH")
+                if lt == rt == QTY and lv.unit != rv.unit:
+                    raise RT.TermError("DIMENSION_MISMATCH")
+                if {lt, rt} == {DATE, INSTANT}:
+                    raise RT.TermError("DATE_INSTANT_MISMATCH")
+                if norm(lt) != norm(rt):
+                    raise RT.TermError("TYPE_ERROR")
+                if lt == BOOL:
+                    # §57 (DECISION-0266): Boolean сравнимо только на равенство; порядок — TYPE_ERROR оракула.
+                    if op not in ("eq", "ne"):
+                        raise RT.TermError("TYPE_ERROR")
+                    return RT.cmp(lv, op, rv), BOOL
+                if lt not in NUM and lt not in (DATE, INSTANT):
+                    raise RT.Refused("операция вне среза раннера: " + op)
+                return RT.cmp(lv, op, rv), BOOL
+            if lt not in NUM or rt not in NUM:
+                raise RT.Refused(f"арифметика вне среза (§58): не числовой операнд {op}")
+            if op not in ("add", "sub", "mul", "div", "mod"):
+                raise RT.Refused("операция вне среза раннера: " + op)
+            # §58 `values.binary` (DECISION-0252 п. 8): вид исхода — по значению;
+            # ошибка значения — TermError, ответ вопроса `term` — RUNTIME_ERROR.
+            v = RT.arith(op, lv, rv, KIND_CODE[lt], KIND_CODE[rt])
+            if isinstance(v, RT.Rat):
+                return v, RAT
+            if isinstance(v, RT.Money):
+                return v, MON
+            if isinstance(v, RT.Qty):
+                return v, QTY
+            return v, (INT if norm(lt) == norm(rt) == INT else DEC)
+        if k == "call" and node.get("function") in M.FUNCTIONS:
+            # DECISION-0273: функция §46 модуля; арность и типы аргументов — TYPE_ERROR
+            # оракула (`_require_type`), вид результата — объявленный.
+            f, params, returns = M.FUNCTIONS[node["function"]]
+            args = [eval_term(x, env) for x in node.get("args") or []]
+            if len(args) != len(params):
+                raise RT.TermError("TYPE_ERROR")
+            for (_v, t), want in zip(args, params):
+                ok = norm(t) == norm(want) if want.startswith("urn:law:std#") else t in ("enum", want)
+                if not ok:
+                    raise RT.TermError("TYPE_ERROR")
+            return f(*[v for v, _t in args]), (returns if returns.startswith("urn:law:std#") else "enum")
+        if k == "call":
+            fn = str(node.get("function")).split("#")[-1]
+            args = [eval_term(x, env) for x in node.get("args") or []]
+            t = call_kind(fn, [x[1] for x in args])
+            if fn == "round":
+                # DECISION-0259: политика §50 проверяется рантаймом; виды вопроса точные.
+                return RT.round_mode(args[0][0], args[1][0], args[2][0],
+                                     KIND_CODE[args[0][1]], KIND_CODE[args[1][1]]), t
+            if fn == "div_round":
+                return RT.div_round(args[0][0], args[1][0], args[2][0], args[3][0],
+                                    KIND_CODE[args[0][1]], KIND_CODE[args[1][1]], KIND_CODE[args[2][1]]), t
+            return getattr(RT, RT_NAME.get(fn, fn))(*[x[0] for x in args]), t
+        if k == "aggregate":
+            return aggregate(node)
+        if k == "if":
+            # §56 (E-0180, DECISION-0270): чистое data-условие, ветвь вычисляется лениво.
+            return eval_term(node["then"] if data_cond(node.get("condition"), env) else node["else"], env)
+        raise RT.Refused("узел терма вне среза раннера: " + str(k))
+
+    def data_cond(f: dict, env: dict) -> bool:
+        """Data-условие §56 (`values.is_data_condition`): boolean, comparison, and, or."""
+        k = (f or {}).get("kind")
+        if k == "boolean":
+            return bool(f.get("value"))
+        if k == "comparison":
+            return bool(eval_term({"kind": "binary", "op": f["op"], "left": f["left"], "right": f["right"]}, env)[0])
+        if k == "and":
+            return all(data_cond(x, env) for x in f.get("items") or [])
+        if k == "or":
+            return any(data_cond(x, env) for x in f.get("items") or [])
+        raise RT.Refused("условие терма §56 вне data-условия вне среза раннера: " + str(k))
+
+    def materialize(comp: dict) -> list:
+        """Материализация §52.1: элементы в порядке канонических байтов, distinct — множество."""
+        if (comp or {}).get("kind") != "comprehension":
+            raise RT.Refused("aggregate.input вне среза раннера")
+        if comp.get("binders"):
+            raise RT.Refused("связки comprehension вне среза раннера")
+        atoms, guards = [], []
+        flatten(comp["generator"], atoms, guards)
+        if not atoms:
+            raise RT.Refused("тело без перебираемых атомов вне среза генератора")
+        for a in atoms:
+            if a.get("polarity") != "positive":
+                raise RT.Refused("отрицательный литерал в теле вне L0-среза")
+            if a["predicate"] not in M.PARAMS:
+                raise RT.Refused("предикат comprehension не объявлен в пакете: " + str(a["predicate"]))
+            if len(a.get("args") or []) != len(M.PARAMS[a["predicate"]]):
+                raise RT.Refused("арность атома тела не совпадает с сигнатурой §189")
+        out, seen = [], set()
+        # L1 (DECISION-0237): перечисляются только установленные строки (TRUE_ONLY) —
+        # в таблицах модели лежат и строки с одной отрицательной либо спорной опорой.
+        rows_of = M.established_rows if LAYER == "L1" else (lambda urn: M.TABLES[urn])
+
+        def walk(i: int, env: dict) -> None:
+            if i == len(atoms):
+                for g in guards:
+                    if not RT.cmp(eval_term(g["left"], env)[0], g["op"], eval_term(g["right"], env)[0]):
+                        return
+                val = eval_term(comp["element"], env)
+                key = canon(literal(val))
+                if comp["distinct"]:
+                    if key in seen:
+                        return
+                    seen.add(key)
+                out.append((key, val))
+                return
+            a = atoms[i]
+            for row in rows_of(a["predicate"]):
+                nxt = dict(env)
+                ok = True
+                for j, x in enumerate(a["args"]):
+                    if x.get("kind") == "var":
+                        b = nxt.get(x["var"])
+                        if b is None:
+                            nxt[x["var"]] = slot_typed(a["predicate"], j, row[j])
+                        elif not RT.eq(b[0], row[j]):
+                            ok = False
+                    elif not RT.eq(eval_term(x, nxt)[0], row[j]):
+                        ok = False
+                    if not ok:
+                        break
+                if ok:
+                    walk(i + 1, nxt)
+
+        walk(0, {})
+        out.sort(key=lambda kv: kv[0].encode("utf-8"))
+        return [v for _, v in out]
+
+    def aggregate(node: dict) -> tuple:
+        items = materialize(node.get("input"))
+        op = str(node.get("op"))
+        if op == "count":
+            return RT.dec(str(len(items))), INT
+        if op == "only":
+            # §51 (errata E-0256): функциональный lookup. Политика — TYPE_ERROR у
+            # оракула; пусто и два различных значения (канонические байты §208) —
+            # ошибки значения RUNTIME_ERROR, код тот же, что у оракула.
+            if node.get("options"):
+                raise RT.TermError("TYPE_ERROR")
+            if not items:
+                raise RT.TermError("EMPTY_AGGREGATE")
+            if len({canon(literal(it)) for it in items}) > 1:
+                raise RT.TermError("CARDINALITY_CONFLICT")
+            return items[0][0], norm(items[0][1])
+        if op not in ("sum", "min", "max"):
+            raise RT.Refused("агрегат вне среза раннера: " + op)
+        if not items:
+            empty = (node.get("options") or {}).get("empty")
+            if empty is None:
+                raise RT.Refused(f"EMPTY_AGGREGATE: {op} над пустой коллекцией без явной empty-политики (§59)")
+            if empty.get("kind") != "value":
+                # `from_literal_term` оракула: политика — LiteralTerm §53; иной узел
+                # даёт TYPE_ERROR раньше сверки вида.
+                raise RT.TermError("TYPE_ERROR")
+            value = typed_arg(empty)
+            # errata E-0195: вид политики обязан совпасть с видом элемента. У оракула
+            # это issue `TYPE_ERROR` с текстом «aggregate.empty: вид политики integer
+            # не совпадает с видом элемента коллекции money (§59)»; порождённый
+            # модуль сообщений не печатает вовсе, и байтовый контракт среза здесь —
+            # КОД issue, который тот же. До правки коллекция Money с политикой
+            # Integer отвечала `Integer 0` и `COMPUTED` — другой ответ, не меньший.
+            expected = EMPTY_ELEMENT_KINDS.get(
+                (((node.get("input") or {}).get("variable") or {}).get("type") or {}).get("name"))
+            if expected is not None and norm(value[1]) != expected:
+                raise RT.TermError("TYPE_ERROR")
+            return value
+        acc = items[0]
+        for it in items[1:]:
+            if acc[1] not in NUM or norm(it[1]) != norm(acc[1]):
+                raise RT.Refused(f"арифметика вне среза (§58): виды операндов не совпадают у {op}")
+            if op == "sum":
+                acc = (RT.add(acc[0], it[0]), acc[1])
+            elif RT.cmp(it[0], "lt" if op == "min" else "gt", acc[0]):
+                acc = it
+        if acc[1] not in NUM:
+            raise RT.Refused(f"арифметика вне среза (§58): не числовой операнд {op}")
+        # DECISION-0266: итог агрегата над Natural у оракула — вид `integer`, то есть Integer.
+        return acc[0], norm(acc[1])
+
+    def term_error_status(goal: dict):
+        """Порт `whynot.term_error_blockers` + `term_error_status`: правила с
+        совместимой головой, их ошибки терма и конъюнкты без опоры — вглубь."""
+        nonlocal LAST_TERM_CODES
+        by_rule: dict = {}
+        for name, code in getattr(M, "_ISSUE_SEEN", ()):
+            if code != "MISSING_PARAMETER_VALUE":
+                by_rule.setdefault(name, []).append(code)
+        if not by_rule:
+            return None
+        index: dict = {}
+        for r in M.BACKCHAIN:
+            index.setdefault(r["head"]["predicate"], []).append(r)
+
+        def deref(a):
+            if a.get("kind") == "const_ref" and a.get("id") in M.BACKCHAIN_CONSTS:
+                return M.BACKCHAIN_CONSTS[a["id"]]
+            return a
+
+        def compatible(head, target):
+            if head.get("polarity", "positive") != target.get("polarity", "positive"):
+                return None
+            if len(head["args"]) != len(target["args"]):
+                return None
+            subst = {}
+            for h, g in zip(head["args"], target["args"]):
+                if g.get("kind") == "var":
+                    continue
+                if h.get("kind") == "var":
+                    if h["var"] in subst and _canon_json(subst[h["var"]]) != _canon_json(g):
+                        return None
+                    subst[h["var"]] = g
+                elif h.get("kind") not in ("entity_ref", "const_ref", "value"):
+                    continue
+                elif _canon_json(h) != _canon_json(g):
+                    return None
+            return subst
+
+        def truth(lit) -> str:
+            saved = (set(ENTITIES), set(TEXTS))
+            try:
+                st = M.status(lit["predicate"], [arg(x) for x in lit["args"]])
+            finally:
+                ENTITIES.clear(); ENTITIES.update(saved[0]); TEXTS.clear(); TEXTS.update(saved[1])
+            return MIRROR[st] if lit.get("polarity") == "negative" else st
+
+        found, visited = set(), set()
+
+        def walk(target) -> None:
+            key = _canon_json(target)
+            if key in visited:
+                return
+            visited.add(key)
+            for r in index.get(target.get("predicate"), ()):
+                subst = compatible(r["head"], target)
+                if subst is None:
+                    continue
+                w = r["window"]
+                if w and ((w.get("start") and RT.legal_time() < w["start"])
+                          or (w.get("end") and RT.legal_time() >= w["end"])):
+                    continue
+                found.update(by_rule.get(r["name"], ()))
+                for _status, lit in r["body"]:
+                    if lit.get("kind") != "literal":
+                        continue  # DECISION-0274: гарды в backchain — только для пути судьи
+                    args = lit.get("args") or []
+                    if any(a.get("kind") == "wildcard" for a in args):
+                        continue
+                    # DECISION-0270: вычисляемый аргумент (binary/call/if) не заземляется
+                    # обходом — как несвязанная переменная, конъюнкт идёт вглубь без оценки.
+                    computed = lambda a: (a or {}).get("kind") in ("binary", "call", "if", "let", "match")
+                    if any((a.get("kind") == "var" and (a["var"] not in subst or computed(subst[a["var"]])))
+                           or computed(a) for a in args):
+                        walk(dict(lit, args=[subst.get(a["var"], a) if a.get("kind") == "var" else a
+                                             for a in args]))
+                        continue
+                    ground = dict(lit, args=[subst[a["var"]] if a.get("kind") == "var" else a for a in args])
+                    if truth(ground) == "NEITHER":
+                        walk(ground)
+
+        walk(dict(goal, args=[deref(a) for a in goal.get("args") or []]))
+        LAST_TERM_CODES = set(found)
+        statuses = {TERM_ERROR_STATUS.get(c, "RUNTIME_ERROR") for c in found}
+        return next((st for st in TERM_ERROR_PRECEDENCE if st in statuses), None)
+
+    def rule_error_status(goal: dict, truth: str):
+        """Статус результата, зависящего от упавшего правила: NEITHER — статус кода
+        (E-0105), иная истинность — итог §181.2; смешанные коды — порядок issue,
+        которого раннер не воспроизводит, — названный отказ."""
+        te = term_error_status(goal)
+        codes = set(LAST_TERM_CODES) if te is not None else set()
+        ct = carrier_type_error(goal)
+        if te is None and ct is None:
+            return None
+        if truth == "NEITHER":
+            return te or ct
+        if ct is not None:
+            codes.add("TYPE_ERROR")
+        kept = [c for c in codes if c in OUTCOME_CODES]
+        if not kept:
+            return "NON_EXECUTABLE"
+        if len(kept) == len(codes) and len(set(kept)) == 1:
+            return kept[0]
+        raise RT.Refused("статус итога §181.2 зависит от порядка issue вне среза раннера")
+
+    def carrier_type_error(goal: dict):
+        """E-0243 §181.2: TYPE_ERROR of a fact blocks only its forward readers."""
+        if not TYPE_ERROR_PREDICATES:
+            return None
+        index = getattr(M, "CARRIER_EDGES", {})
+        seen = set()
+
+        def walk(predicate):
+            if predicate in seen:
+                return False
+            seen.add(predicate)
+            if predicate in TYPE_ERROR_PREDICATES:
+                return True
+            return any(walk(child) for child in index.get(predicate, ()))
+        return "TYPE_ERROR" if walk(goal.get("predicate")) else None
+
+    def _jhook_val(t: dict):
+        """Значение литерал-терма для обхода суждения; множества сущностей и текстов дела не двигаются."""
+        saved = (set(ENTITIES), set(TEXTS))
+        try:
+            return arg(t)
+        finally:
+            ENTITIES.clear(); ENTITIES.update(saved[0]); TEXTS.clear(); TEXTS.update(saved[1])
+
+    JHOOKS = {"val": _jhook_val, "cell": lambda pred, col, v: literal(slot_typed(pred, col, v))}
+
+    def judgment_requests(goal: dict, status: str, conflict: bool, tail: str) -> list:
+        """Обход запроса судье §47.3 (DECISION-0274) — порт в рантайме, здесь переводы термов."""
+        goal = dict(goal, polarity=goal.get("polarity", "positive"))
+        return RT.build_requests(M, RT.judgment_blockers(M, JHOOKS, goal, status, conflict), tail)
+
+    def key_conflict_blocks(predicate: str) -> bool:
+        """E-0210/E-0242: only the forward closure of a conflicted relation blocks."""
+        tainted = set(M.key_conflict_predicates())
+        waiting = list(tainted)
+        while waiting:
+            source = waiting.pop()
+            for consumer in getattr(M, "KEY_READERS", {}).get(source, ()):
+                if consumer not in tainted:
+                    tainted.add(consumer)
+                    waiting.append(consumer)
+        return predicate in tainted
+
+    def calendar_setup() -> None:
+        """Политика §86 и снимок §85 дела до вывода (DECISION-0245 п. 4): порт
+        `engine._resolve_deadline_policy` и `engine._calendar_snapshot`."""
+        ref = effective_context(case).get("deadlinePolicy")
+        policy = None
+        if ref is not None:
+            if M.CAL_SEMVER.startswith("0.1"):
+                if not isinstance(ref, dict):
+                    raise RT.Refused("case.context.deadlinePolicy вне среза раннера (§86)")
+                policy = ref
+            elif not isinstance(ref, str):
+                raise RT.Refused("case.context.deadlinePolicy: в 0.2 ожидался DeadlinePolicyRef (DECISION-0111 §2.9)")
+            elif ref not in M.CAL_POLICIES:
+                raise RT.Refused("case.context.deadlinePolicy: ссылка не разрешена в закреплённом CLIR (§86)")
+            else:
+                policy = M.CAL_POLICIES[ref]
+        selected = (case.get("options") or {}).get("calendarSnapshot")
+        snapshot = None
+        if selected:
+            snapshot = next((c for c in M.CAL_SNAPSHOTS if c["id"] == selected), None)
+            if snapshot is None:
+                raise RT.Refused("MISSING_CALENDAR: calendar_snapshot не объявлен в программе (§85, §168.2)")
+        elif len(M.CAL_SNAPSHOTS) >= 2:
+            raise RT.Refused("AMBIGUOUS_CALENDAR: в программе несколько calendar_snapshot без выбора (§85, §168.2)")
+        elif M.CAL_SNAPSHOTS:
+            snapshot = M.CAL_SNAPSHOTS[0]
+        RT.set_calendar(policy, snapshot)
+
+    def rows_answer(query: dict, issues: list) -> dict:
+        """Внутренний вид API `rows` (DECISION-0423 §2.1): установленные строки
+        вопроса литерал-термами §53, статус вычисления — как у вопроса о том же
+        отношении (конфликт ключа блокирует читателей, E-0242)."""
+        pred = query.get("predicate")
+        if pred not in M.PARAMS:
+            raise RT.Refused("предикат rows не объявлен в пакете: " + str(pred))
+        src = M.established_rows(pred) if LAYER == "L1" else M.TABLES.get(pred, [])
+        rows = [[literal(slot_typed(pred, col, v)) for col, v in enumerate(r)] for r in src]
+        rows.sort(key=lambda r: canon(r).encode("utf-8"))
+        evaluation = "NON_EXECUTABLE" if key_conflict_blocks(pred) else "COMPUTED"
+        return {"queryId": query["queryId"], "resultKind": "COLLECTION", "rows": rows,
+                "evaluationStatus": evaluation, "judgmentRequests": [], "issues": list(issues)}
+
+    # --- исполнение -----------------------------------------------------------
+    try:
+        RT.set_legal_time(str((case.get("context") or {}).get("legalTime", "")))
+        context = case.get("context") or {}
+        # E-0212 §135.1: a supplied decision is the status moment; a default is not.
+        if "decisionTime" in context and hasattr(M, "set_status_time"):
+            M.set_status_time(str(context["decisionTime"])[:10])
+        if hasattr(M, "CAL_SNAPSHOTS"):
+            calendar_setup()
+        for a in case.get("assertions") or []:
+            if a.get("valid") is not None:
+                raise RT.Refused("поле assertion.valid вне среза раннера (§72)")
+            lit = a["literal"]
+            if lit.get("polarity") != "positive" and (LAYER != "L1" or lit.get("polarity") != "negative"):
+                raise RT.Refused("§113: отрицательный факт вне L0-среза")
+            if lit["predicate"] == "urn:law:std#incompatible" and hasattr(M, "POSITIONS"):
+                # §105.1: явная несовместимость позиций — конфликт вне среза (DECISION-0242 K5).
+                raise RT.Refused("конфликт позиций §105.1 (incompatible) вне среза раннера (DECISION-0242 K5)")
+            if not well_typed(lit):
+                continue
+            if lit["predicate"] not in M.PARAMS:
+                continue
+            # §47.3.1 (E-0089, DECISION-0274): ответ судьи не от того органа или не по форме — не принят.
+            rejected = RT.judgment_answer(M, a)
+            if rejected is not None:
+                ISSUES.append(rejected)
+                continue
+            if LAYER == "L1":
+                M.register(lit["predicate"], [arg(x) for x in lit["args"]], lit["polarity"])
+            else:
+                M.register(lit["predicate"], [arg(x) for x in lit["args"]])
+        M.saturate()
+        if stats is not None and LAYER == "L1":
+            # Замер потребителя (DECISION-0237 этап 6): кандидаты, группы и
+            # наибольшая группа конфликта; в протокол ответа не входит.
+            stats.update(M.STATS)
+        # DECISION-0239 G3: ошибки значения агрегатов в правилах — issues модели.
+        ISSUES.extend(getattr(M, "RULE_ISSUES", []))
+        # DECISION-0242: диагностики эффектов полномочий §127–§128.
+        ISSUES.extend(getattr(M, "NORM_ISSUES", []))
+        ISSUES.extend(["KEY_CONFLICT"] * M.key_conflicts())
+        kind = query.get("kind")
+        if kind == "rows" and api:
+            return rows_answer(query, ISSUES)
+        if kind == "collect":
+            elements = materialize(query["comprehension"])
+            if any(isinstance(e[0], str) and e[0].startswith("urn:position:") for e in elements):
+                raise RT.Refused("позиция в элементе коллекции вне среза раннера (DECISION-0242 K4)")
+            return {"queryId": query["queryId"], "resultKind": "COLLECTION",
+                    "value": [literal(e) for e in elements], "evaluationStatus": "COMPUTED", "issues": list(ISSUES)}
+        if kind == "term":
+            try:
+                value = literal(eval_term(query["term"], {}))
+            except RT.TermError as exc:
+                # §58/§175 (DECISION-0252 п. 8): ошибка значения вопроса — без значения;
+                # статус по таблице `queries.query_calc`: несовместимость видов —
+                # TYPE_ERROR, прочее — RUNTIME_ERROR.
+                status = "TYPE_ERROR" if exc.code in TYPE_ERROR_CODES else "RUNTIME_ERROR"
+                return {"queryId": query["queryId"], "resultKind": "DATA", "evaluationStatus": status,
+                        "issues": ISSUES + [exc.code]}
+            return {"queryId": query["queryId"], "resultKind": "DATA", "value": value,
+                    "evaluationStatus": "COMPUTED", "issues": list(ISSUES)}
+        if kind != "truth":
+            raise RT.Refused("вид запроса вне среза раннера: " + str(kind))
+        # Ключ атома у оракула §208 включает ТИП значения: запрос с Integer к
+        # утверждению Decimal той же величины атома не находит и отвечает NEITHER
+        # без issue. Рантайм сравнивает числа по величине, поэтому запрос
+        # сверяется с сигнатурой так же, как утверждение, но без TYPE_ERROR.
+        literal_q = query["literal"]
+        if any(x.get("kind") == "entity_ref" and str(x.get("id", "")).startswith("urn:position:")
+               for x in literal_q.get("args") or []):
+            raise RT.Refused("позиция в аргументе вопроса вне среза раннера (DECISION-0242 K4)")
+        tail = str(query["queryId"]).rsplit(":", 1)[-1]
+        if LAYER == "L1":
+            # §62/§63: статус атома по опорам обеих полярностей; отрицательный
+            # вопрос зеркалит стороны. Несогласованный по сигнатуре вопрос атома
+            # не находит — NEITHER.
+            status = "NEITHER"
+            if query_typed(literal_q):
+                status = M.status(literal_q["predicate"], [arg(x) for x in literal_q["args"]])
+            if literal_q.get("polarity") == "negative":
+                status = MIRROR[status]
+            evaluation = "COMPUTED"
+            conflict = literal_q["predicate"] in M.PARAMS and (literal_q["predicate"], RT.key(
+                    [arg(x) for x in literal_q["args"]])) in getattr(M, "BLOCKED", ())
+            # §47.3 (DECISION-0274): судьи по лестнице §175 — конфликт старше судьи, судья старше ошибки терма.
+            requests = judgment_requests(literal_q, status, conflict, tail)
+            if conflict:
+                # §127: эффект заперт непобеждённой парой Power/Immunity.
+                evaluation = "UNRESOLVED_NORMATIVE_CONFLICT"
+            elif key_conflict_blocks(literal_q["predicate"]):
+                evaluation = "NON_EXECUTABLE"
+            elif requests:
+                evaluation = "REQUIRES_JUDGMENT"
+            elif term_error_status(literal_q) or carrier_type_error(literal_q):
+                evaluation = rule_error_status(literal_q, status)
+            elif status == "NEITHER" and hasattr(M, "BACKCHAIN"):
+                # E-0105 (§175/§185): NEITHER над ошибкой терма правила-кандидата.
+                evaluation = term_error_status(literal_q) or evaluation
+            return {"queryId": query["queryId"], "truthStatus": status, "evaluationStatus": evaluation,
+                    "judgmentRequests": requests, "issues": list(ISSUES)}
+        hit = False
+        if query_typed(literal_q):
+            want = [arg(x) for x in literal_q["args"]]
+            rows = M.TABLES.get(literal_q["predicate"], [])
+            hit = any(len(r) == len(want) and all(RT.eq(v, want[i]) for i, v in enumerate(r)) for r in rows)
+        # Открытый мир: отсутствие строки — это NEITHER, а не FALSE_ONLY.
+        # §47.3 (DECISION-0274): судьи у модели L0 — тот же обход по `backchain`.
+        status0 = "TRUE_ONLY" if hit else "NEITHER"
+        requests0 = judgment_requests(literal_q, status0, False, tail)
+        # Error status is scoped through the compatible producer/backchain of the
+        # queried atom.  An unrelated failed derivation remains an issue in the
+        # document but must not turn this query into TYPE_ERROR.
+        rule_error = rule_error_status(literal_q, status0)
+        return {"queryId": query["queryId"],
+                "truthStatus": status0,
+                "evaluationStatus": "NON_EXECUTABLE" if key_conflict_blocks(literal_q["predicate"])
+                else ("REQUIRES_JUDGMENT" if requests0 else (rule_error or "COMPUTED")),
+                "judgmentRequests": requests0,
+                "issues": list(ISSUES)}
+    except RT.TermError as exc:
+        # Ошибка значения вне вопроса `term` и вне правил модели (гард
+        # comprehension вопроса) — названный отказ, а не крах.
+        raise RT.Refused("ошибка значения вне среза раннера: " + exc.code) from None