arxo-codegen 0.4.0__py3-none-any.whl

arxo_codegen/check_xlsx.py

@@ -0,0 +1,320 @@
+#!/usr/bin/env python3
+"""Check exported XLSX fixtures without importing the Law DSL oracle.
+
+The publisher-side exporter computes ``expectations.json`` with lawref.  This
+consumer verifies fixture hashes and workbook structure, then optionally asks
+LibreOffice to recalculate copies of the exported workbooks.  It compares only
+against those pinned expected results; it never imports lawref or implements
+Excel formulae in Python.
+"""
+from __future__ import annotations
+
+import argparse
+from decimal import Decimal
+import datetime as dt
+import hashlib
+import json
+from pathlib import Path
+import shutil
+import subprocess
+import sys
+import tempfile
+import zipfile
+from xml.etree import ElementTree as ET
+
+
+FORMAT = "law.codegen-xlsx-fixtures/0.1"
+CURRENT_REFUSAL = "цель xlsx не поддерживает возможности плана: admission:current"
+XMLNS = {"s": "http://schemas.openxmlformats.org/spreadsheetml/2006/main"}
+REL = "{http://schemas.openxmlformats.org/officeDocument/2006/relationships}id"
+EPOCH = dt.date(1899, 12, 30)
+HERE = Path(__file__).resolve().parent
+
+
+class FixtureError(RuntimeError):
+    pass
+
+
+def sha(data: bytes) -> str:
+    return "sha256:" + hashlib.sha256(data).hexdigest()
+
+
+def load(fixtures: Path) -> tuple[dict, dict]:
+    fixtures = Path(fixtures)
+    if fixtures.is_symlink() or not fixtures.is_dir():
+        raise FixtureError("fixtures are not a directory")
+    for path in fixtures.rglob("*"):
+        if path.is_symlink():
+            raise FixtureError("fixtures contain a symlink")
+    try:
+        manifest = json.loads((fixtures / "manifest.json").read_bytes())
+        expected = json.loads((fixtures / "expectations.json").read_bytes())
+    except (OSError, UnicodeDecodeError, json.JSONDecodeError) as error:
+        raise FixtureError("invalid fixture JSON") from error
+    if manifest.get("format") != FORMAT or expected.get("format") != FORMAT:
+        raise FixtureError("unsupported fixture format")
+    files = manifest.get("files")
+    if not isinstance(files, list):
+        raise FixtureError("fixture manifest has no inventory")
+    seen = set()
+    for row in files:
+        if not isinstance(row, dict) or not isinstance(row.get("path"), str):
+            raise FixtureError("invalid fixture inventory row")
+        rel = row["path"]
+        if not rel or rel.startswith("/") or ".." in Path(rel).parts or rel in seen:
+            raise FixtureError("invalid fixture inventory path")
+        seen.add(rel); path = fixtures / rel
+        if path.is_symlink() or not path.is_file() or row.get("sha256") != sha(path.read_bytes()) or row.get("bytes") != path.stat().st_size:
+            raise FixtureError("fixture inventory hash mismatch")
+    actual = {path.relative_to(fixtures).as_posix() for path in fixtures.rglob("*") if path.is_file()}
+    if actual != seen | {"manifest.json"}:
+        raise FixtureError("fixture inventory differs from files")
+    if expected.get("semanticVersion") != "0.2.11":
+        raise FixtureError("fixture does not declare current semanticVersion 0.2.11")
+    if not isinstance(expected.get("programs"), dict) or not expected["programs"]:
+        raise FixtureError("fixture has no programs")
+    return manifest, expected
+
+
+def cached(path: Path) -> dict[str, object]:
+    with zipfile.ZipFile(path) as archive:
+        strings = []
+        if "xl/sharedStrings.xml" in archive.namelist():
+            strings = ["".join(node.itertext()) for node in ET.fromstring(archive.read("xl/sharedStrings.xml")).findall("s:si", XMLNS)]
+        relationships = {row.attrib["Id"]: row.attrib["Target"].lstrip("/") for row in ET.fromstring(archive.read("xl/_rels/workbook.xml.rels"))}
+        book = ET.fromstring(archive.read("xl/workbook.xml")); values: dict[str, object] = {}
+        for sheet in book.findall("s:sheets/s:sheet", XMLNS):
+            target = relationships[sheet.attrib[REL]]
+            target = target if target.startswith("xl/") else "xl/" + target
+            for cell in ET.fromstring(archive.read(target)).findall(".//s:c", XMLNS):
+                value = cell.find("s:v", XMLNS)
+                data: object = value.text if value is not None else None
+                if cell.get("t") == "inlineStr": data = "".join(cell.find("s:is", XMLNS).itertext())
+                elif cell.get("t") == "s" and data is not None: data = strings[int(data)]
+                elif cell.get("t") == "b": data = data == "1"
+                elif cell.get("t") not in ("str", "e") and data is not None: data = Decimal(data)
+                values[sheet.attrib["name"] + "!" + cell.attrib["r"]] = data
+        return values
+
+
+def _sheets(archive: zipfile.ZipFile) -> dict[str, str]:
+    rels = {row.attrib["Id"]: row.attrib["Target"].lstrip("/") for row in ET.fromstring(archive.read("xl/_rels/workbook.xml.rels"))}
+    book = ET.fromstring(archive.read("xl/workbook.xml"))
+    return {sheet.attrib["name"]: (rels[sheet.attrib[REL]] if rels[sheet.attrib[REL]].startswith("xl/") else "xl/" + rels[sheet.attrib[REL]]) for sheet in book.findall("s:sheets/s:sheet", XMLNS)}
+
+
+def edit_copy(source: Path, destination: Path, changes: dict[str, object]) -> None:
+    """Edit only declared Inputs cells; formula XML is copied byte-for-byte."""
+    with zipfile.ZipFile(source) as original, zipfile.ZipFile(destination, "w", zipfile.ZIP_DEFLATED) as output:
+        sheets = _sheets(original)
+        for name in original.namelist():
+            data = original.read(name)
+            for sheet, target in sheets.items():
+                if name != target:
+                    continue
+                document = ET.fromstring(data)
+                for cell in document.findall(".//s:c", XMLNS):
+                    key = sheet + "!" + cell.get("r")
+                    if key not in changes:
+                        continue
+                    for child in list(cell): cell.remove(child)
+                    cell.attrib.pop("t", None); value = changes[key]
+                    if isinstance(value, str):
+                        cell.set("t", "inlineStr")
+                        ET.SubElement(ET.SubElement(cell, "{" + XMLNS["s"] + "}is"), "{" + XMLNS["s"] + "}t").text = value
+                    elif value is not None:
+                        ET.SubElement(cell, "{" + XMLNS["s"] + "}v").text = str(value)
+                data = ET.tostring(document, encoding="utf-8", xml_declaration=True)
+            output.writestr(name, data)
+
+
+def result_rows(values: dict[str, object], mapping: dict, predicate: str) -> list[list[object]]:
+    rows = []
+    for row in mapping["tables"][predicate]:
+        if values.get(row["status"]) == "PRESENT":
+            rows.append([values.get(address) for address in row["args"]])
+    return rows
+
+
+def same_rows(actual: list[list[object]], expected: list[list[str]]) -> bool:
+    """Compare Excel numeric cells to oracle decimal strings by value, not scale."""
+    if len(actual) != len(expected): return False
+    def equivalent(left: object, right: str) -> bool:
+        if isinstance(left, Decimal):
+            try: return left == Decimal(right)
+            except Exception: return False
+        return left == right
+    unmatched = list(expected)
+    for row in actual:
+        for index, candidate in enumerate(unmatched):
+            if len(row) == len(candidate) and all(equivalent(left, right) for left, right in zip(row, candidate)):
+                unmatched.pop(index); break
+        else: return False
+    return not unmatched
+
+
+def changes_for(name: str, case: dict, mapping: dict, prefix: str) -> dict[str, object]:
+    change = case["changes"]
+    if name == "pricing":
+        first, second = mapping["inputs"][prefix + "quote"]
+        out = {}
+        for index, key in enumerate(("ident", "category", "amount")):
+            if key in change: out[first["args"][index]] = change[key]
+        if "enabled" in change: out[first["enabled"]] = change["enabled"]
+        if "legalTime" in change: out["Inputs!B4"] = None if change["legalTime"] is None else (dt.date.fromisoformat(change["legalTime"]) - EPOCH).days
+        if "second" in change:
+            out[second["enabled"]] = 1
+            out.update(dict(zip(second["args"], change["second"])))
+        return out
+    if name == "arithmetic":
+        row = mapping["inputs"][prefix + "operands"][0]
+        return {address: Decimal(value) for address, value in zip(row["args"], change.get("operands", []))}
+    if name == "discrete":
+        out = {}
+        for table, values in change.items():
+            row = mapping["inputs"][prefix + table][0]
+            if table == "dates":
+                values = [(dt.date.fromisoformat(value) - EPOCH).days for value in values]
+            out.update(dict(zip(row["args"], values)))
+        return out
+    raise FixtureError("unknown exported workbook")
+
+
+def structural_tree(fixtures: Path, expected: dict) -> None:
+    for name, program in expected["programs"].items():
+        directory = fixtures / name
+        if program.get("expectedRefusal"):
+            if program["expectedRefusal"] != CURRENT_REFUSAL:
+                raise FixtureError(f"{name}: unqualified current XLSX refusal")
+            ir = json.loads((directory / "program.lawir.json").read_bytes())
+            if (ir.get("semanticVersion"), ir.get("schemaVersion")) != ("0.2.11", "law.core.ir/0.7"):
+                raise FixtureError(f"{name}: refusal fixture is not current")
+            if {p.name for p in directory.iterdir()} != {"program.lawir.json", "config.json"}:
+                raise FixtureError(f"{name}: refused workbook must not contain generated output")
+            continue
+        for required in ("model.xlsx", "cells.json", "law-backend.json", "program.lawir.json", "config.json"):
+            if not (directory / required).is_file(): raise FixtureError(f"{name}: missing {required}")
+        with zipfile.ZipFile(directory / "model.xlsx") as book:
+            names = set(book.namelist())
+            if not {"xl/workbook.xml", "xl/_rels/workbook.xml.rels"} <= names or any("vba" in item.lower() or "externallink" in item.lower() for item in names):
+                raise FixtureError(f"{name}: unsafe or incomplete workbook")
+        passport = json.loads((directory / "law-backend.json").read_bytes())
+        if passport.get("profile") != "excel-calculator/0.1": raise FixtureError(f"{name}: unexpected delivery profile")
+        for rel, digest in passport.get("files", {}).items():
+            if digest != sha((directory / rel).read_bytes()): raise FixtureError(f"{name}: delivery passport hash mismatch")
+        program_ir = json.loads((directory / "program.lawir.json").read_bytes())
+        if program_ir.get("semanticVersion") != "0.2.11": raise FixtureError(f"{name}: archived program leaked into active fixtures")
+
+
+def structural(fixtures: Path, expected: dict) -> None:
+    structural_tree(fixtures, expected)
+
+
+def _backend_modules():
+    """Support both a direct script and installed ``arxo_codegen`` package."""
+    try:
+        from . import core_support, deliver
+    except ImportError:
+        if str(HERE) not in sys.path: sys.path.insert(0, str(HERE))
+        import core_support, deliver
+    return core_support, deliver
+
+
+def regenerate(fixtures: Path, expected: dict, core_kit: Path, output: Path) -> None:
+    """Regenerate pinned deliveries with the installed backend and core kit."""
+    core_support, deliver = _backend_modules()
+    core_support.configure_core_kit(core_kit)
+    core_support.validate_core_kit(core_kit)
+    try:
+        for name in expected["programs"]:
+            source, target = fixtures / name, output / name
+            target.mkdir(parents=True)
+            program = json.loads((source / "program.lawir.json").read_bytes())
+            config = json.loads((source / "config.json").read_bytes())
+            # Resources are deliberately explicit and empty: these fixtures do
+            # not rely on a neighbouring corpus or an implicit resolver.
+            if expected["programs"][name].get("expectedRefusal"):
+                try:
+                    deliver.deliver(program, "xlsx", target, options=config, resources={})
+                except deliver.P.Refused as exc:
+                    if str(exc) != CURRENT_REFUSAL:
+                        raise FixtureError(f"{name}: wrong current XLSX refusal") from exc
+                else:
+                    raise FixtureError(f"{name}: uncertified XLSX unexpectedly admitted")
+                if any(target.iterdir()):
+                    raise FixtureError(f"{name}: refusal wrote output")
+                for asset in ("program.lawir.json", "config.json"):
+                    shutil.copyfile(source / asset, target / asset)
+                continue
+            deliver.deliver(program, "xlsx", target, options=config, resources={})
+            for asset in ("program.lawir.json", "config.json"):
+                shutil.copyfile(source / asset, target / asset)
+            for asset in ("model.xlsx", "plan.json", "cells.json", "law-backend.json"):
+                if sha((source / asset).read_bytes()) != sha((target / asset).read_bytes()):
+                    raise FixtureError(f"{name}: installed backend regenerated different {asset}")
+        structural_tree(output, expected)
+    finally:
+        core_support.configure_core_kit(None)
+
+
+def recalculate(fixtures: Path, expected: dict, soffice: str) -> int:
+    if not Path(soffice).is_file(): raise FixtureError("LibreOffice executable is unavailable")
+    checked = 0
+    with tempfile.TemporaryDirectory(prefix="arxo-xlsx-check-") as temporary:
+        work = Path(temporary); incoming, outgoing = work / "incoming", work / "outgoing"; incoming.mkdir(); outgoing.mkdir()
+        pending = []
+        for name, program in expected["programs"].items():
+            mapping = json.loads((fixtures / name / "cells.json").read_bytes()); prefix = program["predicatePrefix"]
+            for case in program["cases"]:
+                target = incoming / f"{name}--{case['id']}.xlsx"
+                edit_copy(fixtures / name / "model.xlsx", target, changes_for(name, case, mapping, prefix))
+                pending.append((name, case, mapping, prefix, target.name))
+        command = [soffice, "-env:UserInstallation=" + (work / "profile").as_uri(), "--headless", "--convert-to", "xlsx", "--outdir", str(outgoing)] + [str(incoming / item[-1]) for item in pending]
+        result = subprocess.run(command, capture_output=True, text=True, timeout=120)
+        if result.returncode or len(list(outgoing.glob("*.xlsx"))) != len(pending):
+            raise FixtureError(f"LibreOffice recalculation failed: {result.returncode}\n{result.stdout}\n{result.stderr}")
+        for name, case, mapping, prefix, filename in pending:
+            values = cached(outgoing / filename)
+            if values.get("Results!B3") != case["status"]: raise FixtureError(f"{name}/{case['id']}: status mismatch")
+            if case["status"] == "READY" and any(isinstance(value, str) and value.startswith(("#REF!", "#DIV/0!", "#VALUE!", "#NAME?", "#N/A", "#NUM!")) for value in values.values()):
+                raise FixtureError(f"{name}/{case['id']}: spreadsheet formula error")
+            for table, expected_rows in case["results"].items():
+                actual = result_rows(values, mapping, prefix + table)
+                if table == "before":
+                    actual = [[(EPOCH + dt.timedelta(days=int(Decimal(value)))).isoformat() for value in row] for row in actual]
+                if not same_rows(actual, expected_rows): raise FixtureError(f"{name}/{case['id']}/{table}: result mismatch: {actual!r} != {expected_rows!r}")
+            checked += 1
+    return checked
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("--fixtures", required=True, type=Path)
+    parser.add_argument("--core-kit", type=Path, help="validate the selected core kit without importing lawref")
+    parser.add_argument("--recalculate", action="store_true")
+    parser.add_argument("--soffice", default=shutil.which("soffice") or "/Applications/LibreOffice.app/Contents/MacOS/soffice")
+    args = parser.parse_args()
+    try:
+        _, expected = load(args.fixtures); structural(args.fixtures, expected)
+        refused = sum(bool(p.get("expectedRefusal")) for p in expected["programs"].values())
+        print(f"check_xlsx: fixture integrity — PASS; qualified current refusals {refused}")
+        with tempfile.TemporaryDirectory(prefix="arxo-xlsx-regenerated-") as temporary:
+            active = args.fixtures
+            if args.core_kit:
+                active = Path(temporary) / "delivery"
+                regenerate(args.fixtures, expected, args.core_kit, active)
+                print("check_xlsx: installed backend regenerated pinned XLSX delivery — PASS")
+            if refused:
+                if not args.core_kit:
+                    raise FixtureError("--core-kit required to execute qualified refusals")
+                print("check_xlsx: current XLSX unsupported; no workbook/recalculation PASS claimed")
+            elif args.recalculate:
+                print(f"check_xlsx: LibreOffice recalculated {recalculate(active, expected, args.soffice)} cases — PASS")
+            else:
+                print("check_xlsx: recalculation NOT CHECKED (pass --recalculate with --soffice to verify formulas)")
+    except (OSError, ValueError, FixtureError, zipfile.BadZipFile, subprocess.SubprocessError) as error:
+        parser.exit(1, f"check_xlsx: REFUSED: {error}\n")
+
+
+if __name__ == "__main__":
+    main()

arxo_codegen/consumer_runner.py

@@ -0,0 +1,316 @@
+#!/usr/bin/env python3
+"""Run an already-lowered consumer bundle without corpus, lawref, or CI code."""
+from __future__ import annotations
+
+import argparse
+import hashlib
+import json
+import os
+from pathlib import Path
+import shutil
+import sys
+import tempfile
+
+HERE = Path(__file__).resolve().parent
+if str(HERE) not in sys.path:
+    sys.path.insert(0, str(HERE))
+import core_support
+import deliver as D
+import inputs
+import plan as P
+import target_runner as T
+
+
+FORMAT = "law.codegen-consumer/0.1"
+SET_FORMAT = "law.codegen-consumer-set/0.1"
+FIELDS = ("truth_status", "evaluation_status", "result_kind", "normative_status")
+UNSUPPORTED_FIELDS = frozenset(("applicability_status", "trigger_status", "value"))
+POSITION_OBS = ("position", "position_status", "position_count", "positions_present")
+UNSUPPORTED_OBS = frozenset(("applied", "any_applied", "issue", "any_issue", "issues_within", "issues_exactly",
+                       "certificate", "conflicts", "judgment_requests", "judgment_request", "interpretations",
+                       "argumentation_class", "refused", "collected", "collected_exactly", "collected_count",
+                       "any_position", "blocked_by", "blockers", "deadline_trace_present", "deadline_trace",
+                       "position_proved", "status_support"))
+
+
+def sha(data: bytes) -> str:
+    return "sha256:" + hashlib.sha256(data).hexdigest()
+
+
+def _file(root: Path, entry: dict, label: str) -> Path:
+    if not isinstance(entry, dict) or set(entry) != {"path", "sha256"} or not all(isinstance(value, str) for value in entry.values()):
+        raise ValueError(f"{label}: expected {{path, sha256}}")
+    path = (root / entry["path"]).resolve()
+    if not path.is_relative_to(root) or not path.is_file():
+        raise ValueError(f"{label}: file is absent or outside bundle")
+    if sha(path.read_bytes()) != entry["sha256"]:
+        raise ValueError(f"{label}: SHA-256 differs")
+    return path
+
+
+def load_bundle(path: Path, *, allow_set: bool = True) -> dict:
+    root = path.resolve()
+    manifest = root / "bundle.json"
+    try:
+        doc = json.loads(manifest.read_text(encoding="utf-8"))
+    except (OSError, json.JSONDecodeError) as error:
+        raise ValueError(f"consumer bundle: {error}") from error
+    if isinstance(doc, dict) and doc.get("format") == SET_FORMAT and allow_set:
+        members = doc.get("groups")
+        skipped = doc.get("skipped", [])
+        if not isinstance(members, list) or not members:
+            raise ValueError("groups: non-empty list required")
+        if not isinstance(skipped, list) or not all(isinstance(value, str) for value in skipped):
+            raise ValueError("skipped: list of named source skips required")
+        manifests = [_file(root, item, "group") for item in members]
+        if any(item.name != "bundle.json" for item in manifests) or len(set(manifests)) != len(manifests):
+            raise ValueError("groups: distinct bundle.json manifests required")
+        return {"groups": [load_bundle(item.parent, allow_set=False) for item in manifests],
+                "source_skipped": skipped}
+    if not isinstance(doc, dict) or doc.get("format") != FORMAT:
+        raise ValueError(f"consumer bundle: expected format {FORMAT}")
+    program = _file(root, doc.get("program"), "program")
+    world_rows = doc.get("world", [])
+    if not isinstance(world_rows, list):
+        raise ValueError("world: expected list")
+    world = [_file(root, row, "world") for row in world_rows]
+    mode = doc.get("programMode", "source")
+    if mode not in ("source", "linked") or (mode == "linked" and world):
+        raise ValueError("programMode: source or prelinked program with empty world required")
+    tests = doc.get("tests")
+    if not isinstance(tests, list) or not tests:
+        raise ValueError("tests: non-empty list required")
+    loaded = []
+    for row in tests:
+        if not isinstance(row, dict) or not isinstance(row.get("id"), str):
+            raise ValueError("test: id required")
+        case, query = _file(root, row.get("case"), f"test {row['id']} case"), _file(root, row.get("query"), f"test {row['id']} query")
+        expectations = row.get("expectations", [])
+        if not isinstance(expectations, list):
+            raise ValueError(f"test {row['id']}: expectations must be a list")
+        query_doc = json.loads(query.read_text(encoding="utf-8"))
+        validate_expectations(row["id"], query_doc.get("kind"), expectations)
+        loaded.append(dict(row, case=case, query=query, expectations=expectations))
+    resources = doc.get("resources")
+    resource_file = _file(root, resources, "resources") if resources is not None else None
+    group = doc.get("group")
+    if not isinstance(group, dict) or set(group) != {"world", "concat", "resolve", "merge"} or group.get("merge") != "link" \
+            or any(not isinstance(group.get(key), list) or not all(isinstance(value, str) for value in group[key])
+                   for key in ("world", "concat", "resolve")):
+        raise ValueError("group: explicit {world, concat, resolve, merge:'link'} required")
+    skipped_at_source = doc.get("skipped", [])
+    if not isinstance(skipped_at_source, list) or not all(isinstance(value, str) for value in skipped_at_source):
+        raise ValueError("skipped: list of named source skips required")
+    return {"root": root, "doc": doc, "program": program, "world": world, "tests": loaded,
+            "group": group, "source_skipped": skipped_at_source, "program_mode": mode,
+            "resource_file": resource_file}
+
+
+def validate_expectations(identifier: str, query_kind: object, expectations: list) -> None:
+    allowed_fields = {"truth": {"truth_status", "evaluation_status", "result_kind"},
+                      "positions": {"result_kind", "normative_status", "evaluation_status"}}
+    for item in expectations:
+        if not isinstance(item, dict):
+            raise ValueError(f"test {identifier}: expectation must be an object")
+        field, observation = item.get("field"), item.get("observation")
+        if field is not None:
+            if item.get("op") != "eq":
+                raise ValueError(f"test {identifier}: unsupported expectation op {item.get('op')!r}")
+            if field not in FIELDS and field not in UNSUPPORTED_FIELDS:
+                raise ValueError(f"test {identifier}: unknown expectation field {field!r}")
+            if query_kind in allowed_fields and field in FIELDS and field not in allowed_fields[query_kind]:
+                raise ValueError(f"test {identifier}: field {field!r} is inapplicable to query {query_kind!r}")
+        elif observation is not None:
+            if observation in POSITION_OBS:
+                if query_kind != "positions":
+                    raise ValueError(f"test {identifier}: observation {observation!r} requires positions query")
+            elif observation not in UNSUPPORTED_OBS:
+                raise ValueError(f"test {identifier}: unknown unsupported observation {observation!r}")
+        else:
+            raise ValueError(f"test {identifier}: expectation needs field or observation")
+
+
+def expected(test: dict) -> tuple[dict, list[str], list[dict]]:
+    fields, skipped, positions = {}, [], []
+    for item in test["expectations"]:
+        if not isinstance(item, dict):
+            raise ValueError(f"test {test['id']}: expectation must be an object")
+        if item.get("op") == "eq" and item.get("field") in FIELDS:
+            fields[item["field"]] = item.get("value")
+        elif item.get("observation") in POSITION_OBS:
+            positions.append(item)
+        else:
+            skipped.append(str(item.get("observation") or item.get("field") or "?"))
+    return fields, skipped, positions
+
+
+def observe(item: dict, positions: list[dict]) -> bool:
+    value, kind = item.get("value"), item["observation"]
+    if kind == "positions_present":
+        found = bool(positions)
+    elif kind == "position_status":
+        found = any(row.get("status") == value for row in positions)
+    elif kind == "position_count":
+        found = sum(row.get("template") == value and row.get("status") == item.get("status", "") for row in positions) == item.get("count")
+    else:
+        found = any(row.get("template") == value and row.get("status") == item.get("status", "") for row in positions)
+    return found != bool(item.get("negated"))
+
+
+def compare(answer: dict, test: dict) -> list[str]:
+    fields, _skips, position_expectations = expected(test)
+    kind = json.loads(test["query"].read_text(encoding="utf-8")).get("kind")
+    if kind == "truth":
+        actual = {"truth_status": answer.get("truthStatus"), "evaluation_status": answer.get("evaluationStatus"),
+                  "result_kind": answer.get("resultKind", "PROPOSITION" if answer.get("truthStatus") in
+                                            {"TRUE_ONLY", "FALSE_ONLY", "BOTH", "NEITHER"} else None)}
+    elif kind == "positions":
+        actual = {"result_kind": answer.get("resultKind"), "normative_status": answer.get("normativeStatus"),
+                  "evaluation_status": answer.get("evaluationStatus")}
+        bad_positions = [item["observation"] for item in position_expectations if not observe(item, answer.get("positions") or [])]
+        if bad_positions:
+            return ["наблюдения позиций не совпали: " + ", ".join(bad_positions)]
+    else:
+        return [f"пропуск: запрос {kind}"]
+    return [f"{name}: ожидалось {value!r}, получено {actual.get(name)!r}" for name, value in fields.items() if actual.get(name) != value]
+
+
+def checkable(test: dict) -> bool:
+    fields, _skipped, positions = expected(test)
+    return bool(fields or positions)
+
+
+def run(bundle: dict, targets: list[str], work: Path) -> tuple[dict, list[str]]:
+    if "groups" in bundle:
+        summaries, failures = [], []
+        for number, member in enumerate(bundle["groups"]):
+            summary, errors = run(member, targets, work / f"group{number:03d}")
+            summaries.append(summary)
+            failures.extend(f"group {number}: {error}" for error in errors)
+            if not errors and summary.get("matched", 0) == 0:
+                failures.append(f"group {number}: нет проверенных ожиданий")
+        return {"groups": summaries, "tests": sum(s.get("tests", 0) for s in summaries),
+                "matched": sum(s.get("matched", 0) for s in summaries),
+                "sourceSkipped": bundle["source_skipped"]}, failures
+    ir = json.loads(bundle["program"].read_text(encoding="utf-8"))
+    world = [json.loads(path.read_text(encoding="utf-8")) for path in bundle["world"]]
+    # Validate names/duplicates even though resolve_world receives documents as
+    # explicit extras rather than its path-index argument.
+    inputs.dependency_index(world)
+    resources = inputs.load_resources(bundle["resource_file"]) if bundle["resource_file"] else {}
+    negative = any(any((item.get("literal") or {}).get("polarity") == "negative" for item in
+                       (json.loads(test["case"].read_text(encoding="utf-8")).get("assertions") or [])) for test in bundle["tests"])
+    # ``extra`` is documents, not the path index accepted by resolve_world.
+    # Retain every explicitly delivered world member afterwards: concat worlds
+    # may not be imported by the root but still change its program.
+    resolved = P.resolve_world(ir, {}, world) if ir.get("imports") and bundle.get("program_mode") != "linked" else []
+    names = {(document.get("package") or {}).get("name") for document in resolved}
+    for document in world:
+        name = (document.get("package") or {}).get("name")
+        if name not in names:
+            resolved.append(document)
+            names.add(name)
+    plan = P.build_plan(ir, resolved, {"negation"} if negative else None, resources)
+    known = D.targets(protocol="runner")
+    unknown = sorted(set(targets) - set(known))
+    if unknown:
+        return {}, ["неизвестные цели: " + ", ".join(unknown)]
+    emit = {name: D.emitter(name) for name in targets}
+    unavailable = [f"{name}: {emit[name].available()[1]}" for name in targets if not emit[name].available()[0]]
+    active = [name for name in targets if emit[name].available()[0]]
+    if not active:
+        return {}, ["нет доступных целей"]
+    projects = {}
+    for name in active:
+        project = work / "module" / name
+        D.emit_project(plan, name, project)
+        projects[name] = [project]
+    environment = dict(os.environ, GOCACHE=str(work.resolve() / "gocache"),
+                       GOMODCACHE=str(work.resolve() / "gomodcache"),
+                       CLANG_MODULE_CACHE_PATH=str(work.resolve() / "clang-cache"),
+                       SWIFT_MODULECACHE_PATH=str(work.resolve() / "swift-cache"))
+    failures = T.build_projects(emit, projects, work / "module", environment)
+    summary = {"tests": len(bundle["tests"]), "matched": 0, "unchecked": 0, "refused": {},
+               "skipped": {}, "sourceSkipped": bundle["source_skipped"], "unavailable": unavailable}
+    if failures:
+        return summary, failures
+    for test in bundle["tests"]:
+        query = json.loads(test["query"].read_text(encoding="utf-8"))
+        if query.get("kind") not in ("truth", "positions"):
+            summary["skipped"][f"запрос {query.get('kind')}"] = summary["skipped"].get(f"запрос {query.get('kind')}", 0) + 1
+            continue
+        _fields, skipped, _positions = expected(test)
+        for name in skipped:
+            summary["skipped"][f"наблюдение {name}"] = summary["skipped"].get(f"наблюдение {name}", 0) + 1
+        got = {name: T.run_target(emit[name], work / "module" / name, "runner",
+                                 [str(test["case"]), str(test["query"])], environment) for name in active}
+        crashes = {name: value for name, (kind, value) in got.items() if kind == "crash"}
+        if crashes:
+            failures.append(f"{test['id']}: КРАХ {crashes}")
+            continue
+        refusals = {name: value for name, (kind, value) in got.items() if kind == "refused"}
+        if refusals:
+            if len(refusals) != len(got):
+                failures.append(f"{test['id']}: отказ не единогласен {refusals}")
+            elif len(set(refusals.values())) != 1:
+                failures.append(f"{test['id']}: тексты отказа различаются {refusals}")
+            else:
+                text = next(iter(refusals.values()))
+                summary["refused"][text] = summary["refused"].get(text, 0) + 1
+            continue
+        answers = {name: value for name, (_kind, value) in got.items()}
+        if len({T.answer_key(value) for value in answers.values()}) != 1:
+            failures.append(f"{test['id']}: ответы целей разошлись")
+            continue
+        if not checkable(test):
+            summary["unchecked"] += 1
+            continue
+        differences = compare(next(iter(answers.values())), test)
+        if differences:
+            failures.extend(f"{test['id']}: {line}" for line in differences)
+        else:
+            summary["matched"] += 1
+    return summary, failures
+
+
+def main(argv: list[str] | None = None) -> int:
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("--bundle", required=True, type=Path)
+    parser.add_argument("--core-kit", type=Path, required=True)
+    parser.add_argument("--targets", default="ts,py,go")
+    parser.add_argument("--keep", type=Path)
+    parser.add_argument("--allow-source-skips", action="store_true", help="explicitly accept named source omissions")
+    args = parser.parse_args(argv)
+    previous_core_kit = core_support.core_kit_path()
+    try:
+        core_support.validate_core_kit(args.core_kit)
+        core_support.configure_core_kit(args.core_kit)
+        bundle = load_bundle(args.bundle)
+        source_skips = list(bundle["source_skipped"])
+        for member in bundle.get("groups", []):
+            source_skips.extend(member["source_skipped"])
+        if source_skips and not args.allow_source_skips:
+            raise ValueError("source omissions require --allow-source-skips: " + "; ".join(source_skips))
+        work = args.keep or Path(tempfile.mkdtemp(prefix="arxo-codegen-consumer-"))
+        work.mkdir(parents=True, exist_ok=True)
+        summary, failures = run(bundle, [name for name in args.targets.split(",") if name], work)
+    except (ValueError, P.Refused, core_support.CoreKitError) as error:
+        print(f"arxo-codegen-consumer: {error}")
+        return 1
+    finally:
+        if not args.keep and 'work' in locals():
+            shutil.rmtree(work, ignore_errors=True)
+        # CLI invocations may share an interpreter with other verification
+        # modules.  Selecting a temporary kit must not poison the next call.
+        core_support.configure_core_kit(previous_core_kit)
+    print("arxo-codegen-consumer: " + json.dumps(summary, ensure_ascii=False, sort_keys=True))
+    for failure in failures:
+        print("  " + failure)
+    if not failures and summary["matched"] == 0:
+        print("  ничего не проверено: нет совпавших проверяемых ожиданий")
+        return 1
+    return 1 if failures else 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())