Script Compliance Drift

class ComplianceChecker:
    """Validate agent responses before delivery"""
    
    PROHIBITED_WORDS = [
        "quick", "quickly", "just", "basically", "simply",
        "kindly", "would you", "perfect", "awesome"
    ]
    
    PROMISE_PATTERNS = [
        r"team will (send|share|deliver|contact|reach)",
        r"you('ll| will) (receive|get|hear)",
        r"(sending|sharing) (it|the playbook)",
        r"(shortly|soon|today|tomorrow|in \d+ minutes)"
    ]
    
    REQUIRED_CLOSINGS = {
        "not_interested": "All good, totally understand. All the best!",
        "wrong_number": "Oh sorry, my bad!",
        "dnc": None  # Dynamic based on context
    }
    
    def __init__(self, max_turn_words=15):
        self.max_turn_words = max_turn_words
    
    def validate(self, response: str, context: dict) -> dict:
        """Validate response against compliance rules"""
        issues = []
        
        # Check prohibited words
        prohibited_found = self.check_prohibited(response)
        if prohibited_found:
            issues.append({
                "type": "prohibited_words",
                "words": prohibited_found,
                "severity": "high"
            })
        
        # Check promise patterns
        promises = self.check_promises(response)
        if promises:
            issues.append({
                "type": "promise_leakage",
                "patterns": promises,
                "severity": "critical"
            })
        
        # Check turn length
        word_count = len(response.split())
        if word_count > self.max_turn_words:
            issues.append({
                "type": "verbosity",
                "words": word_count,
                "limit": self.max_turn_words,
                "severity": "medium"
            })
        
        # Check required closing if applicable
        if context.get("is_closing"):
            closing_issue = self.check_closing(
                response, context.get("outcome")
            )
            if closing_issue:
                issues.append(closing_issue)
        
        return {
            "compliant": len(issues) == 0,
            "issues": issues,
            "response": response
        }
    
    def check_prohibited(self, text: str) -> list:
        text_lower = text.lower()
        return [w for w in self.PROHIBITED_WORDS 
                if w in text_lower]
    
    def check_promises(self, text: str) -> list:
        import re
        found = []
        for pattern in self.PROMISE_PATTERNS:
            if re.search(pattern, text, re.IGNORECASE):
                found.append(pattern)
        return found
    
    def check_closing(self, response: str, outcome: str) -> dict:
        required = self.REQUIRED_CLOSINGS.get(outcome)
        if required and response.strip() != required:
            return {
                "type": "closing_mismatch",
                "expected": required,
                "actual": response,
                "severity": "high"
            }
        return None
    
    def fix_response(self, response: str, issues: list, 
                     context: dict) -> str:
        """Attempt to fix compliance issues"""
        fixed = response
        
        for issue in issues:
            if issue["type"] == "prohibited_words":
                # Remove prohibited words
                for word in issue["words"]:
                    fixed = re.sub(
                        rf'\b{word}\b', '', fixed, 
                        flags=re.IGNORECASE
                    )
            
            if issue["type"] == "closing_mismatch":
                # Replace with required closing
                required = self.REQUIRED_CLOSINGS.get(
                    context.get("outcome")
                )
                if required:
                    fixed = required
            
            if issue["type"] == "promise_leakage":
                # Regenerate - can't easily fix promises
                return None  # Signal regeneration needed
        
        return fixed.strip()

# Put compliance rules at END of prompt (recency bias)
instructions: |
  ... [main instructions] ...
  
  ## CRITICAL COMPLIANCE RULES (ALWAYS FOLLOW)
  
  NEVER use these words: quick, just, basically, simply, kindly
  
  NEVER say:
  - "team will send/share/deliver"
  - "you'll receive/get"
  - Any promise of delivery timing
  
  ALWAYS use exact closing phrases:
  - Not Interested: "All good, totally understand. All the best!"
  - Wrong Number: "Oh sorry, my bad!"
  
  ALWAYS keep responses under 15 words.
  
  NEVER re-pitch after caller declines.