arxo-codegen 0.4.0__py3-none-any.whl

arxo_codegen/test_consumer_runner.py

@@ -0,0 +1,175 @@
+"""Contracts for the standalone lowered-consumer bundle reader."""
+from __future__ import annotations
+
+import hashlib
+import json
+from pathlib import Path
+import sys
+import tempfile
+import unittest
+from unittest import mock
+
+HERE = Path(__file__).resolve().parent
+sys.path.insert(0, str(HERE))
+import consumer_runner as runner  # noqa: E402
+from test_support import materialize_core_kit, vector  # noqa: E402
+
+
+def entry(root: Path, relative: str) -> dict:
+    data = (root / relative).read_bytes()
+    return {"path": relative, "sha256": "sha256:" + hashlib.sha256(data).hexdigest()}
+
+
+class ConsumerRunnerTests(unittest.TestCase):
+    def tearDown(self):
+        runner.core_support.configure_core_kit(None)
+
+    def bundle(self, root: Path) -> None:
+        for relative, document in {
+            "program.json": {"package": {"name": "example"}, "imports": [], "nodes": []},
+            "case.json": {"assertions": []},
+            "query.json": {"kind": "truth"},
+        }.items():
+            (root / relative).write_text(json.dumps(document), encoding="utf-8")
+        document = {"format": runner.FORMAT, "program": entry(root, "program.json"), "world": [],
+                    "group": {"world": [], "concat": [], "resolve": [], "merge": "link"},
+                    "tests": [{"id": "one", "case": entry(root, "case.json"), "query": entry(root, "query.json"),
+                               "expectations": [{"field": "truth_status", "op": "eq", "value": "TRUE_ONLY"},
+                                                {"observation": "any_applied", "value": "rule"}]}]}
+        (root / "bundle.json").write_text(json.dumps(document), encoding="utf-8")
+
+    def test_loads_explicit_hashed_lowered_inputs(self):
+        with tempfile.TemporaryDirectory(prefix="consumer-runner-") as tmp:
+            root = Path(tmp)
+            self.bundle(root)
+            bundle = runner.load_bundle(root)
+            self.assertEqual(bundle["program"].name, "program.json")
+            self.assertEqual(bundle["tests"][0]["id"], "one")
+            self.assertEqual(bundle["source_skipped"], [])
+            fields, skipped, positions = runner.expected(bundle["tests"][0])
+            self.assertEqual(fields, {"truth_status": "TRUE_ONLY"})
+            self.assertEqual(skipped, ["any_applied"])
+            self.assertEqual(positions, [])
+
+    def test_rejects_changed_or_escaping_inputs(self):
+        with tempfile.TemporaryDirectory(prefix="consumer-runner-") as tmp:
+            root = Path(tmp)
+            self.bundle(root)
+            (root / "case.json").write_text("{}", encoding="utf-8")
+            with self.assertRaisesRegex(ValueError, "SHA-256"):
+                runner.load_bundle(root)
+            self.bundle(root)
+            doc = json.loads((root / "bundle.json").read_text(encoding="utf-8"))
+            doc["program"]["path"] = "../program.json"
+            (root / "bundle.json").write_text(json.dumps(doc), encoding="utf-8")
+            with self.assertRaisesRegex(ValueError, "outside"):
+                runner.load_bundle(root)
+
+    def test_rejects_unknown_or_query_inappropriate_expectations(self):
+        with tempfile.TemporaryDirectory(prefix="consumer-runner-") as tmp:
+            root = Path(tmp); self.bundle(root)
+            doc = json.loads((root / "bundle.json").read_text(encoding="utf-8"))
+            doc["tests"][0]["expectations"] = [{"field": "typo", "op": "eq", "value": "x"}]
+            (root / "bundle.json").write_text(json.dumps(doc), encoding="utf-8")
+            with self.assertRaisesRegex(ValueError, "unknown expectation field"):
+                runner.load_bundle(root)
+            self.bundle(root)
+            doc = json.loads((root / "bundle.json").read_text(encoding="utf-8"))
+            doc["tests"][0]["expectations"] = [{"field": "normative_status", "op": "eq", "value": "SATISFIED"}]
+            (root / "bundle.json").write_text(json.dumps(doc), encoding="utf-8")
+            with self.assertRaisesRegex(ValueError, "inapplicable"):
+                runner.load_bundle(root)
+
+    def test_compares_truth_and_names_unsupported_query_as_skip(self):
+        with tempfile.TemporaryDirectory(prefix="consumer-runner-") as tmp:
+            root = Path(tmp)
+            self.bundle(root)
+            bundle = runner.load_bundle(root)
+            test = bundle["tests"][0]
+            self.assertEqual(runner.compare({"truthStatus": "TRUE_ONLY", "evaluationStatus": "COMPUTED"}, test), [])
+            (root / "query.json").write_text(json.dumps({"kind": "why_not"}), encoding="utf-8")
+            # Recreate the entry after changing the input, as a lowering adapter would.
+            doc = json.loads((root / "bundle.json").read_text(encoding="utf-8"))
+            doc["tests"][0]["query"] = entry(root, "query.json")
+            doc["tests"][0]["expectations"] = []
+            (root / "bundle.json").write_text(json.dumps(doc), encoding="utf-8")
+            test = runner.load_bundle(root)["tests"][0]
+            self.assertEqual(runner.compare({}, test), ["пропуск: запрос why_not"])
+
+    def test_executes_real_lowered_bundle_and_keeps_unchecked_proof_named(self):
+        """One active 0.2 vector proves the runner needs neither corpus nor CI."""
+        active_vector = vector("t/T199")
+        with tempfile.TemporaryDirectory(prefix="consumer-runner-real-") as tmp:
+            root = Path(tmp) / "bundle"; root.mkdir()
+            ir = json.loads((active_vector / "ir.json").read_text(encoding="utf-8"))
+            ir["imports"] = [{"package": {"name": "dependency"}}]
+            (root / "ir.json").write_text(json.dumps(ir), encoding="utf-8")
+            (root / "world.json").write_text(json.dumps({"semanticVersion": "0.2.11", "schemaVersion": "law.core.ir/0.7", "package": {"name": "dependency"}, "imports": [], "nodes": []}), encoding="utf-8")
+            for name in ("case.json", "query.json"):
+                (root / name).write_bytes((active_vector / name).read_bytes())
+            rows = []
+            for identifier, expectations in (
+                ("truth", [{"field": "truth_status", "op": "eq", "value": "TRUE_ONLY"},
+                           {"field": "evaluation_status", "op": "eq", "value": "COMPUTED"}]),
+                ("no-status", []),
+                ("proof-only", [{"observation": "any_applied", "value": "x"}]),
+            ):
+                rows.append({"id": identifier, "case": entry(root, "case.json"), "query": entry(root, "query.json"),
+                             "expectations": expectations})
+            (root / "bundle.json").write_text(json.dumps({"format": runner.FORMAT,
+                "program": entry(root, "ir.json"), "world": [entry(root, "world.json")],
+                "group": {"world": ["dependency"], "concat": [], "resolve": ["dependency"], "merge": "link"}, "tests": rows}), encoding="utf-8")
+            kit = Path(tmp) / "kit"; materialize_core_kit(kit, source_commit="a" * 40)
+            runner.core_support.configure_core_kit(kit)
+            summary, failures = runner.run(runner.load_bundle(root), ["py"], Path(tmp) / "work")
+            self.assertEqual(failures, [])
+            self.assertEqual(summary["matched"], 1)
+            self.assertEqual(summary["unchecked"], 2)
+            self.assertEqual(summary["skipped"], {"наблюдение any_applied": 1})
+            runner.core_support.configure_core_kit(None)
+
+    def test_truth_result_kind_and_unsupported_observations_are_not_dropped(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            root = Path(tmp); self.bundle(root)
+            test = runner.load_bundle(root)["tests"][0]
+            test["expectations"] = [{"field": "result_kind", "op": "eq", "value": "PROPOSITION"}]
+            runner.validate_expectations(test["id"], "truth", test["expectations"])
+            self.assertEqual(runner.compare({"truthStatus": "TRUE_ONLY"}, test), [])
+            self.assertTrue(runner.compare({}, test))
+            runner.validate_expectations("collection", "collect", [{"observation": "collected_count", "value": 0}])
+
+    def test_source_omissions_require_explicit_opt_in(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            root = Path(tmp); self.bundle(root)
+            doc = json.loads((root / "bundle.json").read_text()); doc["skipped"] = ["external snapshots"]
+            (root / "bundle.json").write_text(json.dumps(doc))
+            kit = root / "kit"; materialize_core_kit(kit, source_commit="b" * 40)
+            with mock.patch.object(runner, "run") as run:
+                self.assertEqual(runner.main(["--bundle", str(root), "--core-kit", str(kit)]), 1)
+                run.assert_not_called()
+
+    def test_collection_validates_each_group_and_rejects_changed_manifest(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            root = Path(tmp)
+            for name in ("one", "two"):
+                (root / name).mkdir(); self.bundle(root / name)
+            doc = {"format": runner.SET_FORMAT, "groups": [entry(root, name + "/bundle.json") for name in ("one", "two")]}
+            (root / "bundle.json").write_text(json.dumps(doc))
+            loaded = runner.load_bundle(root)
+            self.assertEqual(len(loaded["groups"]), 2)
+            (root / "two/bundle.json").write_text("{}")
+            with self.assertRaisesRegex(ValueError, "SHA-256"):
+                runner.load_bundle(root)
+
+    def test_main_fails_when_all_cases_are_unchecked(self):
+        with tempfile.TemporaryDirectory(prefix="consumer-runner-main-") as tmp:
+            root = Path(tmp); self.bundle(root)
+            kit = root / "kit"; materialize_core_kit(kit, source_commit="b" * 40)
+            summary = {"tests": 1, "matched": 0, "unchecked": 1, "refused": {}, "skipped": {},
+                       "sourceSkipped": [], "unavailable": []}
+            with mock.patch.object(runner, "run", return_value=(summary, [])):
+                self.assertEqual(runner.main(["--bundle", str(root), "--core-kit", str(kit), "--targets", "py"]), 1)
+
+
+if __name__ == "__main__":
+    unittest.main()

arxo_codegen/test_core_support.py

@@ -0,0 +1,80 @@
+import os
+import json
+import sys
+import tempfile
+import unittest
+from pathlib import Path
+import hashlib
+
+HERE = Path(__file__).resolve().parent
+sys.path.insert(0, str(HERE))
+import core_support
+from test_support import materialize_core_kit, uses_exported_inputs
+
+
+class CoreSupportTests(unittest.TestCase):
+    def tearDown(self):
+        core_support.configure_core_kit(None)
+        os.environ.pop("LAW_CODEGEN_CORE_KIT", None)
+
+    def test_explicit_kit_matches_monorepo_semantic_contract(self):
+        ir = {"schemaVersion": "law.core/0.2", "package": "urn:test", "nodes": [],
+              "metadata": {"local": True}}
+        with tempfile.TemporaryDirectory() as name:
+            out = Path(name) / "kit"
+            manifest = materialize_core_kit(out, source_commit="d" * 40)
+            core_support.configure_core_kit(out)
+            self.assertFalse(core_support.using_monorepo_fallback())
+            self.assertTrue(core_support.semantic_hash(ir).startswith("sha256:"))
+            self.assertTrue(core_support.canonical_bytes({"nodes": [{"id": "b"}, {"id": "a"}]}))
+            schema = core_support.calendar_schema()
+            self.assertEqual(schema["title"], "Arxo calendar dataset 0.1")
+            schema["title"] = "changed"
+            self.assertEqual(core_support.calendar_schema()["title"], "Arxo calendar dataset 0.1")
+            self.assertFalse((out / "python/lawref/__pycache__").exists())
+            self.assertEqual(core_support.validate_core_kit(out), manifest)
+            if not uses_exported_inputs():
+                self.assertEqual(manifest["sourceCommit"], "d" * 40)
+
+    def test_environment_kit_is_validated_before_import(self):
+        with tempfile.TemporaryDirectory() as name:
+            out = Path(name) / "kit"
+            materialize_core_kit(out, source_commit="e" * 40)
+            (out / "python/lawref/hashing.py").write_text("raise RuntimeError('must not import')")
+            os.environ["LAW_CODEGEN_CORE_KIT"] = str(out)
+            with self.assertRaisesRegex(core_support.CodegenCoreError, "hash mismatch"):
+                core_support.semantic_hash({"nodes": []})
+
+    def test_refuses_symlinked_explicit_kit(self):
+        with tempfile.TemporaryDirectory() as name:
+            base = Path(name); kit = base / "kit"; materialize_core_kit(kit, source_commit="f" * 40)
+            link = base / "linked-kit"; link.symlink_to(kit, target_is_directory=True)
+            core_support.configure_core_kit(link)
+            with self.assertRaisesRegex(core_support.CoreKitError, "not a directory"):
+                core_support.semantic_hash({"nodes": []})
+
+    def test_refuses_unsupported_compatibility_before_import(self):
+        with tempfile.TemporaryDirectory() as name:
+            out = Path(name) / "kit"; materialize_core_kit(out, source_commit="1" * 40)
+            lock_name = "codegen-core.lock.json"
+            lock = json.loads((out / lock_name).read_bytes())
+            lock["compatibility"]["semanticVersions"] = ["0.3"]
+            (out / lock_name).write_text(json.dumps(lock, ensure_ascii=False, indent=2) + "\n", encoding="utf-8")
+            manifest = json.loads((out / "manifest.json").read_bytes())
+            for row in manifest["files"]:
+                if row["path"] == lock_name:
+                    data = (out / lock_name).read_bytes()
+                    row.update(sha256="sha256:" + hashlib.sha256(data).hexdigest(), bytes=len(data))
+            (out / "manifest.json").write_text(json.dumps(manifest, ensure_ascii=False, indent=2) + "\n", encoding="utf-8")
+            core_support.configure_core_kit(out)
+            with self.assertRaisesRegex(core_support.CoreKitError, "compatibility"):
+                core_support.semantic_hash({"nodes": []})
+
+    def test_missing_kit_is_named_error(self):
+        self.assertFalse(core_support.using_monorepo_fallback())
+        with self.assertRaisesRegex(core_support.CoreKitError, "explicit LAW_CODEGEN_CORE_KIT"):
+            core_support.semantic_hash({"nodes": []})
+
+
+if __name__ == "__main__":
+    unittest.main()

arxo_codegen/test_e0212_decision_time.py

@@ -0,0 +1,63 @@
+"""E-0212: position status uses an explicitly supplied decision time."""
+from __future__ import annotations
+
+import json
+from pathlib import Path
+import subprocess
+import sys
+import tempfile
+import unittest
+
+
+HERE = Path(__file__).resolve().parent
+sys.path.insert(0, str(HERE))
+import deliver  # noqa: E402
+import plan  # noqa: E402
+from test_support import vector  # noqa: E402
+
+
+CASES = {
+    "ERR-E0212-ACTIVE-AT-DECISION": "ACTIVE",
+    "ERR-E0212-PENDING-AT-EARLIER-DECISION": "PENDING",
+    "ERR-E0212-SATISFIED-AT-DECISION": "SATISFIED",
+    "ERR-E0212-VIOLATED-AT-DECISION": "VIOLATED",
+}
+
+
+class DecisionTimeStatusTests(unittest.TestCase):
+    def test_normative_models_refuse_before_the_old_status_clock(self):
+        for ident in CASES:
+            ir = json.loads((vector("errata/" + ident) / "ir.json").read_text())
+            with self.subTest(ident=ident), self.assertRaisesRegex(plan.Refused, "NORM_RANKS_UNAVAILABLE"):
+                plan.build_plan(ir)
+
+    def test_go_l0_model_keeps_the_shared_runner_status_hook(self):
+        """The Go runner is shared with L0, whose model has no positions."""
+        fixture = vector("smoke/LQ6-T170-V02")
+        ir = json.loads((fixture / "ir.json").read_text())
+        with tempfile.TemporaryDirectory(prefix="e0212-go-l0-") as raw:
+            project = Path(raw)
+            deliver.emit_project(plan.build_plan(ir), "go", project)
+            source = (project / deliver.emitter("go").MODEL).read_text(encoding="utf-8")
+        # DECISION-0423 §2.3: хук — замыкание фабрики newModel, подключённое к Model.
+        self.assertIn("setStatusTime = func(t string) {}", source)
+        self.assertIn("setStatusTime: setStatusTime", source)
+
+    def test_python_runner_refuses_old_position_ladder_until_w6(self):
+        with tempfile.TemporaryDirectory(prefix="e0212-python-") as raw:
+            root = Path(raw)
+            for vector_id, expected in CASES.items():
+                fixture = vector("errata/" + vector_id).resolve()
+                ir = json.loads((fixture / "ir.json").read_text())
+                project = root / vector_id
+                deliver.emit_project(plan.build_plan({"semanticVersion":"0.2.11", "schemaVersion":"law.core.ir/0.7", "nodes":[]}), "py", project)
+                result = subprocess.run([sys.executable, str(project / "runner.py"),
+                                         str(fixture / "case.json"), str(fixture / "query.json")],
+                                        capture_output=True, text=True, check=False)
+                answer = json.loads(result.stdout)
+                self.assertEqual(result.returncode, 3)
+                self.assertEqual(answer, {"refused": "POSITIONS_UNAVAILABLE: positions requires current norm ranks (W6)"})
+
+
+if __name__ == "__main__":
+    unittest.main()

arxo_codegen/test_head_aggregate.py

@@ -0,0 +1,71 @@
+"""W5 (errata E-0265): агрегат `sum` без политики `empty` в голове — план строится,
+правило помечено `headFallible` и `headAgg`: ошибка агрегата снимает только свою
+подстановку, issue одна на (правило, код)."""
+from __future__ import annotations
+
+from pathlib import Path
+import sys
+import unittest
+
+HERE = Path(__file__).resolve().parent
+sys.path.insert(0, str(HERE))
+import plan as P  # noqa: E402
+
+NS = "urn:law:test:head-agg"
+TEXT, MONEY = "urn:law:std#Text", "urn:law:std#Money"
+H = "sha256:" + "0" * 64
+
+
+def _rel(name, kind, params):
+    return {"kind": "symbol_decl", "symbolKind": "relation", "id": f"{NS}#{name}", "package": NS, "name": name,
+            "relationKind": kind, "contentHash": H,
+            "parameters": [{"id": f"{NS}#{name}/arg/{p}", "name": p, "type": {"name": t}} for p, t in params]}
+
+
+def _lit(pred, args):
+    return {"kind": "literal", "polarity": "positive", "predicate": pred, "args": args}
+
+
+def _est(lit):
+    return {"kind": "status", "status": "established", "formula": lit}
+
+
+def _ir(options=None):
+    element = {"kind": "var", "var": "v9"}
+    agg = {"kind": "aggregate", "op": "sum",
+           "input": {"kind": "comprehension", "distinct": False, "variable": {"id": "v9", "type": {"name": MONEY}},
+                     "binders": [], "element": element,
+                     "generator": _est(_lit(f"{NS}#item", [{"kind": "var", "var": "v0"}, element]))}}
+    if options is not None:
+        agg["options"] = options
+    rule = {"kind": "rule", "id": f"{NS}#Total", "package": NS, "strength": "strict",
+            "variables": [{"id": "v0", "type": {"name": TEXT}}],
+            "body": _est(_lit(f"{NS}#holder", [{"kind": "var", "var": "v0"}])),
+            "head": _lit(f"{NS}#total", [{"kind": "var", "var": "v0"}, agg]),
+            "scope": {"kind": "boolean", "value": True}, "interpretations": [], "contentHash": H}
+    return {"schemaVersion": "law.core.ir/0.7", "semanticVersion": "0.2.11",
+            "package": {"name": "test.head_agg", "version": "0.1.0", "namespace": NS, "semanticHash": H},
+            "imports": [], "features": ["core-executable"],
+            "nodes": [_rel("holder", "empirical", [("e", TEXT)]), _rel("item", "empirical", [("e", TEXT), ("x", MONEY)]),
+                      _rel("total", "institutional", [("e", TEXT), ("t", MONEY)]), rule],
+            "strata": [], "metadata": {}}
+
+
+class HeadAggregateTests(unittest.TestCase):
+    def test_head_aggregate_without_empty_policy_is_planned_per_substitution(self):
+        plan = P.build_plan(_ir())
+        rules = [r for r in plan.get("rules", []) if r.get("id") == f"{NS}#Total"]
+        self.assertEqual(len(rules), 1)
+        self.assertTrue(rules[0].get("headFallible"))
+        self.assertTrue(rules[0].get("headAgg"))
+
+    def test_empty_policy_keeps_head_total(self):
+        plan = P.build_plan(_ir({"empty": {"kind": "value", "type": {"name": MONEY}, "value": "0",
+                                           "currency": "KZT"}}))
+        rules = [r for r in plan.get("rules", []) if r.get("id") == f"{NS}#Total"]
+        self.assertEqual(len(rules), 1)
+        self.assertFalse(rules[0].get("headAgg"))
+
+
+if __name__ == "__main__":
+    unittest.main()

arxo_codegen/test_inert.py

@@ -0,0 +1,143 @@
+"""Инертные конструкции (W1): манифест держится свидетелями, план пропускает
+только перечисленное, ворота роняют строку без свидетеля."""
+from __future__ import annotations
+
+import copy
+import json
+from pathlib import Path
+import sys
+import tempfile
+import unittest
+
+HERE = Path(__file__).resolve().parent
+sys.path.insert(0, str(HERE))
+import inert  # noqa: E402
+import plan as P  # noqa: E402
+
+NS = "urn:law:test:inert"
+TEXT = "urn:law:std#Text"
+
+
+def _relation(name: str, kind: str) -> dict:
+    return {"kind": "symbol_decl", "symbolKind": "relation", "id": f"{NS}#{name}", "package": NS,
+            "name": name, "relationKind": kind, "contentHash": "sha256:" + "0" * 64,
+            "parameters": [{"id": f"{NS}#{name}/arg/a", "name": "a", "type": {"name": TEXT}}]}
+
+
+def _rule(**extra) -> dict:
+    node = {"kind": "rule", "id": f"{NS}#Ok", "package": NS, "strength": "strict",
+            "variables": [{"id": "v0", "type": {"name": TEXT}}],
+            "body": {"kind": "status", "status": "established",
+                     "formula": {"kind": "literal", "polarity": "positive", "predicate": f"{NS}#flag",
+                                 "args": [{"kind": "var", "var": "v0"}]}},
+            "head": {"kind": "literal", "polarity": "positive", "predicate": f"{NS}#ok",
+                     "args": [{"kind": "var", "var": "v0"}]},
+            "scope": {"kind": "boolean", "value": True}, "interpretations": [],
+            "contentHash": "sha256:" + "0" * 64}
+    node.update(extra)
+    return node
+
+
+def _ir(nodes: list[dict]) -> dict:
+    return {"schemaVersion": "law.core.ir/0.7", "semanticVersion": "0.2.11",
+            "package": {"name": "test.inert", "version": "0.1.0", "namespace": NS,
+                        "semanticHash": "sha256:" + "0" * 64},
+            "imports": [], "features": ["core-executable"], "nodes": nodes, "strata": [], "metadata": {}}
+
+
+BASE = [_relation("flag", "empirical"), _relation("ok", "institutional"), _rule()]
+
+
+class ManifestTests(unittest.TestCase):
+    def test_manifest_loads_and_names_pairs(self):
+        manifest = inert.load()
+        self.assertEqual(manifest["format"], inert.FORMAT)
+        for construct, row in manifest["constructs"].items():
+            self.assertTrue(construct.startswith(inert.FAMILIES), construct)
+            self.assertNotEqual(row["witness"], row["bare"])
+            self.assertTrue(row["witness"].startswith("LAY-L0-INERT-"), construct)
+
+    def test_plan_reads_exactly_the_manifest(self):
+        manifest = inert.load()
+        self.assertEqual(P.INERT_NODE_KINDS, inert.node_kinds(manifest))
+        self.assertEqual(P.INERT_RULE_FIELDS, inert.rule_fields(manifest))
+        self.assertNotIn(("source_work", None), P.KNOWN_NODES)
+
+    def test_malformed_manifest_is_refused(self):
+        for broken in ({"format": "x", "constructs": {}},
+                       {"format": inert.FORMAT, "constructs": {"term:foo": {"witness": "a", "bare": "b"}}},
+                       {"format": inert.FORMAT, "constructs": {"node:anchor": {"witness": "a"}}},
+                       {"format": inert.FORMAT, "constructs": {"node:anchor": {"witness": "a", "bare": "a"}}}):
+            with tempfile.TemporaryDirectory() as temporary, self.subTest(broken=broken):
+                path = Path(temporary) / "m.json"
+                path.write_text(json.dumps(broken), encoding="utf-8")
+                with self.assertRaises(ValueError):
+                    inert.load(path)
+
+
+class PlanTests(unittest.TestCase):
+    def test_inert_nodes_are_skipped_and_unknown_nodes_refused(self):
+        anchor = {"kind": "anchor", "id": f"{NS}#Ok/anchor/1", "package": NS, "semanticNode": f"{NS}#Ok",
+                  "sourceFragment": f"{NS}#F1", "relation": "formalizes", "coverage": "exact",
+                  "contentHash": "sha256:" + "1" * 64}
+        P.build_plan(_ir(BASE + [anchor]))
+        for kind in sorted(P.INERT_NODE_KINDS):
+            with self.subTest(kind=kind):
+                P.build_plan(_ir(BASE + [{"kind": kind, "id": f"{NS}#X", "package": NS,
+                                          "contentHash": "sha256:" + "2" * 64}]))
+        with self.assertRaisesRegex(P.Refused, "объявление вне среза генератора: interpretation"):
+            P.build_plan(_ir(BASE + [{"kind": "interpretation", "id": f"{NS}#I", "package": NS,
+                                      "contentHash": "sha256:" + "3" * 64}]))
+        with self.assertRaisesRegex(P.Refused, "объявление вне среза генератора: reference"):
+            P.build_plan(_ir(BASE + [{"kind": "reference", "id": f"{NS}#R", "package": NS, "work": f"{NS}#W",
+                                      "resolveAt": "legal_time", "contentHash": "sha256:" + "4" * 64}]))
+
+    def test_inert_rule_field_is_skipped_and_others_refused(self):
+        P.build_plan(_ir(BASE[:2] + [_rule(visibility="public")]))
+        with self.assertRaisesRegex(P.Refused, "поле правила вне среза генератора: origin"):
+            P.build_plan(_ir(BASE[:2] + [_rule(origin="somewhere")]))
+
+
+class WitnessTests(unittest.TestCase):
+    def _fixtures(self, temporary: Path, pairs: dict[str, tuple[dict, dict]]) -> Path:
+        vectors = temporary / "vectors" / "lay"
+        for name, (witness, bare) in pairs.items():
+            for suffix, doc in (("", witness), ("-BARE", bare)):
+                directory = vectors / f"LAY-L0-INERT-{name}{suffix}"
+                directory.mkdir(parents=True)
+                (directory / "expected.json").write_text(json.dumps(doc), encoding="utf-8")
+        return temporary / "vectors"
+
+    def test_witness_must_match_and_documents_must_agree(self):
+        doc = {"results": [{"truthStatus": "TRUE_ONLY"}], "positions": [], "issues": [], "conflicts": [],
+               "proofGraph": {"nodes": []}, "manifest": {"artifactHash": "a"}, "resultHash": "x"}
+        other = copy.deepcopy(doc)
+        other["manifest"]["artifactHash"] = "b"
+        other["resultHash"] = "y"
+        manifest = {"format": inert.FORMAT, "constructs": {
+            "node:anchor": {"witness": "LAY-L0-INERT-ANCHOR", "bare": "LAY-L0-INERT-ANCHOR-BARE"},
+            "node:revision": {"witness": "LAY-L0-INERT-REVISION", "bare": "LAY-L0-INERT-REVISION-BARE"},
+            "node:ghost": {"witness": "LAY-L0-INERT-GHOST", "bare": "LAY-L0-INERT-GHOST-BARE"}}}
+        changed = copy.deepcopy(doc)
+        changed["results"] = []
+        with tempfile.TemporaryDirectory() as temporary:
+            vectors = self._fixtures(Path(temporary), {"ANCHOR": (doc, other), "REVISION": (changed, doc)})
+            rows = [{"id": "LAY-L0-INERT-ANCHOR", "actual": "match"},
+                    {"id": "LAY-L0-INERT-ANCHOR-BARE", "actual": "match"},
+                    {"id": "LAY-L0-INERT-REVISION", "actual": "plan: объявление вне среза генератора"},
+                    {"id": "LAY-L0-INERT-REVISION-BARE", "actual": "match"}]
+            table, failures = inert.witness_failures(manifest, rows, vectors)
+        by_construct = {row["construct"]: row for row in table}
+        self.assertTrue(by_construct["node:anchor"]["documentsAgree"])
+        self.assertFalse(by_construct["node:revision"]["documentsAgree"])
+        self.assertIsNone(by_construct["node:ghost"]["documentsAgree"])
+        text = "\n".join(failures)
+        self.assertNotIn("node:anchor", text)
+        self.assertIn("node:revision: свидетель LAY-L0-INERT-REVISION — «plan: объявление вне среза генератора»", text)
+        self.assertIn("node:revision: половины пары расходятся по results", text)
+        self.assertIn("node:ghost: свидетель LAY-L0-INERT-GHOST не среди активных векторов", text)
+        self.assertIn("node:ghost: у половины пары нет голдена", text)
+
+
+if __name__ == "__main__":
+    unittest.main()

arxo_codegen/test_instant_types.py

@@ -0,0 +1,113 @@
+"""Instant §2.15 в срезе (W2, часть 2): вид значения `inst`, длительности §84.1,
+отказы плана там, где у оракула TYPE_ERROR по виду всегда."""
+from __future__ import annotations
+
+from pathlib import Path
+import sys
+import unittest
+
+HERE = Path(__file__).resolve().parent
+sys.path.insert(0, str(HERE))
+import plan as P  # noqa: E402
+
+NS = "urn:law:test:instant"
+INST, INT, QTY, DATE, TEXT = ("urn:law:std#Instant", "urn:law:std#Integer", "urn:law:std#Quantity",
+                              "urn:law:std#Date", "urn:law:std#Text")
+H = "sha256:" + "0" * 64
+
+
+def _rel(name, kind, params):
+    return {"kind": "symbol_decl", "symbolKind": "relation", "id": f"{NS}#{name}", "package": NS, "name": name,
+            "relationKind": kind, "contentHash": H,
+            "parameters": [{"id": f"{NS}#{name}/arg/{p}", "name": p, "type": {"name": t}} for p, t in params]}
+
+
+def _lit(pred, args):
+    return {"kind": "literal", "polarity": "positive", "predicate": pred, "args": args}
+
+
+def _var(i):
+    return {"kind": "var", "var": f"v{i}"}
+
+
+def _val(t, v, unit=None):
+    node = {"kind": "value", "type": {"name": t}, "value": v}
+    if unit:
+        node["unit"] = unit
+    return node
+
+
+def _call(fn, *args):
+    return {"kind": "call", "function": f"urn:law:std#{fn}", "args": list(args)}
+
+
+def _rule(name, variables, body_items, head):
+    body = body_items[0] if len(body_items) == 1 else {"kind": "and", "items": body_items}
+    return {"kind": "rule", "id": f"{NS}#{name}", "package": NS, "strength": "strict",
+            "variables": [{"id": f"v{i}", "type": {"name": t}} for i, t in variables],
+            "body": body, "head": head, "scope": {"kind": "boolean", "value": True},
+            "interpretations": [], "contentHash": H}
+
+
+def _est(lit):
+    return {"kind": "status", "status": "established", "formula": lit}
+
+
+def _ir(nodes):
+    return {"schemaVersion": "law.core.ir/0.7", "semanticVersion": "0.2.11",
+            "package": {"name": "test.instant", "version": "0.1.0", "namespace": NS, "semanticHash": H},
+            "imports": [], "features": ["core-executable"], "nodes": nodes, "strata": [], "metadata": {}}
+
+
+def _plan(nodes):
+    return P.build_plan(_ir(nodes))
+
+
+class InstantTests(unittest.TestCase):
+    def test_instant_slot_guard_and_capability(self):
+        nodes = [_rel("filed", "empirical", [("a", TEXT), ("t", INST)]),
+                 _rel("late", "institutional", [("a", TEXT)]),
+                 _rule("Late", [(0, TEXT), (1, INST)],
+                       [{"kind": "comparison", "op": "gt", "left": _var(1), "right": _val(INST, "2026-08-26T12:00:00Z")},
+                        _est(_lit(f"{NS}#filed", [_var(0), _var(1)]))],
+                       _lit(f"{NS}#late", [_var(0)]))]
+        plan = _plan(nodes)
+        self.assertIn("value:instant", plan["capabilities"])
+        self.assertEqual(P.TYPES[INST], "inst")
+
+    def test_duration_functions_static_types(self):
+        nodes = [_rel("window", "empirical", [("a", TEXT), ("s", INST), ("e", INST)]),
+                 _rel("two_days", "institutional", [("a", TEXT)]),
+                 _rel("deadline", "institutional", [("a", TEXT), ("d", INST)]),
+                 _rule("TwoDays", [(0, TEXT), (1, INST), (2, INST)],
+                       [{"kind": "comparison", "op": "ge", "left": _call("hours_between", _var(1), _var(2)),
+                         "right": _val(INT, 48)},
+                        _est(_lit(f"{NS}#window", [_var(0), _var(1), _var(2)]))],
+                       _lit(f"{NS}#two_days", [_var(0)])),
+                 _rule("Deadline", [(0, TEXT), (1, INST), (2, INST)],
+                       [_est(_lit(f"{NS}#window", [_var(0), _var(1), _var(2)]))],
+                       _lit(f"{NS}#deadline", [_var(0), _call("add_duration", _var(1), _val(QTY, "24", "hour"))]))]
+        plan = _plan(nodes)
+        self.assertIn("value:instant", plan["capabilities"])
+        # Литерал Quantity длительности сворачивается в (число, единица), как у календарных функций.
+        self.assertNotIn("value:quantity", plan["capabilities"])
+
+    def test_refusals_match_oracle_type_errors(self):
+        base = [_rel("filed", "empirical", [("a", TEXT), ("t", INST)]), _rel("late", "institutional", [("a", TEXT)])]
+        with self.assertRaisesRegex(P.Refused, "Instant с иным видом"):
+            _plan(base + [_rule("Late", [(0, TEXT), (1, INST)],
+                                 [{"kind": "comparison", "op": "gt", "left": _var(1), "right": _val(DATE, "2026-08-26")},
+                                  _est(_lit(f"{NS}#filed", [_var(0), _var(1)]))], _lit(f"{NS}#late", [_var(0)]))])
+        with self.assertRaisesRegex(P.Refused, "hours_between: аргумент не Instant"):
+            _plan(base + [_rule("Late", [(0, TEXT), (1, INST)],
+                                 [{"kind": "comparison", "op": "gt",
+                                   "left": _call("hours_between", _var(1), _val(DATE, "2026-08-26")), "right": _val(INT, 1)},
+                                  _est(_lit(f"{NS}#filed", [_var(0), _var(1)]))], _lit(f"{NS}#late", [_var(0)]))])
+        with self.assertRaisesRegex(P.Refused, "add_duration: единица week"):
+            _plan(base + [_rel("due", "institutional", [("a", TEXT), ("d", INST)]),
+                          _rule("Due", [(0, TEXT), (1, INST)], [_est(_lit(f"{NS}#filed", [_var(0), _var(1)]))],
+                                _lit(f"{NS}#due", [_var(0), _call("add_duration", _var(1), _val(QTY, "1", "week"))]))])
+
+
+if __name__ == "__main__":
+    unittest.main()