Unnecessary Data Collection

class DataCollectionMinimizer:
    """Ensure only necessary data is collected"""
    
    TASK_REQUIREMENTS = {
        "qualification_call": {
            "required": ["interest", "whatsapp_permission"],
            "optional": ["college_name", "whatsapp_number"],
            "never": ["name", "email", "age", "address", 
                     "phone_verification"]
        },
        "support_call": {
            "required": ["issue_description"],
            "optional": ["order_number"],
            "never": ["name", "email"]  # Already in context
        },
        "appointment": {
            "required": ["preferred_time"],
            "optional": ["alternate_time"],
            "never": ["full_address", "insurance"]  # Unless needed
        }
    }
    
    def __init__(self, task_type: str, context: dict):
        self.requirements = self.TASK_REQUIREMENTS.get(
            task_type, {"required": [], "optional": [], "never": []}
        )
        self.context = context  # Data already available
        self.collected = {}
    
    def should_ask(self, field: str) -> bool:
        """Determine if field should be asked"""
        # Never ask for "never" fields
        if field in self.requirements["never"]:
            return False
        
        # Don't ask for data already in context
        if field in self.context and self.context[field]:
            return False
        
        # Don't ask again if already collected
        if field in self.collected:
            return False
        
        # Required fields: yes
        if field in self.requirements["required"]:
            return True
        
        # Optional: only if conversation naturally leads there
        return False
    
    def get_question_budget(self) -> int:
        """Get remaining question budget"""
        required_remaining = len([
            f for f in self.requirements["required"]
            if f not in self.collected and f not in self.context
        ])
        return required_remaining + 1  # +1 for one optional
    
    def validate_collection_plan(self, 
                                  planned_questions: list) -> dict:
        """Validate planned data collection"""
        issues = []
        
        for question in planned_questions:
            field = self.extract_field(question)
            
            if field in self.requirements["never"]:
                issues.append({
                    "field": field,
                    "issue": "Never collect this field",
                    "severity": "high"
                })
            
            if field in self.context:
                issues.append({
                    "field": field,
                    "issue": "Already in context",
                    "severity": "medium"
                })
        
        return {
            "valid": len(issues) == 0,
            "issues": issues,
            "question_count": len(planned_questions),
            "budget": self.get_question_budget()
        }


class FrictionAnalyzer:
    """Analyze friction from data collection"""
    
    DROP_RATES = {
        # Estimated drop-off per question type
        "name": 0.15,
        "email": 0.12,
        "phone": 0.10,
        "address": 0.20,
        "dob": 0.18,
        "verification": 0.08,
        "optional_general": 0.08
    }
    
    def estimate_drop_off(self, questions: list) -> float:
        """Estimate cumulative drop-off from questions"""
        completion = 1.0
        
        for q in questions:
            field_type = self.classify_question(q)
            drop_rate = self.DROP_RATES.get(field_type, 0.08)
            completion *= (1 - drop_rate)
        
        return 1 - completion  # Total drop-off
    
    def recommend_removal(self, questions: list, 
                           target_completion: float) -> list:
        """Recommend questions to remove to hit target"""
        current = 1 - self.estimate_drop_off(questions)
        
        if current >= target_completion:
            return []  # Already meeting target
        
        # Sort by drop rate, recommend removing highest
        scored = [(q, self.DROP_RATES.get(
            self.classify_question(q), 0.08
        )) for q in questions]
        scored.sort(key=lambda x: x[1], reverse=True)
        
        removals = []
        for q, rate in scored:
            if q not in ["interest", "whatsapp_permission"]:
                removals.append(q)
                current = current / (1 - rate)
                if current >= target_completion:
                    break
        
        return removals

instructions: |
  ## DATA COLLECTION RULES
  
  ONLY collect what you need for THIS task:
  - WhatsApp permission: yes/no
  - Same number or different WhatsApp
  - College name (optional)
  
  DO NOT ask for:
  - Caller's name (you don't need it)
  - Email address (WhatsApp is the channel)
  - Phone number (you already called them)
  - Age, year of study, major, etc.
  - "How did you hear about us"
  
  DO NOT verify data already in context:
  - Don't ask "Can you confirm your number?"
  - You called them—you have the number
  
  FRICTION BUDGET: 
  - Max 3 questions total
  - Required: interest + WhatsApp permission + number confirm
  - Optional: college (if natural)
  
  If not strictly needed for playbook delivery, don't ask.