skills utilized for enhanced response synthesis v1

src/agents/synthesis_agent.py

@@ -1,620 +1,557 @@
 """
-Response Synthesis Agent
-Specialized in integrating multiple agent outputs into coherent responses
+Enhanced Synthesis Agent with Expert Consultant Assignment
+Based on skill probability scores from Skills Identification Agent
 """
 
 import logging
-from typing import Dict, Any, List
+import json
+from typing import Dict, List, Any, Optional, Tuple
+from datetime import datetime
 import re
 
 logger = logging.getLogger(__name__)
 
-class ResponseSynthesisAgent:
-    def __init__(self, llm_router=None):
-        self.llm_router = llm_router
-        self.agent_id = "RESP_SYNTH_001"
-        self.specialization = "Multi-source information integration and coherent response generation"
-        self._current_user_input = None
-        
-        # Response templates for different intent types
-        self.response_templates = {
-            "information_request": {
-                "structure": "introduction → key_points → conclusion",
-                "tone": "informative, clear, authoritative"
-            },
-            "task_execution": {
-                "structure": "confirmation → steps → expected_outcome",
-                "tone": "action-oriented, precise, reassuring"
-            },
-            "creative_generation": {
-                "structure": "concept → development → refinement",
-                "tone": "creative, engaging, expressive"
-            },
-            "analysis_research": {
-                "structure": "hypothesis → analysis → insights",
-                "tone": "analytical, evidence-based, objective"
-            },
-            "casual_conversation": {
-                "structure": "engagement → response → follow_up",
-                "tone": "friendly, conversational, natural"
-            }
+
+class ExpertConsultantAssigner:
+    """
+    Assigns expert consultant profiles based on skill probabilities
+    and generates weighted expertise for response synthesis
+    """
+    
+    # Expert consultant profiles with skill mappings
+    EXPERT_PROFILES = {
+        "data_analysis": {
+            "title": "Senior Data Analytics Consultant",
+            "expertise": ["Statistical Analysis", "Data Visualization", "Business Intelligence", "Predictive Modeling"],
+            "background": "15+ years in data science across finance, healthcare, and tech sectors",
+            "style": "methodical, evidence-based, quantitative reasoning"
+        },
+        "technical_programming": {
+            "title": "Principal Software Engineering Consultant", 
+            "expertise": ["Full-Stack Development", "System Architecture", "DevOps", "Code Optimization"],
+            "background": "20+ years leading technical teams at Fortune 500 companies",
+            "style": "practical, solution-oriented, best practices focused"
+        },
+        "project_management": {
+            "title": "Strategic Project Management Consultant",
+            "expertise": ["Agile/Scrum", "Risk Management", "Stakeholder Communication", "Resource Optimization"],
+            "background": "12+ years managing complex enterprise projects across industries",
+            "style": "structured, process-driven, outcome-focused"
+        },
+        "financial_analysis": {
+            "title": "Executive Financial Strategy Consultant",
+            "expertise": ["Financial Modeling", "Investment Analysis", "Risk Assessment", "Corporate Finance"],
+            "background": "18+ years in investment banking and corporate finance advisory",
+            "style": "analytical, risk-aware, ROI-focused"
+        },
+        "digital_marketing": {
+            "title": "Chief Marketing Strategy Consultant",
+            "expertise": ["Digital Campaign Strategy", "Customer Analytics", "Brand Development", "Growth Hacking"],
+            "background": "14+ years scaling marketing for startups to enterprise clients",
+            "style": "creative, data-driven, customer-centric"
+        },
+        "business_consulting": {
+            "title": "Senior Management Consultant",
+            "expertise": ["Strategic Planning", "Organizational Development", "Process Improvement", "Change Management"],
+            "background": "16+ years at top-tier consulting firms (McKinsey, BCG equivalent)",
+            "style": "strategic, framework-driven, holistic thinking"
+        },
+        "cybersecurity": {
+            "title": "Chief Information Security Consultant",
+            "expertise": ["Threat Assessment", "Security Architecture", "Compliance", "Incident Response"],
+            "background": "12+ years protecting critical infrastructure across government and private sectors",
+            "style": "security-first, compliance-aware, risk mitigation focused"
+        },
+        "healthcare_technology": {
+            "title": "Healthcare Innovation Consultant",
+            "expertise": ["Health Informatics", "Telemedicine", "Medical Device Integration", "HIPAA Compliance"],
+            "background": "10+ years implementing healthcare technology solutions",
+            "style": "patient-centric, regulation-compliant, evidence-based"
+        },
+        "educational_technology": {
+            "title": "Learning Technology Strategy Consultant",
+            "expertise": ["Instructional Design", "EdTech Implementation", "Learning Analytics", "Curriculum Development"],
+            "background": "13+ years transforming educational experiences through technology",
+            "style": "learner-focused, pedagogy-driven, accessibility-minded"
+        },
+        "environmental_science": {
+            "title": "Sustainability Strategy Consultant",
+            "expertise": ["Environmental Impact Assessment", "Carbon Footprint Analysis", "Green Technology", "ESG Reporting"],
+            "background": "11+ years driving environmental initiatives for corporations",
+            "style": "sustainability-focused, data-driven, long-term thinking"
         }
+    }
     
-    async def execute(self, agent_outputs: List[Dict[str, Any]], user_input: str, 
-                     context: Dict[str, Any] = None, **kwargs) -> Dict[str, Any]:
+    def assign_expert_consultant(self, skill_probabilities: Dict[str, float]) -> Dict[str, Any]:
         """
-        Synthesize responses from multiple agent outputs
-        """
-        try:
-            logger.info(f"{self.agent_id} synthesizing {len(agent_outputs)} agent outputs")
-            
-            # Log context for debugging
-            if context:
-                logger.info(f"{self.agent_id} context has {len(context.get('interactions', []))} interactions")
-            
-            # Extract intent information
-            intent_info = self._extract_intent_info(agent_outputs)
-            primary_intent = intent_info.get('primary_intent', 'casual_conversation')
-            
-            # Store user_input for use in synthesis
-            self._current_user_input = user_input
-            
-            # Structure the synthesis process
-            synthesis_result = await self._synthesize_response(
-                agent_outputs, user_input, context, primary_intent
-            )
-            
-            # Add quality metrics
-            synthesis_result.update({
-                "agent_id": self.agent_id,
-                "synthesis_quality_metrics": self._calculate_quality_metrics(synthesis_result),
-                "intent_alignment": self._check_intent_alignment(synthesis_result, intent_info)
-            })
-            
-            logger.info(f"{self.agent_id} completed synthesis")
-            return synthesis_result
+        Create ultra-expert profile combining all relevant consultants
+        
+        Args:
+            skill_probabilities: Dict mapping skill categories to probability scores (0.0-1.0)
             
-        except Exception as e:
-            logger.error(f"{self.agent_id} synthesis error: {str(e)}", exc_info=True)
-            return self._get_fallback_response(user_input, agent_outputs)
-    
-    async def _synthesize_response(self, agent_outputs: List[Dict[str, Any]], 
-                                 user_input: str, context: Dict[str, Any], 
-                                 primary_intent: str) -> Dict[str, Any]:
-        """Synthesize responses using appropriate method based on intent"""
-        
-        if self.llm_router:
-            # Use LLM for sophisticated synthesis
-            return await self._llm_based_synthesis(agent_outputs, user_input, context, primary_intent)
-        else:
-            # Use template-based synthesis
-            return await self._template_based_synthesis(agent_outputs, user_input, primary_intent)
-    
-    async def _llm_based_synthesis(self, agent_outputs: List[Dict[str, Any]], 
-                                  user_input: str, context: Dict[str, Any], 
-                                  primary_intent: str) -> Dict[str, Any]:
-        """Use LLM for sophisticated response synthesis"""
+        Returns:
+            Dict containing ultra-expert profile with combined expertise
+        """
+        if not skill_probabilities:
+            return self._get_default_consultant()
         
-        synthesis_prompt = await self._build_synthesis_prompt(agent_outputs, user_input, context, primary_intent)
+        # Calculate weighted scores for available expert profiles
+        expert_scores = {}
+        total_weight = 0
         
-        try:
-            # Call actual LLM for response generation
-            if self.llm_router:
-                logger.info(f"{self.agent_id} calling LLM for response synthesis")
-                llm_response = await self.llm_router.route_inference(
-                    task_type="response_synthesis",
-                    prompt=synthesis_prompt,
-                    max_tokens=2000,  # Updated to match model config
-                    temperature=0.7
-                )
-                
-                if llm_response and isinstance(llm_response, str) and len(llm_response.strip()) > 0:
-                    # Clean up the response
-                    clean_response = llm_response.strip()
-                    logger.info(f"{self.agent_id} received LLM response (length: {len(clean_response)})")
-                    logger.info("=" * 80)
-                    logger.info("SYNTHESIS AGENT - COMPLETE LLM RESPONSE:")
-                    logger.info("=" * 80)
-                    logger.info(f"Agent: {self.agent_id}")
-                    logger.info(f"Task: response_synthesis")
-                    logger.info(f"Response Length: {len(clean_response)} characters")
-                    logger.info("-" * 40)
-                    logger.info("FULL LLM RESPONSE CONTENT:")
-                    logger.info("-" * 40)
-                    logger.info(clean_response)
-                    logger.info("-" * 40)
-                    logger.info("END OF SYNTHESIS LLM RESPONSE")
-                    logger.info("=" * 80)
-                    
-                    return {
-                        "draft_response": clean_response,
-                        "final_response": clean_response,
-                        "source_references": self._extract_source_references(agent_outputs),
-                        "coherence_score": 0.90,
-                        "improvement_opportunities": self._identify_improvements(clean_response),
-                        "synthesis_method": "llm_enhanced"
-                    }
-                else:
-                    # LLM returned empty or None - use fallback
-                    logger.warning(f"{self.agent_id} LLM returned empty/invalid response, using template")
-        except Exception as e:
-            logger.error(f"{self.agent_id} LLM call failed: {e}, falling back to template")
+        for skill, probability in skill_probabilities.items():
+            if skill in self.EXPERT_PROFILES and probability >= 0.2:  # 20% threshold
+                expert_scores[skill] = probability
+                total_weight += probability
         
-        # Fallback to template-based if LLM fails
-        synthesized_response = await self._template_based_synthesis(agent_outputs, user_input, primary_intent)
-        draft_response = synthesized_response["final_response"]
+        if not expert_scores:
+            return self._get_default_consultant()
         
-        # Enhance the template response to make it more relevant
-        enhanced_response = self._enhance_response_quality(draft_response, primary_intent)
+        # Create ultra-expert combining all relevant consultants
+        ultra_expert = self._create_ultra_expert(expert_scores, total_weight)
         
         return {
-            "draft_response": draft_response,
-            "final_response": enhanced_response,
-            "source_references": self._extract_source_references(agent_outputs),
-            "coherence_score": 0.75,
-            "improvement_opportunities": self._identify_improvements(enhanced_response),
-            "synthesis_method": "template_enhanced"
+            "assigned_consultant": ultra_expert,
+            "expertise_weights": expert_scores,
+            "total_weight": total_weight,
+            "assignment_rationale": self._generate_ultra_expert_rationale(expert_scores, total_weight)
+        }
+    
+    def _get_default_consultant(self) -> Dict[str, Any]:
+        """Default consultant for general inquiries"""
+        return {
+            "assigned_consultant": {
+                "primary_expertise": "business_consulting",
+                "title": "Senior Management Consultant",
+                "expertise": ["Strategic Planning", "Problem Solving", "Analysis", "Communication"],
+                "background": "Generalist consultant with broad industry experience",
+                "style": "balanced, analytical, comprehensive",
+                "secondary_expertise": [],
+                "confidence_score": 0.7
+            },
+            "expertise_weights": {"business_consulting": 0.7},
+            "total_weight": 0.7,
+            "assignment_rationale": "Default consultant assigned for general business inquiry"
         }
     
-    async def _template_based_synthesis(self, agent_outputs: List[Dict[str, Any]], 
-                                     user_input: str, primary_intent: str) -> Dict[str, Any]:
-        """Template-based response synthesis"""
+    def _create_ultra_expert(self, expert_scores: Dict[str, float], total_weight: float) -> Dict[str, Any]:
+        """Create ultra-expert profile combining all relevant consultants"""
         
-        template = self.response_templates.get(primary_intent, self.response_templates["casual_conversation"])
+        # Sort skills by probability (highest first)
+        sorted_skills = sorted(expert_scores.items(), key=lambda x: x[1], reverse=True)
+        
+        # Combine all expertise areas with weights
+        combined_expertise = []
+        combined_background_elements = []
+        combined_style_elements = []
+        
+        for skill, weight in sorted_skills:
+            if skill in self.EXPERT_PROFILES:
+                profile = self.EXPERT_PROFILES[skill]
+                
+                # Weight-based contribution
+                contribution_ratio = weight / total_weight
+                
+                # Add expertise areas with weight indicators
+                for expertise in profile["expertise"]:
+                    weighted_expertise = f"{expertise} (Weight: {contribution_ratio:.1%})"
+                    combined_expertise.append(weighted_expertise)
+                
+                # Extract background years and combine
+                background = profile["background"]
+                combined_background_elements.append(f"{background} [{skill}]")
+                
+                # Combine style elements
+                style_parts = [s.strip() for s in profile["style"].split(",")]
+                combined_style_elements.extend(style_parts)
         
-        # Extract relevant content from agent outputs
-        content_blocks = self._extract_content_blocks(agent_outputs)
+        # Create ultra-expert title combining top skills
+        top_skills = [skill.replace("_", " ").title() for skill, _ in sorted_skills[:3]]
+        ultra_title = f"Visionary Ultra-Expert: {' + '.join(top_skills)} Integration Specialist"
         
-        # Apply template structure
-        structured_response = self._apply_response_template(content_blocks, template, primary_intent)
+        # Combine backgrounds into comprehensive experience
+        total_years = sum([self._extract_years_from_background(bg) for bg in combined_background_elements])
+        ultra_background = f"{total_years}+ years combined experience across {len(sorted_skills)} domains: " + \
+                          "; ".join(combined_background_elements[:3])  # Limit for readability
         
-        # Ensure we have a response even if no content blocks
-        if not structured_response or len(structured_response.strip()) == 0:
-            structured_response = f"Thank you for your message: '{user_input}'. I'm working on understanding how to best help you with this."
+        # Create unified style combining all approaches
+        unique_styles = list(set(combined_style_elements))
+        ultra_style = ", ".join(unique_styles[:6])  # Top 6 style elements
         
         return {
-            "draft_response": structured_response,
-            "final_response": structured_response,  # No enhancement in template mode
-            "source_references": self._extract_source_references(agent_outputs),
-            "coherence_score": 0.75,
-            "improvement_opportunities": ["Consider adding more specific details"] if content_blocks else ["Need more agent inputs"],
-            "synthesis_method": "template_based"
+            "primary_expertise": "ultra_expert_integration",
+            "title": ultra_title,
+            "expertise": combined_expertise,
+            "background": ultra_background,
+            "style": ultra_style,
+            "domain_integration": sorted_skills,
+            "confidence_score": total_weight / len(sorted_skills),  # Average confidence
+            "ultra_expert": True,
+            "expertise_count": len(sorted_skills),
+            "total_experience_years": total_years
         }
     
-    async def _build_synthesis_prompt(self, agent_outputs: List[Dict[str, Any]], 
-                              user_input: str, context: Dict[str, Any], 
-                              primary_intent: str) -> str:
-        """Build prompt for LLM-based synthesis - optimized for Qwen instruct format with context"""
-        
-        # Build a comprehensive prompt for actual LLM generation
-        agent_content = self._format_agent_outputs_for_synthesis(agent_outputs)
-        
-        # Extract conversation history for context (moving window strategy)
-        conversation_history = ""
-        if context and context.get('interactions'):
-            recent_interactions = context.get('interactions', [])[:40]  # Last 40 interactions from memory buffer
-            if recent_interactions:
-                # Split into: recent (last 10) + older (all remaining, LLM summarized)
-                if len(recent_interactions) > 10:
-                    oldest_interactions = recent_interactions[10:]  # All older interactions
-                    newest_interactions = recent_interactions[:10]  # Last 10 (newest)
-                    
-                    # Summarize ALL older interactions using LLM (no fallback)
-                    summary = await self._summarize_interactions(oldest_interactions)
-                    
-                    conversation_history = f"\n\nConversation Summary (earlier context):\n{summary}\n\n"
-                    conversation_history += "Recent conversation details:\n"
-                    
-                    # Include recent 10 interactions in full detail
-                    for i, interaction in enumerate(reversed(newest_interactions), 1):
-                        user_msg = interaction.get('user_input', '')
-                        if user_msg:
-                            conversation_history += f"Q{i}: {user_msg}\n"
-                            response = interaction.get('response', '')
-                            if response:
-                                conversation_history += f"A{i}: {response}\n"
-                            conversation_history += "\n"
-                else:
-                    # 10 or fewer interactions, show all in detail
-                    conversation_history = "\n\nPrevious conversation:\n"
-                    for i, interaction in enumerate(reversed(recent_interactions), 1):
-                        user_msg = interaction.get('user_input', '')
-                        if user_msg:
-                            conversation_history += f"Q{i}: {user_msg}\n"
-                            response = interaction.get('response', '')
-                            if response:
-                                conversation_history += f"A{i}: {response}\n"
-                            conversation_history += "\n"
-        
-        # Qwen instruct format with conversation history
-        prompt = f"""User Question: {user_input}
-{conversation_history}
-{agent_content if agent_content else ""}
-
-Instructions: Provide a comprehensive, helpful response that directly addresses the question. If there's conversation context, use it to answer the current question appropriately. Be detailed and informative.
-
-Response:"""
-        
-        return prompt
+    def _extract_years_from_background(self, background: str) -> int:
+        """Extract years of experience from background string"""
+        years_match = re.search(r'(\d+)\+?\s*years?', background.lower())
+        return int(years_match.group(1)) if years_match else 10  # Default to 10 years
     
-    async def _summarize_interactions(self, interactions: List[Dict[str, Any]]) -> str:
-        """Summarize older interactions using LLM third-person narrative (NO FALLBACK)"""
-        if not interactions:
-            return ""
+    def _generate_ultra_expert_rationale(self, expert_scores: Dict[str, float], total_weight: float) -> str:
+        """Generate explanation for ultra-expert assignment"""
+        sorted_skills = sorted(expert_scores.items(), key=lambda x: x[1], reverse=True)
         
-        # Use LLM-based narrative summarization ONLY (no fallback)
-        llm_summary = await self._generate_narrative_summary(interactions)
+        rationale_parts = [
+            f"Ultra-Expert Profile combining {len(sorted_skills)} specialized domains",
+            f"Total expertise weight: {total_weight:.2f} across integrated skill areas"
+        ]
         
-        if llm_summary and len(llm_summary.strip()) > 20:
-            return llm_summary
-        else:
-            # If LLM fails, return minimal placeholder
-            return f"Earlier conversation included {len(interactions)} interactions covering various topics."
-    
-    async def _generate_narrative_summary(self, interactions: List[Dict[str, Any]]) -> str:
-        """Use LLM to generate a third-person narrative summary of the conversation"""
-        if not interactions or not self.llm_router:
-            return ""
+        # Add top 3 contributions
+        top_contributions = []
+        for skill, weight in sorted_skills[:3]:
+            contribution = (weight / total_weight) * 100
+            top_contributions.append(f"{skill} ({weight:.1%}, {contribution:.0f}% contribution)")
         
-        # Build conversation transcript for LLM
-        conversation_text = "Conversation History:\n"
-        for i, interaction in enumerate(interactions, 1):
-            user_msg = interaction.get('user_input', '')
-            response = interaction.get('response', '')
-            
-            conversation_text += f"\nTurn {i}:\n"
-            if user_msg:
-                conversation_text += f"User: {user_msg}\n"
-            if response:
-                conversation_text += f"Assistant: {response[:200]}\n"  # First 200 chars of response
-        
-        # Prompt for third-person narrative
-        prompt = f"""{conversation_text}
-
-Task: Write a brief third-person narrative summary (2-3 sentences) of this conversation.
+        rationale_parts.append(f"Primary domains: {'; '.join(top_contributions)}")
+        
+        if len(sorted_skills) > 3:
+            additional_count = len(sorted_skills) - 3
+            rationale_parts.append(f"Plus {additional_count} additional specialized areas")
+        
+        return " | ".join(rationale_parts)
 
-The summary should:
-- Use third-person perspective ("The user started...", "The AI assistant responded...")
-- Capture the flow and progression of the conversation
-- Highlight key topics and themes
-- Be concise but informative
 
-Summary:"""
+class EnhancedSynthesisAgent:
+    """
+    Enhanced synthesis agent with expert consultant assignment
+    Compatible with existing ResponseSynthesisAgent interface
+    """
+    
+    def __init__(self, llm_router, agent_id: str = "RESP_SYNTH_001"):
+        self.llm_router = llm_router
+        self.agent_id = agent_id
+        self.specialization = "Multi-source information integration and coherent response generation"
+        self.expert_assigner = ExpertConsultantAssigner()
+        self._current_user_input = None
+        
+    async def execute(self, user_input: str = None, agent_outputs: List[Dict[str, Any]] = None, 
+                     context: Dict[str, Any] = None, skills_result: Dict[str, Any] = None,
+                     **kwargs) -> Dict[str, Any]:
+        """
+        Execute synthesis with expert consultant assignment
+        Compatible with both old interface (agent_outputs first) and new interface (user_input first)
+        
+        Args:
+            user_input: Original user question
+            agent_outputs: Results from other agents (can be first positional arg for compatibility)
+            context: Conversation context
+            skills_result: Output from skills identification agent
+            
+        Returns:
+            Dict containing synthesized response and metadata
+        """
+        # Handle backward compatibility and normalize arguments
+        # Case 1: First arg is agent_outputs (old interface)
+        if isinstance(user_input, list) and agent_outputs is None:
+            agent_outputs = user_input
+            user_input = kwargs.get('user_input', '')
+            context = kwargs.get('context', context)
+            skills_result = kwargs.get('skills_result', skills_result)
+        # Case 2: All args via kwargs
+        elif user_input is None:
+            user_input = kwargs.get('user_input', '')
+            agent_outputs = kwargs.get('agent_outputs', agent_outputs)
+            context = kwargs.get('context', context)
+            skills_result = kwargs.get('skills_result', skills_result)
+        
+        # Ensure user_input is a string
+        if not isinstance(user_input, str):
+            user_input = str(user_input) if user_input else ''
+        
+        # Default agent_outputs to empty list
+        if agent_outputs is None:
+            agent_outputs = []
         
+            logger.info(f"{self.agent_id} synthesizing {len(agent_outputs)} agent outputs")
+            if context:
+                logger.info(f"{self.agent_id} context has {len(context.get('interactions', []))} interactions")
+            
+        # STEP 1: Extract skill probabilities from skills_result
+        skill_probabilities = self._extract_skill_probabilities(skills_result)
+        logger.info(f"Extracted skill probabilities: {skill_probabilities}")
+        
+        # STEP 2: Assign expert consultant based on probabilities
+        consultant_assignment = self.expert_assigner.assign_expert_consultant(skill_probabilities)
+        assigned_consultant = consultant_assignment["assigned_consultant"]
+        logger.info(f"Assigned consultant: {assigned_consultant['title']} ({assigned_consultant.get('primary_expertise', 'N/A')})")
+        
+        # STEP 3: Generate expert consultant preamble
+        expert_preamble = self._generate_expert_preamble(assigned_consultant, consultant_assignment)
+        
+        # STEP 4: Build synthesis prompt with expert context
+        synthesis_prompt = self._build_synthesis_prompt_with_expert(
+            user_input=user_input,
+            context=context,
+            agent_outputs=agent_outputs,
+            expert_preamble=expert_preamble,
+            assigned_consultant=assigned_consultant
+        )
+        
+        logger.info(f"{self.agent_id} calling LLM for response synthesis")
+        
+        # Call LLM with enhanced prompt
         try:
-            import asyncio
-            summary = await self.llm_router.route_inference(
+            response = await self.llm_router.route_inference(
                 task_type="response_synthesis",
-                prompt=prompt,
-                max_tokens=300,
-                temperature=0.5
+                prompt=synthesis_prompt,
+                max_tokens=2000,
+                temperature=0.7
             )
             
-            if summary and isinstance(summary, str):
-                # Clean up the summary
-                clean_summary = summary.strip()
-                # Remove any "Summary:" prefix if present
-                if clean_summary.startswith("Summary:"):
-                    clean_summary = clean_summary[9:].strip()
-                
-                # Log the complete narrative summary response
-                logger.info("=" * 80)
-                logger.info("NARRATIVE SUMMARY - COMPLETE LLM RESPONSE:")
-                logger.info("=" * 80)
-                logger.info(f"Agent: {self.agent_id}")
-                logger.info(f"Task: narrative_summary")
-                logger.info(f"Interactions Count: {len(interactions)}")
-                logger.info(f"Summary Length: {len(clean_summary)} characters")
-                logger.info("-" * 40)
-                logger.info("FULL NARRATIVE SUMMARY CONTENT:")
-                logger.info("-" * 40)
-                logger.info(clean_summary)
-                logger.info("-" * 40)
-                logger.info("END OF NARRATIVE SUMMARY RESPONSE")
-                logger.info("=" * 80)
-                
-                return clean_summary
+            # Only use fallback if LLM actually fails (returns None, empty, or invalid)
+            if not response or not isinstance(response, str) or len(response.strip()) == 0:
+                logger.warning(f"{self.agent_id} LLM returned empty/invalid response, using fallback")
+                return self._get_fallback_response(user_input, agent_outputs, assigned_consultant)
             
-        except Exception as e:
-            logger.error(f"{self.agent_id} narrative summary generation failed: {e}")
-        
-        return ""
-    
-    def _extract_intent_info(self, agent_outputs: List[Dict[str, Any]]) -> Dict[str, Any]:
-        """Extract intent information from agent outputs"""
-        for output in agent_outputs:
-            if 'primary_intent' in output:
-                return {
-                    'primary_intent': output['primary_intent'],
-                    'confidence': output.get('confidence_scores', {}).get(output['primary_intent'], 0.5),
-                    'source_agent': output.get('agent_id', 'unknown')
+            clean_response = response.strip()
+            logger.info(f"{self.agent_id} received LLM response (length: {len(clean_response)})")
+            
+            # Build comprehensive result compatible with existing interface
+            result = {
+                "synthesized_response": clean_response,
+                "draft_response": clean_response,
+                "final_response": clean_response,  # Main response field - used by UI
+                "assigned_consultant": assigned_consultant,
+                "expertise_weights": consultant_assignment["expertise_weights"],
+                "assignment_rationale": consultant_assignment["assignment_rationale"],
+                "source_references": self._extract_source_references(agent_outputs),
+                "coherence_score": 0.90,
+                "improvement_opportunities": self._identify_improvements(clean_response),
+                "synthesis_method": "expert_enhanced_llm",
+                "agent_id": self.agent_id,
+                "synthesis_quality_metrics": self._calculate_quality_metrics({"final_response": clean_response}),
+                "synthesis_metadata": {
+                    "agent_outputs_count": len(agent_outputs),
+                    "context_interactions": len(context.get('interactions', [])) if context else 0,
+                    "expert_enhanced": True,
+                    "processing_timestamp": datetime.now().isoformat()
                 }
-        return {'primary_intent': 'casual_conversation', 'confidence': 0.5}
+            }
+            
+            # Add intent alignment if available
+            intent_info = self._extract_intent_info(agent_outputs)
+            if intent_info:
+                result["intent_alignment"] = self._check_intent_alignment(result, intent_info)
+            
+            return result
+            
+        except Exception as e:
+            logger.error(f"{self.agent_id} synthesis failed: {str(e)}", exc_info=True)
+            return self._get_fallback_response(user_input, agent_outputs, assigned_consultant)
     
-    def _extract_content_blocks(self, agent_outputs: List[Dict[str, Any]]) -> List[Dict[str, Any]]:
-        """Extract content blocks from agent outputs for synthesis"""
-        content_blocks = []
-        
-        for output in agent_outputs:
-            if 'result' in output:
-                content_blocks.append({
-                    'content': output['result'],
-                    'source': output.get('agent_id', 'unknown'),
-                    'confidence': output.get('confidence', 0.5)
-                })
-            elif 'primary_intent' in output:
-                content_blocks.append({
-                    'content': f"Intent analysis: {output['primary_intent']}",
-                    'source': output.get('agent_id', 'intent_agent'),
-                    'confidence': output.get('confidence_scores', {}).get(output['primary_intent'], 0.5)
-                })
-            elif 'final_response' in output:
-                content_blocks.append({
-                    'content': output['final_response'],
-                    'source': output.get('agent_id', 'unknown'),
-                    'confidence': output.get('confidence_score', 0.7)
-                })
-        
-        return content_blocks
+    def _extract_skill_probabilities(self, skills_result: Dict[str, Any]) -> Dict[str, float]:
+        """Extract skill probabilities from skills identification result"""
+        if not skills_result:
+            return {}
+        
+        # Check for skill_classification structure
+        skill_classification = skills_result.get('skill_classification', {})
+        if 'skill_probabilities' in skill_classification:
+            return skill_classification['skill_probabilities']
+        
+        # Check for direct skill_probabilities
+        if 'skill_probabilities' in skills_result:
+            return skills_result['skill_probabilities']
+        
+        # Extract from identified_skills if structured differently
+        identified_skills = skills_result.get('identified_skills', [])
+        if isinstance(identified_skills, list):
+            probabilities = {}
+            for skill in identified_skills:
+                if isinstance(skill, dict) and 'skill' in skill and 'probability' in skill:
+                    # Map skill name to expert profile name if needed
+                    skill_name = skill['skill']
+                    probability = skill['probability']
+                    probabilities[skill_name] = probability
+                elif isinstance(skill, dict) and 'category' in skill:
+                    skill_name = skill['category']
+                    probability = skill.get('probability', skill.get('confidence', 0.5))
+                    probabilities[skill_name] = probability
+            return probabilities
+        
+        return {}
     
-    def _apply_response_template(self, content_blocks: List[Dict[str, Any]], 
-                               template: Dict[str, str], intent: str) -> str:
-        """Apply response template to structure the content"""
-        
-        if intent == "information_request":
-            return self._structure_informative_response(content_blocks)
-        elif intent == "task_execution":
-            return self._structure_actionable_response(content_blocks)
+    def _generate_expert_preamble(self, assigned_consultant: Dict[str, Any], 
+                                 consultant_assignment: Dict[str, Any]) -> str:
+        """Generate expert consultant preamble for LLM prompt"""
+        
+        if assigned_consultant.get('ultra_expert'):
+            # Ultra-expert preamble
+            preamble = f"""You are responding as a {assigned_consultant['title']} - an unprecedented combination of industry-leading experts.
+
+ULTRA-EXPERT PROFILE:
+- Integrated Expertise: {assigned_consultant['expertise_count']} specialized domains
+- Combined Experience: {assigned_consultant['total_experience_years']}+ years across multiple industries
+- Integration Approach: Cross-domain synthesis with deep specialization
+- Response Style: {assigned_consultant['style']}
+
+DOMAIN INTEGRATION: {', '.join([f"{skill} ({weight:.1%})" for skill, weight in assigned_consultant['domain_integration']])}
+
+SPECIALIZED EXPERTISE AREAS:
+{chr(10).join([f"• {expertise}" for expertise in assigned_consultant['expertise'][:8]])}
+
+ASSIGNMENT RATIONALE: {consultant_assignment['assignment_rationale']}
+
+KNOWLEDGE DEPTH REQUIREMENT: 
+- Provide insights equivalent to a visionary thought leader combining expertise from multiple domains
+- Synthesize knowledge across {assigned_consultant['expertise_count']} specialization areas
+- Apply interdisciplinary thinking and cross-domain innovation
+- Leverage combined {assigned_consultant['total_experience_years']}+ years of integrated experience
+
+ULTRA-EXPERT RESPONSE GUIDELINES:
+- Draw from extensive cross-domain experience and pattern recognition
+- Provide multi-perspective analysis combining different expert viewpoints
+- Include interdisciplinary frameworks and innovative approaches
+- Acknowledge complexity while providing actionable, synthesized recommendations
+- Balance broad visionary thinking with deep domain-specific insights
+- Use integrative problem-solving that spans multiple expertise areas
+"""
         else:
-            return self._structure_conversational_response(content_blocks, self._current_user_input)
-    
-    def _structure_informative_response(self, content_blocks: List[Dict[str, Any]]) -> str:
-        """Structure an informative response (intro → key_points → conclusion)"""
-        if not content_blocks:
-            return "I'm here to help! Could you provide more details about what you're looking for?"
-        
-        intro = f"Based on the information available"
-        key_points = "\n".join([f"• {block['content']}" for block in content_blocks[:3]])
-        conclusion = "I hope this helps! Let me know if you need any clarification."
+            # Standard single expert preamble
+            preamble = f"""You are responding as a {assigned_consultant['title']} with the following profile:
+
+EXPERTISE PROFILE:
+- Primary Expertise: {assigned_consultant['primary_expertise']}
+- Core Skills: {', '.join(assigned_consultant['expertise'])}
+- Background: {assigned_consultant['background']}
+- Response Style: {assigned_consultant['style']}
+
+ASSIGNMENT RATIONALE: {consultant_assignment['assignment_rationale']}
+
+EXPERTISE WEIGHTS: {', '.join([f"{skill}: {weight:.1%}" for skill, weight in consultant_assignment['expertise_weights'].items()])}
+
+"""
+            
+            if assigned_consultant.get('secondary_expertise'):
+                preamble += f"SECONDARY EXPERTISE: {', '.join(assigned_consultant['secondary_expertise'])}\n"
+            
+            preamble += f"""
+KNOWLEDGE DEPTH REQUIREMENT: Provide insights equivalent to a highly experienced, industry-leading {assigned_consultant['title']} with deep domain expertise and practical experience.
+
+RESPONSE GUIDELINES:
+- Draw from extensive practical experience in your field
+- Provide industry-specific insights and best practices  
+- Include relevant frameworks, methodologies, or tools
+- Acknowledge complexity while remaining actionable
+- Balance theoretical knowledge with real-world application
+"""
         
-        return f"{intro}:\n\n{key_points}\n\n{conclusion}"
+        return preamble
     
-    def _structure_actionable_response(self, content_blocks: List[Dict[str, Any]]) -> str:
-        """Structure an actionable response (confirmation → steps → outcome)"""
-        if not content_blocks:
-            return "I understand you'd like some help. What specific task would you like to accomplish?"
+    def _build_synthesis_prompt_with_expert(self, user_input: str, context: Dict[str, Any],
+                                          agent_outputs: List[Dict[str, Any]], 
+                                          expert_preamble: str,
+                                          assigned_consultant: Dict[str, Any]) -> str:
+        """Build synthesis prompt with expert consultant context"""
         
-        confirmation = "I can help with that!"
-        steps = "\n".join([f"{i+1}. {block['content']}" for i, block in enumerate(content_blocks[:5])])
-        outcome = "This should help you get started. Feel free to ask if you need further assistance."
+        # Build context section with summarization for long conversations
+        context_section = self._build_context_section(context)
         
-        return f"{confirmation}\n\n{steps}\n\n{outcome}"
-    
-    def _structure_conversational_response(self, content_blocks: List[Dict[str, Any]], user_input: str = None) -> str:
-        """Structure a conversational response with context-aware content"""
-        if not content_blocks:
-            # Generate a meaningful, context-aware response based on user input
-            if user_input:
-                return self._generate_intelligent_response(user_input)
-            return "I'm here to help! Could you provide more details about what you're looking for?"
-        
-        # Combine content naturally
-        combined_content = " ".join([block['content'] for block in content_blocks])
-        if len(combined_content) == 0:
-            return self._generate_intelligent_response(user_input) if user_input else "I'm here to help. Could you tell me more about what you're looking for?"
-        return combined_content[:500] + "..." if len(combined_content) > 500 else combined_content
-    
-    def _generate_intelligent_response(self, user_input: str) -> str:
-        """Generate an intelligent, context-aware response based on user input"""
-        input_lower = user_input.lower()
+        # Build agent outputs section if any
+        agent_outputs_section = ""
+        if agent_outputs:
+            agent_outputs_section = f"\n\nAgent Analysis Results:\n"
+            for i, output in enumerate(agent_outputs, 1):
+                agent_outputs_section += f"Agent {i}: {output.get('result', output.get('final_response', str(output)))}\n"
         
-        if "agentic ai" in input_lower or "agentic" in input_lower:
-            return """Here's a practical guide to mastering Agentic AI as a data science professional:
+        # Construct full prompt
+        prompt = f"""{expert_preamble}
 
-**1. Foundational Understanding**
-- Study autonomous agent architectures (ReAct, Tool Use, Multi-Agent patterns)
-- Understand the agent reasoning loop: Perception → Decision → Action
-- Learn how agents maintain state and context across interactions
+User Question: {user_input}
 
-**2. Implementation Practice**
-- Start with frameworks like LangChain or AutoGen for building agent systems
-- Build simple agents that use tools (search, computation, databases)
-- Progress to multi-agent systems where agents collaborate
-- Implement agent memory and learning mechanisms
+{context_section}{agent_outputs_section}
 
-**3. Real-World Application**
-- Apply agentic principles to data science workflows (auto-EDA, model selection)
-- Build intelligent data processing pipelines with agent-based orchestration
-- Create autonomous model monitoring and retraining systems
+Instructions: Provide a comprehensive, helpful response that directly addresses the question from your expert perspective. If there's conversation context, use it to answer the current question appropriately. Be detailed, informative, and leverage your specialized expertise in {assigned_consultant.get('primary_expertise', 'general consulting')}.
 
-**4. Advanced Concepts**
-- Implement reasoning engines (Chain of Thought, Tree of Thoughts)
-- Build agent collaboration patterns (supervisor → worker, hierarchical)
-- Add reflection and self-correction capabilities
-
-**Resources**: Research papers on agentic systems, LangChain documentation, and multi-agent frameworks like AutoGen.
-
-Would you like me to dive deeper into any specific aspect?"""
+Response:"""
         
-        elif "master" in input_lower and "implement" in input_lower:
-            return """To master implementation skills systematically:
-
-**1. Start with Basics**
-- Build a simple implementation from scratch to understand core concepts
-- Study existing implementations and their design patterns
-- Identify common pitfalls and best practices
-
-**2. Progressive Complexity**
-- Implement increasingly complex features step by step
-- Test edge cases and handle error scenarios
-- Optimize for performance and maintainability
-
-**3. Real-World Practice**
-- Work on actual projects, not just tutorials
-- Contribute to open-source to get feedback
-- Build a portfolio showcasing your implementations
-
-**4. Advanced Techniques**
-- Study different architectural approaches
-- Learn about testing, documentation, and deployment
-- Understand scalability and production considerations
-
-Would you like specific guidance on implementation approaches or best practices?"""
+        return prompt
+    
+    def _build_context_section(self, context: Dict[str, Any]) -> str:
+        """Build context section with summarization for long conversations"""
+        if not context:
+            return ""
         
+        interactions = context.get('interactions', [])
+        
+        if len(interactions) <= 8:
+            # Show all interactions for short conversations
+            context_section = "\n\nPrevious conversation:\n"
+            for i, interaction in enumerate(interactions, 1):
+                context_section += f"Q{i}: {interaction.get('user_input', '')}\n"
+                if interaction.get('assistant_response') or interaction.get('response'):
+                    context_section += f"A{i}: {interaction.get('assistant_response') or interaction.get('response', '')}\n\n"
         else:
-            # Generate a substantive answer based on the question
-            return self._generate_substantive_answer(user_input)
+            # Summarize older interactions, show recent ones in full
+            recent_interactions = interactions[-8:]  # Last 8 interactions
+            older_interactions = interactions[:-8]   # Everything before last 8
+            
+            # Create summary of older interactions
+            summary = self._summarize_interactions(older_interactions)
+            
+            context_section = f"\n\nConversation Summary (earlier context):\n{summary}\n\nRecent conversation details:\n"
+            
+            for i, interaction in enumerate(recent_interactions, 1):
+                context_section += f"Q{i}: {interaction.get('user_input', '')}\n"
+                if interaction.get('assistant_response') or interaction.get('response'):
+                    context_section += f"A{i}: {interaction.get('assistant_response') or interaction.get('response', '')}\n\n"
+        
+        return context_section
     
-    def _generate_substantive_answer(self, user_input: str) -> str:
-        """Generate a substantive answer based on the topic"""
-        input_lower = user_input.lower()
+    def _summarize_interactions(self, interactions: List[Dict[str, Any]]) -> str:
+        """Summarize older interactions to preserve key context"""
+        if not interactions:
+            return "No prior context."
         
-        # Knowledge base for common queries
-        if "gemini" in input_lower and "google" in input_lower:
-            return """Google's Gemini chatbot is built on their Gemini family of multimodal AI models. Here are the key features:
-
-**1. Multimodal Capabilities**
-- Processes text, images, audio, video, and code simultaneously
-- Understands and generates content across different modalities
-- Supports seamless integration of visual and textual understanding
-
-**2. Three Model Sizes**
-- Gemini Ultra: Most capable for complex tasks
-- Gemini Pro: Balanced performance for general use  
-- Gemini Nano: Efficient on-device processing
-
-**3. Advanced Reasoning**
-- Chain-of-thought reasoning for complex problem-solving
-- Tool use and function calling for real-world applications
-- Code generation with multiple programming languages
-
-**4. Integration Features**
-- Google Workspace integration (Docs, Sheets, Slides)
-- YouTube content understanding and summarization
-- Real-time web search capabilities
-- Code execution in multiple languages
-
-**5. Developer Platform**
-- API access for building custom applications
-- Function calling for structured outputs
-- Streaming responses for better UX
-- Context window up to 1 million tokens (experimental)
-
-**6. Safety & Alignment**
-- Built-in safety filters and content moderation
-- Responsible AI practices and bias mitigation
-- Transparency in AI decision-making
-
-The chatbot excels at combining multiple capabilities like understanding uploaded images, searching the web, coding, and providing detailed explanations."""
+        # Extract key topics and themes
+        topics = []
+        key_points = []
         
-        elif any(keyword in input_lower for keyword in ["key features", "what can", "capabilities"]):
-            # Generic but substantive features response
-            return """Here are key capabilities I can help with:
-
-**Research & Analysis**
-- Synthesize information from multiple sources
-- Analyze complex topics and provide structured insights
-- Conduct literature reviews and summarize findings
-- Compare different approaches or methods
-
-**Content Generation**
-- Create detailed explanations and tutorials
-- Generate code examples and implementations
-- Write comprehensive documentation
-- Develop learning paths and guides
-
-**Problem-Solving**
-- Break down complex problems into steps
-- Propose solutions with trade-offs analysis
-- Debug code and suggest improvements
-- Design systems and architectures
-
-**Multi-Modal Understanding**
-- Process and discuss images, data, and text
-- Extract insights from visual content
-- Combine information from different modalities
-- Generate multimodal responses
-
-How can I assist you with a specific task or question?"""
+        for interaction in interactions:
+            user_input = interaction.get('user_input', '')
+            assistant_response = interaction.get('assistant_response') or interaction.get('response', '')
+            
+            # Extract topics (simple keyword extraction)
+            if user_input:
+                # Simple topic extraction - could be enhanced with NLP
+                user_words = user_input.lower().split()
+                key_terms = [word for word in user_words if len(word) > 4][:3]
+                topics.extend(key_terms)
+            
+            # Extract key points from responses (first sentence)
+            if assistant_response:
+                first_sentence = assistant_response.split('.')[0][:100]
+                if first_sentence:
+                    key_points.append(first_sentence + "...")
         
-        else:
-            # Provide a helpful, direct answer attempt
-            return f"""Let me address your question: "{user_input}"
-
-To provide you with the most accurate and helpful information, could you clarify:
-
-1. What specific aspect would you like me to focus on?
-2. What level of detail do you need? (Brief overview, detailed explanation, or step-by-step guide)
-3. Are you looking for practical implementation guidance, theoretical concepts, or both?
-
-Alternatively, you can rephrase your question with more specific details, and I'll provide a comprehensive answer."""
-    
-    def _enhance_response_quality(self, response: str, intent: str) -> str:
-        """Enhance response quality to ensure substantive content"""
-        enhanced = response
-        
-        # If response is too short or generic, enrich it with context
-        if self._current_user_input and len(response.split()) < 50:
-            if intent == "information_request" or intent == "analysis_research":
-                # Try to enhance with relevant knowledge
-                enhancement = self._get_topic_knowledge(self._current_user_input)
-                if enhancement:
-                    enhanced += "\n\n" + enhancement
-        
-        # Ensure minimum substance
-        if len(enhanced.split()) < 30:
-            enhanced += "\n\nWould you like me to elaborate on any specific aspect of this topic?"
-        
-        return enhanced
+        # Build summary
+        unique_topics = list(set(topics))[:5]  # Top 5 unique topics
+        recent_points = key_points[-3:]  # Last 3 key points
+        
+        summary = f"Topics discussed: {', '.join(unique_topics)}\n"
+        summary += f"Key points: {' '.join(recent_points)}"
+        
+        return summary
     
-    def _get_topic_knowledge(self, user_input: str) -> str:
-        """Get knowledge snippets for various topics"""
-        input_lower = user_input.lower()
-        
-        if "machine learning" in input_lower or "ml" in input_lower:
-            return """**Machine Learning Fundamentals:**
-- Supervised Learning: Models learn from labeled data (classification, regression)
-- Unsupervised Learning: Finding patterns in unlabeled data (clustering, dimensionality reduction)
-- Reinforcement Learning: Learning through rewards and punishments
-- Deep Learning: Neural networks with multiple layers for complex pattern recognition
-- Key algorithms include: Decision Trees, SVM, Random Forest, Neural Networks, Transformers"""
-        
-        elif "deep learning" in input_lower or "neural network" in input_lower:
-            return """**Deep Learning Essentials:**
-- Convolutional Neural Networks (CNNs): Best for image recognition
-- Recurrent Neural Networks (RNNs/LSTMs): For sequential data like text
-- Transformers: Modern architecture for NLP tasks
-- Key frameworks: TensorFlow, PyTorch, Keras
-- Applications: Computer vision, NLP, speech recognition, recommendation systems"""
-        
-        elif "data science" in input_lower:
-            return """**Data Science Workflow:**
-- Data Collection: Gathering relevant data from various sources
-- Data Cleaning: Removing errors, handling missing values
-- Exploratory Data Analysis: Understanding patterns and relationships
-- Feature Engineering: Creating meaningful input variables
-- Model Building: Selecting and training appropriate models
-- Evaluation & Deployment: Testing and productionizing solutions"""
-        
-        elif "nlp" in input_lower or "natural language" in input_lower:
-            return """**Natural Language Processing:**
-- Tokenization: Breaking text into words/subwords
-- Embeddings: Converting words to dense vector representations (Word2Vec, GloVe, BERT)
-- Named Entity Recognition: Identifying people, places, organizations
-- Sentiment Analysis: Understanding emotional tone
-- Machine Translation: Converting between languages
-- Modern approach: Large Language Models (GPT, BERT, Llama) with transfer learning"""
-        
-        elif "ai" in input_lower and "trends" in input_lower:
-            return """**Current AI Trends:**
-- Large Language Models (LLMs): GPT-4, Claude, Gemini for text generation
-- Multimodal AI: Processing text, images, audio simultaneously
-- Generative AI: Creating new content (text, images, code, music)
-- Autonomous Agents: AI systems that can act independently
-- Edge AI: Running models on devices for privacy and speed
-- Responsible AI: Fairness, ethics, and safety in AI systems"""
-        
-        return ""
+    def _extract_intent_info(self, agent_outputs: List[Dict[str, Any]]) -> Dict[str, Any]:
+        """Extract intent information from agent outputs"""
+        for output in agent_outputs:
+            if 'primary_intent' in output:
+                return {
+                    'primary_intent': output['primary_intent'],
+                    'confidence': output.get('confidence_scores', {}).get(output['primary_intent'], 0.5),
+                    'source_agent': output.get('agent_id', 'unknown')
+                }
+        return None
     
     def _extract_source_references(self, agent_outputs: List[Dict[str, Any]]) -> List[str]:
         """Extract source references from agent outputs"""
@@ -624,30 +561,25 @@ Alternatively, you can rephrase your question with more specific details, and I'
             sources.append(agent_id)
         return list(set(sources))  # Remove duplicates
     
-    def _format_agent_outputs_for_synthesis(self, agent_outputs: List[Dict[str, Any]]) -> str:
-        """Format agent outputs for LLM synthesis prompt"""
-        formatted = []
-        for i, output in enumerate(agent_outputs, 1):
-            agent_id = output.get('agent_id', 'unknown')
-            content = output.get('result', output.get('final_response', str(output)))
-            formatted.append(f"Agent {i} ({agent_id}): {content[:100]}...")
-        return "\n".join(formatted)
-    
     def _calculate_quality_metrics(self, synthesis_result: Dict[str, Any]) -> Dict[str, Any]:
         """Calculate quality metrics for synthesis"""
         response = synthesis_result.get('final_response', '')
         
         return {
             "length": len(response),
-            "word_count": len(response.split()),
+            "word_count": len(response.split()) if response else 0,
             "coherence_score": synthesis_result.get('coherence_score', 0.7),
             "source_count": len(synthesis_result.get('source_references', [])),
-            "has_structured_elements": bool(re.search(r'[•\d+\.]', response))
+            "has_structured_elements": bool(re.search(r'[•\d+\.]', response)) if response else False
         }
     
     def _check_intent_alignment(self, synthesis_result: Dict[str, Any], intent_info: Dict[str, Any]) -> Dict[str, Any]:
         """Check if synthesis aligns with detected intent"""
-        alignment_score = 0.8  # Placeholder
+        # Calculate alignment based on intent confidence and response quality
+        intent_confidence = intent_info.get('confidence', 0.5)
+        coherence_score = synthesis_result.get('coherence_score', 0.7)
+        # Alignment is average of intent confidence and coherence
+        alignment_score = (intent_confidence + coherence_score) / 2.0
         
         return {
             "intent_detected": intent_info.get('primary_intent'),
@@ -667,41 +599,36 @@ Alternatively, you can rephrase your question with more specific details, and I'
         
         return improvements
     
-    def _get_fallback_response(self, user_input: str, agent_outputs: List[Dict[str, Any]]) -> Dict[str, Any]:
-        """Provide substantive response even when synthesis fails"""
-        # Generate a real response using our knowledge
-        try:
-            response = self._generate_intelligent_response(user_input)
-            response = self._enhance_response_quality(response, "information_request")
-            
-            return {
-                "final_response": response,
-                "draft_response": response,
-                "source_references": self._extract_source_references(agent_outputs),
-                "coherence_score": 0.70,
-                "improvement_opportunities": [],
-                "synthesis_method": "knowledge_base",
-                "agent_id": self.agent_id,
-                "synthesis_quality_metrics": self._calculate_quality_metrics({"final_response": response}),
-                "intent_alignment": {"intent_detected": "information_request", "alignment_score": 0.75, "alignment_verified": True},
-                "fallback_mode": True
-            }
-        except Exception as e:
-            logger.error(f"Fallback response generation failed: {e}")
-            return {
-                "final_response": f"Thank you for your question: '{user_input}'. I'm processing your request and will provide a detailed response shortly.",
-                "draft_response": "",
-                "source_references": [],
-                "coherence_score": 0.5,
-                "improvement_opportunities": ["Fallback mode active"],
-                "synthesis_method": "emergency_fallback",
-                "agent_id": self.agent_id,
-                "synthesis_quality_metrics": {"error": "emergency_mode"},
-                "intent_alignment": {"error": "system_recovery"},
-                "error_handled": True
-            }
+    def _get_fallback_response(self, user_input: str, agent_outputs: List[Dict[str, Any]], 
+                               assigned_consultant: Dict[str, Any]) -> Dict[str, Any]:
+        """Provide fallback response when synthesis fails (LLM API failure only)"""
+        # Only use fallback when LLM API actually fails - not as default
+        if user_input:
+            fallback_text = f"Thank you for your question: '{user_input}'. I'm processing your request and will provide a detailed response shortly."
+        else:
+            fallback_text = "I apologize, but I encountered an issue processing your request. Please try again."
+        
+        return {
+            "synthesized_response": fallback_text,
+            "draft_response": fallback_text,
+            "final_response": fallback_text,
+            "assigned_consultant": assigned_consultant,
+            "source_references": self._extract_source_references(agent_outputs),
+            "coherence_score": 0.5,
+            "improvement_opportunities": ["LLM API error - fallback activated"],
+            "synthesis_method": "expert_enhanced_fallback",
+            "agent_id": self.agent_id,
+            "synthesis_quality_metrics": self._calculate_quality_metrics({"final_response": fallback_text}),
+            "error": True,
+            "synthesis_metadata": {"expert_enhanced": True, "error": True, "llm_api_failed": True}
+        }
+
+
+# Backward compatibility: ResponseSynthesisAgent is now EnhancedSynthesisAgent
+ResponseSynthesisAgent = EnhancedSynthesisAgent
 
-# Factory function for easy instantiation
-def create_synthesis_agent(llm_router=None):
-    return ResponseSynthesisAgent(llm_router)
 
+# Factory function for compatibility
+def create_synthesis_agent(llm_router) -> EnhancedSynthesisAgent:
+    """Factory function to create enhanced synthesis agent"""
+    return EnhancedSynthesisAgent(llm_router)

src/orchestrator_engine.py

@@ -160,7 +160,8 @@ class MVPOrchestrator:
             final_response = await self.agents['response_synthesis'].execute(
                 agent_outputs=agent_results,
                 user_input=user_input,
-                context=context
+                context=context,
+                skills_result=skills_result
             )
             self.execution_trace[-1].update({
                 "status": "completed",