feat(risk): add trailing stop, volatility sizing, and position limits

3 files changed, 114 insertions, 7 deletions

diff --git a/services/order-executor/src/order_executor/config.py b/services/order-executor/src/order_executor/config.py
index 6542a31..14828ea 100644
--- a/services/order-executor/src/order_executor/config.py
+++ b/services/order-executor/src/order_executor/config.py
@@ -4,4 +4,7 @@ from shared.config import Settings
 
 
 class ExecutorConfig(Settings):
-    pass
+    risk_trailing_stop_pct: float = 0.0
+    risk_max_open_positions: int = 10
+    risk_volatility_lookback: int = 20
+    risk_volatility_scale: bool = False
diff --git a/services/order-executor/src/order_executor/main.py b/services/order-executor/src/order_executor/main.py
index 24a166e..32470f6 100644
--- a/services/order-executor/src/order_executor/main.py
+++ b/services/order-executor/src/order_executor/main.py
@@ -42,6 +42,10 @@ async def run() -> None:
         max_position_size=Decimal(str(config.risk_max_position_size)),
         stop_loss_pct=Decimal(str(config.risk_stop_loss_pct)),
         daily_loss_limit_pct=Decimal(str(config.risk_daily_loss_limit_pct)),
+        trailing_stop_pct=Decimal(str(config.risk_trailing_stop_pct)),
+        max_open_positions=config.risk_max_open_positions,
+        volatility_lookback=config.risk_volatility_lookback,
+        volatility_scale=config.risk_volatility_scale,
     )
 
     executor = OrderExecutor(
diff --git a/services/order-executor/src/order_executor/risk_manager.py b/services/order-executor/src/order_executor/risk_manager.py
index db162e1..2b0a864 100644
--- a/services/order-executor/src/order_executor/risk_manager.py
+++ b/services/order-executor/src/order_executor/risk_manager.py
@@ -1,7 +1,8 @@
 """Risk management for order execution."""
-
 from dataclasses import dataclass
 from decimal import Decimal
+from collections import deque
+import math
 
 from shared.models import Signal, OrderSide, Position
 
@@ -12,18 +13,106 @@ class RiskCheckResult:
     reason: str
 
 
+@dataclass
+class TrailingStop:
+    """Tracks trailing stop for a symbol."""
+    symbol: str
+    highest_price: Decimal
+    stop_pct: Decimal  # e.g. 5.0 for 5%
+
+    @property
+    def stop_price(self) -> Decimal:
+        return self.highest_price * (1 - self.stop_pct / 100)
+
+    def update(self, current_price: Decimal) -> None:
+        if current_price > self.highest_price:
+            self.highest_price = current_price
+
+    def is_triggered(self, current_price: Decimal) -> bool:
+        return current_price <= self.stop_price
+
+
 class RiskManager:
-    """Evaluates risk before order execution."""
+    """Evaluates risk before order execution with advanced features."""
 
     def __init__(
         self,
         max_position_size: Decimal,
         stop_loss_pct: Decimal,
         daily_loss_limit_pct: Decimal,
+        trailing_stop_pct: Decimal = Decimal("0"),
+        max_open_positions: int = 10,
+        volatility_lookback: int = 20,
+        volatility_scale: bool = False,
     ) -> None:
         self.max_position_size = max_position_size
         self.stop_loss_pct = stop_loss_pct
         self.daily_loss_limit_pct = daily_loss_limit_pct
+        self.trailing_stop_pct = trailing_stop_pct
+        self.max_open_positions = max_open_positions
+        self.volatility_lookback = volatility_lookback
+        self.volatility_scale = volatility_scale
+
+        self._trailing_stops: dict[str, TrailingStop] = {}
+        self._price_history: dict[str, deque[float]] = {}
+
+    def update_price(self, symbol: str, price: Decimal) -> None:
+        """Update price tracking for trailing stops and volatility."""
+        # Trailing stop
+        if symbol in self._trailing_stops:
+            self._trailing_stops[symbol].update(price)
+
+        # Price history for volatility
+        if symbol not in self._price_history:
+            self._price_history[symbol] = deque(maxlen=self.volatility_lookback)
+        self._price_history[symbol].append(float(price))
+
+    def set_trailing_stop(self, symbol: str, entry_price: Decimal) -> None:
+        """Set a trailing stop for a new position."""
+        if self.trailing_stop_pct > 0:
+            self._trailing_stops[symbol] = TrailingStop(
+                symbol=symbol,
+                highest_price=entry_price,
+                stop_pct=self.trailing_stop_pct,
+            )
+
+    def remove_trailing_stop(self, symbol: str) -> None:
+        """Remove trailing stop when position is closed."""
+        self._trailing_stops.pop(symbol, None)
+
+    def get_volatility(self, symbol: str) -> float | None:
+        """Calculate annualized volatility for a symbol."""
+        history = self._price_history.get(symbol)
+        if not history or len(history) < 2:
+            return None
+        prices = list(history)
+        returns = [(prices[i] - prices[i-1]) / prices[i-1] for i in range(1, len(prices)) if prices[i-1] != 0]
+        if not returns:
+            return None
+        mean = sum(returns) / len(returns)
+        var = sum((r - mean) ** 2 for r in returns) / len(returns)
+        daily_vol = math.sqrt(var)
+        return daily_vol * math.sqrt(365)  # Annualized
+
+    def calculate_position_size(self, symbol: str, balance: Decimal) -> Decimal:
+        """Calculate position size adjusted for volatility.
+
+        Lower volatility -> larger position, higher volatility -> smaller position.
+        Base: max_position_size of balance. Scaled by inverse volatility.
+        """
+        base_size = balance * self.max_position_size
+
+        if not self.volatility_scale:
+            return base_size
+
+        vol = self.get_volatility(symbol)
+        if vol is None or vol == 0:
+            return base_size
+
+        # Target volatility of 20% annualized
+        target_vol = 0.20
+        scale = min(target_vol / vol, 2.0)  # Cap at 2x
+        return base_size * Decimal(str(scale))
 
     def check(
         self,
@@ -37,6 +126,15 @@ class RiskManager:
         if balance > 0 and (daily_pnl / balance) * 100 < -self.daily_loss_limit_pct:
             return RiskCheckResult(allowed=False, reason="Daily loss limit exceeded")
 
+        # Check trailing stop
+        if signal.side == OrderSide.BUY:
+            trailing = self._trailing_stops.get(signal.symbol)
+            if trailing and trailing.is_triggered(signal.price):
+                return RiskCheckResult(
+                    allowed=False,
+                    reason=f"Trailing stop triggered at {trailing.stop_price}",
+                )
+
         if signal.side == OrderSide.BUY:
             order_cost = signal.price * signal.quantity
 
@@ -44,16 +142,18 @@ class RiskManager:
             if order_cost > balance:
                 return RiskCheckResult(allowed=False, reason="Insufficient balance")
 
+            # Check max open positions
+            open_count = sum(1 for p in positions.values() if p.quantity > 0)
+            if open_count >= self.max_open_positions:
+                return RiskCheckResult(allowed=False, reason="Max open positions reached")
+
             # Check position size limit
             position = positions.get(signal.symbol)
             current_position_value = Decimal(0)
             if position is not None:
                 current_position_value = position.quantity * position.current_price
 
-            if (
-                balance > 0
-                and (current_position_value + order_cost) / balance > self.max_position_size
-            ):
+            if balance > 0 and (current_position_value + order_cost) / balance > self.max_position_size:
                 return RiskCheckResult(allowed=False, reason="Position size exceeded")
 
         return RiskCheckResult(allowed=True, reason="OK")