refactor: add rule engine, risk service, quote state machine, and replay tests

core/rules/engine.py

@@ -0,0 +1,59 @@
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from typing import Any, Awaitable, Callable, Dict, List, Optional
+
+
+@dataclass
+class RuleContext:
+    data: Dict[str, Any] = field(default_factory=dict)
+
+    def get(self, key: str, default: Any = None) -> Any:
+        return self.data.get(key, default)
+
+    def set(self, key: str, value: Any) -> None:
+        self.data[key] = value
+
+
+@dataclass
+class RuleResult:
+    matched: bool = False
+    stop: bool = False
+    action: str = ""
+    payload: Dict[str, Any] = field(default_factory=dict)
+
+
+Predicate = Callable[[RuleContext], Awaitable[bool]]
+Action = Callable[[RuleContext], Awaitable[RuleResult]]
+
+
+@dataclass
+class Rule:
+    name: str
+    priority: int
+    predicate: Predicate
+    action: Action
+
+
+class RuleEngine:
+    """Priority-ordered async rule chain."""
+
+    def __init__(self, rules: Optional[List[Rule]] = None):
+        self._rules: List[Rule] = sorted(rules or [], key=lambda x: x.priority)
+
+    def add_rule(self, rule: Rule) -> None:
+        self._rules.append(rule)
+        self._rules.sort(key=lambda x: x.priority)
+
+    async def run(self, ctx: RuleContext) -> RuleResult:
+        for rule in self._rules:
+            if not await rule.predicate(ctx):
+                continue
+            result = await rule.action(ctx)
+            if not result.matched:
+                result.matched = True
+            if not result.action:
+                result.action = rule.name
+            if result.stop:
+                return result
+        return RuleResult(matched=False, stop=False, action="no_match")