Risk Management

type DailyLossTracker struct {
    redis  *redis.Client
    config DailyLossCapConfig
}

type DailyLossCapConfig struct {
    MaxDailyLoss decimal.Decimal  // Max loss allowed per day
}

func (d *DailyLossTracker) RecordLoss(
    ctx context.Context,
    userID string,
    loss decimal.Decimal,
) error {
    key := fmt.Sprintf("risk:daily_loss:%s", userID)
    
    // Get current loss
    currentLossStr, err := d.redis.Get(ctx, key).Result()
    var currentLoss decimal.Decimal
    if err == redis.Nil {
        currentLoss = decimal.Zero
    } else {
        currentLoss, _ = decimal.NewFromString(currentLossStr)
    }
    
    // Add new loss
    newLoss := currentLoss.Add(loss)
    
    // Store with 24-hour TTL (resets daily)
    return d.redis.Set(ctx, key, newLoss.String(), 24*time.Hour).Err()
}

func (d *DailyLossTracker) CheckLossLimit(
    ctx context.Context,
    userID string,
) (bool, decimal.Decimal, error) {
    currentLoss, err := d.GetCurrentLoss(ctx, userID)
    if err != nil {
        return false, decimal.Zero, err
    }
    
    exceeded := currentLoss.GreaterThanOrEqual(d.config.MaxDailyLoss)
    return exceeded, currentLoss, nil
}

func (t *PositionSizeThrottle) RecordLoss(
    ctx context.Context,
    userID string,
    consecutiveLosses int,
) (decimal.Decimal, error) {
    if consecutiveLosses < t.config.LossThreshold {
        return decimal.NewFromInt(1), nil  // No throttle yet
    }
    
    // Calculate reduction
    effectiveLosses := consecutiveLosses - t.config.LossThreshold + 1
    reductionFloat, _ := t.config.ReductionFactor.Float64()
    newMultiplier := decimal.NewFromFloat(
        math.Pow(reductionFloat, float64(effectiveLosses)),
    )
    
    // Apply minimum cap
    if newMultiplier.LessThan(t.config.MinPositionMultiplier) {
        newMultiplier = t.config.MinPositionMultiplier
    }
    
    // Store in Redis with 24-hour TTL
    key := fmt.Sprintf("risk:position_throttle:%s", userID)
    return newMultiplier, t.redis.Set(ctx, key, newMultiplier.String(), 24*time.Hour).Err()
}

func (t *PositionSizeThrottle) RecordWin(
    ctx context.Context,
    userID string,
) (decimal.Decimal, error) {
    currentMultiplier, _ := t.GetThrottleMultiplier(ctx, userID)
    
    // Already at full size?
    if currentMultiplier.GreaterThanOrEqual(decimal.NewFromInt(1)) {
        return decimal.NewFromInt(1), nil
    }
    
    // Increase by recovery factor
    newMultiplier := currentMultiplier.Mul(t.config.RecoveryFactor)
    
    // Cap at 1.0 (full size)
    if newMultiplier.GreaterThan(decimal.NewFromInt(1)) {
        newMultiplier = decimal.NewFromInt(1)
    }
    
    // Store updated multiplier
    key := fmt.Sprintf("risk:position_throttle:%s", userID)
    t.redis.Set(ctx, key, newMultiplier.String(), 24*time.Hour)
    
    // If fully recovered, delete key
    if newMultiplier.GreaterThanOrEqual(decimal.NewFromInt(1)) {
        t.redis.Del(ctx, key)
    }
    
    return newMultiplier, nil
}

type PositionSizeThrottleConfig struct {
    Enabled               bool            // Enable throttling
    ReductionFactor       decimal.Decimal // Multiply by this on loss (0.7 = 70%)
    MinPositionMultiplier decimal.Decimal // Minimum size cap (0.1 = 10%)
    LossThreshold         int             // Start throttling after N losses
    RecoveryFactor        decimal.Decimal // Multiply by this on win (1.5 = 150%)
}

func DefaultPositionSizeThrottleConfig() PositionSizeThrottleConfig {
    return PositionSizeThrottleConfig{
        Enabled:               true,
        ReductionFactor:       decimal.NewFromFloat(0.7),   // 30% reduction per loss
        MinPositionMultiplier: decimal.NewFromFloat(0.1),   // Max 90% reduction
        LossThreshold:         1,                           // Throttle after 1 loss
        RecoveryFactor:        decimal.NewFromFloat(1.5),   // 50% recovery per win
    }
}

type ConsecutiveLossTracker struct {
    redis  *redis.Client
    config ConsecutiveLossConfig
}

type ConsecutiveLossConfig struct {
    MaxConsecutiveLosses int           // Pause after N losses
    PauseDuration        time.Duration // How long to pause
}

func (c *ConsecutiveLossTracker) RecordLoss(
    ctx context.Context,
    userID string,
) (int, bool, error) {
    key := fmt.Sprintf("risk:consecutive_loss:%s", userID)
    
    // Increment consecutive loss counter
    count, err := c.redis.Incr(ctx, key).Result()
    if err != nil {
        return 0, false, err
    }
    
    // Set expiry if first loss
    if count == 1 {
        c.redis.Expire(ctx, key, 24*time.Hour)
    }
    
    // Check if pause threshold exceeded
    shouldPause := int(count) >= c.config.MaxConsecutiveLosses
    
    if shouldPause {
        // Set pause flag
        pauseKey := fmt.Sprintf("risk:pause:%s", userID)
        c.redis.Set(ctx, pauseKey, "paused", c.config.PauseDuration)
    }
    
    return int(count), shouldPause, nil
}

func (c *ConsecutiveLossTracker) RecordWin(
    ctx context.Context,
    userID string,
) error {
    // Reset consecutive loss counter on win
    key := fmt.Sprintf("risk:consecutive_loss:%s", userID)
    return c.redis.Del(ctx, key).Err()
}

func (a *RiskManagerAgent) CheckEmergencyConditions(
    _ context.Context,
    currentDrawdown float64,
    dailyLoss decimal.Decimal,
) (*RiskAssessment, error) {
    isEmergency := false
    
    // Check max drawdown threshold
    if currentDrawdown >= a.config.EmergencyThreshold {
        assessment.Reasons = append(assessment.Reasons,
            fmt.Sprintf("Drawdown %.2f%% exceeds emergency threshold %.2f%%",
                currentDrawdown*100, a.config.EmergencyThreshold*100))
        isEmergency = true
    }
    
    // Check daily loss cap
    if dailyLoss.GreaterThanOrEqual(a.config.MaxDailyLoss) {
        assessment.Reasons = append(assessment.Reasons,
            fmt.Sprintf("Daily loss %s exceeds maximum %s",
                dailyLoss.String(), a.config.MaxDailyLoss.String()))
        isEmergency = true
    }
    
    if isEmergency {
        assessment.Action = RiskActionEmergency
        assessment.RiskLevel = RiskLevelExtreme
        assessment.Recommendations = append(assessment.Recommendations,
            "EMERGENCY: All positions should be closed immediately",
            "Halt all trading activity",
            "Review strategy before resuming")
        a.metrics.IncrementEmergency()
    }
    
    return assessment, nil
}

type RiskManagerConfig struct {
    MaxPortfolioRisk     float64         // Max % of portfolio at risk
    MaxPositionRisk      float64         // Max % per position
    MaxDailyLoss         decimal.Decimal // Max daily loss
    MaxDrawdown          float64         // Max drawdown before warning
    EmergencyThreshold   float64         // Drawdown for emergency halt
    ConsecutiveLossLimit int             // Max consecutive losses
    PositionSizeLimit    decimal.Decimal // Max position size
}

func DefaultRiskManagerConfig() RiskManagerConfig {
    return RiskManagerConfig{
        MaxPortfolioRisk:     0.1,                        // 10%
        MaxPositionRisk:      0.02,                       // 2%
        MaxDailyLoss:         decimal.NewFromFloat(100),  // $100
        MaxDrawdown:          0.15,                       // 15% warning
        EmergencyThreshold:   0.20,                       // 20% emergency halt
        ConsecutiveLossLimit: 3,
        PositionSizeLimit:    decimal.NewFromFloat(1000),
    }
}

func (e *QuestEngine) shouldBlockQuestEntryByRiskLockLocked(quest *Quest) bool {
    if quest == nil || !e.isRiskLockEnabledLocked() {
        return false
    }
    
    definitionID := quest.Metadata["definition_id"]
    // Block new scalping entries while risk-lock is active
    return definitionID == "scalping_execution"
}

// Risk event notification
{
  type: "risk_alert",
  level: "emergency",
  message: "⚠️ EMERGENCY: Daily loss cap reached ($100/$100)\n\nAll trading halted.",
  actions: ["/doctor", "/status"]
}