Verbosity Despite Brevity Instructions

class BrevityEnforcer:
    """Enforce response length constraints"""
    
    def __init__(self, max_words=12, max_sentences=2):
        self.max_words = max_words
        self.max_sentences = max_sentences
    
    def check_length(self, response: str) -> dict:
        """Check if response exceeds limits"""
        words = response.split()
        sentences = response.count('.') + response.count('?') + \
                    response.count('!')
        
        return {
            "word_count": len(words),
            "sentence_count": sentences,
            "words_over": max(0, len(words) - self.max_words),
            "compliant": len(words) <= self.max_words
        }
    
    def truncate(self, response: str) -> str:
        """Truncate response to limits"""
        words = response.split()
        
        if len(words) <= self.max_words:
            return response
        
        # Find sentence boundary within limit
        truncated_words = words[:self.max_words]
        truncated = ' '.join(truncated_words)
        
        # Try to end at sentence boundary
        last_period = truncated.rfind('.')
        last_question = truncated.rfind('?')
        last_boundary = max(last_period, last_question)
        
        if last_boundary > len(truncated) * 0.6:
            return truncated[:last_boundary + 1]
        
        # Otherwise just truncate and add period
        return truncated.rstrip('.,!? ') + '.'
    
    def rewrite_concise(self, response: str, 
                        context: dict) -> str:
        """Request a more concise version"""
        # Use LLM to compress
        compression_prompt = f"""
        Rewrite this to under {self.max_words} words.
        Keep the same meaning. No filler words.
        
        Original: {response}
        
        Concise version:
        """
        # Call LLM with compression prompt
        return self.llm_compress(compression_prompt)


class CallDurationMonitor:
    """Monitor and enforce call duration"""
    
    def __init__(self, target_seconds=60, max_seconds=90):
        self.target = target_seconds
        self.max = max_seconds
        self.start_time = None
        self.warnings_given = 0
    
    def start(self):
        self.start_time = time.time()
    
    def get_elapsed(self) -> float:
        if not self.start_time:
            return 0
        return time.time() - self.start_time
    
    def get_remaining(self) -> float:
        return max(0, self.target - self.get_elapsed())
    
    def should_wrap_up(self) -> bool:
        """Check if we should start wrapping up"""
        return self.get_elapsed() > self.target * 0.8
    
    def is_over_max(self) -> bool:
        return self.get_elapsed() > self.max
    
    def get_response_budget(self, step: str) -> dict:
        """Get word budget based on remaining time"""
        remaining = self.get_remaining()
        
        # Rough estimate: 150 words per minute speech
        words_remaining = int(remaining * 2.5)  # 150/60 = 2.5
        
        step_allocations = {
            "opening": 0.15,
            "hook": 0.25,
            "interest": 0.15,
            "capture": 0.30,
            "close": 0.15
        }
        
        allocation = step_allocations.get(step, 0.2)
        step_budget = int(words_remaining * allocation)
        
        return {
            "max_words": min(step_budget, 20),
            "remaining_total": words_remaining,
            "should_be_brief": remaining < 20
        }


class ConciseResponseGenerator:
    """Generate responses that respect length constraints"""
    
    FILLER_WORDS = [
        "basically", "so", "just", "actually", "really",
        "simply", "definitely", "absolutely", "totally"
    ]
    
    REDUNDANT_PHRASES = [
        "I wanted to",
        "I just wanted to",
        "So basically",
        "What I mean is",
        "In other words"
    ]
    
    def remove_filler(self, response: str) -> str:
        """Remove filler words and phrases"""
        result = response
        
        for phrase in self.REDUNDANT_PHRASES:
            result = result.replace(phrase, "")
        
        words = result.split()
        filtered = [w for w in words 
                   if w.lower() not in self.FILLER_WORDS]
        
        return ' '.join(filtered).strip()
    
    def enforce_single_sentence_for(self, response: str,
                                     question_type: str) -> str:
        """Enforce single sentence for certain question types"""
        single_sentence_types = [
            "yes_no", "confirmation", "permission"
        ]
        
        if question_type in single_sentence_types:
            # Take only first sentence
            for end in ['.', '?', '!']:
                idx = response.find(end)
                if idx > 0:
                    return response[:idx + 1]
        
        return response

instructions: |
  ## BREVITY RULES (ENFORCED)
  
  WORD LIMITS:
  - Normal turns: 5-12 words
  - Maximum any turn: 20 words
  - Full call: 45-60 seconds
  
  SENTENCE LIMITS:
  - Most turns: 1-2 sentences
  - Never more than 2 sentences per turn
  
  EXAMPLES OF CORRECT LENGTH:
  ✓ "Got it! Evening or weekend better?"  (6 words)
  ✓ "Cool, which college are you at?"  (6 words)
  ✓ "Can the team share it on WhatsApp?"  (7 words)
  
  EXAMPLES OF TOO LONG:
  ✗ "So basically what we're looking for is someone who 
     can help us run a chess tournament at their college 
     and we'll provide all the support..."  (25+ words)
  
  TECHNIQUES:
  - Skip "So" and "Basically" at start
  - Don't list perks—summarize
  - Don't repeat what you already said
  - Don't elaborate unless asked
  - Answer yes/no questions in < 5 words
  
  If a response is getting long, STOP and simplify.