arxo-codegen 0.4.0__py3-none-any.whl

arxo_codegen/runtime_cert.py

@@ -0,0 +1,233 @@
+"""Capability contracts and bounded certification for backend runtimes.
+
+``runtime-cert.json`` is deliberately broader than the minimal runtime used by
+some targets.  A target is certified against the operations its ``cert``
+runner dispatches, never by attempting unsupported calls and reclassifying the
+result afterwards.  The common contract remains mandatory for every target.
+"""
+from __future__ import annotations
+
+import json
+from pathlib import Path
+from typing import Callable
+
+
+FORMAT = "law.backends-runtime-cert/1"
+
+# These names are the common dispatch surface in every targets/*/cert.*
+# harness.  Keep this explicit: adding a target must state its contract here,
+# rather than getting an accidental partial PASS from the fixture contents.
+BASELINE_OPERATIONS = frozenset({
+    "abs", "add", "cmp", "date", "dec", "div", "eq", "keyEq",
+    "legalTime", "max", "min", "mod", "money", "mul", "pow", "round",
+    "setLegalTime", "sub", "sym",
+})
+EXTENSION_OPERATIONS = frozenset({
+    "arith", "counter", "divRound", "monthEnd", "monthStart", "qty",
+    "rat", "ratTerm", "roundMode",
+    # W2 часть 2: Instant — момент, порядок по моменту, длительности §84.1.
+    "instant", "hoursBetween", "minutesBetween", "addDuration",
+})
+ALL_OPERATIONS = BASELINE_OPERATIONS | EXTENSION_OPERATIONS
+
+# A cert operation is only meaningful with literals its harness can decode.
+# Every common harness accepts scalar strings plus these tagged literal forms;
+# `rat`, `qty`/`unit`, and `bool` are decoded only by the full harnesses.
+COMMON_LITERAL_TAGS = frozenset({"dec", "money", "cur", "text", "date", "sym", "row"})
+EXTENSION_LITERAL_TAGS = frozenset({"rat", "qty", "unit", "bool", "instant"})
+ALL_LITERAL_TAGS = COMMON_LITERAL_TAGS | EXTENSION_LITERAL_TAGS
+
+# Evidence is the explicit operation switch/table in each target's cert
+# harness, audited 2026-09-24.  The three full runtimes expose every fixture
+# operation; every other runner has the baseline table only.
+FULL_TARGETS = frozenset({"go", "py", "ts"})
+BASELINE_TARGETS = frozenset({
+    "bsl", "cs", "dart", "erl", "ex", "java", "kt", "lua", "php", "rb",
+    "rs", "scala", "swift",
+})
+TARGET_OPERATIONS = {
+    **{target: ALL_OPERATIONS for target in FULL_TARGETS},
+    **{target: BASELINE_OPERATIONS for target in BASELINE_TARGETS},
+}
+TARGET_LITERAL_TAGS = {
+    **{target: ALL_LITERAL_TAGS for target in FULL_TARGETS},
+    **{target: COMMON_LITERAL_TAGS for target in BASELINE_TARGETS},
+}
+
+
+class FixtureError(ValueError):
+    """The fixture cannot support a trustworthy certification run."""
+
+
+def validate_contract() -> None:
+    """Reject an incomplete or stale target declaration before execution."""
+    overlap = FULL_TARGETS & BASELINE_TARGETS
+    if overlap:
+        raise FixtureError("цель одновременно в full и baseline контрактах: " + ", ".join(sorted(overlap)))
+    for target, operations in TARGET_OPERATIONS.items():
+        missing = BASELINE_OPERATIONS - operations
+        unknown = operations - ALL_OPERATIONS
+        if missing or unknown:
+            details = []
+            if missing:
+                details.append("нет baseline: " + ", ".join(sorted(missing)))
+            if unknown:
+                details.append("неизвестны: " + ", ".join(sorted(unknown)))
+            raise FixtureError(f"контракт {target}: " + "; ".join(details))
+        literals = TARGET_LITERAL_TAGS.get(target)
+        if literals is None or not COMMON_LITERAL_TAGS <= literals or not literals <= ALL_LITERAL_TAGS:
+            raise FixtureError(f"контракт {target}: неполная или неизвестная literal-поверхность")
+
+
+def load_fixture(path: Path) -> dict:
+    """Load and validate fixture IDs and operations before filtering it."""
+    try:
+        fixture = json.loads(Path(path).read_text(encoding="utf-8"))
+    except (OSError, json.JSONDecodeError) as exc:
+        raise FixtureError(f"runtime-cert не прочитан: {exc}") from exc
+    if not isinstance(fixture, dict) or fixture.get("format") != FORMAT:
+        raise FixtureError(f"runtime-cert должен иметь format {FORMAT}")
+    cases = fixture.get("cases")
+    if not isinstance(cases, list) or not cases:
+        raise FixtureError("runtime-cert должен содержать непустой cases")
+    ids, operations = set(), set()
+    for number, case in enumerate(cases, 1):
+        if not isinstance(case, dict):
+            raise FixtureError(f"runtime-cert: случай {number} не объект")
+        case_id, operation = case.get("id"), case.get("op")
+        if not isinstance(case_id, str) or not case_id:
+            raise FixtureError(f"runtime-cert: случай {number} без id")
+        if case_id in ids:
+            raise FixtureError(f"runtime-cert: повтор id {case_id}")
+        if not isinstance(operation, str) or operation not in ALL_OPERATIONS:
+            raise FixtureError(f"runtime-cert: {case_id}: неизвестная операция {operation!r}")
+        unknown_tags = literal_tags(case.get("args", [])) - ALL_LITERAL_TAGS
+        if unknown_tags:
+            raise FixtureError(f"runtime-cert: {case_id}: неизвестные literal-теги: "
+                               + ", ".join(sorted(unknown_tags)))
+        if "expect" not in case:
+            raise FixtureError(f"runtime-cert: {case_id}: нет expect")
+        ids.add(case_id)
+        operations.add(operation)
+    missing = BASELINE_OPERATIONS - operations
+    if missing:
+        raise FixtureError("runtime-cert: нет обязательных baseline операций: " + ", ".join(sorted(missing)))
+    validate_contract()
+    return fixture
+
+
+def literal_tags(value: object) -> set[str]:
+    """Tagged literal keys used by the cert wire fixture, recursively."""
+    if isinstance(value, dict):
+        return set(value) | set().union(*(literal_tags(item) for item in value.values()))
+    if isinstance(value, list):
+        return set().union(*(literal_tags(item) for item in value)) if value else set()
+    return set()
+
+
+def profile(target: str, fixture: dict) -> dict:
+    """Return a reviewable target profile and the fixture to execute."""
+    if target not in TARGET_OPERATIONS:
+        raise FixtureError(f"runtime-cert: для runner-цели {target} нет capability-контракта")
+    declared = TARGET_OPERATIONS[target]
+    literal_tags_for_target = TARGET_LITERAL_TAGS[target]
+    cases = fixture["cases"]
+    checked, unsupported_operation, unsupported_literal = [], [], []
+    for case in cases:
+        if case["op"] not in declared:
+            unsupported_operation.append(case)
+            continue
+        unsupported = literal_tags(case.get("args", [])) - literal_tags_for_target
+        if unsupported:
+            unsupported_literal.append((case, sorted(unsupported)))
+            continue
+        checked.append(case)
+    checked_ops = {case["op"] for case in checked}
+    # load_fixture verifies this for the whole fixture; retaining it here makes
+    # direct callers fail safely as well.
+    missing = BASELINE_OPERATIONS - checked_ops
+    if missing:
+        raise FixtureError(f"runtime-cert {target}: не отобраны baseline операции: " + ", ".join(sorted(missing)))
+    # Declaring an extension without any compatible fixture would make a
+    # target look fully certified while that extension was never exercised.
+    # This is stricter than checking raw fixture presence: a case carrying an
+    # unsupported literal form does not cover the declared operation either.
+    declared_without_checked_cases = sorted(declared - checked_ops)
+    if declared_without_checked_cases:
+        raise FixtureError(f"runtime-cert {target}: нет проверяемых случаев для объявленных операций: "
+                           + ", ".join(declared_without_checked_cases))
+    return {
+        "target": target,
+        "declaredOperations": sorted(declared),
+        "checkedOperations": sorted(checked_ops),
+        "literalTags": sorted(literal_tags_for_target),
+        "unsupportedOperations": sorted({case["op"] for case in unsupported_operation}),
+        "unsupportedLiteralTags": sorted({tag for _case, tags in unsupported_literal for tag in tags}),
+        "declaredOperationsWithoutCheckedCases": declared_without_checked_cases,
+        "checkedFixtureIds": [case["id"] for case in checked],
+        "unsupportedFixtureIds": [case["id"] for case in unsupported_operation] +
+                                 [case["id"] for case, _tags in unsupported_literal],
+        "unsupportedOperationFixtureIds": [case["id"] for case in unsupported_operation],
+        "unsupportedOperandFixtureIds": [case["id"] for case, _tags in unsupported_literal],
+        "unsupportedOperandForms": {case["id"]: tags for case, tags in unsupported_literal},
+        "fixture": {key: value for key, value in fixture.items() if key != "cases"} | {"cases": checked},
+    }
+
+
+def validate_answer(target: str, checked_cases: list[dict], payload: object) -> list[str]:
+    """Compare one target answer, refusing silent omissions and surplus rows."""
+    if not isinstance(payload, list):
+        return [f"сертификация {target}: ответ cert должен быть массивом"]
+    expected = {case["id"]: case["expect"] for case in checked_cases}
+    received: dict[str, object] = {}
+    problems = []
+    for number, row in enumerate(payload, 1):
+        if not isinstance(row, dict) or not isinstance(row.get("id"), str) or "got" not in row:
+            problems.append(f"сертификация {target}: строка ответа {number} не имеет id/got")
+            continue
+        case_id = row["id"]
+        if case_id in received:
+            problems.append(f"сертификация {target}: повтор ответа {case_id}")
+        elif case_id not in expected:
+            problems.append(f"сертификация {target}: ответ для невыбранного случая {case_id}")
+        else:
+            received[case_id] = row["got"]
+    for case_id, want in expected.items():
+        if case_id not in received:
+            problems.append(f"сертификация {target}: случай {case_id} не исполнен")
+        elif received[case_id] != want:
+            problems.append(f"сертификация {target}: {case_id}: ожидалось "
+                            f"{json.dumps(want, ensure_ascii=False)}, получено "
+                            f"{json.dumps(received[case_id], ensure_ascii=False)}")
+    return problems
+
+
+def certify_target(target: str, descriptor, work: Path, fixture_path: Path,
+                   emit_project: Callable, build_projects: Callable,
+                   run_target: Callable) -> tuple[dict, list[str]]:
+    """Emit, build, and run one target against its declared fixture subset.
+
+    The three callables are supplied by the invoking gate, keeping this module
+    independent from CI and allowing its subprocess/time-limit policy to stay
+    in force.
+    """
+    fixture = load_fixture(fixture_path)
+    report = profile(target, fixture)
+    cert_dir = Path(work) / "cert" / target
+    selected = Path(work) / "cert" / f"runtime-cert-{target}.json"
+    selected.parent.mkdir(parents=True, exist_ok=True)
+    selected.write_text(json.dumps(report.pop("fixture"), ensure_ascii=False, indent=1) + "\n", encoding="utf-8")
+    report["selectedFixture"] = selected.name
+    try:
+        emit_project({}, target, cert_dir, main="cert")
+    except Exception as exc:
+        return report, [f"сертификация {target}: не создан cert-проект: {exc}"]
+    errors = ["сертификация: " + error for error in build_projects({target: descriptor}, {target: [cert_dir]}, Path(work) / "cert")]
+    if errors:
+        return report, errors
+    kind, payload = run_target(descriptor, cert_dir, "cert", [str(selected)])
+    if kind != "answer":
+        return report, [f"сертификация {target}: {str(kind).upper()}, {payload}"]
+    checked_ids = set(report["checkedFixtureIds"])
+    return report, validate_answer(target, [case for case in fixture["cases"]
+                                            if case["id"] in checked_ids], payload)

arxo_codegen/survey.py

@@ -0,0 +1,272 @@
+#!/usr/bin/env python3
+"""Обзор явного набора CLIR планом: какие пакеты срез принимает сегодня и
+почему отказывает остальным. Считает ВСЕ отказы пакета, а не первый.
+
+Зачем. Следующий шаг среза выбирается по потребителю, а не по числу: пакет,
+которому до плана не хватает одной формы, стоит одной формы; пакет с
+десятью — не стоит ничего. Первая причина отказа эту разницу скрывает.
+
+    arxo-codegen-survey PROGRAM.lawir.json [PROGRAM2.lawir.json ...]
+    arxo-codegen-survey --input-dir FIXTURES --dep DEP.lawir.json
+    arxo-codegen-survey --corpus-root LAW_DSL_ROOT     # переходный adapter
+"""
+from __future__ import annotations
+
+import argparse
+import collections
+import json
+import sys
+from pathlib import Path
+
+HERE = Path(__file__).resolve().parent
+sys.path.insert(0, str(HERE))
+import plan as P  # noqa: E402
+
+
+def snapshots(root: Path) -> list[Path]:
+    """CLIR корпуса и собственные снимки пакетов вне корпуса; `deps/` и
+    `.build/` — копии чужих снимков, они не считаются дважды."""
+    out = 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
+        out.append(p)
+    return out
+
+
+def head(reason: str) -> str:
+    return reason.split(":")[0]
+
+
+def inputs(paths: list[Path], directories: list[Path], corpus_root: Path | None) -> tuple[list[Path], list[Path]]:
+    """Collect only explicitly named inputs; corpus scanning needs its adapter flag."""
+    selected = [Path(path) for path in paths]
+    bases = [Path(directory) for directory in directories]
+    for directory in bases:
+        if not directory.is_dir():
+            raise ValueError(f"survey: каталога входов нет: {directory}")
+        selected += sorted(directory.rglob("*.lawir.json"))
+    if corpus_root is not None:
+        root = Path(corpus_root)
+        if not root.is_dir():
+            raise ValueError(f"survey: corpus-root не каталог: {root}")
+        if not selected:
+            selected = snapshots(root)
+        bases.append(root)
+    unique = []
+    seen = set()
+    for path in selected:
+        resolved = path.resolve()
+        if resolved not in seen:
+            seen.add(resolved)
+            unique.append(resolved)
+    if not unique:
+        raise ValueError("survey: укажите CLIR-файлы, --input-dir или --corpus-root")
+    missing = [str(path) for path in unique if not path.is_file()]
+    if missing:
+        raise ValueError(f"survey: входного CLIR нет: {', '.join(missing)}")
+    return unique, bases
+
+
+def display_path(path: Path, bases: list[Path]) -> str:
+    """Stable useful name without assuming an installed package has law-dsl ROOT."""
+    for base in bases:
+        try:
+            return path.resolve().relative_to(base.resolve()).as_posix()
+        except ValueError:
+            continue
+    return path.name
+
+
+def named_documents(paths: list[Path]) -> tuple[list[tuple[Path, dict]], dict[str, Path], dict[str, dict]]:
+    """Read the bounded input set once and reject ambiguous package names."""
+    documents: list[tuple[Path, dict]] = []
+    locations: dict[str, Path] = {}
+    by_name: dict[str, dict] = {}
+    for path in paths:
+        document = json.loads(path.read_text(encoding="utf-8"))
+        documents.append((path, document))
+        name = (document.get("package") or {}).get("name")
+        if not name:
+            continue
+        if name in locations:
+            raise ValueError(f"survey: неоднозначный CLIR пакета {name}: {locations[name]} и {path}")
+        locations[name] = path
+        by_name[name] = document
+    return documents, locations, by_name
+
+
+def main(argv: list[str] | None = None) -> int:
+    ap = argparse.ArgumentParser()
+    ap.add_argument("input", nargs="*", type=Path, metavar="CLIR", help="корневой CLIR")
+    ap.add_argument("--input-dir", action="append", type=Path, default=[], metavar="DIR",
+                    help="рекурсивно взять *.lawir.json только из указанного каталога")
+    ap.add_argument("--dep", action="append", type=Path, default=[], metavar="CLIR",
+                    help="явная CLIR-зависимость (можно повторять)")
+    ap.add_argument("--corpus-root", type=Path,
+                    help="переходный adapter: индекс corpus/clir и packs; без входов — обзор этого корпуса")
+    ap.add_argument("--core-kit", type=Path, help="проверенный комплект поддержки ядра")
+    ap.add_argument("--report", type=Path, help="markdown-отчёт")
+    ap.add_argument("--package", help="имя пакета: печатать все его отказы")
+    args = ap.parse_args(argv)
+
+    try:
+        selected, bases = inputs(args.input, args.input_dir, args.corpus_root)
+        documents, selected_index, selected_by_name = named_documents(selected)
+        extra = [json.loads(path.read_text(encoding="utf-8")) for path in args.dep]
+        from inputs import dependency_index
+        explicit = dependency_index(extra)
+        for name, document in explicit.items():
+            if name in selected_by_name and document != selected_by_name[name]:
+                raise ValueError(f"survey: неоднозначный CLIR пакета {name}: --dep и входной набор различаются")
+        index = P.world_index(args.corpus_root) if args.corpus_root else {}
+        # Files named on the command line are a bounded dependency bundle.
+        # They supplement the transition adapter and never require discovery.
+        index.update(selected_index)
+        if args.core_kit:
+            import core_support
+            core_support.configure_core_kit(args.core_kit)
+            core_support.validate_core_kit(args.core_kit)
+    except (OSError, ValueError, json.JSONDecodeError, P.Refused) as exc:
+        ap.error(str(exc))
+
+    rows = []
+    caps: dict = {}
+    for path, ir in documents:
+        name = (ir.get("package") or {}).get("name") or path.stem
+        try:
+            world = P.resolve_world(ir, index, extra) if ir.get("imports") else []
+            reasons = P.survey_plan(ir, world)
+        except P.Refused as exc:
+            reasons = [str(exc)]
+        rules = sum(1 for n in ir["nodes"] if n.get("kind") == "rule")
+        # Возможности поражаемого слоя (DECISION-0237): у принятого пакета
+        # они и есть ответ «L0- или L1-план».
+        caps[name] = []
+        if not reasons:
+            # DECISION-0252: `value:rational` видна только проходом компиляции,
+            # как в `build_plan`; без неё план 0.12 читался бы L0-планом.
+            probe = P.Builder(ir, world)
+            probe.survey()
+            caps[name] = P.Builder(ir, world, P.value_caps(probe) or None).capabilities()
+        rows.append((name, display_path(path, bases), rules, reasons))
+
+    if args.package:
+        for name, rel, rules, reasons in rows:
+            if name == args.package or rel.endswith(args.package):
+                print(f"{name} ({rel}): правил {rules}, отказов {len(reasons)}")
+                for r in reasons:
+                    print("  " + r)
+        return 0
+
+    accepted = [r for r in rows if not r[3]]
+    by_head = collections.Counter()
+    pkg_by_head = collections.Counter()
+    for _name, _rel, _rules, reasons in rows:
+        by_head.update(head(r) for r in reasons)
+        pkg_by_head.update(set(head(r) for r in reasons))
+    distinct = sorted(rows, key=lambda r: (len(set(head(x) for x in r[3])), len(r[3])))
+    near = [r for r in distinct if r[3] and len(set(head(x) for x in r[3])) == 1]
+
+    l1 = [r for r in accepted if caps.get(r[0])]
+    lines = []
+    lines.append(f"снимков рассмотрено: {len(rows)}; план строится у {len(accepted)} "
+                 f"(L0 {len(accepted) - len(l1)}, L1 {len(l1)})")
+    for name, rel, rules, _ in accepted:
+        lines.append(f"  принят: {name} ({rel}), правил {rules}"
+                     + (f"; возможности: {', '.join(caps[name])}" if caps.get(name) else ""))
+    lines.append("")
+    lines.append("причины отказа: пакетов с причиной / вхождений")
+    for k, n in pkg_by_head.most_common():
+        lines.append(f"  {n:4d} / {by_head[k]:5d}  {k}")
+    detail = collections.defaultdict(collections.Counter)
+    for _name, _rel, _rules, reasons in rows:
+        for r in reasons:
+            if ":" in r:
+                detail[head(r)][r.split(":", 1)[1].strip()] += 1
+    lines.append("")
+    lines.append("уточнения (что именно вне среза), по пакетам:")
+    for k in ("объявление вне среза генератора", "тип аргумента вне среза генератора",
+              "сила правила вне L0-среза", "тип значения вне среза генератора",
+              "узел терма вне среза генератора", "операция вне среза генератора",
+              "функция вне среза генератора"):
+        pk = collections.Counter()
+        for _name, _rel, _rules, reasons in rows:
+            pk.update({r.split(":", 1)[1].strip() for r in reasons if head(r) == k and ":" in r})
+        lines.append(f"  {k}:")
+        for det, n in pk.most_common(12):
+            lines.append(f"    {n:4d}  {det}")
+    lines.append("")
+    lines.append(f"пакеты с ЕДИНСТВЕННЫМ видом причины: {len(near)}")
+    for name, rel, rules, reasons in near[:40]:
+        lines.append(f"  {name}: {head(reasons[0])} × {len(reasons)} (правил {rules})")
+    print("\n".join(lines))
+
+    if args.report:
+        # Версия плана следует из возможностей так же, как в `build_plan`.
+        def version(name):
+            c = set(caps.get(name) or [])
+            return (P.PLAN_VERSION_19 if "judgment" in c
+                    else P.PLAN_VERSION_18 if c & P.FN_CAPS
+                    else P.PLAN_VERSION_17 if c & P.TERM_CAPS
+                    else P.PLAN_VERSION_16 if "priority:dated" in c
+                    else P.PLAN_VERSION_15 if c & P.V15_CAPS
+                    else P.PLAN_VERSION_14 if c & {"value:round", "value:div_round"}
+                    else P.PLAN_VERSION_13 if "value:quantity" in c
+                    else P.PLAN_VERSION_12 if "value:rational" in c else P.PLAN_VERSION_11 if c & P.CAL_CAPS
+                    else P.PLAN_VERSION_10 if "norm" in c
+                    else P.PLAN_VERSION_09 if c & {"aggregate", "closure"} else P.PLAN_VERSION_L1 if c
+                    else P.PLAN_VERSION)
+        byv = collections.Counter(version(r[0]) for r in accepted)
+        md = ["# Обзор корпуса планом кодогенерации", "",
+              f"Снимков рассмотрено: {len(rows)}. План строится у {len(accepted)}: "
+              f"`{P.PLAN_VERSION}` (L0) у {byv[P.PLAN_VERSION]}, `{P.PLAN_VERSION_L1}` "
+              f"(поражаемый слой, DECISION-0237) у {byv[P.PLAN_VERSION_L1]}, `{P.PLAN_VERSION_09}` "
+              f"(агрегаты и замыкания, DECISION-0239) у {byv[P.PLAN_VERSION_09]}, `{P.PLAN_VERSION_10}` "
+              f"(нормативные позиции, DECISION-0242) у {byv[P.PLAN_VERSION_10]}, `{P.PLAN_VERSION_11}` "
+              f"(календарные функции, DECISION-0245) у {byv[P.PLAN_VERSION_11]}, `{P.PLAN_VERSION_12}` "
+              f"(Rational, DECISION-0252) у {byv[P.PLAN_VERSION_12]}, `{P.PLAN_VERSION_13}` "
+              f"(Quantity, DECISION-0256) у {byv[P.PLAN_VERSION_13]}, `{P.PLAN_VERSION_14}` "
+              f"(round/div_round, DECISION-0259) у {byv[P.PLAN_VERSION_14]}, `{P.PLAN_VERSION_15}` "
+              f"(Boolean/Natural, границы месяца, `_`, DECISION-0266–0268) у {byv[P.PLAN_VERSION_15]}, "
+              f"`{P.PLAN_VERSION_16}` (датированные приоритеты, DECISION-0269) у {byv[P.PLAN_VERSION_16]}, "
+              f"`{P.PLAN_VERSION_17}` (условный терм и вычисляемый аргумент тела, DECISION-0270) у {byv[P.PLAN_VERSION_17]}, "
+              f"`{P.PLAN_VERSION_18}` (функции §46, параметры A3, let/match, DECISION-0273) у {byv[P.PLAN_VERSION_18]}, "
+              f"`{P.PLAN_VERSION_19}` (канал суждения §47.3, DECISION-0274) у {byv[P.PLAN_VERSION_19]}.",
+              "", "## Принятые пакеты", ""]
+        md += [f"- `{name}` ({rel}), правил {rules}"
+               + (f"; возможности: {', '.join(caps[name])}" if caps.get(name) else "")
+               for name, rel, rules, _ in accepted] or ["- нет"]
+        capc = collections.Counter(c for r in l1 for c in caps[r[0]])
+        md += ["", "## Возможности L1-планов", "", "| возможность | пакетов |", "|---|---:|"]
+        md += [f"| `{c}` | {n} |" for c, n in capc.most_common()]
+        md += ["", "## Причины отказа", "", "| причина | пакетов | вхождений |", "|---|---:|---:|"]
+        md += [f"| {k} | {n} | {by_head[k]} |" for k, n in pkg_by_head.most_common()]
+        md += ["", "## Уточнения: что именно вне среза (пакетов)", ""]
+        for k in ("объявление вне среза генератора", "тип аргумента вне среза генератора",
+                  "сила правила вне L0-среза", "тип значения вне среза генератора",
+                  "узел терма вне среза генератора", "операция вне среза генератора",
+                  "функция вне среза генератора"):
+            pk = collections.Counter()
+            for _name, _rel, _rules, reasons in rows:
+                pk.update({r.split(":", 1)[1].strip() for r in reasons if head(r) == k and ":" in r})
+            md += [f"**{k}**", "", "| что | пакетов |", "|---|---:|"]
+            md += [f"| `{det}` | {n} |" for det, n in pk.most_common(12)] + [""]
+        md += ["## Пакеты с единственным видом причины", "",
+               "Ближайшие кандидаты: устранение одной формы даёт план.", "",
+               "| пакет | причина | вхождений | правил |", "|---|---|---:|---:|"]
+        md += [f"| `{name}` | {head(reasons[0])} | {len(reasons)} | {rules} |"
+               for name, rel, rules, reasons in near]
+        md += ["", "## Все пакеты по числу видов причин", "",
+               "| пакет | видов | вхождений | правил | причины |", "|---|---:|---:|---:|---|"]
+        for name, rel, rules, reasons in distinct:
+            kinds = collections.Counter(head(r) for r in reasons)
+            md.append(f"| `{name}` | {len(kinds)} | {len(reasons)} | {rules} | "
+                      + "; ".join(f"{k} × {n}" for k, n in kinds.most_common()) + " |")
+        args.report.write_text("\n".join(md) + "\n", encoding="utf-8")
+        print(f"отчёт: {args.report}")
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

arxo_codegen/target_runner.py

@@ -0,0 +1,101 @@
+"""Target build/run protocol shared by standalone backend consumers.
+
+This module deliberately has no CI, corpus, or oracle imports.  Target
+descriptors remain the only language-specific boundary.
+"""
+from __future__ import annotations
+
+import json
+import subprocess
+from typing import Mapping
+from pathlib import Path
+
+
+REFUSED_EXIT = 3
+
+
+def shell(command: list[str], cwd: str | Path | None = None,
+          env: Mapping[str, str] | None = None) -> subprocess.CompletedProcess:
+    """Run a target command; optional environment keeps host toolchains isolated."""
+    return subprocess.run(command, capture_output=True, text=True, cwd=cwd, env=env)
+
+
+def crash_line(stderr: str) -> str:
+    lines = [line.strip() for line in stderr.splitlines() if line.strip()]
+    if not lines:
+        return "(stderr пуст)"
+    return next((line[:200] for line in lines if line.startswith("panic:") or "Error:" in line
+                 or "Error [" in line or "error:" in line), lines[-1][:200])
+
+
+def build_projects(emit: dict, projects: dict[str, list[Path]], work: Path,
+                   env: Mapping[str, str] | None = None) -> list[str]:
+    """Build every emitted project and return named failures."""
+    failures = []
+    for language, directories in projects.items():
+        if not directories:
+            continue
+        descriptor = emit[language]
+        if hasattr(descriptor, "build_many"):
+            command, cwd = descriptor.build_many([str(path) for path in directories], work / "out")
+            result = shell(command, cwd, env)
+            if result.returncode:
+                failures.append(f"сборка {language} отказала\n{(result.stdout + result.stderr)[:1200]}")
+            continue
+        for directory in directories:
+            step = descriptor.build(str(directory))
+            if step is None:
+                continue
+            command, cwd = step
+            result = shell(command, cwd, env)
+            if result.returncode:
+                failures.append(f"сборка {language} отказала на {directory}\n{(result.stdout + result.stderr)[:1200]}")
+    return failures
+
+
+def run_target(descriptor, project: Path, main: str, arguments: list[str],
+               env: Mapping[str, str] | None = None) -> tuple[str, object]:
+    """Return ``answer`` (decoded JSON), named ``refused``, or ``crash``."""
+    command, cwd = descriptor.run(str(project), main)
+    result = shell(command + arguments, cwd, env)
+    if result.returncode == 0:
+        try:
+            return "answer", json.loads(result.stdout)
+        except json.JSONDecodeError:
+            return "crash", f"код 0, но ответ не JSON: {result.stdout[:200]!r}"
+    if result.returncode == REFUSED_EXIT:
+        try:
+            return "refused", json.loads(result.stdout)["refused"]
+        except (json.JSONDecodeError, KeyError, TypeError):
+            return "crash", f"код {REFUSED_EXIT} без JSON отказа: {result.stdout[:200]!r}"
+    return "crash", f"код {result.returncode}: {crash_line(result.stderr or result.stdout)}"
+
+
+def answer_key(answer: dict) -> tuple:
+    """Gate-compatible comparable answer without importing the CI harness."""
+    from core_support import canonical_bytes
+
+    def canon(value) -> str:
+        return canonical_bytes(value, document=False).decode("utf-8")
+
+    def actor(value):
+        return "<fallback>" if str(value).startswith("urn:position:") else value
+
+    if "normativeStatus" in answer:
+        positions = []
+        for position in answer.get("positions") or []:
+            item = {"template": position["template"], "modality": position["modality"],
+                    "holder": actor(position.get("holder")), "status": position["status"],
+                    "payload": position["payload"]}
+            if "beneficiary" in position:
+                item["beneficiary"] = actor(position["beneficiary"])
+            positions.append(canon(item))
+        supports = sorted(canon([item["status"], item["truthStatus"]]) for item in answer.get("supports") or [])
+        head = "NORM_POSITION:" + answer["normativeStatus"] + ":" + canon(sorted(positions)) + ":" + canon(supports)
+    elif "truthStatus" in answer:
+        head = answer["truthStatus"]
+    else:
+        head = answer["resultKind"] + ":" + (canon(answer["value"]) if "value" in answer else "")
+    requests = [{key: value for key, value in row.items() if key != "proof"}
+                for row in answer.get("judgmentRequests") or []]
+    return head, answer["evaluationStatus"], tuple(answer.get("issues") or []), canon(requests)