arxo-codegen 0.4.0__py3-none-any.whl

arxo_codegen/core_support.py

@@ -0,0 +1,203 @@
+"""Pinned core support loaded by code-generation backends.
+
+Set ``LAW_CODEGEN_CORE_KIT`` to a directory made by
+``apps/registry/codegen_core_pack.py``, or call :func:`configure_core_kit`
+before using the helpers.  The selected delivery is validated before its code
+is imported.  A standalone backend never searches a monorepo for support
+sources.
+"""
+from __future__ import annotations
+
+import copy
+import hashlib
+import importlib.util
+import json
+import os
+from pathlib import Path
+import sys
+from types import ModuleType
+from typing import Any
+
+
+HERE = Path(__file__).resolve().parent
+ROOT = HERE.parents[1]
+FORMAT = "law.codegen-core-kit/0.1"
+LOCK_FORMAT = "law.codegen-core-lock/0.1"
+MANIFEST = "manifest.json"
+LOCK = "codegen-core.lock.json"
+COMPATIBILITY = {
+    "semanticVersions": ["0.2.11"],
+    "languageSemantics": ["law.core/0.2.11"],
+    "clirSchemaVersions": ["law.core.ir/0.7"],
+}
+PROVENANCE = {
+    "lawref": {"package": "lawref", "version": "0.0.1", "license": "Apache-2.0",
+               "requiresPython": ">=3.12", "runtimeDependencies": []},
+    "calendarDatasetSchema": {"license": "CC-BY-4.0", "source": "spec/schema/calendar-dataset.schema.json"},
+}
+REQUIRED_PATHS = frozenset({
+    "python/lawref/__init__.py", "python/lawref/canon.py", "python/lawref/hashing.py",
+    "schemas/calendar-dataset.schema.json", "licenses/Apache-2.0.txt", "licenses/CC-BY-4.0.txt",
+    "NOTICE", LOCK,
+})
+_configured_kit: Path | None = None
+_loaded: tuple[Path | None, ModuleType, dict[str, Any]] | None = None
+
+
+class CoreKitError(RuntimeError):
+    """The selected core kit cannot safely provide backend support."""
+
+
+# Kept as a source-compatible spelling for early B1 callers.
+CodegenCoreError = CoreKitError
+
+
+def _sha(data: bytes) -> str:
+    return "sha256:" + hashlib.sha256(data).hexdigest()
+
+
+def _regular(path: Path, label: str) -> None:
+    if path.is_symlink() or not path.is_file():
+        raise CoreKitError(f"{label} is not a regular file")
+
+
+def validate_core_kit(kit: Path) -> dict[str, Any]:
+    """Validate the exact payload before dynamically importing it."""
+    supplied = Path(kit)
+    if supplied.is_symlink() or not supplied.is_dir():
+        raise CoreKitError("codegen core kit is not a directory")
+    kit = supplied.resolve()
+    for path in kit.rglob("*"):
+        if path.is_symlink():
+            raise CoreKitError("codegen core kit contains a symlink")
+    _regular(kit / MANIFEST, "core-kit manifest")
+    _regular(kit / LOCK, "core-kit lock")
+    try:
+        manifest = json.loads((kit / MANIFEST).read_bytes())
+        lock = json.loads((kit / LOCK).read_bytes())
+    except (UnicodeDecodeError, json.JSONDecodeError) as error:
+        raise CoreKitError("invalid codegen core-kit JSON") from error
+    if not isinstance(manifest, dict) or manifest.get("format") != FORMAT:
+        raise CoreKitError("unsupported codegen core-kit manifest")
+    if not isinstance(lock, dict) or lock.get("format") != LOCK_FORMAT:
+        raise CoreKitError("unsupported codegen core-kit lock")
+    if lock.get("sourceCommit") != manifest.get("sourceCommit"):
+        raise CoreKitError("codegen core-kit source commit mismatch")
+    if lock.get("compatibility") != COMPATIBILITY:
+        raise CoreKitError("unsupported codegen core-kit compatibility")
+    if lock.get("provenance") != PROVENANCE:
+        raise CoreKitError("unsupported codegen core-kit provenance")
+    files = manifest.get("files")
+    if not isinstance(files, list):
+        raise CoreKitError("codegen core-kit has no inventory")
+    expected = REQUIRED_PATHS
+    seen: set[str] = set()
+    hashes: dict[str, str] = {}
+    for row in files:
+        if not isinstance(row, dict):
+            raise CoreKitError("invalid codegen core-kit inventory row")
+        rel = row.get("path")
+        if not isinstance(rel, str) or not rel or rel.startswith("/") or ".." in Path(rel).parts or rel in seen:
+            raise CoreKitError("invalid codegen core-kit inventory path")
+        seen.add(rel)
+        path = kit / rel
+        _regular(path, "codegen core-kit payload")
+        if row.get("sha256") != _sha(path.read_bytes()) or row.get("bytes") != path.stat().st_size:
+            raise CoreKitError("codegen core-kit payload hash mismatch")
+        hashes[rel] = row["sha256"]
+    actual = {p.relative_to(kit).as_posix() for p in kit.rglob("*") if p.is_file()}
+    if actual != seen | {MANIFEST} or seen != expected:
+        raise CoreKitError("codegen core-kit inventory differs from files")
+    if lock.get("files") != {name: digest for name, digest in hashes.items() if name != LOCK}:
+        raise CoreKitError("codegen core-kit lock differs from inventory")
+    return manifest
+
+
+def configure_core_kit(path: str | Path | None) -> None:
+    """Explicitly select a core kit; ``None`` restores environment selection."""
+    global _configured_kit, _loaded
+    _configured_kit = Path(path) if path is not None else None
+    _loaded = None
+
+
+def core_kit_path() -> Path | None:
+    """Return the explicit kit selected by API/environment, if any."""
+    if _configured_kit is not None:
+        return _configured_kit
+    value = os.environ.get("LAW_CODEGEN_CORE_KIT")
+    return Path(value) if value else None
+
+
+def using_monorepo_fallback() -> bool:
+    """Compatibility spelling; standalone delivery never falls back."""
+    return False
+
+
+def _load_package(package: Path, identity: str) -> ModuleType:
+    package_name = f"_law_codegen_core_{identity}"
+    hashing_name = package_name + ".hashing"
+    existing = sys.modules.get(hashing_name)
+    if existing is not None:
+        return existing
+    package_spec = importlib.util.spec_from_file_location(
+        package_name, package / "__init__.py", submodule_search_locations=[str(package)]
+    )
+    if package_spec is None or package_spec.loader is None:
+        raise CoreKitError("cannot load codegen core-kit namespace")
+    namespace = importlib.util.module_from_spec(package_spec)
+    hashing_spec = importlib.util.spec_from_file_location(hashing_name, package / "hashing.py")
+    if hashing_spec is None or hashing_spec.loader is None:
+        raise CoreKitError("cannot load codegen core-kit hashing")
+    module = importlib.util.module_from_spec(hashing_spec)
+    # The delivery is immutable.  In particular, importing it must not produce
+    # an unlisted ``__pycache__`` directory which would make a later integrity
+    # check fail.  Restore the interpreter-wide flag even when imported code
+    # raises; the small critical section runs only during initial kit loading.
+    previous_bytecode_setting = sys.dont_write_bytecode
+    sys.dont_write_bytecode = True
+    try:
+        sys.modules[package_name] = namespace
+        package_spec.loader.exec_module(namespace)
+        sys.modules[hashing_name] = module
+        hashing_spec.loader.exec_module(module)
+    except Exception:
+        sys.modules.pop(hashing_name, None)
+        sys.modules.pop(package_name, None)
+        raise
+    finally:
+        sys.dont_write_bytecode = previous_bytecode_setting
+    return module
+
+
+def _support() -> tuple[ModuleType, dict[str, Any]]:
+    global _loaded
+    selected = core_kit_path()
+    if _loaded is not None and _loaded[0] == selected:
+        return _loaded[1], _loaded[2]
+    if selected is None:
+        raise CoreKitError("explicit LAW_CODEGEN_CORE_KIT or configure_core_kit() is required")
+    manifest = validate_core_kit(selected)
+    module = _load_package(selected / "python/lawref", hashlib.sha256(
+        json.dumps(manifest, sort_keys=True).encode()).hexdigest()[:20]
+    )
+    schema = json.loads((selected / "schemas/calendar-dataset.schema.json").read_bytes())
+    _loaded = (selected, module, schema)
+    return module, schema
+
+
+def semantic_hash(ir: dict) -> str:
+    """Core semantic hash (§209) from the selected, validated support kit."""
+    module, _ = _support()
+    return module.semantic_hash(ir)
+
+
+def canonical_bytes(value: Any, **kwargs: Any) -> bytes:
+    """Core canonical JSON bytes (§208) from the selected support kit."""
+    module, _ = _support()
+    return module.canonical_bytes(value, **kwargs)
+
+
+def calendar_schema() -> dict[str, Any]:
+    """Return a private copy of the selected calendar dataset schema."""
+    _, schema = _support()
+    return copy.deepcopy(schema)

arxo_codegen/coverage.py

@@ -0,0 +1,341 @@
+#!/usr/bin/env python3
+"""Реестр покрытия по конструкциям (CODEGEN-COVERAGE-PLAN §1.1, волна W0).
+
+Обходит CLIR корпуса, пакетов вне корпуса и conformance-векторов, строит
+план каждого документа (`plan.survey_plan`) и сводит для каждой конструкции
+CLIR — вида узла, поля правила, силы, формы терма, статусного теста,
+агрегата, std-функции, типа аргумента, вида вопроса — четыре числа: в
+скольких снимках она встречается, в скольких из них план построен, в
+скольких векторах она есть и сколько из них совпали с голденом по реестру
+исходов. Статус конструкции выводится из этих чисел и из явных списков:
+
+  отказ         — конструкцию называет причина отказа плана либо раннера;
+  принята       — есть вектор с конструкцией, совпавший с голденом;
+  принята·корпус — вектора нет, но есть снимок корпуса с планом;
+  инертна       — названа в манифесте инертности `inert-nodes.json`
+                  (пока пуст: инертность доказывается вектором, §1.1);
+  вне профиля   — аналитика и `core-auditable` (§1.3–§1.4);
+  не покрыта    — встречается только в отвергнутых снимках, отказ её не
+                  называет: атрибуция неизвестна.
+
+Реестр — не голден: он пересобирается генератором и описывает состояние,
+а не ожидание. Ожидания живут в `active-outcomes.json` и в манифестах ворот.
+"""
+from __future__ import annotations
+
+import argparse
+import collections
+import datetime
+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
+
+FORMAT = "law.codegen-coverage/0.1"
+
+# §1.4 плана: ответ не входит в исполняемый профиль без отдельного решения.
+OUTSIDE_PROFILE = {
+    "query:argumentation": "аналитика над proof-графом (DECISION-0188 п. 1)",
+    "query:precedent": "аналитика §… прецедентов, читает proof",
+    "query:interpretation_analysis": "аналитика прочтений §156",
+    "node:precedent_decl": "данные прецедентов для аналитики",
+    "node:counterfactual_decl": "контрфактический поиск §186 — аналитика",
+    "node:evidence_policy": "политика доказательств §… — L3",
+    "node:temporal_resolution_policy": "политика разрешения моментов — вне среза значений",
+}
+
+# Причина отказа → конструкция, которую она называет.
+REASON_PREFIXES = (
+    ("объявление вне среза генератора: ", "node:"),
+    ("тип аргумента вне среза генератора: ", "type:"),
+    ("тип значения вне среза генератора: ", "type:"),
+    ("операция вне среза генератора: ", "op:"),
+    ("функция вне среза генератора: ", "fn:"),
+    ("узел терма вне среза генератора: ", "term:"),
+    ("статусный тест вне среза генератора: ", "status:"),
+    ("статусный тест вне L0-среза: ", "status:"),
+    ("поле правила вне среза генератора: ", "rulefield:"),
+    ("сила правила вне среза генератора: ", "strength:"),
+    ("сила правила вне L0-среза: ", "strength:"),
+    ("агрегат вне среза генератора: ", "agg:"),
+    ("вид запроса вне среза раннера: ", "query:"),
+)
+
+
+def construct_of(reason: str) -> str:
+    """Конструкция, названная причиной, либо сама причина как структурный отказ."""
+    for prefix, family in REASON_PREFIXES:
+        if reason.startswith(prefix):
+            value = reason[len(prefix):].strip()
+            if family == "node:" and value.endswith("/None"):
+                value = value[:-5]
+            if family == "type:":
+                return "type:" + value if value.startswith("urn:law:std#") else "type:<foreign-entity>"
+            if family == "fn:":
+                return fn_construct(value)
+            return family + value
+    head = reason.split(":", 1)[0].strip()
+    return "reason:" + head
+
+
+def type_construct(name: str, own: str) -> str:
+    """Типы std — поимённо; сущности — своего пакета либо чужого (мир §92.3)."""
+    if name.startswith("urn:law:std#"):
+        return "type:" + name
+    return "type:<own-entity>" if name.split("#", 1)[0] == own else "type:<foreign-entity>"
+
+
+def fn_construct(name: str) -> str:
+    """std-функции — поимённо; функции пакета и параметры A3 — родами."""
+    if name.startswith("urn:law:std#"):
+        return "fn:" + name
+    return "fn:<a3-parameter>" if "/value/" in name else "fn:<package-function>"
+
+
+def inventory(ir: dict) -> set[str]:
+    """Конструкции CLIR документа."""
+    out: set[str] = set()
+    own = (ir.get("package") or {}).get("namespace") or ""
+
+    def terms(node, in_type=False):
+        if isinstance(node, dict):
+            k = node.get("kind")
+            if k and not in_type:
+                out.add("term:" + k)
+                if k == "status":
+                    out.add("status:" + str(node.get("status")))
+                elif k == "aggregate":
+                    out.add("agg:" + str(node.get("op")))
+                elif k == "call":
+                    out.add(fn_construct(str(node.get("function"))))
+                elif k == "value":
+                    t = (node.get("type") or {}).get("name")
+                    if t:
+                        out.add(type_construct(t, own))
+            for key, value in node.items():
+                terms(value, in_type or key == "type")
+        elif isinstance(node, list):
+            for value in node:
+                terms(value, in_type)
+
+    for n in ir.get("nodes", []):
+        kind = n.get("kind")
+        sub = n.get("symbolKind")
+        out.add("node:" + (f"{kind}/{sub}" if sub else str(kind)))
+        if kind == "rule":
+            out.update("rulefield:" + f for f in n if f not in P.RULE_META)
+            out.add("strength:" + str(n.get("strength")))
+            for v in n.get("variables") or []:
+                t = (v.get("type") or {}).get("name")
+                if t:
+                    out.add(type_construct(t, own))
+            terms(n.get("body"))
+            terms(n.get("head"))
+            terms(n.get("scope"))
+        elif kind == "symbol_decl":
+            for p in n.get("params") or n.get("parameters") or []:
+                t = (p.get("type") or p).get("name") if isinstance(p, dict) else None
+                if t:
+                    out.add(type_construct(t, own))
+        elif kind == "assertion":
+            terms(n.get("formula") or n.get("literal"))
+        elif kind in ("norm_template", "priority_rule", "closure_policy", "constraint", "function_decl"):
+            terms({k: v for k, v in n.items() if k not in ("kind", "id", "package", "labels", "anchors",
+                                                              "provenance", "contentHash")})
+    return out
+
+
+def survey(ir: dict, world: list) -> list[str]:
+    try:
+        return P.survey_plan(ir, world)
+    except P.Refused as exc:
+        return [str(exc)]
+    except Exception as exc:  # крах плана — тоже исход, но не отказ
+        return ["крах плана: " + type(exc).__name__ + ": " + str(exc)[:120]]
+
+
+def corpus_documents(root: Path):
+    paths = sorted((root / "corpus" / "clir").glob("*.lawir.json"))
+    for p in sorted((root / "packs").rglob("*.lawir.json")):
+        if "deps" not in p.parts and ".build" not in p.parts:
+            paths.append(p)
+    for path in paths:
+        yield path, json.loads(path.read_text(encoding="utf-8"))
+
+
+def vector_documents(root: Path):
+    for meta_path in sorted((root / "verify" / "vectors").rglob("vector.json")):
+        d = meta_path.parent
+        if not (d / "ir.json").is_file():
+            continue
+        meta = json.loads(meta_path.read_text(encoding="utf-8"))
+        ir = json.loads((d / "ir.json").read_text(encoding="utf-8"))
+        query = json.loads((d / "query.json").read_text(encoding="utf-8")) if (d / "query.json").is_file() else {}
+        producer = d / "producer.ir.json"
+        world = [json.loads(producer.read_text(encoding="utf-8"))] if producer.is_file() else []
+        yield d, meta, ir, query, world
+
+
+def main(argv=None) -> int:
+    ap = argparse.ArgumentParser(description=__doc__.split("\n\n")[0])
+    ap.add_argument("--root", type=Path, default=HERE.parent.parent, help="checkout law-dsl")
+    ap.add_argument("--outcomes", type=Path, default=HERE / "active-outcomes.json")
+    ap.add_argument("--inert", type=Path, default=HERE / "inert-nodes.json")
+    ap.add_argument("--json", type=Path, default=HERE / "coverage.json")
+    ap.add_argument("--markdown", type=Path, default=HERE / "coverage.md")
+    ap.add_argument("--wheel", default="")
+    ap.add_argument("--from-json", action="store_true", help="перерисовать статусы и markdown из готового coverage.json")
+    args = ap.parse_args(argv)
+    root = args.root.resolve()
+    if args.from_json:
+        data = json.loads(args.json.read_text(encoding="utf-8"))
+        stats = {c["id"]: {k: c[k] for k in ("packages", "packagesPlanned", "packagesNamedByRefusal",
+                                             "vectors", "vectorsMatched", "vectorsNamedByRefusal", "vectorsWithdrawn")}
+                 for c in data["constructs"]}
+        return finish(args, stats, data["packages"], data["vectors"], data["summary"].get("wheel", args.wheel))
+    try:
+        import core_support
+        kit = root / "vendor" / "codegen" / "core-kit"
+        if kit.is_dir():
+            core_support.configure_core_kit(kit)
+    except Exception:
+        pass
+
+    outcomes = json.loads(args.outcomes.read_text(encoding="utf-8")).get("vectors", {}) if args.outcomes.is_file() else {}
+    index = P.world_index(root)
+    stats: dict[str, dict] = collections.defaultdict(lambda: {
+        "packages": 0, "packagesPlanned": 0, "packagesNamedByRefusal": 0,
+        "vectors": 0, "vectorsMatched": 0, "vectorsNamedByRefusal": 0, "vectorsWithdrawn": 0,
+    })
+    packages, vectors = [], []
+
+    for path, ir in corpus_documents(root):
+        name = (ir.get("package") or {}).get("name") or path.stem
+        try:
+            world = P.resolve_world(ir, index, []) if ir.get("imports") else []
+        except Exception as exc:
+            world, pre = [], ["мир не разрешён: " + str(exc)[:120]]
+        else:
+            pre = []
+        reasons = pre or survey(ir, world)
+        named = {construct_of(r) for r in reasons}
+        present = inventory(ir)
+        for c in present | {c for c in named if c.startswith("reason:")}:
+            s = stats[c]
+            if c in present:
+                s["packages"] += 1
+                if not reasons:
+                    s["packagesPlanned"] += 1
+            if c in named:
+                s["packagesNamedByRefusal"] += 1
+        packages.append({"name": name, "path": str(path.relative_to(root)), "planned": not reasons,
+                         "rules": sum(1 for n in ir.get("nodes", []) if n.get("kind") == "rule"),
+                         "reasons": sorted(collections.Counter(construct_of(r) for r in reasons).items())})
+
+    for d, meta, ir, query, world in vector_documents(root):
+        vid = meta.get("id") or d.name
+        outcome = outcomes.get(vid)
+        if isinstance(outcome, dict):  # реестр формата 0.3: пин — объект с хэшем входов
+            outcome = outcome.get("outcome")
+        withdrawn = str(ir.get("semanticVersion")) == "0.1.1"
+        present = inventory(ir)
+        qk = query.get("kind")
+        if qk:
+            present.add("query:" + qk)
+        reasons = [] if withdrawn else survey(ir, world)
+        named = {construct_of(r) for r in reasons}
+        if isinstance(outcome, str):
+            if outcome.startswith("query: "):
+                named.add("query:" + outcome[7:].strip())
+            elif outcome.startswith("runtime: "):
+                named.add(construct_of(outcome[9:]))
+        matched = outcome == "match"
+        for c in present | {c for c in named if c.startswith("reason:")}:
+            s = stats[c]
+            if c in present:
+                s["vectors"] += 1
+                if withdrawn:
+                    s["vectorsWithdrawn"] += 1
+                if matched:
+                    s["vectorsMatched"] += 1
+            if c in named:
+                s["vectorsNamedByRefusal"] += 1
+        vectors.append({"id": vid, "layer": meta.get("layer"), "query": qk,
+                        "semanticVersion": ir.get("semanticVersion"),
+                        "outcome": outcome if isinstance(outcome, str) else ("withdrawn" if withdrawn else "unpinned"),
+                        "planRefusals": sorted(named)})
+
+    return finish(args, stats, packages, vectors, args.wheel)
+
+
+def finish(args, stats, packages, vectors, wheel) -> int:
+    inert = json.loads(args.inert.read_text(encoding="utf-8")) if args.inert.is_file() else {"constructs": {}}
+
+    def status(c: str, s: dict) -> str:
+        if c in inert.get("constructs", {}):
+            return "инертна"
+        if c in OUTSIDE_PROFILE:
+            return "вне профиля"
+        named = s["packagesNamedByRefusal"] or s["vectorsNamedByRefusal"]
+        if named and (s["vectorsMatched"] or s["packagesPlanned"]):
+            # Конструкция и принята, и названа отказом: срез зависит от формы
+            # или значения (пустое/непустое поле, тип слота, вид эффекта).
+            return "частично"
+        if named or c.startswith("reason:"):
+            return "отказ"
+        if s["vectorsMatched"]:
+            return "принята"
+        if s["packagesPlanned"]:
+            return "принята·корпус"
+        return "не покрыта"
+
+    constructs = []
+    for c in sorted(stats):
+        s = stats[c]
+        constructs.append({"id": c, "family": c.split(":", 1)[0], "status": status(c, s), **s,
+                           **({"note": OUTSIDE_PROFILE[c]} if c in OUTSIDE_PROFILE else {})})
+    families = collections.defaultdict(collections.Counter)
+    for c in constructs:
+        families[c["family"]][c["status"]] += 1
+    planned = sum(1 for p in packages if p["planned"])
+    active = [v for v in vectors if v["outcome"] not in ("withdrawn", "unpinned")]
+    summary = {
+        "format": FORMAT, "date": datetime.date.today().isoformat(), "wheel": wheel,  # determinism: allow(отчёт о состоянии, не артефакт семантики)
+        "packages": len(packages), "packagesPlanned": planned,
+        "vectors": len(vectors), "vectorsActive": len(active),
+        "vectorsMatched": sum(1 for v in active if v["outcome"] == "match"),
+        "vectorsWithdrawn": sum(1 for v in vectors if v["outcome"] == "withdrawn"),
+        "vectorsUnpinned": sum(1 for v in vectors if v["outcome"] == "unpinned"),
+        "constructs": len(constructs),
+        "byFamily": {f: dict(c) for f, c in sorted(families.items())},
+    }
+    args.json.write_text(json.dumps({"summary": summary, "constructs": constructs, "packages": packages,
+                                     "vectors": vectors}, ensure_ascii=False, indent=1) + "\n", encoding="utf-8")
+
+    md = ["# Реестр покрытия по конструкциям", "",
+          f"Собрано `coverage.py` {summary['date']}, wheel `{wheel or '?'}`. "
+          f"Снимков {summary['packages']}, с планом {planned}. Векторов с CLIR {summary['vectors']}: "
+          f"активных {summary['vectorsActive']}, совпало {summary['vectorsMatched']}, отозвано (0.1.1) "
+          f"{summary['vectorsWithdrawn']}, вне реестра {summary['vectorsUnpinned']}.", "",
+          "| семейство | " + " | ".join(("принята", "принята·корпус", "частично", "отказ", "инертна", "вне профиля", "не покрыта")) + " |",
+          "|---|---:|---:|---:|---:|---:|---:|---:|"]
+    for f, c in sorted(families.items()):
+        md.append(f"| `{f}` | " + " | ".join(str(c.get(k, 0)) for k in
+                  ("принята", "принята·корпус", "частично", "отказ", "инертна", "вне профиля", "не покрыта")) + " |")
+    md += ["", "| конструкция | статус | снимков | с планом | назван отказом | векторов | совпало | назван отказом | отозвано |",
+           "|---|---|---:|---:|---:|---:|---:|---:|---:|"]
+    order = {"отказ": 0, "частично": 1, "не покрыта": 2, "принята·корпус": 3, "принята": 4, "инертна": 5, "вне профиля": 6}
+    for c in sorted(constructs, key=lambda c: (order[c["status"]], -c["packages"], c["id"])):
+        md.append(f"| `{c['id']}` | {c['status']} | {c['packages']} | {c['packagesPlanned']} | "
+                  f"{c['packagesNamedByRefusal']} | {c['vectors']} | {c['vectorsMatched']} | "
+                  f"{c['vectorsNamedByRefusal']} | {c['vectorsWithdrawn']} |")
+    args.markdown.write_text("\n".join(md) + "\n", encoding="utf-8")
+    print(json.dumps(summary, ensure_ascii=False, indent=1))
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())