Qualification Flow Violations

class QualificationFlow:
    """Enforce step sequence with validation"""
    
    STEPS = [
        "opening",
        "availability_check",
        "pitch",
        "interest_check",
        "college_capture",  # optional
        "permission_request",
        "number_confirmation",
        "close"
    ]
    
    REQUIRED_FOR_CLOSE = {
        "qualified": ["permission", "whatsapp_number"],
        "callback": ["callback_time"],
        "not_interested": [],
        "dnc": []
    }
    
    def __init__(self):
        self.current_step = "opening"
        self.captured = {}
        self.step_history = []
    
    def can_advance_to(self, target_step: str) -> tuple:
        """Check if we can advance to target step"""
        current_idx = self.STEPS.index(self.current_step)
        target_idx = self.STEPS.index(target_step)
        
        # Check for skips
        if target_idx > current_idx + 1:
            skipped = self.STEPS[current_idx + 1:target_idx]
            # Check if skipped steps are optional
            required_skipped = [s for s in skipped 
                               if not self.is_optional(s)]
            if required_skipped:
                return False, f"Cannot skip required steps: {required_skipped}"
        
        # Check prerequisites for specific steps
        prereqs = self.get_prerequisites(target_step)
        missing = [p for p in prereqs if p not in self.captured]
        if missing:
            return False, f"Missing prerequisites: {missing}"
        
        return True, None
    
    def get_prerequisites(self, step: str) -> list:
        """Get required captured data for step"""
        prereqs = {
            "permission_request": ["interest"],  # Must have interest
            "number_confirmation": ["permission"],  # Must have permission
            "close": []  # Depends on outcome
        }
        return prereqs.get(step, [])
    
    def is_optional(self, step: str) -> bool:
        return step in ["college_capture"]
    
    def advance_step(self, to_step: str) -> dict:
        """Advance to next step with validation"""
        can_advance, reason = self.can_advance_to(to_step)
        
        if not can_advance:
            return {
                "success": False,
                "error": reason,
                "stay_at": self.current_step
            }
        
        self.step_history.append(self.current_step)
        self.current_step = to_step
        
        return {
            "success": True,
            "current_step": to_step,
            "prompt_hint": self.get_step_prompt(to_step)
        }
    
    def capture_data(self, field: str, value: any) -> None:
        """Record captured data"""
        if field not in self.captured:
            self.captured[field] = value
        # Don't overwrite unless it's a correction
    
    def can_close(self, outcome: str) -> tuple:
        """Check if we have required data for this close type"""
        required = self.REQUIRED_FOR_CLOSE.get(outcome, [])
        missing = [f for f in required if f not in self.captured]
        
        if missing:
            return False, missing
        return True, []
    
    def get_step_prompt(self, step: str) -> str:
        """Get instruction for specific step"""
        prompts = {
            "interest_check": 
                "Ask ONE casual interest question. "
                "Do not ask about WhatsApp or permission yet.",
            "permission_request":
                "Ask ONLY for WhatsApp permission. "
                "Do not ask about the number yet.",
            "number_confirmation":
                "Ask ONLY whether same number or different number. "
                "Permission already captured."
        }
        return prompts.get(step, "")


class QuestionValidator:
    """Ensure single question per turn"""
    
    QUESTION_PATTERNS = [
        r'\?',
        r'^(can|could|would|do|does|is|are|what|which|how)',
        r'(okay|right|correct)\?'
    ]
    
    def count_questions(self, response: str) -> int:
        """Count number of questions in response"""
        # Simple: count question marks
        return response.count('?')
    
    def has_combined_questions(self, response: str) -> bool:
        """Check if response has multiple distinct questions"""
        question_count = self.count_questions(response)
        return question_count > 1
    
    def split_if_combined(self, response: str) -> list:
        """Split combined questions into separate turns"""
        if not self.has_combined_questions(response):
            return [response]
        
        # Split at question marks, keeping first question only
        parts = response.split('?')
        first_question = parts[0] + '?'
        
        return [first_question.strip()]

instructions: |
  ## CONVERSATION STEPS (MUST FOLLOW IN ORDER)
  
  STEP 1: OPENING - Greet, remind about form, check availability
          → Only proceed if caller is available NOW
  
  STEP 2: PITCH - Brief hook about program (15 seconds max)
          → Let caller react before asking questions
  
  STEP 3: INTEREST CHECK - Ask ONE interest question
          → "Does this sound interesting?"
          → Wait for clear response before proceeding
  
  STEP 4: COLLEGE - Ask which college (OPTIONAL)
          → Skip if they don't want to share
  
  STEP 5: PERMISSION - Ask ONLY for WhatsApp permission
          → "Can the team share the playbook on WhatsApp?"
          → This is a SEPARATE question from number confirmation
  
  STEP 6: NUMBER CONFIRMATION - Ask ONLY after permission granted
          → "Is this same number okay, or different WhatsApp?"
          → NEVER combine with permission question
  
  ## RULES
  - Complete each step before moving to next
  - ASK ONLY ONE QUESTION PER TURN
  - Never ask permission before interest is confirmed
  - Never ask number before permission is granted
  - If a step was already completed, skip it
  
  Current step: {current_step}
  Captured data: {captured_fields}