arxo-codegen 0.4.0__py3-none-any.whl

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

@@ -0,0 +1,463 @@
+"""Фикстуры поражаемого слоя для ворот кодогенерации (DECISION-0237, этап 4).
+
+Векторы L1 держат совпадение с голденом, но не держат РЕШАЮЩУЮ норму: модуль,
+который потерял приоритет или дефитер, на части векторов всё ещё отвечал бы
+верно. Поэтому у каждой фикстуры с ответом есть канарейка — та же программа
+без решающего узла. Ожидание канарейки записано из прозы, как и ожидание
+фикстуры, и обязано ОТЛИЧАТЬСЯ от него: если снятие нормы ответа не меняет,
+ворота этой нормы не видят, и канарейка валит ворота.
+
+Каждая фикстура исполняется ещё и в перестановке — правила, приоритеты,
+факты пакета и дела в обратном порядке: ответ не зависит от порядка
+кандидатов (DECISION-0237 п. 10).
+
+Структурные фикстуры ответа не несут: план обязан отказать ровно названной
+причиной (§110, §111) либо построиться (монотонная рекурсия §103).
+
+Ожидания записаны из SPEC; сверка с оракулом 14.09.2026 — в DECISION-0237,
+раздел «Исполнение»: у позднего производителя через строгую цепочку оракул
+отвечает не по прозе, срез отказывает.
+
+Язык описания: литерал `p(X, a)` — переменная с заглавной, сущность
+`urn:entity:<имя>` со строчной; `!p(X)` — отрицательная полярность;
+`not_known[p(X)]` и другие статусы §65 — статусный конъюнкт; `&` — конъюнкция.
+Число в аргументе — Decimal. Агрегат §59 в гарде (DECISION-0239):
+`count{Y | p(X, Y); q(Y)} >= 2` — элемент, генератор через `;`, сравнение,
+порог-Integer; `sum{V | fee(X, V)} >= 0` — порог-Decimal. У предиката арность
+либо список типов (`["Text", "Decimal"]`); `closures` — (имя, предикат, домен).
+Ожидание `issues` — коды диагностик среза, сверяются вместе со статусом.
+
+Календарь (DECISION-0245): `@2026-01-31` — Date, `5 business_day` —
+Quantity-счётчик, `add_business_days(D, 5 business_day)` — вызов std;
+сравнение термов `F > add_business_days(D, 3 business_day)` — гард.
+`calendar` — датасет снимка §85 (узел и байты ресурса), `policy` — политика
+§86: узел `deadline_policy` программы, а контекст дела несёт только его
+StableId — `DeadlinePolicyRef` 0.2 (DECISION-0111 §2.9). Канарейка снимает
+`Overrides` (исключения календаря) или `Policy` (ссылку дела на политику) так
+же, как правило.
+"""
+from __future__ import annotations
+
+import hashlib
+import json
+import re
+
+NS = "urn:law:backends:l1"
+
+_WEEK = [{"day": d, "working": d not in ("saturday", "sunday"),
+          "intervals": [{"start": "09:00:00", "end": "18:00:00"}] if d not in ("saturday", "sunday") else []}
+         for d in ("monday", "tuesday", "wednesday", "thursday", "friday", "saturday", "sunday")]
+CAL_2026 = {"schemaVersion": "law.calendar/0.1", "id": "urn:law:backends:calendar:2026", "timezone": "Asia/Qyzylorda",
+            "timezoneDbSnapshot": "iana-tzdb@2026a", "valid": {"start": "2026-01-01", "endExclusive": "2027-01-01"},
+            "weeklySchedule": _WEEK, "sourceArtifacts": ["urn:law:backends:calendar-source:2026"],
+            "overrides": [{"date": "2026-03-09", "working": False, "intervals": [], "reason": "перенос выходного"}]}
+POLICY = {"start_count": "next_day", "include_end": True, "roll": "no_roll"}
+
+CAL_FIXTURES = [
+    # --- календарные функции §84–§86 (DECISION-0245) ----------------------
+    {"name": "business-days-holiday", "basis": "§85.1/§86: нерабочий день исключения не считается днём срока",
+     "preds": {"got": ["Text", "Date"], "filed": ["Text", "Date"], "late": 1},
+     "rules": [("Late", "strict", "late(X)", "got(X, D) & filed(X, F) & F > add_business_days(D, 3 business_day)")],
+     "calendar": CAL_2026, "policy": POLICY,
+     "case": ["got(a, @2026-03-05)", "filed(a, @2026-03-11)"], "query": "late(a)", "expect": "NEITHER",
+     "canary": {"drop": ["Overrides"], "expect": "TRUE_ONLY"}},
+    {"name": "calendar-month-end", "basis": "§84.2/§86 (E-0026): 31 января + месяц — последний день февраля",
+     "preds": {"start": ["Text", "Date"], "expires": ["Text", "Date"]},
+     "rules": [("Expire", "strict", "expires(X, add_calendar_period(D, 1 calendar_month))", "start(X, D)")],
+     "policy": {"start_count": "same_day", "include_end": True, "roll": "no_roll", "month_end": "last_day_of_month"},
+     "case": ["start(a, @2026-01-31)"], "query": "expires(a, @2026-02-28)", "expect": "TRUE_ONLY",
+     "canary": {"drop": ["Policy"], "expect": "NEITHER", "issues": ["MISSING_POLICY"]}},
+    {"name": "guard-out-of-range", "basis": "§85.1 (T040): срок за покрытием снимка — CALENDAR_OUT_OF_RANGE, "
+                                           "правило не срабатывает",
+     "preds": {"got": ["Text", "Date"], "filed": ["Text", "Date"], "late": 1},
+     "rules": [("Late", "strict", "late(X)", "got(X, D) & filed(X, F) & F > add_business_days(D, 5 business_day)")],
+     "calendar": CAL_2026, "policy": POLICY,
+     "case": ["got(a, @2026-12-28)", "filed(a, @2027-01-20)"], "query": "late(a)", "expect": "NEITHER",
+     "issues": ["CALENDAR_OUT_OF_RANGE"],
+     "canary": {"drop": ["Policy"], "expect": "NEITHER", "issues": ["MISSING_POLICY"]}},
+    {"name": "days-between-l0", "basis": "§84.4 (E-0015): календарные дни между датами, модель L0",
+     "preds": {"pair": ["Text", "Date", "Date"], "long": 1},
+     "rules": [("Long", "strict", "long(X)", "pair(X, A, B) & days_between(A, B) >= 30")],
+     "case": ["pair(a, @2026-01-01, @2026-02-15)"], "query": "long(a)", "expect": "TRUE_ONLY",
+     "canary": {"drop": ["Long"], "expect": "NEITHER"}},
+    {"name": "window-calendar-bound", "basis": "§135/§84.2: граница окна обязанности — календарный терм; "
+                                              "без политики граница неизвестна (issue)",
+     "preds": {"owes": ["Text", "Date"], "paid": 1},
+     "templates": [("Pay", "duty", {"kind": "duty", "bearer": "X", "goal": {
+         "kind": "achievement", "condition": "paid(X)",
+         "window": ["D", "add_calendar_period(D, 1 calendar_month)"]}})],
+     "rules": [("MakePay", "strict", "norm:Pay", "owes(X, D)")],
+     "policy": {"start_count": "same_day", "include_end": True, "roll": "no_roll", "month_end": "last_day_of_month"},
+     "case": ["owes(a, @2026-08-01)"], "query": "positions", "expect": "UNDETERMINED",
+     "canary": {"drop": ["Policy"], "expect": "ACTIVE", "issues": ["MISSING_POLICY"]}},
+]
+
+L2_FIXTURES = [
+    # --- нормативные позиции L2 (DECISION-0242) ---------------------------
+    {"name": "duty-satisfied", "basis": "§136: условие цели TRUE_ONLY — обязанность SATISFIED",
+     "preds": {"owes": 1, "receipt": 1, "paid": 1},
+     "templates": [("Pay", "duty", {"kind": "duty", "bearer": "X", "goal": {
+         "kind": "achievement", "condition": "paid(X)", "window": ["2026-01-01", "2026-12-31"]}})],
+     "rules": [("MakePay", "strict", "norm:Pay", "owes(X)"), ("Paid", "strict", "paid(X)", "receipt(X)")],
+     "case": ["owes(a)", "receipt(a)"], "query": "positions", "expect": "SATISFIED",
+     "canary": {"drop": ["Paid"], "expect": "ACTIVE"}},
+    {"name": "duty-violated-by-closure", "basis": "§136.3/§70: после окна явный негатив замыкания — VIOLATED",
+     "preds": {"owes": 1, "debtor": 1, "paid": 1},
+     "templates": [("Pay", "duty", {"kind": "duty", "bearer": "X", "goal": {
+         "kind": "achievement", "condition": "paid(X)", "window": ["2026-01-01", "2026-06-30"]}})],
+     "rules": [("MakePay", "strict", "norm:Pay", "owes(X)")],
+     "closures": [("PaidRegistry", "paid", "debtor")],
+     "case": ["owes(a)", "debtor(a)"], "query": "positions", "expect": "VIOLATED",
+     "canary": {"drop": ["PaidRegistry"], "expect": "UNDETERMINED"}},
+    {"name": "maintenance-completeness", "basis": "§137: закрытие покрывает окно — maintenance SATISFIED",
+     "preds": {"holder": 1, "insured": 1, "registry": 1},
+     "templates": [("Insure", "duty", {"kind": "duty", "bearer": "X", "goal": {
+         "kind": "maintenance", "condition": "insured(X)", "window": ["2026-01-01", "2026-06-30"]}})],
+     "rules": [("MakeInsure", "strict", "norm:Insure", "holder(X)")],
+     "closures": [("InsuredRegistry", "insured", "registry")],
+     "case": ["holder(a)", "insured(a)", "registry(a)"], "query": "positions", "expect": "SATISFIED",
+     "canary": {"drop": ["InsuredRegistry"], "expect": "UNDETERMINED"}},
+    {"name": "power-effect", "basis": "§127: действительное осуществление полномочия создаёт эффект",
+     "preds": {"minister": 1, "appoint_act": 1, "signed": 1, "authorised": 1, "appointed": 1},
+     "templates": [("Appoint", "power", {"kind": "power", "holder": "X", "exercise": "appoint_act(X)",
+                                         "validWhen": "authorised(X)", "effect": {"kind": "create",
+                                                                                  "after": "appointed(X)"}})],
+     "rules": [("MakeAppoint", "strict", "norm:Appoint", "minister(X)"),
+               ("Auth", "strict", "authorised(X)", "signed(X)")],
+     "case": ["minister(a)", "appoint_act(a)", "signed(a)"], "query": "appointed(a)", "expect": "TRUE_ONLY",
+     "canary": {"drop": ["Auth"], "expect": "NEITHER", "issues": ["POWER_INVALID_EXERCISE"]}},
+    {"name": "immunity-blocks", "basis": "§128/§106: иммунитет старшего правила блокирует эффект",
+     "preds": {"minister": 1, "appoint_act": 1, "authorised": 1, "appointed": 1, "protected": 1},
+     "templates": [("Appoint", "power", {"kind": "power", "holder": "X", "exercise": "appoint_act(X)",
+                                         "validWhen": "authorised(X)", "effect": {"kind": "create",
+                                                                                  "after": "appointed(X)"}}),
+                   ("Protect", "immunity", {"kind": "immunity", "holder": "X",
+                                            "protectedEffect": {"after": "appointed(X)"}})],
+     "rules": [("MakeAppoint", "strict", "norm:Appoint", "minister(X)"),
+               ("MakeProtect", "strict", "norm:Protect", "protected(X)")],
+     "priorities": [("MakeProtect", "MakeAppoint")],
+     "case": ["minister(a)", "appoint_act(a)", "authorised(a)", "protected(a)"], "query": "appointed(a)",
+     "expect": "NEITHER", "issues": ["EFFECT_BLOCKED_BY_IMMUNITY"],
+     "canary": {"drop": ["prio0"], "expect": "NEITHER", "issues": ["UNRESOLVED_NORMATIVE_CONFLICT"]}},
+    {"name": "l2-feedback", "basis": "DECISION-0242 п. 1: норм-правило читает эффект полномочия",
+     "preds": {"minister": 1, "appoint_act": 1, "authorised": 1, "appointed": 1},
+     "templates": [("Appoint", "power", {"kind": "power", "holder": "X", "exercise": "appoint_act(X)",
+                                         "validWhen": "authorised(X)", "effect": {"kind": "create",
+                                                                                  "after": "appointed(X)"}}),
+                   ("Protect", "immunity", {"kind": "immunity", "holder": "X",
+                                            "protectedEffect": {"after": "appointed(X)"}})],
+     "rules": [("MakeAppoint", "strict", "norm:Appoint", "minister(X)"),
+               ("MakeProtect", "strict", "norm:Protect", "appointed(X)")],
+     "plan": "обратная связь L2 вне среза генератора (DECISION-0242 п. 1)"},
+    {"name": "norm-defeater", "basis": "DECISION-0242 K6: дефитер норм-правила вне среза",
+     "preds": {"owes": 1, "paid": 1, "exempt": 1},
+     "templates": [("Pay", "duty", {"kind": "duty", "bearer": "X", "goal": {
+         "kind": "achievement", "condition": "paid(X)", "window": ["2026-01-01", "2026-12-31"]}})],
+     "rules": [("MakePay", "strict", "norm:Pay", "owes(X)"), ("Exempt", "defeater", "norm:Pay", "exempt(X)")],
+     "plan": "дефитер норм-правила вне среза генератора (DECISION-0242 K6)"},
+]
+
+FIXTURES = [
+    {"name": "both-survive", "basis": "§108/§112: несравнимые кандидаты обеих сторон выживают — BOTH",
+     "preds": {"p": 1, "q": 1},
+     "rules": [("D1", "defeasible", "q(X)", "p(X)"), ("D2", "defeasible", "!q(X)", "p(X)")],
+     "case": ["p(a)"], "query": "q(a)", "expect": "BOTH",
+     "canary": {"drop": ["D2"], "expect": "TRUE_ONLY"}},
+    {"name": "strict-over-defeasible", "basis": "§107.1: strict-опора комплемента побеждает defeasible",
+     "preds": {"p": 1, "r": 1, "q": 1},
+     "rules": [("D", "defeasible", "q(X)", "p(X)"), ("S", "strict", "!q(X)", "r(X)")],
+     "case": ["p(a)", "r(a)"], "query": "q(a)", "expect": "FALSE_ONLY",
+     "canary": {"drop": ["S"], "expect": "TRUE_ONLY"}},
+    {"name": "defeater-overcome", "basis": "§107.3: более сильное правило преодолевает дефитер",
+     "preds": {"p": 1, "b": 1, "q": 1},
+     "rules": [("D", "defeasible", "q(X)", "p(X)"), ("X", "defeater", "q(X)", "b(X)")],
+     "priorities": [("D", "X")],
+     "case": ["p(a)", "b(a)"], "query": "q(a)", "expect": "TRUE_ONLY",
+     "canary": {"drop": ["prio0"], "expect": "NEITHER"}},
+    {"name": "defeater-blocks", "basis": "§107.3: дефитер блокирует несравнимого кандидата и опор не создаёт",
+     "preds": {"p": 1, "b": 1, "q": 1},
+     "rules": [("D", "defeasible", "q(X)", "p(X)"), ("X", "defeater", "q(X)", "b(X)")],
+     "case": ["p(a)", "b(a)"], "query": "q(a)", "expect": "NEITHER",
+     "canary": {"drop": ["X"], "expect": "TRUE_ONLY"}},
+    {"name": "one-survivor", "basis": "§107.2/§109: побеждённый D3 всё равно поражает D1 (полный снимок), "
+                                      "D2 выживает один",
+     "preds": {"p": 1, "s": 1, "t": 1, "q": 1},
+     "rules": [("D1", "defeasible", "q(X)", "p(X)"), ("D2", "defeasible", "q(X)", "s(X)"),
+               ("D3", "defeasible", "!q(X)", "t(X)")],
+     "priorities": [("D3", "D1"), ("D2", "D3")],
+     "case": ["p(a)", "s(a)", "t(a)"], "query": "q(a)", "expect": "TRUE_ONLY",
+     "canary": {"drop": ["D2"], "expect": "FALSE_ONLY"}},
+    {"name": "default-negation", "basis": "§113: not_known истинен при FALSE_ONLY; вывод по умолчанию "
+                                          "в страте выше производителя",
+     "preds": {"req": 1, "ban": 1, "ok": 1},
+     "rules": [("Ban", "defeasible", "ban(X)", "req(X)"), ("Ok", "defeasible", "ok(X)", "req(X) & not_known[ban(X)]")],
+     "case": ["req(a)"], "query": "ok(a)", "expect": "NEITHER",
+     "canary": {"drop": ["Ban"], "expect": "TRUE_ONLY"}},
+    # --- агрегаты §59 и замыкания §70 (DECISION-0239) ---------------------
+    {"name": "count-over-derived", "basis": "§59/E-0112: count читает завершённое множество strict-вывода",
+     "preds": {"joined": 2, "member": 2, "board": 1, "quorum": 1},
+     "rules": [("Join", "strict", "member(C, P)", "joined(C, P)"),
+               ("Quorum", "strict", "quorum(C)", "board(C) & count{P | member(C, P)} >= 2")],
+     "case": ["board(c)", "joined(c, a)", "joined(c, b)"], "query": "quorum(c)", "expect": "TRUE_ONLY",
+     "canary": {"drop": ["Join"], "expect": "NEITHER"}},
+    {"name": "empty-sum-issue", "basis": "§59: sum над пустой коллекцией без empty — EMPTY_AGGREGATE, "
+                                         "правило не срабатывает (DECISION-0239 G3)",
+     "preds": {"board": 1, "fee": ["Text", "Decimal"], "charged": 1},
+     "rules": [("Charge", "strict", "charged(C)", "board(C) & sum{V | fee(C, V)} >= 0")],
+     "case": ["board(c)"], "query": "charged(c)", "expect": "NEITHER", "issues": ["EMPTY_AGGREGATE"],
+     "canary": {"drop": ["Charge"], "expect": "NEITHER", "issues": []}},
+    {"name": "closure-negative", "basis": "§70: член домена без позитивной записи получает явный негатив",
+     "preds": {"company": 1, "licensed": 1},
+     "closures": [("LicenceRegistry", "licensed", "company")],
+     "case": ["company(a)"], "query": "licensed(a)", "expect": "FALSE_ONLY",
+     "canary": {"drop": ["LicenceRegistry"], "expect": "NEITHER"}},
+    {"name": "closure-strict-positive", "basis": "§70: strict-вывод позитива снимает негатив замыкания",
+     "preds": {"company": 1, "permit": 1, "licensed": 1},
+     "rules": [("Permit", "strict", "licensed(X)", "permit(X)")],
+     "closures": [("LicenceRegistry", "licensed", "company")],
+     "case": ["company(a)", "permit(a)"], "query": "licensed(a)", "expect": "TRUE_ONLY",
+     "canary": {"drop": ["Permit"], "expect": "FALSE_ONLY"}},
+    # E-0174: читатель, опровергаемый негативом замыкания, ждёт его
+    # материализации. Канарейка без замыкания отвечает TRUE_ONLY — тот же
+    # ответ дал бы и модуль, исполнивший читателя до замыкания.
+    {"name": "closure-unknown-reader", "basis": "§70/E-0174: strict unknown над закрытым предикатом исполняется "
+                                                "после замыкания — NEITHER",
+     "preds": {"company": 1, "licensed": 1, "pending": 1},
+     "rules": [("Pending", "strict", "pending(X)", "company(X) & unknown[licensed(X)]")],
+     "closures": [("LicenceRegistry", "licensed", "company")],
+     "case": ["company(a)"], "query": "pending(a)", "expect": "NEITHER",
+     "canary": {"drop": ["LicenceRegistry"], "expect": "TRUE_ONLY"}},
+    {"name": "closure-transitive-default", "basis": "§70/§113/E-0174: not_known над strict-выводом из негатива "
+                                                    "замыкания ждёт замыкание транзитивно — NEITHER",
+     "preds": {"company": 1, "licensed": 1, "barred": 1, "clean": 1},
+     "rules": [("Barred", "strict", "barred(X)", "company(X) & !licensed(X)"),
+               ("Clean", "strict", "clean(X)", "company(X) & not_known[barred(X)]")],
+     "closures": [("LicenceRegistry", "licensed", "company")],
+     "case": ["company(a)"], "query": "clean(a)", "expect": "NEITHER",
+     "canary": {"drop": ["LicenceRegistry"], "expect": "TRUE_ONLY"}},
+    {"name": "monotone-recursion", "basis": "§103: рекурсия строгих правил через monotone(P) допустима",
+     "preds": {"link": 2, "reach": 2},
+     "rules": [("Base", "strict", "reach(X, Y)", "link(X, Y)"),
+               ("Step", "strict", "reach(X, Z)", "link(X, Y) & monotone[reach(Y, Z)]")],
+     "case": ["link(a, b)", "link(b, c)"], "query": "reach(a, c)", "expect": "TRUE_ONLY",
+     "canary": {"drop": ["Step"], "expect": "NEITHER"}},
+    # --- структурные контрпримеры: план обязан отказать названной причиной ---
+    {"name": "default-cycle", "basis": "§110/§113: цикл через not_known не стратифицируем",
+     "preds": {"req": 1, "a": 1, "b": 1},
+     "rules": [("C1", "defeasible", "a(X)", "req(X) & not_known[b(X)]"),
+               ("C2", "defeasible", "b(X)", "req(X) & not_known[a(X)]")],
+     "plan": "программа не стратифицируема (§110, NON_EXECUTABLE_UNSTRATIFIED)"},
+    {"name": "late-producer", "basis": "§111: читатель стоит в страте, где строгая цепочка над поражаемым "
+                                       "выводом ещё не завершена (оракул отвечает NEITHER вместо TRUE_ONLY)",
+     "preds": {"a": 1, "q": 1, "p": 1, "r": 1},
+     "rules": [("D1", "defeasible", "q(X)", "a(X)"), ("S", "strict", "p(X)", "monotone[q(X)]"),
+               ("D2", "defeasible", "r(X)", "p(X)")],
+     "plan": "поздний производитель (§111, LDC-E4103)"},
+    {"name": "completion-cycle", "basis": "§110/E-0112: цикл через перечисление не стратифицируем",
+     "preds": {"seed": 1, "p": 1},
+     "rules": [("P", "strict", "p(X)", "seed(X) & count{Y | p(Y)} >= 1")],
+     "plan": "программа не стратифицируема (§110, NON_EXECUTABLE_UNSTRATIFIED)"},
+    {"name": "monotone-guard-derived", "basis": "E-0116 над выводимым предикатом вне среза (DECISION-0239 G2)",
+     "preds": {"joined": 2, "member": 2, "board": 1, "quorum": 1},
+     "rules": [("Join", "strict", "member(C, P)", "joined(C, P)"),
+               ("Quorum", "strict", "quorum(C)", "board(C) & count{P | monotone[member(C, P)]} >= 2")],
+     "plan": "монотонный агрегатный гард (E-0116) над выводимым предикатом вне среза генератора (DECISION-0239 G2)"},
+    {"name": "closure-over-defeasible", "basis": "§70: замыкание над поражаемым производителем (DECISION-0239 G5)",
+     "preds": {"company": 1, "applied": 1, "licensed": 1},
+     "rules": [("Apply", "defeasible", "licensed(X)", "applied(X)")],
+     "closures": [("LicenceRegistry", "licensed", "company")],
+     "plan": "замыкание §70 над поражаемым производителем вне среза генератора (DECISION-0239 G5)"},
+    {"name": "orphan-defeater", "basis": "§110 п. 5: дефитер без обычного кандидата той же полярности",
+     "preds": {"a": 1, "b": 1, "q": 1},
+     "rules": [("D", "defeasible", "q(X)", "a(X)"), ("X", "defeater", "!q(X)", "b(X)")],
+     "plan": "дефитер без обычного кандидата той же полярности (§110 п. 5, NON_EXECUTABLE_STRATUM_BARRIER)"},
+]
+
+
+def _split(text: str) -> list:
+    """Аргументы через запятую верхнего уровня (вызов внутри аргумента)."""
+    out, depth, cur = [], 0, ""
+    for ch in text:
+        if ch == "," and depth == 0:
+            out.append(cur)
+            cur = ""
+            continue
+        depth += (ch == "(") - (ch == ")")
+        cur += ch
+    return out + [cur]
+
+
+def _term(a: str) -> dict:
+    a = a.strip()
+    m = re.fullmatch(r"(\w+)\((.*)\)", a)
+    if m:
+        return {"kind": "call", "function": f"urn:law:std#{m.group(1)}", "args": [_term(x) for x in _split(m.group(2))]}
+    if a.startswith("@"):
+        return {"kind": "value", "type": {"name": "urn:law:std#Date"}, "value": a[1:]}
+    m = re.fullmatch(r"(\d+) (\w+)", a)
+    if m:
+        return {"kind": "value", "type": {"name": "urn:law:std#Quantity"}, "unit": m.group(2), "value": m.group(1)}
+    if a[:1].isupper():
+        return {"kind": "var", "var": a}
+    if re.fullmatch(r"-?\d+(\.\d+)?", a):
+        return {"kind": "value", "type": {"name": "urn:law:std#Decimal"}, "value": a}
+    return {"kind": "entity_ref", "id": f"urn:entity:{a}"}
+
+
+def literal(text: str) -> dict:
+    text = text.strip()
+    polarity = "positive"
+    if text.startswith("!"):
+        polarity, text = "negative", text[1:]
+    m = re.fullmatch(r"(\w+)\((.*)\)", text)
+    return {"kind": "literal", "polarity": polarity, "predicate": f"{NS}#{m.group(1)}",
+            "args": [_term(a) for a in _split(m.group(2))]}
+
+
+OPS = {">=": "ge", ">": "gt", "<=": "le", "<": "lt", "==": "eq", "!=": "ne"}
+
+
+def conjunct(text: str) -> dict:
+    text = text.strip()
+    m = re.fullmatch(r"(count|sum|min|max)\{(\w+) \| (.*)\} *(>=|<=|==|!=|>|<) *(-?[\d.]+)", text)
+    if m:
+        op, var, gen, cmp, num = m.groups()
+        items = [conjunct(x) for x in gen.split(";")]
+        threshold = {"kind": "value", "value": int(num) if op == "count" else num,
+                     "type": {"name": "urn:law:std#Integer" if op == "count" else "urn:law:std#Decimal"}}
+        return {"kind": "comparison", "op": OPS[cmp], "right": threshold,
+                "left": {"kind": "aggregate", "op": op, "input": {
+                    "kind": "comprehension", "distinct": True, "binders": [],
+                    "element": {"kind": "var", "var": var},
+                    "variable": {"id": var, "type": {"name": "urn:law:std#Text"}},
+                    "generator": items[0] if len(items) == 1 else {"kind": "and", "items": items}}}}
+    m = re.fullmatch(r"(.+?) (>=|<=|==|!=|>|<) (.+)", text)
+    if m and "{" not in text:
+        right = m.group(3).strip()
+        if re.fullmatch(r"-?\d+", right):
+            right_term = {"kind": "value", "type": {"name": "urn:law:std#Integer"}, "value": int(right)}
+        else:
+            right_term = _term(right)
+        return {"kind": "comparison", "op": OPS[m.group(2)], "left": _term(m.group(1)), "right": right_term}
+    m = re.fullmatch(r"(\w+)\[(.*)\]", text)
+    if m:
+        return {"kind": "status", "status": m.group(1), "formula": literal(m.group(2))}
+    return {"kind": "status", "status": "established", "formula": literal(text)}
+
+
+def _vars(lit: dict) -> set:
+    if lit.get("kind") == "comparison":
+        return set()
+    out, stack = set(), list(lit["args"])
+    while stack:
+        a = stack.pop()
+        if a["kind"] == "var":
+            out.add(a["var"])
+        stack.extend(a.get("args") or [])
+    return out
+
+
+def _calendar(fx: dict, drop: tuple = ()) -> dict | None:
+    if "calendar" not in fx:
+        return None
+    cal = dict(fx["calendar"])
+    if "Overrides" in drop:
+        cal["overrides"] = []
+    return cal
+
+
+def resources(fx: dict, drop: tuple = ()) -> dict:
+    """Байты ресурса снимка §85 фикстуры по `resourceUri`."""
+    cal = _calendar(fx, drop)
+    return {} if cal is None else {"artifact:fixture.calendar.json": json.dumps(cal, sort_keys=True).encode()}
+
+
+def program(fx: dict, drop: tuple = (), reverse: bool = False) -> dict:
+    """CLIR фикстуры; `drop` — локальные имена снятых узлов, `reverse` —
+    обратный порядок правил, приоритетов и фактов."""
+    nodes = []
+    for p, n in fx["preds"].items():
+        kinds = ["Text"] * n if isinstance(n, int) else n
+        nodes.append({"id": f"{NS}#{p}", "kind": "symbol_decl", "symbolKind": "relation", "name": p,
+                      "package": NS, "relationKind": "institutional",
+                      "parameters": [{"id": f"{NS}#{p}/arg/{i}", "name": f"a{i}",
+                                      "type": {"name": f"urn:law:std#{k}"}} for i, k in enumerate(kinds)]})
+    rules = []
+    for rid, strength, head, body in fx.get("rules", []):
+        items = [conjunct(x) for x in body.split("&")]
+        norm = head.startswith("norm:")
+        head_node = {"kind": "norm_template_ref", "id": f"{NS}#{head[5:]}"} if norm else literal(head)
+        names = sorted(set().union(*[_vars(i.get("formula") or i) for i in items])
+                       | (set() if norm else _vars(head_node)))
+        rules.append({"id": f"{NS}#{rid}", "kind": "rule", "package": NS, "strength": strength,
+                      "head": head_node, "body": {"kind": "and", "items": items},
+                      "scope": {"kind": "boolean", "value": True}, "interpretations": [],
+                      "variables": [{"id": v, "type": {"name": "urn:law:std#Text"}} for v in names]})
+    prios = [{"id": f"{NS}#prio{i}", "kind": "priority_rule", "package": NS, "priorityKind": "direct",
+              "condition": {"kind": "boolean", "value": True},
+              "higher": {"kind": "const_ref", "id": f"{NS}#{hi}"},
+              "lower": {"kind": "const_ref", "id": f"{NS}#{lo}"}}
+             for i, (hi, lo) in enumerate(fx.get("priorities", []))]
+    closures = [{"id": f"{NS}#{cid}", "kind": "closure_policy", "package": NS, "predicate": f"{NS}#{pred}",
+                 "domain": {"kind": "const_ref", "id": f"{NS}#{dom}"}, "snapshot": f"{NS}#snapshot",
+                 "completeAsOf": "2026-09-14T00:00:00+05:00", "deriveExplicitNegative": True}
+                for cid, pred, dom in fx.get("closures", [])]
+    templates = [{"id": f"{NS}#{tid}", "kind": "norm_template", "package": NS, "modality": modality,
+                  "payload": _payload(payload)} for tid, modality, payload in fx.get("templates", [])]
+    nodes += templates
+    if "policy" in fx:
+        nodes.append({"id": f"{NS}#Policy", "kind": "deadline_policy", "package": NS, "policy": dict(fx["policy"])})
+    cal = resources(fx, drop)
+    for uri, data in cal.items():
+        nodes.append({"id": f"{NS}#calendar", "kind": "calendar_snapshot", "package": NS, "resourceUri": uri,
+                      "datasetHash": "sha256:" + hashlib.sha256(data).hexdigest(), "format": "law.calendar/0.1"})
+    tail = [n for n in rules + prios + closures if n["id"].split("#")[1] not in drop]
+    if reverse:
+        tail.reverse()
+    return {"schemaVersion": "law.core.ir/0.7", "semanticVersion": "0.2.11", "features": ["core-executable"],
+            "imports": [], "metadata": {}, "strata": [],
+            "package": {"name": "backends.l1_fixture", "namespace": NS, "version": "0.1.0",
+                        "semanticHash": "sha256:" + "0" * 64},
+            "nodes": nodes + tail}
+
+
+def case(fx: dict, reverse: bool = False, drop: tuple = ()) -> dict:
+    facts = list(fx.get("case", []))
+    if reverse:
+        facts.reverse()
+    context = {"legalTime": "2026-09-14"}
+    if "policy" in fx and "Policy" not in drop:
+        context["deadlinePolicy"] = f"{NS}#Policy"
+    return {"assertions": [{"id": f"{NS}#case{i}", "kind": "assertion", "literal": literal(f),
+                            "origin": "case_input", "package": NS, "evidence": []}
+                           for i, f in enumerate(facts)],
+            "context": context, "options": {}}
+
+
+def _payload(value, key: str = ""):
+    """Мини-запись payload шаблона → CLIR: литералы строками, окно — пара дат,
+    участники — термы, exercise — вызов."""
+    if isinstance(value, dict):
+        return {k: _payload(v, k) for k, v in value.items()}
+    if key == "window":
+        bound = (lambda v: _term(v) if v[:1].isupper() or "(" in v
+                 else {"kind": "value", "type": {"name": "urn:law:std#Date"}, "value": v})
+        return {"kind": "interval", "start": bound(value[0]), "end": bound(value[1]),
+                "startInclusive": True, "endInclusive": True}
+    if key in ("condition", "validWhen", "after"):
+        return literal(value)
+    if key == "exercise":
+        lit = literal(value)
+        return {"kind": "call", "function": lit["predicate"], "args": lit["args"]}
+    if key in ("bearer", "holder", "beneficiary", "against"):
+        return _term(value)
+    return value
+
+
+def query(fx: dict) -> dict:
+    if fx["query"] == "positions":
+        return {"kind": "positions", "queryId": f"urn:query:{fx['name']}"}
+    return {"kind": "truth", "queryId": f"urn:query:{fx['name']}", "literal": literal(fx["query"])}
+
+
+FIXTURES += L2_FIXTURES + CAL_FIXTURES

arxo_codegen/inert-nodes.json

@@ -0,0 +1,62 @@
+{
+  "format": "law.codegen-inert-nodes/0.1",
+  "about": "Инертные конструкции CLIR: план пропускает их без отказа, потому что на ответ поддержанных видов вопросов они не влияют (CODEGEN-COVERAGE-PLAN §1.1, волна W1). Пропуск без свидетеля — отказ ворот check_conformance.",
+  "criterion": "Пара векторов над одной программой, делом и вопросом — с конструкцией (witness) и без неё (bare) — у оракула даёт один документ по results, positions, issues, conflicts и proofGraph; manifest и resultHash различаются по построению (§209 покрывает конверт, §208 — manifest). Половина с конструкцией обязана совпасть с голденом на каждой активной цели.",
+  "constructs": {
+    "node:source_work": {
+      "witness": "LAY-L0-INERT-SOURCE-WORK",
+      "bare": "LAY-L0-INERT-SOURCE-WORK-BARE",
+      "spec": "§28",
+      "note": "Акт как понятие; до W1 пропускался списком KNOWN_NODES — перенесён в манифест как образец."
+    },
+    "node:anchor": {
+      "witness": "LAY-L0-INERT-ANCHOR",
+      "bare": "LAY-L0-INERT-ANCHOR-BARE",
+      "spec": "§33",
+      "note": "Привязка нормы к фрагменту (E-0240): провенанс; конверт с anchor пишется law.core.ir/0.4, что меняет только manifest."
+    },
+    "node:revision": {
+      "witness": "LAY-L0-INERT-REVISION",
+      "bare": "LAY-L0-INERT-REVISION-BARE",
+      "spec": "§32",
+      "note": "Ребро графа редакций; операции §32.1 читает миграция, не исполнение."
+    },
+    "node:entrenchment": {
+      "witness": "LAY-L0-INERT-ENTRENCHMENT",
+      "bare": "LAY-L0-INERT-ENTRENCHMENT-BARE",
+      "spec": "§92.3",
+      "note": "Окно защищённости источника; читает миграция."
+    },
+    "node:factor_vocabulary": {
+      "witness": "LAY-L0-INERT-FACTOR-VOCABULARY",
+      "bare": "LAY-L0-INERT-FACTOR-VOCABULARY-BARE",
+      "spec": "§201",
+      "note": "Словарь факторов аналитического вида вопроса precedent (вне профиля core-executable)."
+    },
+    "node:precedent_decl": {
+      "witness": "LAY-L0-INERT-PRECEDENT-DECL",
+      "bare": "LAY-L0-INERT-PRECEDENT-DECL-BARE",
+      "spec": "§201",
+      "note": "Прецедент аналитического вида precedent."
+    },
+    "node:counterfactual_decl": {
+      "witness": "LAY-L0-INERT-COUNTERFACTUAL-DECL",
+      "bare": "LAY-L0-INERT-COUNTERFACTUAL-DECL-BARE",
+      "spec": "§186",
+      "note": "Данные аналитического вида counterfactual."
+    },
+    "rulefield:visibility": {
+      "witness": "LAY-L0-INERT-VISIBILITY",
+      "bare": "LAY-L0-INERT-VISIBILITY-BARE",
+      "spec": "§23.2",
+      "note": "Экспорт имени `pub` (DECISION-0386); на исполнение не влияет."
+    }
+  },
+  "notInert": {
+    "node:reference": {
+      "spec": "§30.2, §170",
+      "evidence": "LAY-L0-DYNAMIC-REFERENCE-V02",
+      "note": "Динамическая ссылка резолвится на legal_time дела: без применимой редакции результаты пусты и issue SOURCE_RESOLUTION_FAILED, при двух редакциях в силе — SOURCE_RESOLUTION_AMBIGUOUS; при удачной резолюции proofGraph получает узел source_resolution. Остаётся отказом плана до порта резолюции §30.2 (проверено оракулом 27.09.2026)."
+    }
+  }
+}