Autonomous Trading

type QuestEngine struct {
    mu                  sync.RWMutex
    quests              map[string]*Quest
    executing           map[string]bool
    executionStarts     map[string]time.Time
    executionStage      map[string]string
    autonomousState     map[string]*AutonomousState
    definitions         map[string]*QuestDefinition
    handlers            map[QuestType]QuestHandler
    store               QuestStore
    redis               *redis.Client  // Distributed locks
    runtimeBudget       questRuntimeBudget
    riskLockActive      bool
    notificationService *NotificationService
}

func (l *AgentExecutionLoop) Execute(
    ctx context.Context,
    symbol string,
    marketContext MarketContext,
    portfolio PortfolioState,
) (*ExecutionLoopResult, error) {
    // Step 1: Run AnalystAgent analysis
    analysis, err := l.runAnalysis(ctx, symbol, marketContext)
    
    // Step 2: Run LLM with tool calling (optional)
    if l.llmClient != nil && l.config.EnableToolCalls {
        toolCalls, toolResults, _ := l.runLLMWithTools(ctx, symbol, analysis, marketContext)
    }
    
    // Step 3: Generate trading decision using TraderAgent
    tradingDecision, err := l.traderAgent.MakeDecision(ctx, marketContext, portfolio)
    
    // Step 4: Run risk assessment
    if l.config.RequireRiskApproval {
        riskAssessment, err := l.riskManager.AssessTradingRisk(ctx, symbol, side, riskSignals)
        
        // Block or reduce position based on risk level
        switch riskAssessment.Action {
        case risk.RiskActionBlock, risk.RiskActionEmergency:
            result.Decision = ExecutionDecisionReject
            return result, nil
        case risk.RiskActionReduce:
            tradingDecision.SizePercent = adjustedSize
        }
    }
    
    // Step 5: Approve execution if confidence threshold met
    if result.Confidence >= l.config.MinConfidence {
        result.Decision = ExecutionDecisionApprove
    }
    
    // Step 6: Execute order if auto-execute enabled
    if l.config.AutoExecute && l.orderExecutor != nil {
        l.orderExecutor.ExecuteOrder(ctx, tradingDecision)
    }
    
    return result, nil
}

type AgentExecutionLoopConfig struct {
    MaxIterations       int           // Max LLM iterations per cycle
    Timeout             time.Duration // Max time for execution cycle
    RequireRiskApproval bool          // Require risk manager approval
    MinConfidence       float64       // Min confidence threshold (0.0-1.0)
    EnableToolCalls     bool          // Enable LLM tool calling
    AutoExecute         bool          // Auto-execute approved orders
}

// Default configuration
func DefaultAgentExecutionLoopConfig() AgentExecutionLoopConfig {
    return AgentExecutionLoopConfig{
        MaxIterations:       5,
        Timeout:             60 * time.Second,
        RequireRiskApproval: true,
        MinConfidence:       0.7,
        EnableToolCalls:     true,
        AutoExecute:         false,  // Manual approval by default
    }
}

func (e *QuestEngine) BeginAutonomous(chatID string) (*AutonomousState, error) {
    e.mu.Lock()
    defer e.mu.Unlock()
    
    // Pause existing active quests for this chat
    for _, q := range e.quests {
        if q.Status == QuestStatusActive && q.Metadata["chat_id"] == chatID {
            q.Status = QuestStatusPaused
        }
    }
    
    state := &AutonomousState{
        ChatID:    chatID,
        IsActive:  true,
        StartedAt: time.Now(),
    }
    
    // Create default quests (scalping-first mode)
    defaultQuests := []string{"scalping_execution"}
    for _, defID := range defaultQuests {
        quest, _ := e.createQuestInternal(defID, chatID)
        quest.Status = QuestStatusActive
        quest.Metadata["dry_run"] = "false"  // LIVE TRADING
        state.ActiveQuests = append(state.ActiveQuests, quest.ID)
    }
    
    return state, nil
}

func (e *QuestEngine) determineCadenceModeLocked() string {
    if e.isRiskLockEnabledLocked() {
        return "risk_lock"
    }
    
    activeQuests := 0
    for _, quest := range e.quests {
        if quest.Status == QuestStatusActive {
            activeQuests++
        }
    }
    
    if activeQuests == 0 {
        return "idle"
    }
    if len(e.executing) > 0 {
        return "active_risk"
    }
    return "normal"
}

func (e *QuestEngine) acquireLock(ctx context.Context, key string, ttl time.Duration) bool {
    if e.redis == nil {
        return true  // No Redis, allow execution
    }
    
    ok, err := e.redis.SetNX(ctx, key, "locked", ttl).Result()
    if err != nil {
        log.Printf("Failed to acquire lock %s: %v", key, err)
        return false
    }
    return ok
}

func (e *QuestEngine) GetRuntimeDiagnostics() map[string]interface{} {
    return map[string]interface{}{
        "cadence_mode":               e.cadenceMode,
        "active_quests":              len(e.quests),
        "executing_quests":           len(e.executing),
        "risk_lock_active":           e.isRiskLockEnabledLocked(),
        "risk_lock_source":           e.currentRiskLockSourceLocked(),
        "execution_stage":            executionStage,
        "execution_last_progress_at": executionLastProgress,
        "provider_chain_configured":  e.aiProviderChainConfigured,
        "provider_chain_usable":      e.aiProviderChainUsable,
        "watchdog_stale":             e.runtimeBudget.StaleTimeout,
        "execution_timeout":          e.runtimeBudget.ExecutionTimeout,
        "lock_ttl":                   e.runtimeBudget.LockTTL,
    }
}

type ExecutionLoopMetrics struct {
    TotalCycles          int64
    ApprovedExecutions   int64
    RejectedExecutions   int64
    DeferredExecutions   int64
    EmergencyTriggers    int64
    TotalToolCalls       int64
    FailedToolCalls      int64
    AverageIterations    float64
    AverageExecutionTime float64  // milliseconds
    AverageConfidence    float64
    DecisionsBySymbol    map[string]int64
    DecisionsByAction    map[string]int64
}