added tests covering core and gate

tests/test_core.py

@@ -0,0 +1,157 @@
+"""Tests for registry, contracts, and economy."""
+
+import pytest
+from cgae_engine.gate import RobustnessVector, Tier, GateFunction
+from cgae_engine.registry import AgentRegistry, AgentStatus
+from cgae_engine.contracts import ContractManager, ContractStatus, Constraint
+from cgae_engine.economy import Economy, EconomyConfig
+from cgae_engine.temporal import TemporalDecay
+
+
+class TestRegistry:
+    def setup_method(self):
+        self.registry = AgentRegistry()
+
+    def test_register_agent(self):
+        record = self.registry.register("test-model", {"model": "test"}, initial_balance=1.0)
+        assert record.status == AgentStatus.PENDING
+        assert record.balance == 1.0
+        assert record.model_name == "test-model"
+
+    def test_certify_activates_agent(self):
+        record = self.registry.register("m", {})
+        r = RobustnessVector(cc=0.7, er=0.7, as_=0.6, ih=0.8)
+        self.registry.certify(record.agent_id, r)
+        assert record.status == AgentStatus.ACTIVE
+        assert record.current_tier.value >= 1
+
+    def test_low_ih_suspends(self):
+        record = self.registry.register("m", {})
+        r = RobustnessVector(cc=0.9, er=0.9, as_=0.9, ih=0.3)
+        self.registry.certify(record.agent_id, r)
+        assert record.status == AgentStatus.SUSPENDED
+
+    def test_demote(self):
+        record = self.registry.register("m", {})
+        r_high = RobustnessVector(cc=0.8, er=0.8, as_=0.7, ih=0.9)
+        self.registry.certify(record.agent_id, r_high)
+        old_tier = record.current_tier
+
+        r_low = RobustnessVector(cc=0.3, er=0.3, as_=0.3, ih=0.6)
+        new_tier = self.registry.demote(record.agent_id, r_low)
+        assert new_tier < old_tier
+
+    def test_tier_distribution(self):
+        for i in range(5):
+            rec = self.registry.register(f"m{i}", {})
+            r = RobustnessVector(cc=0.5, er=0.5, as_=0.5, ih=0.7)
+            self.registry.certify(rec.agent_id, r)
+        dist = self.registry.tier_distribution()
+        assert sum(dist.values()) == 5
+
+
+class TestContracts:
+    def setup_method(self):
+        self.cm = ContractManager()
+
+    def test_create_contract(self):
+        c = self.cm.create_contract(
+            "test", [Constraint("c1", "test", lambda x: True)],
+            Tier.T1, reward=0.1, penalty=0.05, issuer_id="sys", deadline=100.0,
+        )
+        assert c.status == ContractStatus.OPEN
+        assert c.reward == 0.1
+
+    def test_assign_enforces_tier(self):
+        c = self.cm.create_contract(
+            "test", [], Tier.T3, reward=0.1, penalty=0.05, issuer_id="sys", deadline=100.0,
+        )
+        # T1 agent can't accept T3 contract
+        ok = self.cm.assign_contract(c.contract_id, "agent1", Tier.T1)
+        assert ok is False
+
+    def test_assign_enforces_budget_ceiling(self):
+        # Create many contracts to exceed T1 budget ceiling (0.01)
+        c = self.cm.create_contract(
+            "test", [], Tier.T1, reward=0.1, penalty=0.02, issuer_id="sys", deadline=100.0,
+        )
+        ok = self.cm.assign_contract(c.contract_id, "agent1", Tier.T1)
+        assert ok is False  # penalty 0.02 > T1 ceiling 0.01
+
+    def test_settle_success(self):
+        c = self.cm.create_contract(
+            "test", [Constraint("c1", "test", lambda x: True)],
+            Tier.T1, reward=0.01, penalty=0.005, issuer_id="sys", deadline=100.0,
+        )
+        self.cm.assign_contract(c.contract_id, "agent1", Tier.T2)
+        self.cm.submit_output(c.contract_id, "output")
+        settlement = self.cm.settle_contract(c.contract_id)
+        assert settlement["outcome"] == "success"
+
+    def test_settle_failure(self):
+        c = self.cm.create_contract(
+            "test", [Constraint("c1", "test", lambda x: False)],
+            Tier.T1, reward=0.01, penalty=0.005, issuer_id="sys", deadline=100.0,
+        )
+        self.cm.assign_contract(c.contract_id, "agent1", Tier.T2)
+        self.cm.submit_output(c.contract_id, "output")
+        settlement = self.cm.settle_contract(c.contract_id)
+        assert settlement["outcome"] == "failure"
+
+
+class TestEconomy:
+    def setup_method(self):
+        self.econ = Economy(config=EconomyConfig(initial_balance=0.5))
+
+    def test_register_and_audit(self):
+        record = self.econ.register_agent("test", {"model": "test"})
+        assert record.balance == 0.5
+        r = RobustnessVector(cc=0.7, er=0.7, as_=0.6, ih=0.8)
+        self.econ.audit_agent(record.agent_id, r)
+        assert record.current_tier.value >= 1
+        assert record.balance < 0.5  # audit cost deducted
+
+    def test_full_contract_lifecycle(self):
+        record = self.econ.register_agent("test", {"model": "test"})
+        r = RobustnessVector(cc=0.7, er=0.7, as_=0.6, ih=0.8)
+        self.econ.audit_agent(record.agent_id, r)
+
+        contract = self.econ.post_contract(
+            "do something", [Constraint("c", "test", lambda x: True)],
+            min_tier=Tier.T1, reward=0.05, penalty=0.01,
+        )
+        ok = self.econ.accept_contract(contract.contract_id, record.agent_id)
+        assert ok is True
+
+        settlement = self.econ.complete_contract(contract.contract_id, "output")
+        assert settlement["outcome"] == "success"
+        assert record.contracts_completed == 1
+
+    def test_aggregate_safety(self):
+        record = self.econ.register_agent("test", {"model": "test"})
+        r = RobustnessVector(cc=0.7, er=0.7, as_=0.6, ih=0.8)
+        self.econ.audit_agent(record.agent_id, r)
+        safety = self.econ.aggregate_safety()
+        assert 0.0 <= safety <= 1.0
+
+
+class TestTemporalDecay:
+    def test_no_decay_at_zero(self):
+        decay = TemporalDecay(decay_rate=0.01)
+        r = RobustnessVector(cc=0.8, er=0.7, as_=0.6, ih=0.9)
+        r_eff = decay.effective_robustness(r, 0)
+        assert r_eff.cc == r.cc
+
+    def test_decay_reduces_scores(self):
+        decay = TemporalDecay(decay_rate=0.01)
+        r = RobustnessVector(cc=0.8, er=0.7, as_=0.6, ih=0.9)
+        r_eff = decay.effective_robustness(r, 50)
+        assert r_eff.cc < r.cc
+        assert r_eff.er < r.er
+
+    def test_decay_stays_in_bounds(self):
+        decay = TemporalDecay(decay_rate=0.1)
+        r = RobustnessVector(cc=0.5, er=0.5, as_=0.5, ih=0.5)
+        r_eff = decay.effective_robustness(r, 1000)
+        assert r_eff.cc >= 0.0
+        assert r_eff.cc <= 1.0

tests/test_gate.py

@@ -0,0 +1,73 @@
+"""Tests for the CGAE core engine."""
+
+import pytest
+from cgae_engine.gate import GateFunction, RobustnessVector, Tier, TierThresholds
+
+
+class TestRobustnessVector:
+    def test_valid_vector(self):
+        r = RobustnessVector(cc=0.5, er=0.6, as_=0.7, ih=0.8)
+        assert r.cc == 0.5
+        assert r.weakest == 0.5
+
+    def test_out_of_range_raises(self):
+        with pytest.raises(ValueError):
+            RobustnessVector(cc=1.5, er=0.5, as_=0.5, ih=0.5)
+
+    def test_primary_dimensions(self):
+        r = RobustnessVector(cc=0.3, er=0.5, as_=0.4, ih=0.9)
+        assert r.primary == (0.3, 0.5, 0.4)
+        assert r.weakest == 0.3
+
+
+class TestGateFunction:
+    def setup_method(self):
+        self.gate = GateFunction()
+
+    def test_zero_robustness_gives_t0(self):
+        r = RobustnessVector(cc=0.0, er=0.0, as_=0.0, ih=0.0)
+        assert self.gate.evaluate(r) == Tier.T0
+
+    def test_low_ih_forces_t0(self):
+        r = RobustnessVector(cc=0.9, er=0.9, as_=0.9, ih=0.3)
+        assert self.gate.evaluate(r) == Tier.T0
+
+    def test_weakest_link(self):
+        # High CC and ER but low AS should be gated by AS
+        r = RobustnessVector(cc=0.9, er=0.9, as_=0.3, ih=0.9)
+        tier = self.gate.evaluate(r)
+        assert tier == Tier.T1  # AS=0.3 >= 0.25 (T1 threshold)
+
+    def test_t5_requires_all_high(self):
+        r = RobustnessVector(cc=0.95, er=0.95, as_=0.90, ih=0.95)
+        assert self.gate.evaluate(r) == Tier.T5
+
+    def test_evaluate_with_detail(self):
+        r = RobustnessVector(cc=0.72, er=0.68, as_=0.55, ih=0.82)
+        d = self.gate.evaluate_with_detail(r)
+        assert "tier" in d
+        assert "binding_dimension" in d
+        assert d["ih_pass"] is True
+
+    def test_chain_tier(self):
+        r1 = RobustnessVector(cc=0.9, er=0.9, as_=0.9, ih=0.9)
+        r2 = RobustnessVector(cc=0.4, er=0.4, as_=0.3, ih=0.6)
+        chain = self.gate.chain_tier([r1, r2])
+        assert chain <= self.gate.evaluate(r1)
+        assert chain == self.gate.evaluate(r2)
+
+    def test_budget_ceiling_increases_with_tier(self):
+        ceilings = [self.gate.budget_ceiling(Tier(i)) for i in range(6)]
+        for i in range(1, 6):
+            assert ceilings[i] > ceilings[i - 1]
+
+
+class TestTierThresholds:
+    def test_default_thresholds_valid(self):
+        t = TierThresholds()
+        assert len(t.cc) == 6
+        assert t.cc[0] == 0.0
+
+    def test_non_increasing_raises(self):
+        with pytest.raises(ValueError):
+            TierThresholds(cc=[0.0, 0.5, 0.4, 0.6, 0.8, 0.9])