hapax-agentgov 0.2.0__tar.gz

hapax_agentgov-0.2.0/.gitignore

@@ -0,0 +1,76 @@
+# Python-generated files
+__pycache__/
+*.py[oc]
+build/
+dist/
+wheels/
+*.egg-info
+
+# Virtual environments
+.venv
+
+# Secrets
+.env
+.envrc
+
+# Profile outputs (generated, may contain personal data)
+# Use ** to match subdirectories (engine-audit/, deliberations/, etc.)
+profiles/**/*.json
+profiles/**/*.md
+profiles/**/*.jsonl
+profiles/**/*.yaml
+!profiles/presenter-style.yaml
+!profiles/component-registry.yaml
+!profiles/demo-audiences.yaml
+!profiles/workflow-registry.yaml
+profiles/**/*.bak
+profiles/**/*.db
+profiles/.quarantine/*
+!profiles/.quarantine/.gitkeep
+
+# SQLite WAL/SHM files
+*.db-wal
+*.db-shm
+
+# Playwright MCP cache
+.playwright-mcp/
+.claude/settings.local.json
+.claude/hookify*.local.md
+.claude/worktrees/
+--Frag*
+
+# Demo outputs (generated)
+output/demos/
+.worktrees/
+.venv-ingest/
+
+# Wake word training data (large, generated)
+data/wake-word-training/
+.hypothesis/
+plugins/gst-temporalfx/target/
+
+# Model weights (large binaries, download on demand)
+*.pt
+*.task
+
+# Screenshots / snapshots (generated)
+*.jpeg
+/hapax-visual/
+
+# Temp profiles
+profiles/tmp*
+
+# Voice experiment session data (contains operator interactions)
+agents/hapax_daimonion/proofs/**/data/
+
+# Screenshots (smoke tests, stress tests, explorations)
+*.png
+# Committed test golden images (cairo render regression pins)
+!tests/studio_compositor/golden_images/*.png
+.claude/settings.json
+/plugins/gst-crossfade/target/
+/plugins/gst-smooth-delay/target/
+docs/superpowers/plans/2026-03-29-hapax-obsidian-v2-plan-full.md
+.superpowers/
+gst-plugin-glfeedback/target/
+.compositor-inspect/

hapax_agentgov-0.2.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Ryan Lee
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

hapax_agentgov-0.2.0/PKG-INFO

@@ -0,0 +1,166 @@
+Metadata-Version: 2.4
+Name: hapax-agentgov
+Version: 0.2.0
+Summary: Computational constitutional governance for AI agent systems
+Project-URL: Homepage, https://github.com/hapax-systems/agentgov
+Project-URL: Documentation, https://github.com/hapax-systems/agentgov#readme
+Project-URL: Repository, https://github.com/hapax-systems/agentgov
+Project-URL: Issues, https://github.com/hapax-systems/agentgov/issues
+Author-email: Ryan Lee <rylklee@gmail.com>
+License-Expression: MIT
+License-File: LICENSE
+Keywords: access-control,agents,consent,governance,information-flow,multi-agent
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Science/Research
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Classifier: Topic :: Security
+Classifier: Typing :: Typed
+Requires-Python: >=3.12
+Requires-Dist: pyyaml>=6.0
+Provides-Extra: dev
+Requires-Dist: hypothesis>=6.0; extra == 'dev'
+Requires-Dist: pyright>=1.1; extra == 'dev'
+Requires-Dist: pytest>=8.0; extra == 'dev'
+Requires-Dist: ruff>=0.4; extra == 'dev'
+Description-Content-Type: text/markdown
+
+# agentgov
+
+[![PyPI](https://img.shields.io/pypi/v/hapax-agentgov)](https://pypi.org/project/hapax-agentgov/)
+[![License: MIT](https://img.shields.io/badge/license-MIT-blue)](LICENSE)
+
+Computational constitutional governance for AI agent systems.
+
+agentgov provides algebraically-verified primitives for governing multi-agent systems: consent contracts, information flow control, principal delegation, provenance tracking, and compositional policy enforcement. Zero dependencies beyond PyYAML. Extracted from [hapax-council](https://github.com/hapax-systems/hapax-council), where it governs 200+ AI agents in production.
+
+## Install
+
+```bash
+pip install hapax-agentgov
+```
+
+## Core Concepts
+
+### Principals
+
+Actors in the system. Sovereign principals (humans) originate consent; bound principals (agents) operate under delegated authority with non-amplification guarantees.
+
+```python
+from agentgov import Principal, PrincipalKind
+
+operator = Principal(id="operator", kind=PrincipalKind.SOVEREIGN)
+agent = operator.delegate("sync-agent", frozenset({"email", "calendar"}))
+sub = agent.delegate("sub-agent", frozenset({"email"}))  # narrows authority
+```
+
+### Consent Labels (DLM Join-Semilattice)
+
+Information flow labels track who may read data. Labels combine via join — combining data with different consent requirements produces the most restrictive combination.
+
+```python
+from agentgov import ConsentLabel
+
+public = ConsentLabel.bottom()  # no restrictions
+restricted = ConsentLabel(frozenset({("alice", frozenset({"bob"}))}))
+combined = public.join(restricted)  # most restrictive wins
+assert public.can_flow_to(combined)  # less restrictive flows to more
+```
+
+### Labeled Values (LIO-Style)
+
+Wrap any value with its consent label and why-provenance.
+
+```python
+from agentgov import Labeled, ConsentLabel
+
+data = Labeled(value="secret", label=restricted, provenance=frozenset({"contract-1"}))
+transformed = data.map(str.upper)  # label preserved through transformations
+```
+
+### Provenance Semirings
+
+Track WHY data exists using algebraic provenance (Green et al., PODS 2007). Supports tensor (both required) and plus (either sufficient) composition.
+
+```python
+from agentgov import ProvenanceExpr
+
+combined = ProvenanceExpr.leaf("c1").tensor(ProvenanceExpr.leaf("c2"))
+assert combined.evaluate(frozenset({"c1", "c2"}))  # both active: survives
+assert not combined.evaluate(frozenset({"c1"}))     # one revoked: purged
+```
+
+### Governor (Per-Agent Policy Enforcement)
+
+Each agent gets a governance wrapper that validates inputs/outputs at boundaries. Pure validation layer — allows or denies, never modifies.
+
+```python
+from agentgov import GovernorWrapper, GovernorPolicy, Labeled, ConsentLabel
+
+gov = GovernorWrapper("my-agent")
+gov.add_input_policy(GovernorPolicy(
+    name="require-consent",
+    check=lambda agent_id, data: data.label != ConsentLabel.bottom(),
+    axiom_id="consent",
+))
+result = gov.check_input(Labeled(value="data", label=ConsentLabel.bottom()))
+assert not result.allowed
+```
+
+### VetoChain (Deny-Wins Composition)
+
+Order-independent constraint composition. Any denial blocks the action.
+
+```python
+from agentgov import VetoChain, Veto
+
+chain = VetoChain([
+    Veto("budget", lambda ctx: ctx["budget"] > 0),
+    Veto("auth", lambda ctx: ctx["authenticated"]),
+])
+result = chain.evaluate({"budget": 100, "authenticated": False})
+assert not result.allowed
+assert "auth" in result.denied_by
+```
+
+### Says Monad (DCC Attribution)
+
+Principal-annotated assertions following Abadi's DCC formalism. Threads authority through data transformations.
+
+```python
+from agentgov import Says, Principal, PrincipalKind
+
+operator = Principal(id="op", kind=PrincipalKind.SOVEREIGN)
+assertion = Says.unit(operator, "approved")
+delegated = assertion.handoff(operator.delegate("agent", frozenset({"approve"})))
+```
+
+### Revocation Cascade
+
+When a consent contract is revoked, all data whose provenance includes that contract is automatically purged across registered subsystems.
+
+```python
+from agentgov import ConsentRegistry, RevocationPropagator, CarrierRegistry
+
+registry = ConsentRegistry()
+propagator = RevocationPropagator(registry)
+propagator.register_carrier_registry(carrier_reg)
+report = propagator.revoke("alice")  # cascading purge
+```
+
+## Algebraic Properties (Hypothesis-Verified)
+
+- **ConsentLabel**: join-semilattice (associative, commutative, idempotent, bottom identity)
+- **Labeled[T]**: functor laws (identity, composition)
+- **Principal**: non-amplification (bound authority <= delegator authority)
+- **ProvenanceExpr**: PosBool(X) semiring (plus/tensor commutativity, associativity, distributivity, annihilation)
+- **VetoChain**: monotonic (adding vetoes only restricts, never permits)
+- **Governor**: consistent with can_flow_to
+
+## License
+
+MIT

hapax_agentgov-0.2.0/README.md

@@ -0,0 +1,135 @@
+# agentgov
+
+[![PyPI](https://img.shields.io/pypi/v/hapax-agentgov)](https://pypi.org/project/hapax-agentgov/)
+[![License: MIT](https://img.shields.io/badge/license-MIT-blue)](LICENSE)
+
+Computational constitutional governance for AI agent systems.
+
+agentgov provides algebraically-verified primitives for governing multi-agent systems: consent contracts, information flow control, principal delegation, provenance tracking, and compositional policy enforcement. Zero dependencies beyond PyYAML. Extracted from [hapax-council](https://github.com/hapax-systems/hapax-council), where it governs 200+ AI agents in production.
+
+## Install
+
+```bash
+pip install hapax-agentgov
+```
+
+## Core Concepts
+
+### Principals
+
+Actors in the system. Sovereign principals (humans) originate consent; bound principals (agents) operate under delegated authority with non-amplification guarantees.
+
+```python
+from agentgov import Principal, PrincipalKind
+
+operator = Principal(id="operator", kind=PrincipalKind.SOVEREIGN)
+agent = operator.delegate("sync-agent", frozenset({"email", "calendar"}))
+sub = agent.delegate("sub-agent", frozenset({"email"}))  # narrows authority
+```
+
+### Consent Labels (DLM Join-Semilattice)
+
+Information flow labels track who may read data. Labels combine via join — combining data with different consent requirements produces the most restrictive combination.
+
+```python
+from agentgov import ConsentLabel
+
+public = ConsentLabel.bottom()  # no restrictions
+restricted = ConsentLabel(frozenset({("alice", frozenset({"bob"}))}))
+combined = public.join(restricted)  # most restrictive wins
+assert public.can_flow_to(combined)  # less restrictive flows to more
+```
+
+### Labeled Values (LIO-Style)
+
+Wrap any value with its consent label and why-provenance.
+
+```python
+from agentgov import Labeled, ConsentLabel
+
+data = Labeled(value="secret", label=restricted, provenance=frozenset({"contract-1"}))
+transformed = data.map(str.upper)  # label preserved through transformations
+```
+
+### Provenance Semirings
+
+Track WHY data exists using algebraic provenance (Green et al., PODS 2007). Supports tensor (both required) and plus (either sufficient) composition.
+
+```python
+from agentgov import ProvenanceExpr
+
+combined = ProvenanceExpr.leaf("c1").tensor(ProvenanceExpr.leaf("c2"))
+assert combined.evaluate(frozenset({"c1", "c2"}))  # both active: survives
+assert not combined.evaluate(frozenset({"c1"}))     # one revoked: purged
+```
+
+### Governor (Per-Agent Policy Enforcement)
+
+Each agent gets a governance wrapper that validates inputs/outputs at boundaries. Pure validation layer — allows or denies, never modifies.
+
+```python
+from agentgov import GovernorWrapper, GovernorPolicy, Labeled, ConsentLabel
+
+gov = GovernorWrapper("my-agent")
+gov.add_input_policy(GovernorPolicy(
+    name="require-consent",
+    check=lambda agent_id, data: data.label != ConsentLabel.bottom(),
+    axiom_id="consent",
+))
+result = gov.check_input(Labeled(value="data", label=ConsentLabel.bottom()))
+assert not result.allowed
+```
+
+### VetoChain (Deny-Wins Composition)
+
+Order-independent constraint composition. Any denial blocks the action.
+
+```python
+from agentgov import VetoChain, Veto
+
+chain = VetoChain([
+    Veto("budget", lambda ctx: ctx["budget"] > 0),
+    Veto("auth", lambda ctx: ctx["authenticated"]),
+])
+result = chain.evaluate({"budget": 100, "authenticated": False})
+assert not result.allowed
+assert "auth" in result.denied_by
+```
+
+### Says Monad (DCC Attribution)
+
+Principal-annotated assertions following Abadi's DCC formalism. Threads authority through data transformations.
+
+```python
+from agentgov import Says, Principal, PrincipalKind
+
+operator = Principal(id="op", kind=PrincipalKind.SOVEREIGN)
+assertion = Says.unit(operator, "approved")
+delegated = assertion.handoff(operator.delegate("agent", frozenset({"approve"})))
+```
+
+### Revocation Cascade
+
+When a consent contract is revoked, all data whose provenance includes that contract is automatically purged across registered subsystems.
+
+```python
+from agentgov import ConsentRegistry, RevocationPropagator, CarrierRegistry
+
+registry = ConsentRegistry()
+propagator = RevocationPropagator(registry)
+propagator.register_carrier_registry(carrier_reg)
+report = propagator.revoke("alice")  # cascading purge
+```
+
+## Algebraic Properties (Hypothesis-Verified)
+
+- **ConsentLabel**: join-semilattice (associative, commutative, idempotent, bottom identity)
+- **Labeled[T]**: functor laws (identity, composition)
+- **Principal**: non-amplification (bound authority <= delegator authority)
+- **ProvenanceExpr**: PosBool(X) semiring (plus/tensor commutativity, associativity, distributivity, annihilation)
+- **VetoChain**: monotonic (adding vetoes only restricts, never permits)
+- **Governor**: consistent with can_flow_to
+
+## License
+
+MIT

hapax_agentgov-0.2.0/pyproject.toml

@@ -0,0 +1,62 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "hapax-agentgov"
+version = "0.2.0"
+description = "Computational constitutional governance for AI agent systems"
+readme = "README.md"
+license = "MIT"
+requires-python = ">=3.12"
+authors = [{ name = "Ryan Lee", email = "rylklee@gmail.com" }]
+keywords = [
+    "governance",
+    "consent",
+    "agents",
+    "multi-agent",
+    "information-flow",
+    "access-control",
+]
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Intended Audience :: Developers",
+    "Intended Audience :: Science/Research",
+    "License :: OSI Approved :: MIT License",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+    "Topic :: Scientific/Engineering :: Artificial Intelligence",
+    "Topic :: Security",
+    "Typing :: Typed",
+]
+dependencies = ["pyyaml>=6.0"]
+
+[project.optional-dependencies]
+dev = ["pytest>=8.0", "hypothesis>=6.0", "ruff>=0.4", "pyright>=1.1"]
+
+[project.urls]
+Homepage = "https://github.com/hapax-systems/agentgov"
+Documentation = "https://github.com/hapax-systems/agentgov#readme"
+Repository = "https://github.com/hapax-systems/agentgov"
+Issues = "https://github.com/hapax-systems/agentgov/issues"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/agentgov"]
+
+[tool.ruff]
+line-length = 100
+target-version = "py312"
+
+[tool.ruff.lint]
+select = ["E", "F", "I", "UP", "B", "SIM"]
+
+[tool.ruff.format]
+quote-style = "double"
+
+[tool.pyright]
+pythonVersion = "3.12"
+typeCheckingMode = "standard"
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]

hapax_agentgov-0.2.0/src/agentgov/__init__.py

@@ -0,0 +1,104 @@
+"""agentgov — Computational constitutional governance for AI agent systems.
+
+Pure governance logic with algebraic guarantees:
+- ConsentLabel: join-semilattice (associative, commutative, idempotent)
+- Labeled[T]: functor (identity, composition)
+- Principal: non-amplification (bound <= delegator authority)
+- Governor: consistent with can_flow_to
+- ProvenanceExpr: PosBool(X) semiring
+- VetoChain: deny-wins composition
+- Says: DCC-style principal attribution monad
+"""
+
+from agentgov.agent_governor import create_agent_governor
+from agentgov.carrier import CarrierFact, CarrierRegistry, DisplacementResult
+from agentgov.consent import ConsentContract, ConsentRegistry, load_contracts
+from agentgov.consent_label import ConsentLabel
+from agentgov.governor import (
+    GovernorDenial,
+    GovernorPolicy,
+    GovernorResult,
+    GovernorWrapper,
+    consent_input_policy,
+    consent_output_policy,
+)
+from agentgov.hooks import (
+    HookResult,
+    scan_attribution_entities,
+    scan_management_boundary,
+    scan_pii,
+    scan_provenance_references,
+    scan_single_user_violations,
+    validate_all,
+)
+from agentgov.labeled import Labeled
+from agentgov.primitives import (
+    Candidate,
+    FallbackChain,
+    GatedResult,
+    Selected,
+    Veto,
+    VetoChain,
+    VetoResult,
+)
+from agentgov.principal import Principal, PrincipalKind
+from agentgov.provenance import ProvenanceExpr
+from agentgov.revocation import (
+    PurgeResult,
+    RevocationPropagator,
+    RevocationReport,
+    check_provenance,
+)
+from agentgov.says import Says
+
+__version__ = "0.2.0"
+
+__all__ = [
+    # Principal model
+    "Principal",
+    "PrincipalKind",
+    # Consent
+    "ConsentContract",
+    "ConsentRegistry",
+    "ConsentLabel",
+    "load_contracts",
+    # Labeled data
+    "Labeled",
+    # Provenance
+    "ProvenanceExpr",
+    # Carrier dynamics
+    "CarrierFact",
+    "CarrierRegistry",
+    "DisplacementResult",
+    # Governor
+    "GovernorWrapper",
+    "GovernorPolicy",
+    "GovernorResult",
+    "GovernorDenial",
+    "consent_input_policy",
+    "consent_output_policy",
+    "create_agent_governor",
+    # Revocation cascade
+    "RevocationPropagator",
+    "RevocationReport",
+    "PurgeResult",
+    "check_provenance",
+    # Compositional primitives
+    "Candidate",
+    "FallbackChain",
+    "GatedResult",
+    "Selected",
+    "Veto",
+    "VetoChain",
+    "VetoResult",
+    # Says monad
+    "Says",
+    # Governance hooks
+    "HookResult",
+    "scan_pii",
+    "scan_single_user_violations",
+    "scan_attribution_entities",
+    "scan_provenance_references",
+    "scan_management_boundary",
+    "validate_all",
+]

hapax_agentgov-0.2.0/src/agentgov/agent_governor.py

@@ -0,0 +1,129 @@
+"""Agent governor factory: builds GovernorWrapper from axiom bindings.
+
+Translates declarative axiom bindings in agent manifests into runtime
+governance policies. Each agent gets a GovernorWrapper configured with
+input/output policies derived from its axiom relationships.
+"""
+
+from __future__ import annotations
+
+import logging
+from collections.abc import Callable
+from typing import Any
+
+from agentgov.consent_label import ConsentLabel
+from agentgov.governor import (
+    GovernorPolicy,
+    GovernorWrapper,
+    consent_input_policy,
+    consent_output_policy,
+)
+from agentgov.labeled import Labeled
+
+_log = logging.getLogger(__name__)
+
+PolicyBuilder = Callable[[str], tuple[list[GovernorPolicy], list[GovernorPolicy]]]
+
+
+def interpersonal_transparency_policies(
+    role: str,
+) -> tuple[list[GovernorPolicy], list[GovernorPolicy]]:
+    """Build policies for the interpersonal_transparency axiom."""
+    input_policies: list[GovernorPolicy] = []
+    output_policies: list[GovernorPolicy] = []
+
+    if role in ("subject", "enforcer"):
+        input_policies.append(consent_input_policy(ConsentLabel.bottom()))
+        output_policies.append(consent_output_policy(ConsentLabel.bottom()))
+
+    return input_policies, output_policies
+
+
+def corporate_boundary_policies(
+    role: str,
+) -> tuple[list[GovernorPolicy], list[GovernorPolicy]]:
+    """Build policies for the corporate_boundary axiom."""
+    input_policies: list[GovernorPolicy] = []
+    output_policies: list[GovernorPolicy] = []
+
+    if role in ("subject", "enforcer"):
+
+        def _no_work_data(_agent_id: str, data: Labeled[Any]) -> bool:
+            if not (hasattr(data, "metadata") and isinstance(data.metadata, dict)):
+                _log.warning("corporate_boundary: denying data with no metadata dict (fail-closed)")
+                return False
+            category = data.metadata.get("data_category")
+            if category is None:
+                _log.warning(
+                    "corporate_boundary: denying data with no data_category key (fail-closed)"
+                )
+                return False
+            return category != "work"
+
+        output_policies.append(
+            GovernorPolicy(
+                name="corporate_boundary_output",
+                check=_no_work_data,
+                axiom_id="corporate_boundary",
+                description="Block work data from persisting to home system",
+            )
+        )
+
+    return input_policies, output_policies
+
+
+DEFAULT_AXIOM_BUILDERS: dict[str, PolicyBuilder] = {
+    "interpersonal_transparency": interpersonal_transparency_policies,
+    "corporate_boundary": corporate_boundary_policies,
+}
+
+
+def create_agent_governor(
+    agent_id: str,
+    axiom_bindings: list[dict[str, Any]] | None = None,
+    *,
+    axiom_builders: dict[str, PolicyBuilder] | None = None,
+    binding_loader: Callable[[str], list[Any]] | None = None,
+) -> GovernorWrapper:
+    """Build a GovernorWrapper from agent manifest axiom bindings.
+
+    Args:
+        agent_id: Agent identifier.
+        axiom_bindings: List of binding dicts with keys 'axiom_id', 'role'.
+        axiom_builders: Custom axiom-to-policy mapping. Defaults to
+            built-in interpersonal_transparency and corporate_boundary.
+        binding_loader: Optional callable to load bindings from an
+            external registry when axiom_bindings is None.
+    """
+    gov = GovernorWrapper(agent_id)
+    builders = axiom_builders or DEFAULT_AXIOM_BUILDERS
+
+    bindings = axiom_bindings
+    if bindings is None and binding_loader is not None:
+        bindings = binding_loader(agent_id)
+    if bindings is None:
+        bindings = []
+
+    for binding in bindings:
+        axiom_id = binding.get("axiom_id", "") if isinstance(binding, dict) else binding.axiom_id
+        role = binding.get("role", "subject") if isinstance(binding, dict) else binding.role
+
+        builder = builders.get(axiom_id)
+        if builder is None:
+            continue
+
+        input_policies, output_policies = builder(role)
+        for p in input_policies:
+            gov.add_input_policy(p)
+        for p in output_policies:
+            gov.add_output_policy(p)
+
+        _log.debug(
+            "Governor %s: added %d input + %d output policies for %s",
+            agent_id,
+            len(input_policies),
+            len(output_policies),
+            axiom_id,
+        )
+
+    return gov