malkhut(tests): 1140 test functions across 46 test files

CWM (103): core mechanics, exhaustive edge cases, numba, exchange mechanics
Replay (118): exhaustive verification, microstructure, trajectory
Training (190): asset classification, phase0 extensive, pipeline, exhaustive
DSL (102): v2 syntax, expanded, new features
ASEx (33): validate-before-mutate, single-writer
Planner (48): MCTS, alternatives, hooks
Counterparties (19): 9 adversarial agent policies
Clock (30): event-driven reactor
BingX (28): venue adapter
IPC (8): Zinc SHM
Storage (9): ClickHouse
Risk (4): hard invariants
State (17): frozen dataclass invariants
Integration: E2E, concurrency, sync/async seams, hypothesis, fuzz, adversarial

MALKHUT/malkhut/tests/test_replay_verify.py

@@ -0,0 +1,138 @@
+"""
+Replay verification — determinism, mismatch detection, binary search.
+"""
+import pytest
+from malkhut.state import (
+    AccountState, MarketWorldState, Mode, OrderBookState, PriceLevel, VenueRules,
+)
+from malkhut.cwm.core import MinimalCryptoLOBCWM
+from malkhut.cwm.replay_verify import ReplayVerifier, ReplayStep
+from malkhut.actions import ActionKind, FulfilmentAction
+
+
+def _venue():
+    return VenueRules(
+        exchange="bingx", symbol="BTCUSDT", tick_size=0.1, lot_size=0.001,
+        min_qty=0.001, min_notional=5.0, maker_fee_bps=-0.2, taker_fee_bps=0.5,
+        post_only_supported=True, reduce_only_supported=True,
+        max_orders_per_second=100, max_cancels_per_minute=120,
+    )
+
+
+def _state(ts=1_000_000_000):
+    return MarketWorldState(
+        ts_ns=ts, mode=Mode.REPLAY_NO_IMPACT, venue=_venue(),
+        book=OrderBookState(ts_ns=ts, symbol="BTCUSDT",
+                            bids=(PriceLevel(50000.0, 1.0),),
+                            asks=(PriceLevel(50001.0, 1.0),)),
+        account=AccountState(ts_ns=ts, equity=10000.0, wallet_balance=10000.0,
+                             available_balance=10000.0, margin_used=0.0, total_notional=0.0),
+    )
+
+
+def _noop():
+    return FulfilmentAction(ActionKind.NOOP, None, None, 0, 0.0, 0)
+
+
+class TestReplayVerifyDeterministic:
+    def test_perfect_replay_passes(self):
+        cwm = MinimalCryptoLOBCWM()
+        verifier = ReplayVerifier()
+        s0 = _state()
+        a = _noop()
+        s1 = cwm.transition(s0, (a,))
+        s2 = cwm.transition(s1, (a,))
+
+        replay = [
+            ReplayStep(s0, (a,), s1),
+            ReplayStep(s1, (a,), s2),
+        ]
+        result = verifier.verify(cwm, replay)
+        assert result.passed
+        assert len(result.mismatches) == 0
+
+    def test_mismatch_detected(self):
+        cwm = MinimalCryptoLOBCWM()
+        verifier = ReplayVerifier()
+        s0 = _state()
+        a = _noop()
+        s1 = cwm.transition(s0, (a,))
+        # Tamper with ground truth
+        bad_s1 = MarketWorldState(
+            ts_ns=s1.ts_ns + 999, mode=s1.mode, venue=s1.venue,
+            book=s1.book, account=s1.account,
+        )
+        replay = [ReplayStep(s0, (a,), bad_s1)]
+        result = verifier.verify(cwm, replay)
+        assert not result.passed
+        assert len(result.mismatches) > 0
+
+    def test_mismatch_at_correct_index(self):
+        cwm = MinimalCryptoLOBCWM()
+        verifier = ReplayVerifier()
+        s0 = _state()
+        a = _noop()
+        s1 = cwm.transition(s0, (a,))
+        s2 = cwm.transition(s1, (a,))
+        s3 = cwm.transition(s2, (a,))
+
+        # First step correct, second tampered
+        bad_s2 = MarketWorldState(
+            ts_ns=s2.ts_ns + 999, mode=s2.mode, venue=s2.venue,
+            book=s2.book, account=s2.account,
+        )
+        replay = [
+            ReplayStep(s0, (a,), s1),
+            ReplayStep(s1, (a,), bad_s2),
+            ReplayStep(s2, (a,), s3),
+        ]
+        result = verifier.verify(cwm, replay)
+        assert not result.passed
+        assert result.mismatches[0].index == 1
+
+    def test_empty_replay_passes(self):
+        cwm = MinimalCryptoLOBCWM()
+        verifier = ReplayVerifier()
+        result = verifier.verify(cwm, [])
+        assert result.passed
+
+
+class TestReplayVerifyDeterminismCheck:
+    def test_same_replay_twice_same_result(self):
+        cwm = MinimalCryptoLOBCWM()
+        verifier = ReplayVerifier()
+        s0 = _state()
+        a = _noop()
+        s1 = cwm.transition(s0, (a,))
+        replay = [ReplayStep(s0, (a,), s1)]
+
+        r1 = verifier.verify(cwm, replay)
+        r2 = verifier.verify(cwm, replay)
+        assert r1.passed == r2.passed
+
+    def test_determinism_verification_passes_for_cwm(self):
+        cwm = MinimalCryptoLOBCWM()
+        verifier = ReplayVerifier()
+        s0 = _state()
+        a = _noop()
+        s1 = cwm.transition(s0, (a,))
+        replay = [ReplayStep(s0, (a,), s1)]
+        result = verifier.verify_determinism(cwm, replay)
+        assert result.passed
+
+
+class TestReplayBisect:
+    def test_bisect_returns_first_mismatch(self):
+        cwm = MinimalCryptoLOBCWM()
+        verifier = ReplayVerifier()
+        s0 = _state()
+        a = _noop()
+        s1 = cwm.transition(s0, (a,))
+
+        from malkhut.cwm.replay_verify import ReplayMismatch
+        replay = [ReplayStep(s0, (a,), s1)]
+        result = verifier.verify(cwm, replay)
+        assert result.passed
+        # Bisect on clean replay returns None
+        mismatch = verifier.bisect(cwm, replay)
+        assert mismatch is None