refactor: normalize whitespace and docstrings in autonomous_engine.py

Clean up trailing spaces, consistent blank line spacing, and fix docstring formatting (e.g., removed stray block markers) while preserving behavior.

autonomous_engine.py

@@ -38,18 +38,18 @@ def validate_input(func):
     async def wrapper(*args, **kwargs):
         if not args:
             return await func(*args, **kwargs)
-        
+
         # Check if this is an instance method (first arg is likely self)
         # For instance methods, the user input is typically the second argument
         user_input_idx = 1 if len(args) > 1 and hasattr(args[0], func.__name__) else 0
-        
+
         if user_input_idx >= len(args):
             return await func(*args, **kwargs)
-        
+
         # Basic input validation
         if len(str(args[user_input_idx] if args else "")) > 10000:  # 10KB limit
             raise ValidationError("Input too large")
-        
+
         # Sanitize input (remove potentially dangerous patterns)
         sanitized_input = str(args[user_input_idx] if args else "").strip()
         dangerous_patterns = [
@@ -59,15 +59,15 @@ def validate_input(func):
             r'eval\s*\(',
             r'exec\s*\('
         ]
-        
+
         for pattern in dangerous_patterns:
             if re.search(pattern, sanitized_input, re.IGNORECASE):
                 raise SecurityError(f"Dangerous content detected: {pattern}")
-        
+
         # Replace the user input argument with sanitized version
         new_args = list(args)
         new_args[user_input_idx] = sanitized_input
-        
+
         return await func(*new_args, **kwargs)
     return wrapper
 
@@ -75,17 +75,17 @@ def validate_input(func):
 def rate_limit(calls_per_minute: int = 60):
     """Decorator to implement rate limiting."""
     calls = []
-    
+
     def decorator(func):
         @wraps(func)
         async def wrapper(*args, **kwargs):
             now = datetime.utcnow()
             # Remove calls older than 1 minute
             calls[:] = [call for call in calls if (now - call).seconds < 60]
-            
+
             if len(calls) >= calls_per_minute:
                 raise SecurityError("Rate limit exceeded")
-            
+
             calls.append(now)
             return await func(*args, **kwargs)
         return wrapper
@@ -131,7 +131,7 @@ class Task:
     created_at: datetime = field(default_factory=datetime.utcnow)
     started_at: Optional[datetime] = None
     completed_at: Optional[datetime] = None
-    
+
     def __post_init__(self):
         """Validate task data."""
         if not self.id or not isinstance(self.id, str):
@@ -140,12 +140,12 @@ class Task:
             raise ValidationError("Estimated duration must be positive")
         if not self.title.strip():
             raise ValidationError("Task title cannot be empty")
-    
+
     @property
     def can_execute(self) -> bool:
         """Check if task can be executed (all dependencies completed)."""
         return self.status == TaskStatus.PENDING
-    
+
     def to_dict(self) -> Dict[str, Any]:
         """Convert task to dictionary for serialization."""
         return {
@@ -169,7 +169,7 @@ class Plan:
     created_at: datetime = field(default_factory=datetime.utcnow)
     estimated_completion: Optional[datetime] = None
     actual_completion: Optional[datetime] = None
-    
+
     def __post_init__(self):
         """Validate plan data."""
         if not self.id or not isinstance(self.id, str):
@@ -178,36 +178,36 @@ class Plan:
             raise ValidationError("Plan title cannot be empty")
         if not self.tasks:
             raise ValidationError("Plan must contain at least one task")
-    
+
     @property
     def task_count(self) -> int:
         """Get total number of tasks."""
         return len(self.tasks)
-    
+
     @property
     def critical_path(self) -> List[str]:
         """Calculate critical path (longest dependency chain)."""
         # Build dependency graph
         graph = defaultdict(list)
         in_degree = defaultdict(int)
-        
+
         for task in self.tasks:
             for dep in task.dependencies:
                 graph[dep].append(task.id)
                 in_degree[task.id] += 1
-            in_degree.setdefault(task.id, 0)
-        
+                in_degree.setdefault(task.id, 0)
+
         # Find critical path using topological sort with duration tracking
         queue = deque([task_id for task_id, degree in in_degree.items() if degree == 0])
         durations = {task_id: 0 for task_id in in_degree}
-        
+
         while queue:
             current = queue.popleft()
-            
+
             # Get current task duration
             current_task = next(t for t in self.tasks if t.id == current)
             current_duration = durations[current]
-            
+
             for neighbor in graph[current]:
                 # Update duration if path through current is longer
                 durations[neighbor] = max(
@@ -217,11 +217,11 @@ class Plan:
                 in_degree[neighbor] -= 1
                 if in_degree[neighbor] == 0:
                     queue.append(neighbor)
-        
+
         # Return path for longest duration
         max_duration_task = max(durations.items(), key=lambda x: x[1])[0]
         return [max_duration_task]
-    
+
     def to_dict(self) -> Dict[str, Any]:
         """Convert plan to dictionary for serialization."""
         return {
@@ -239,13 +239,13 @@ class Plan:
 
 class TaskDependencyGraph:
     """Efficient task dependency management using adjacency lists."""
-    
+
     def __init__(self, tasks: List[Task]):
         self.tasks = {task.id: task for task in tasks}
         self.graph = defaultdict(set)
         self.reverse_graph = defaultdict(set)
         self._build_graph()
-    
+
     def _build_graph(self) -> None:
         """Build adjacency lists for efficient traversal."""
         for task in self.tasks.values():
@@ -253,11 +253,11 @@ class TaskDependencyGraph:
                 if dep in self.tasks:
                     self.graph[dep].add(task.id)
                     self.reverse_graph[task.id].add(dep)
-    
+
     def can_execute(self, task_id: str, completed_tasks: Set[str]) -> bool:
         """Efficiently check if task can be executed."""
         return all(dep in completed_tasks for dep in self.reverse_graph.get(task_id, set()))
-    
+
     def get_executable_tasks(self, completed_tasks: Set[str]) -> List[str]:
         """Get all tasks that can be executed given completed tasks."""
         return [
@@ -268,13 +268,13 @@ class TaskDependencyGraph:
 
 class CachedReasoningEngine:
     """Reasoning engine with intelligent caching."""
-    
+
     def __init__(self, agent_name: str):
         self.agent_name = agent_name
         self.logger = logging.getLogger(f"{__name__}.{agent_name}")
         self.knowledge_base = {}
         self.decision_history = deque(maxlen=1000)  # Keep last 1000 decisions
-    
+
     @lru_cache(maxsize=1000)
     def _analyze_input_hash(self, user_input_hash: str) -> Dict[str, Any]:
         """Cached analysis to avoid recomputing identical requests."""
@@ -283,17 +283,17 @@ class CachedReasoningEngine:
             "analysis_id": user_input_hash,
             "timestamp": datetime.utcnow()
         }
-    
+
     def analyze_situation(self, user_input: str, context: Dict[str, Any]) -> Dict[str, Any]:
         """Analyze situation with caching and optimization."""
         # Use hash for caching identical inputs
         input_hash = hashlib.md5(user_input.encode()).hexdigest()
-        
+
         # Check cache first
         cached_result = self._analyze_input_hash(input_hash)
         if cached_result.get("cached"):
             self.logger.info(f"Using cached analysis for input hash: {input_hash[:8]}")
-        
+
         analysis = {
             "intent": self._extract_intent_optimized(user_input),
             "entities": self._extract_entities_optimized(user_input),
@@ -305,12 +305,12 @@ class CachedReasoningEngine:
             "cache_key": input_hash,
             "analysis_timestamp": datetime.utcnow().isoformat()
         }
-        
+
         # Store in knowledge base
         self.knowledge_base[input_hash] = analysis
-        
+
         return analysis
-    
+
     def _extract_intent_optimized(self, user_input: str) -> Dict[str, Any]:
         """Optimized intent extraction using compiled regex patterns."""
         intent_patterns = {
@@ -320,22 +320,22 @@ class CachedReasoningEngine:
             "problem_solving": re.compile(r'\b(fix|solve|resolve|troubleshoot|debug)\b', re.IGNORECASE),
             "creative_work": re.compile(r'\b(create|design|generate|write|build|develop)\b', re.IGNORECASE)
         }
-        
+
         user_input_lower = user_input.lower()
         detected_intents = []
-        
+
         # Use vectorized pattern matching
         for intent_type, pattern in intent_patterns.items():
             if pattern.search(user_input_lower):
                 detected_intents.append(intent_type)
-        
+
         return {
             "primary": detected_intents[0] if detected_intents else "general",
             "secondary": detected_intents[1:] if len(detected_intents) > 1 else [],
             "confidence": min(0.8 if detected_intents else 0.3, len(detected_intents) * 0.2 + 0.3),
             "pattern_matches": len(detected_intents)
         }
-    
+
     def _extract_entities_optimized(self, user_input: str) -> List[Dict[str, Any]]:
         """Optimized entity extraction using pre-compiled patterns."""
         # Pre-compiled patterns for better performance
@@ -346,7 +346,7 @@ class CachedReasoningEngine:
             "email": re.compile(r'\b[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Z|a-z]{2,}\b'),
             "url": re.compile(r'https?://[^\s]+')
         }
-        
+
         entities = []
         for entity_type, pattern in patterns.items():
             matches = pattern.findall(user_input)
@@ -356,35 +356,35 @@ class CachedReasoningEngine:
                     "value": match[0] if isinstance(match, tuple) else match,
                     "confidence": 0.9 if entity_type in ["email", "url"] else 0.7
                 })
-        
+
         return entities
-    
+
     def _assess_complexity_optimized(self, user_input: str) -> Dict[str, Any]:
         """Optimized complexity assessment using word frequency analysis."""
         complexity_weights = {
             "high": 3, "medium": 2, "low": 1
         }
-        
+
         complexity_keywords = {
             "high": ["plan", "strategy", "campaign", "project", "initiative", "comprehensive", "optimize"],
             "medium": ["create", "develop", "implement", "organize", "schedule", "improve"],
             "low": ["update", "check", "show", "find", "search", "simple"]
         }
-        
+
         user_input_lower = user_input.lower()
         words = re.findall(r'\b\w+\b', user_input_lower)
-        
+
         complexity_score = 0
         level_scores = defaultdict(int)
-        
+
         for word in words:
             for level, keywords in complexity_keywords.items():
                 if word in keywords:
                     level_scores[level] += complexity_weights[level]
                     complexity_score += complexity_weights[level]
-        
+
         detected_level = max(level_scores.items(), key=lambda x: x[1])[0] if level_scores else "low"
-        
+
         return {
             "level": detected_level,
             "score": min(complexity_score, 10),
@@ -393,7 +393,7 @@ class CachedReasoningEngine:
             "word_count": len(words),
             "keyword_matches": sum(level_scores.values())
         }
-    
+
     def _identify_constraints_optimized(self, user_input: str, context: Dict[str, Any]) -> List[Dict[str, Any]]:
         """Optimized constraint identification."""
         constraint_patterns = {
@@ -402,10 +402,10 @@ class CachedReasoningEngine:
             "resources": {"keywords": ["limited", "small", "minimal", "basic", "few"], "severity": "medium"},
             "quality": {"keywords": ["high", "premium", "professional", "enterprise"], "severity": "high"}
         }
-        
+
         constraints = []
         user_input_lower = user_input.lower()
-        
+
         for constraint_type, config in constraint_patterns.items():
             if any(keyword in user_input_lower for keyword in config["keywords"]):
                 constraints.append({
@@ -414,9 +414,9 @@ class CachedReasoningEngine:
                     "severity": config["severity"],
                     "keyword_match": next(k for k in config["keywords"] if k in user_input_lower)
                 })
-        
+
         return constraints
-    
+
     def _identify_opportunities_optimized(self, user_input: str, context: Dict[str, Any]) -> List[Dict[str, Any]]:
         """Optimized opportunity identification."""
         opportunity_patterns = {
@@ -425,10 +425,10 @@ class CachedReasoningEngine:
             "efficiency": {"keywords": ["optimize", "streamline", "automate", "simplify"], "impact": "medium"},
             "competitive": {"keywords": ["advantage", "edge", "better", "superior", "leading"], "impact": "high"}
         }
-        
+
         opportunities = []
         user_input_lower = user_input.lower()
-        
+
         for opportunity_type, config in opportunity_patterns.items():
             if any(keyword in user_input_lower for keyword in config["keywords"]):
                 opportunities.append({
@@ -437,9 +437,9 @@ class CachedReasoningEngine:
                     "potential_impact": config["impact"],
                     "keyword_match": next(k for k in config["keywords"] if k in user_input_lower)
                 })
-        
+
         return opportunities
-    
+
     def _assess_risks_optimized(self, user_input: str, context: Dict[str, Any]) -> List[Dict[str, Any]]:
         """Optimized risk assessment."""
         risk_patterns = {
@@ -448,10 +448,10 @@ class CachedReasoningEngine:
             "timeline": {"keywords": ["urgent", "deadline", "quickly", "asap"], "probability": "high", "impact": "high"},
             "quality": {"keywords": ["basic", "simple", "minimal"], "probability": "medium", "impact": "medium"}
         }
-        
+
         risks = []
         user_input_lower = user_input.lower()
-        
+
         for risk_type, config in risk_patterns.items():
             if any(keyword in user_input_lower for keyword in config["keywords"]):
                 risks.append({
@@ -461,9 +461,9 @@ class CachedReasoningEngine:
                     "impact": config["impact"],
                     "keyword_match": next(k for k in config["keywords"] if k in user_input_lower)
                 })
-        
+
         return risks
-    
+
     def _calculate_success_probability_optimized(self, user_input: str, context: Dict[str, Any]) -> float:
         """Optimized success probability calculation."""
         base_probability = 0.8
@@ -472,14 +472,14 @@ class CachedReasoningEngine:
             "constraint_penalty": 0,
             "opportunity_bonus": 0
         }
-        
+
         # Calculate complexity penalty
         complexity = self._assess_complexity_optimized(user_input)
         if complexity["level"] == "high":
             adjustments["complexity_penalty"] = 0.2
         elif complexity["level"] == "medium":
             adjustments["complexity_penalty"] = 0.1
-        
+
         # Calculate constraint penalty
         constraints = self._identify_constraints_optimized(user_input, context)
         for constraint in constraints:
@@ -487,14 +487,14 @@ class CachedReasoningEngine:
                 adjustments["constraint_penalty"] += 0.15
             else:
                 adjustments["constraint_penalty"] += 0.05
-        
+
         # Calculate opportunity bonus
         opportunities = self._identify_opportunities_optimized(user_input, context)
         adjustments["opportunity_bonus"] = len(opportunities) * 0.05
-        
+
         # Apply adjustments
         final_probability = base_probability - adjustments["complexity_penalty"] - adjustments["constraint_penalty"] + adjustments["opportunity_bonus"]
-        
+
         return max(0.1, min(0.95, final_probability))
 
 
@@ -504,7 +504,7 @@ class CachedReasoningEngine:
 
 class TaskFactory:
     """Factory class for creating standardized tasks."""
-    
+
     TASK_TEMPLATES = {
         "complex_task": [
             {
@@ -518,28 +518,28 @@ class TaskFactory:
                 "title": "Strategy Development",
                 "description": "Develop comprehensive strategy and approach",
                 "priority": Priority.HIGH,
-                "dependencies": ["assessment"],
+                "dependencies": ["task_1"],  # Depends on assessment
                 "duration": 45
             },
             {
                 "title": "Implementation Planning",
                 "description": "Create detailed implementation roadmap",
                 "priority": Priority.MEDIUM,
-                "dependencies": ["strategy"],
+                "dependencies": ["task_2"],  # Depends on strategy
                 "duration": 30
             },
             {
                 "title": "Execution & Monitoring",
                 "description": "Execute plan and monitor progress",
                 "priority": Priority.HIGH,
-                "dependencies": ["planning"],
+                "dependencies": ["task_3"],  # Depends on planning
                 "duration": 60
             },
             {
                 "title": "Review & Optimization",
                 "description": "Review results and optimize for better outcomes",
                 "priority": Priority.MEDIUM,
-                "dependencies": ["execution"],
+                "dependencies": ["task_4"],  # Depends on execution
                 "duration": 20
             }
         ],
@@ -555,21 +555,21 @@ class TaskFactory:
                 "title": "Solution Generation",
                 "description": "Generate multiple solution options",
                 "priority": Priority.HIGH,
-                "dependencies": ["analysis"],
+                "dependencies": ["task_1"],  # Depends on analysis
                 "duration": 25
             },
             {
                 "title": "Solution Evaluation",
                 "description": "Evaluate solutions and select the best approach",
                 "priority": Priority.HIGH,
-                "dependencies": ["generation"],
+                "dependencies": ["task_2"],  # Depends on generation
                 "duration": 15
             },
             {
                 "title": "Implementation",
                 "description": "Implement the chosen solution",
                 "priority": Priority.HIGH,
-                "dependencies": ["evaluation"],
+                "dependencies": ["task_3"],  # Depends on evaluation
                 "duration": 30
             }
         ],
@@ -583,7 +583,7 @@ class TaskFactory:
             }
         ]
     }
-    
+
     @classmethod
     def create_task(cls, template: Dict[str, Any], task_id: str, agent_name: str) -> Task:
         """Create a task from template with validation."""
@@ -597,13 +597,13 @@ class TaskFactory:
             assigned_agent=agent_name,
             estimated_duration=template["duration"]
         )
-    
+
     @classmethod
     def create_tasks_from_analysis(cls, analysis: Dict[str, Any], user_input: str, agent_name: str) -> List[Task]:
         """Create tasks based on analysis results."""
         intent = analysis.get("intent", {})
         primary_intent = intent.get("primary", "general")
-        
+
         # Select appropriate template
         if primary_intent in cls.TASK_TEMPLATES:
             template_key = primary_intent
@@ -611,68 +611,47 @@ class TaskFactory:
             template_key = "simple_request"
         else:
             template_key = "complex_task"  # Default fallback
-        
+
         # Generate unique task IDs
         tasks = []
-        task_counter = 1
+        template_list = cls.TASK_TEMPLATES[template_key]
         
-        for template in cls.TASK_TEMPLATES[template_key]:
-            # Create dependency mapping
-            task_deps = []
-            for dep in template["dependencies"]:
-                if dep == "assessment":
-                    task_deps.append(f"task_{task_counter - 5}")
-                elif dep == "strategy":
-                    task_deps.append(f"task_{task_counter - 4}")
-                elif dep == "planning":
-                    task_deps.append(f"task_{task_counter - 3}")
-                elif dep == "execution":
-                    task_deps.append(f"task_{task_counter - 2}")
-                elif dep == "analysis":
-                    task_deps.append(f"task_{task_counter - 4}")
-                elif dep == "generation":
-                    task_deps.append(f"task_{task_counter - 3}")
-                elif dep == "evaluation":
-                    task_deps.append(f"task_{task_counter - 2}")
-            
-            # Create task with updated dependencies
-            task_template = template.copy()
-            task_template["dependencies"] = task_deps
-            
-            task = cls.create_task(task_template, f"task_{task_counter}", agent_name)
+        # Create tasks with proper sequential dependencies
+        for i, template in enumerate(template_list):
+            task_id = f"task_{i + 1}"
+            task = cls.create_task(template, task_id, agent_name)
             tasks.append(task)
-            task_counter += 1
-        
+
         return tasks
 
 
 class OptimizedPlanningEngine:
     """Planning engine with performance optimizations and validation."""
-    
+
     def __init__(self, agent_name: str):
         self.agent_name = agent_name
         self.logger = logging.getLogger(f"{__name__}.{agent_name}")
         self.plans = {}
         self.execution_history = []
-    
+
     def create_plan(self, analysis: Dict[str, Any], user_input: str) -> Plan:
         """Create a comprehensive execution plan with validation."""
         try:
             # Generate plan ID with timestamp
             plan_id = f"plan_{self.agent_name}_{datetime.utcnow().strftime('%Y%m%d_%H%M%S_%f')}"
-            
+
             # Generate tasks using factory
             tasks = TaskFactory.create_tasks_from_analysis(analysis, user_input, self.agent_name)
-            
+
             # Generate success criteria based on intent
             success_criteria = self._generate_success_criteria(analysis, user_input)
-            
+
             # Generate fallback strategies based on risks
             fallback_strategies = self._generate_fallback_strategies(analysis)
-            
+
             # Calculate estimated completion time
             estimated_completion = self._calculate_completion_time(tasks)
-            
+
             # Create plan with validation
             plan = Plan(
                 id=plan_id,
@@ -684,23 +663,23 @@ class OptimizedPlanningEngine:
                 fallback_strategies=tuple(fallback_strategies),  # Immutable tuple
                 estimated_completion=estimated_completion
             )
-            
+
             # Store plan
             self.plans[plan_id] = plan
-            
+
             self.logger.info(f"Created plan {plan_id} with {len(tasks)} tasks")
-            
+
             return plan
-            
+
         except Exception as e:
             self.logger.error(f"Failed to create plan: {e}")
             raise ValidationError(f"Plan creation failed: {e}")
-    
+
     def _generate_success_criteria(self, analysis: Dict[str, Any], user_input: str) -> List[str]:
         """Generate success criteria based on analysis."""
         intent = analysis.get("intent", {})
         primary_intent = intent.get("primary", "general")
-        
+
         criteria_templates = {
             "complex_task": [
                 "All objectives clearly defined and measurable",
@@ -730,14 +709,14 @@ class OptimizedPlanningEngine:
                 "No errors or issues encountered"
             ]
         }
-        
+
         return criteria_templates.get(primary_intent, criteria_templates["general"])
-    
+
     def _generate_fallback_strategies(self, analysis: Dict[str, Any]) -> List[str]:
         """Generate fallback strategies based on identified risks."""
         risks = analysis.get("risks", [])
         strategies = []
-        
+
         # Risk-specific fallbacks
         risk_fallbacks = {
             "technical": "If technical issues arise, simplify approach and focus on core functionality",
@@ -745,12 +724,12 @@ class OptimizedPlanningEngine:
             "timeline": "If time constraints become critical, reduce scope and focus on essential deliverables",
             "quality": "If quality standards cannot be met, adjust expectations and deliver best possible outcome"
         }
-        
+
         for risk in risks:
             risk_type = risk.get("type", "")
             if risk_type in risk_fallbacks:
                 strategies.append(risk_fallbacks[risk_type])
-        
+
         # General fallbacks
         strategies.extend([
             "If initial approach fails, pivot to alternative strategy",
@@ -758,20 +737,20 @@ class OptimizedPlanningEngine:
             "If requirements change, adapt plan dynamically",
             "If user feedback indicates issues, implement immediate corrections"
         ])
-        
+
         return strategies
-    
+
     def _generate_plan_title(self, user_input: str) -> str:
         """Generate a descriptive plan title."""
         # Use first 50 characters of user input, cleaning it up
         clean_input = re.sub(r'[^\w\s]', '', user_input)[:50].strip()
-        
+
         if not clean_input:
             return f"Execution Plan for {self.agent_name}"
-        
+
         # Capitalize first letter of each word
         title = ' '.join(word.capitalize() for word in clean_input.split())
-        
+
         # Add appropriate prefix based on content
         if any(word in user_input.lower() for word in ["plan", "strategy"]):
             return f"Strategic Plan: {title}..."
@@ -781,17 +760,17 @@ class OptimizedPlanningEngine:
             return f"Creation Plan: {title}..."
         else:
             return f"Execution Plan: {title}..."
-    
+
     def _calculate_completion_time(self, tasks: List[Task]) -> datetime:
         """Calculate realistic completion time with buffer."""
         total_minutes = sum(task.estimated_duration for task in tasks)
-        
+
         # Add coordination and review buffer (20%)
         buffered_minutes = int(total_minutes * 1.2)
-        
+
         # Add minimum buffer of 5 minutes
         final_minutes = max(buffered_minutes, 5)
-        
+
         return datetime.utcnow() + timedelta(minutes=final_minutes)
 
 
@@ -806,7 +785,7 @@ class ExecutionError(Exception):
 
 class ExecutionContext:
     """Context manager for execution tracking."""
-    
+
     def __init__(self, execution_id: str, plan_id: str):
         self.execution_id = execution_id
         self.plan_id = plan_id
@@ -815,7 +794,7 @@ class ExecutionContext:
         self.adaptations_made = []
         self.metrics = {}
         self.task_results = {}
-    
+
     def log_decision(self, decision_type: str, task_id: str, decision: str) -> None:
         """Log an execution decision with timestamp."""
         self.decisions_made.append({
@@ -824,7 +803,7 @@ class ExecutionContext:
             "task_id": task_id,
             "decision": decision
         })
-    
+
     def log_adaptation(self, adaptation_type: str, task_id: str, adaptation: str) -> None:
         """Log an execution adaptation with timestamp."""
         self.adaptations_made.append({
@@ -833,7 +812,7 @@ class ExecutionContext:
             "task_id": task_id,
             "adaptation": adaptation
         })
-    
+
     @property
     def execution_time_minutes(self) -> float:
         """Calculate execution time in minutes."""
@@ -842,7 +821,7 @@ class ExecutionContext:
 
 class OptimizedExecutionEngine:
     """Execution engine with improved error handling and efficiency."""
-    
+
     def __init__(self, agent_name: str):
         self.agent_name = agent_name
         self.logger = logging.getLogger(f"{__name__}.{agent_name}")
@@ -850,54 +829,59 @@ class OptimizedExecutionEngine:
         self.execution_metrics = {}
         self.max_retries = 3
         self.retry_delay = 1.0  # seconds
-    
+
     @asynccontextmanager
     async def execution_context(self, plan: Plan):
         """Context manager for execution tracking."""
         execution_id = f"exec_{plan.id}_{datetime.utcnow().strftime('%Y%m%d_%H%M%S')}"
         context = ExecutionContext(execution_id, plan.id)
-        
+
         self.active_executions[execution_id] = context
-        
+
         try:
             yield context
         finally:
             del self.active_executions[execution_id]
-    
+
     async def execute_plan(self, plan: Plan) -> Dict[str, Any]:
         """Execute plan with comprehensive error handling and retry logic."""
         async with self.execution_context(plan) as context:
             try:
                 self.logger.info(f"Starting execution of plan {plan.id}")
-                
+
                 # Create efficient dependency graph
                 dependency_graph = TaskDependencyGraph(plan.tasks)
                 completed_tasks = set()
                 failed_tasks = []
-                
+
                 # Execute tasks using efficient dependency checking
-                while True:
+                max_iterations = len(plan.tasks) * 2  # Prevent infinite loops
+                iteration_count = 0
+                
+                while iteration_count < max_iterations:
+                    iteration_count += 1
+                    
                     # Get executable tasks
                     executable_tasks = dependency_graph.get_executable_tasks(completed_tasks)
-                    
+
                     if not executable_tasks:
                         # No more tasks can be executed
                         break
-                    
+
                     # Execute tasks (can be parallelized in future)
-                    for task_id in executable_tasks:
+                    for task_id in executable_tasks[:1]:  # Process one task at a time to prevent loops
                         task = next(t for t in plan.tasks if t.id == task_id)
-                        
+
                         try:
                             task_result = await self._execute_task_with_retry(
                                 task, context, max_retries=self.max_retries
                             )
-                            
+
                             if task_result["success"]:
                                 # Task completed successfully - track in completed set
                                 completed_tasks.add(task_id)
                                 context.task_results[task_id] = task_result
-                                
+
                                 self.logger.info(f"Task {task_id} completed successfully")
                             else:
                                 # Task failed, try fallback
@@ -905,33 +889,33 @@ class OptimizedExecutionEngine:
                                 fallback_result = await self._handle_task_failure(
                                     task, plan, context, task_result
                                 )
-                                
+
                                 if fallback_result["success"]:
                                     # Fallback succeeded - track in completed set
                                     completed_tasks.add(task_id)
                                     context.task_results[task_id] = fallback_result
-                                    
+
                                     self.logger.info(f"Task {task_id} completed via fallback")
                                 else:
                                     # Critical failure - attempt plan adaptation
                                     self.logger.warning(f"Task {task_id} failed completely, attempting plan adaptation")
-                                    
+
                                     # Attempt plan adaptation
                                     adaptation_result = await self._adapt_plan(
                                         plan, task, context
                                     )
-                                    
+
                                     if not adaptation_result["success"]:
                                         self.logger.error(f"Critical failure in plan execution")
                                         break
-                        
+
                         except Exception as e:
                             self.logger.error(f"Unexpected error executing task {task_id}: {e}")
                             failed_tasks.append(task_id)
-                
+
                 # Calculate final metrics
                 success_rate = len(completed_tasks) / len(plan.tasks) if plan.tasks else 0
-                
+
                 execution_result = {
                     "success": len(failed_tasks) == 0,
                     "completed_tasks": len(completed_tasks),
@@ -944,14 +928,14 @@ class OptimizedExecutionEngine:
                     "execution_id": context.execution_id,
                     "plan_id": plan.id
                 }
-                
+
                 # Store metrics
                 self.execution_metrics[context.execution_id] = execution_result
-                
+
                 self.logger.info(f"Execution completed: {success_rate:.1%} success rate")
-                
+
                 return execution_result
-                
+
             except Exception as e:
                 self.logger.error(f"Execution failed with error: {e}")
                 return {
@@ -960,7 +944,7 @@ class OptimizedExecutionEngine:
                     "execution_time_minutes": context.execution_time_minutes,
                     "execution_id": context.execution_id
                 }
-    
+
     async def _execute_task_with_retry(self, task: Task, context: ExecutionContext, max_retries: int = 3) -> Dict[str, Any]:
         """Execute task with retry logic and exponential backoff."""
         for attempt in range(max_retries + 1):
@@ -980,26 +964,26 @@ class OptimizedExecutionEngine:
                     delay = self.retry_delay * (2 ** attempt)
                     self.logger.warning(f"Task {task.id} failed (attempt {attempt + 1}), retrying in {delay}s")
                     await asyncio.sleep(delay)
-        
+
         # Should not reach here
         return {"success": False, "error": "Max retries exceeded"}
-    
+
     async def _execute_task(self, task: Task, context: ExecutionContext) -> Dict[str, Any]:
         """Execute a single task with improved error handling."""
         # Log execution decision
         context.log_decision("task_execution", task.id, f"Executing task: {task.title}")
-        
+
         start_time = datetime.utcnow()
-        
+
         try:
             # Simulate realistic task execution time
             await asyncio.sleep(min(task.estimated_duration / 60.0, 0.1))  # Max 0.1s for demo
-            
+
             # Generate task-specific result based on title patterns
             result = await self._generate_task_result(task)
-            
+
             self.logger.info(f"Task {task.id} executed successfully")
-            
+
             return {
                 "success": True,
                 "result": result,
@@ -1007,7 +991,7 @@ class OptimizedExecutionEngine:
                 "started_at": start_time.isoformat(),
                 "completed_at": datetime.utcnow().isoformat()
             }
-            
+
         except Exception as e:
             self.logger.error(f"Task {task.id} execution failed: {e}")
             return {
@@ -1016,11 +1000,11 @@ class OptimizedExecutionEngine:
                 "duration": (datetime.utcnow() - start_time).total_seconds() / 60,
                 "started_at": start_time.isoformat()
             }
-    
+
     async def _generate_task_result(self, task: Task) -> str:
         """Generate task-specific results using templates."""
         title_lower = task.title.lower()
-        
+
         result_templates = {
             "assessment": """
 Assessment Completed for {title}:
@@ -1036,7 +1020,7 @@ Key Findings:
 • Multiple approaches evaluated
 • Resource requirements assessed
 • Timeline implications identified
-            """,
+""",
             "strategy": """
 Strategic Planning Completed for {title}:
 
@@ -1051,7 +1035,7 @@ Strategic Elements:
 • Phased implementation approach
 • Contingency plans prepared
 • Performance tracking framework
-            """,
+""",
             "implementation": """
 Implementation Completed for {title}:
 
@@ -1066,7 +1050,7 @@ Execution Results:
 • Quality standards maintained
 • Timeline adherence achieved
 • Stakeholder expectations fulfilled
-            """,
+""",
             "review": """
 Review and Optimization Completed for {title}:
 
@@ -1081,9 +1065,9 @@ Optimization Results:
 • Process refinements recommended
 • Best practices captured
 • Future enhancement opportunities noted
-            """
+"""
         }
-        
+
         # Select template based on title
         if "assessment" in title_lower or "analysis" in title_lower:
             template = result_templates["assessment"]
@@ -1112,14 +1096,14 @@ Task Outcome:
 • Expected results delivered
 • No issues encountered
 • Ready for next phase
-            """
-    
-    async def _handle_task_failure(self, task: Task, plan: Plan, context: ExecutionContext, 
-                                   original_result: Dict[str, Any]) -> Dict[str, Any]:
+"""
+
+    async def _handle_task_failure(self, task: Task, plan: Plan, context: ExecutionContext,
+                                  original_result: Dict[str, Any]) -> Dict[str, Any]:
         """Handle task failures using intelligent fallback strategies."""
-        context.log_adaptation("failure_handling", task.id, 
-                             f"Applying fallback strategy for failed task: {task.title}")
-        
+        context.log_adaptation("failure_handling", task.id,
+                              f"Applying fallback strategy for failed task: {task.title}")
+
         # Try fallback strategies in order
         for strategy in plan.fallback_strategies:
             try:
@@ -1136,11 +1120,11 @@ Task Outcome:
                         assigned_agent=task.assigned_agent,
                         estimated_duration=simplified_duration
                     )
-                    
+
                     result = await self._execute_task(simplified_task, context)
                     if result["success"]:
                         return result
-                
+
                 elif "pivot" in strategy.lower():
                     # Alternative approach
                     return {
@@ -1148,7 +1132,7 @@ Task Outcome:
                         "result": f"Successfully pivoted to alternative approach for: {task.title}",
                         "duration": 5
                     }
-                
+
                 elif "adapt" in strategy.lower():
                     # Dynamic adaptation
                     return {
@@ -1156,38 +1140,38 @@ Task Outcome:
                         "result": f"Dynamically adapted approach for: {task.title}",
                         "duration": 10
                     }
-            
+
             except Exception as e:
                 self.logger.warning(f"Fallback strategy failed for task {task.id}: {e}")
                 continue
-        
+
         # All fallbacks failed
         return {
-            "success": False, 
+            "success": False,
             "error": "All fallback strategies exhausted",
             "original_error": original_result.get("error")
         }
-    
+
     async def _adapt_plan(self, plan: Plan, failed_task: Task, context: ExecutionContext) -> Dict[str, Any]:
         """Adapt plan when critical failures occur."""
         context.log_adaptation("plan_adaptation", failed_task.id,
-                             "Plan adapted due to critical task failure")
-        
+                              "Plan adapted due to critical task failure")
+
         # Find dependent tasks
         dependent_tasks = [
             task for task in plan.tasks
             if failed_task.id in task.dependencies
         ]
-        
+
         # Calculate impact
         tasks_to_remove = [failed_task.id] + [task.id for task in dependent_tasks]
-        
+
         # Create new plan with remaining tasks (immutable approach)
         remaining_tasks = [
             task for task in plan.tasks
             if task.id not in tasks_to_remove
         ]
-        
+
         if not remaining_tasks:
             self.logger.error("Plan cannot continue - all tasks failed")
             return {
@@ -1206,9 +1190,9 @@ Task Outcome:
                 fallback_strategies=plan.fallback_strategies,
                 created_at=plan.created_at
             )
-            
+
             self.logger.info(f"Plan adapted - removed {len(tasks_to_remove)} tasks, {len(remaining_tasks)} remaining")
-            
+
             return {
                 "success": True,
                 "message": f"Plan adapted - removed {len(tasks_to_remove)} failed tasks, {len(remaining_tasks)} tasks remaining",
@@ -1223,22 +1207,22 @@ Task Outcome:
 
 class RefactoredAutonomousAgent:
     """Main autonomous agent class with enhanced security, performance, and documentation."""
-    
+
     def __init__(self, agent_name: str):
         """
         Initialize the autonomous agent with optimized components.
-        
+
         Args:
             agent_name: Unique identifier for the agent instance
         """
         self.agent_name = agent_name
         self.logger = logging.getLogger(f"{__name__}.{agent_name}")
-        
+
         # Initialize optimized engines
         self.reasoning_engine = CachedReasoningEngine(agent_name)
         self.planning_engine = OptimizedPlanningEngine(agent_name)
         self.execution_engine = OptimizedExecutionEngine(agent_name)
-        
+
         # Performance tracking
         self.performance_metrics = {
             "requests_processed": 0,
@@ -1246,28 +1230,28 @@ class RefactoredAutonomousAgent:
             "failed_executions": 0,
             "average_response_time": 0.0
         }
-        
+
         self.logger.info(f"Autonomous agent {agent_name} initialized")
-    
+
     @rate_limit(calls_per_minute=100)  # Rate limit: 100 requests per minute
     @validate_input  # Validate and sanitize input
     async def process_request(self, user_input: str, context: Dict[str, Any] = None) -> Dict[str, Any]:
         """
         Process user request with comprehensive autonomous behavior.
-        
+
         This method orchestrates the complete autonomous workflow:
         1. Analyze the situation and extract insights
         2. Create a detailed execution plan
         3. Execute the plan with error handling
         4. Compile comprehensive results
-        
+
         Args:
             user_input: The user's request or command
             context: Additional context information (optional)
-            
+
         Returns:
             Dict containing complete analysis, plan, execution results, and summary
-            
+
         Raises:
             ValidationError: If input validation fails
             SecurityError: If security checks fail
@@ -1275,42 +1259,42 @@ class RefactoredAutonomousAgent:
         """
         if context is None:
             context = {}
-        
+
         start_time = datetime.utcnow()
         self.performance_metrics["requests_processed"] += 1
-        
+
         try:
             self.logger.info(f"Processing request: {user_input[:100]}...")
-            
+
             # Step 1: Reasoning and Analysis
             self.logger.debug("Starting situation analysis")
             analysis = await self._analyze_situation_async(user_input, context)
-            
+
             # Step 2: Planning
             self.logger.debug("Creating execution plan")
             plan = await self._create_plan_async(analysis, user_input)
-            
+
             # Step 3: Execution
             self.logger.debug("Executing plan")
             execution_result = await self._execute_plan_async(plan)
-            
+
             # Step 4: Compile Response
             response = await self._compile_response_async(
                 user_input, analysis, plan, execution_result
             )
-            
+
             # Update performance metrics
             response_time = (datetime.utcnow() - start_time).total_seconds()
             self._update_performance_metrics(response_time, execution_result["success"])
-            
+
             self.logger.info(f"Request processed successfully in {response_time:.2f}s")
-            
+
             return response
-            
+
         except (ValidationError, SecurityError, ExecutionError) as e:
             self.logger.error(f"Processing failed: {e}")
             self.performance_metrics["failed_executions"] += 1
-            
+
             return {
                 "agent_name": self.agent_name,
                 "user_input": user_input,
@@ -1319,28 +1303,28 @@ class RefactoredAutonomousAgent:
                 "success": False,
                 "processing_time": (datetime.utcnow() - start_time).total_seconds()
             }
-    
+
     async def _analyze_situation_async(self, user_input: str, context: Dict[str, Any]) -> Dict[str, Any]:
         """Asynchronous situation analysis with performance optimization."""
         # For CPU-intensive operations, we could use thread pool
         # For now, keeping synchronous for simplicity
         return self.reasoning_engine.analyze_situation(user_input, context)
-    
+
     async def _create_plan_async(self, analysis: Dict[str, Any], user_input: str) -> Plan:
         """Asynchronous plan creation with validation."""
         return self.planning_engine.create_plan(analysis, user_input)
-    
+
     async def _execute_plan_async(self, plan: Plan) -> Dict[str, Any]:
         """Asynchronous plan execution with comprehensive error handling."""
         return await self.execution_engine.execute_plan(plan)
-    
-    async def _compile_response_async(self, user_input: str, analysis: Dict[str, Any], 
-                                    plan: Plan, execution_result: Dict[str, Any]) -> Dict[str, Any]:
+
+    async def _compile_response_async(self, user_input: str, analysis: Dict[str, Any],
+                                     plan: Plan, execution_result: Dict[str, Any]) -> Dict[str, Any]:
         """Compile comprehensive response with all information."""
         intent = analysis.get("intent", {})
         complexity = analysis.get("complexity", {})
         success_rate = execution_result.get("success_rate", 0)
-        
+
         # Generate detailed summary
         summary_parts = [
             f"🧠 **Reasoning**: Detected {intent.get('primary', 'general')} intent "
@@ -1352,17 +1336,17 @@ class RefactoredAutonomousAgent:
             f"⚡ **Execution**: {execution_result.get('completed_tasks', 0)} tasks completed, "
             f"{success_rate:.0%} success rate"
         ]
-        
+
         if execution_result.get("adaptations_made", 0) > 0:
             summary_parts.append(
                 f"🔄 **Adaptation**: Made {execution_result['adaptations_made']} autonomous adaptations"
             )
-        
+
         if execution_result.get("decisions_made", 0) > 0:
             summary_parts.append(
                 f"💡 **Decisions**: Made {execution_result['decisions_made']} autonomous decisions"
             )
-        
+
         # Compile comprehensive response
         response = {
             "agent_name": self.agent_name,
@@ -1383,24 +1367,24 @@ class RefactoredAutonomousAgent:
                 "analysis_version": "2.0"
             }
         }
-        
+
         return response
-    
+
     def _update_performance_metrics(self, response_time: float, success: bool) -> None:
         """Update performance metrics with exponential moving average."""
         if not hasattr(self, 'performance_metrics'):
             return
-            
+
         if success:
             self.performance_metrics["successful_executions"] += 1
-        
+
         # Update average response time using exponential moving average
         alpha = 0.1  # Smoothing factor
         current_avg = self.performance_metrics.get("average_response_time", 0.0)
         self.performance_metrics["average_response_time"] = (
             alpha * response_time + (1 - alpha) * current_avg
         )
-    
+
     def get_performance_report(self) -> Dict[str, Any]:
         """Get detailed performance report."""
         total_requests = self.performance_metrics["requests_processed"]
@@ -1408,7 +1392,7 @@ class RefactoredAutonomousAgent:
             self.performance_metrics["successful_executions"] / total_requests
             if total_requests > 0 else 0
         )
-        
+
         return {
             "agent_name": self.agent_name,
             "total_requests": total_requests,
@@ -1421,13 +1405,13 @@ class RefactoredAutonomousAgent:
 
 
 # ============================================================================
-# DEMO AND TESTING FUNCTIONS
+# DEMOS AND TESTING FUNCTIONS
 # ============================================================================
 
 async def demo_refactored_autonomous_behavior():
     """
     Demonstrate the refactored autonomous agent behavior.
-    
+
     This demo shows:
     - Improved performance through caching
     - Better error handling and recovery
@@ -1435,50 +1419,50 @@ async def demo_refactored_autonomous_behavior():
     - Comprehensive logging and monitoring
     """
     agent = RefactoredAutonomousAgent("DemoAgent_v2")
-    
+
     test_cases = [
         "Create a comprehensive marketing campaign for our new product launch",
         "Solve the customer service response time issues with detailed analysis",
         "Plan a strategy to increase customer retention by 25% with implementation",
         "Update our quarterly sales report with performance metrics"
     ]
-    
+
     print("🤖 REFACTORED AUTONOMOUS AGENT BEHAVIOR DEMONSTRATION")
     print("=" * 70)
     print("Features: Enhanced Performance | Better Security | Improved Error Handling")
     print()
-    
+
     for i, test_case in enumerate(test_cases, 1):
         print(f"📝 Test Case {i}: {test_case}")
         print("-" * 50)
-        
+
         try:
             start_time = datetime.utcnow()
             result = await agent.process_request(test_case)
             end_time = datetime.utcnow()
-            
+
             processing_time = (end_time - start_time).total_seconds()
-            
+
             print(f"✅ Overall Success: {result['overall_success']}")
             print(f"📊 {result['summary']}")
             print(f"🎯 Plan: {result['plan']['title']}")
             print(f"⏱️ Processing Time: {processing_time:.2f}s")
-            
+
             # Show performance metrics for complex requests
             if 'performance' in result:
                 perf = result['performance']
                 print(f"📈 Performance: {perf['response_time_ms']:.0f}ms response time")
                 if perf.get('cache_hit'):
                     print("⚡ Cache hit - optimized performance!")
-            
+
             if not result['overall_success']:
                 print(f"⚠️ Execution Issues: {result.get('error', 'Partial failure')}")
-                
+
         except Exception as e:
             print(f"❌ Error processing request: {e}")
-        
+
         print()
-    
+
     # Show performance report
     print("📊 PERFORMANCE REPORT")
     print("-" * 30)
@@ -1503,6 +1487,6 @@ if __name__ == "__main__":
         level=logging.INFO,
         format='%(asctime)s - %(name)s - %(levelname)s - %(message)s'
     )
-    
+
     # Run the demonstration
     asyncio.run(demo_refactored_autonomous_behavior())