test(agents): add comprehensive tests for new agents and orchestration

- Add integration tests for José Bonifácio and Maria Quitéria agents
- Test policy-security compliance workflow integration
- Create security-driven policy recommendations tests
- Add parallel agent execution tests
- Implement advanced orchestration tests with multiple patterns
- Add comprehensive performance tests with defined targets
- Test individual agent response times and throughput
- Implement multi-agent pipeline performance tests

tests/integration/test_new_agents_integration.py

@@ -0,0 +1,424 @@
+"""
+Integration tests for José Bonifácio and Maria Quitéria agents.
+Tests agent interactions, coordination, and complete workflows.
+"""
+
+import pytest
+import asyncio
+from datetime import datetime
+from uuid import uuid4
+from unittest.mock import AsyncMock, patch
+
+from src.agents import (
+    BonifacioAgent,
+    MariaQuiteriaAgent,
+    MasterAgent,
+    ZumbiAgent,
+    AgentContext,
+    AgentMessage
+)
+from src.models.agent import AgentStatus
+from src.services.investigation_service import InvestigationService
+
+
+@pytest.fixture
+async def investigation_service():
+    """Create investigation service for tests."""
+    service = InvestigationService()
+    return service
+
+
+@pytest.fixture
+def investigation_context():
+    """Create investigation context for integration tests."""
+    return AgentContext(
+        investigation_id=str(uuid4()),
+        user_id="integration-tester",
+        session_id=str(uuid4()),
+        metadata={
+            "test_type": "integration",
+            "agents": ["bonifacio", "maria_quiteria"],
+            "timestamp": datetime.utcnow().isoformat()
+        }
+    )
+
+
+class TestBonifacioMariaQuiteriaIntegration:
+    """Integration tests for Bonifácio and Maria Quitéria agents."""
+    
+    @pytest.mark.integration
+    @pytest.mark.asyncio
+    async def test_policy_security_compliance_workflow(self, investigation_context):
+        """Test complete workflow: policy analysis + security compliance check."""
+        # Initialize agents
+        bonifacio = BonifacioAgent()
+        maria_quiteria = MariaQuiteriaAgent()
+        
+        # Step 1: Analyze policy with Bonifácio
+        policy_message = AgentMessage(
+            type="policy_analysis",
+            data={
+                "policy_name": "Sistema Nacional de Dados Sensíveis",
+                "policy_area": "security",
+                "budget_data": {
+                    "planned": 10_000_000,
+                    "executed": 9_500_000
+                }
+            },
+            sender="master",
+            metadata={"step": "policy_analysis"}
+        )
+        
+        policy_response = await bonifacio.process(policy_message, investigation_context)
+        
+        assert policy_response.success is True
+        assert "policy_evaluation" in policy_response.data
+        
+        # Step 2: Check security compliance based on policy
+        security_message = AgentMessage(
+            type="security_audit",
+            data={
+                "system_name": "Sistema Nacional de Dados Sensíveis",
+                "policy_requirements": policy_response.data["policy_evaluation"],
+                "compliance_frameworks": ["LGPD", "ISO27001"]
+            },
+            sender="bonifacio",
+            metadata={"step": "security_verification"}
+        )
+        
+        security_response = await maria_quiteria.process(security_message, investigation_context)
+        
+        assert security_response.success is True
+        assert "security_assessment" in security_response.data
+        
+        # Verify cross-agent data flow
+        compliance_status = security_response.data["security_assessment"]["compliance_status"]
+        assert "LGPD" in compliance_status
+        assert compliance_status["LGPD"] > 0.7  # Policy should ensure good compliance
+    
+    @pytest.mark.integration
+    @pytest.mark.asyncio
+    async def test_multi_agent_investigation_with_new_agents(self, investigation_service, investigation_context):
+        """Test complete investigation involving all agents including new ones."""
+        
+        # Mock external data sources
+        with patch("src.services.data_service.TransparencyAPIClient") as mock_api:
+            mock_api.return_value.search_contracts.return_value = [{
+                "id": "contract-123",
+                "valor": 5_000_000,
+                "objeto": "Sistema de Segurança Digital com Compliance LGPD",
+                "fornecedor": "TechSec Solutions",
+                "modalidade": "Pregão Eletrônico",
+                "data_assinatura": "2024-01-15"
+            }]
+            
+            # Create investigation request
+            investigation_request = {
+                "query": "Investigar contrato de sistema de segurança com compliance",
+                "investigation_type": "comprehensive",
+                "include_agents": ["zumbi", "bonifacio", "maria_quiteria"]
+            }
+            
+            # Execute investigation
+            result = await investigation_service.create_investigation(
+                request=investigation_request,
+                user_id=investigation_context.user_id
+            )
+            
+            investigation_id = result["investigation_id"]
+            
+            # Wait for investigation to complete (with timeout)
+            max_attempts = 30
+            for _ in range(max_attempts):
+                status = await investigation_service.get_investigation_status(investigation_id)
+                if status["status"] in ["completed", "failed"]:
+                    break
+                await asyncio.sleep(1)
+            
+            # Verify investigation results
+            assert status["status"] == "completed"
+            assert "agents_involved" in status
+            
+            # Check that all requested agents participated
+            agents_involved = status["agents_involved"]
+            assert "zumbi" in agents_involved
+            assert "bonifacio" in agents_involved
+            assert "maria_quiteria" in agents_involved
+    
+    @pytest.mark.integration
+    @pytest.mark.asyncio
+    async def test_security_driven_policy_recommendations(self, investigation_context):
+        """Test workflow: security issues trigger policy recommendations."""
+        
+        bonifacio = BonifacioAgent()
+        maria_quiteria = MariaQuiteriaAgent()
+        
+        # Step 1: Security audit finds vulnerabilities
+        security_audit_msg = AgentMessage(
+            type="security_audit",
+            data={
+                "system_name": "Portal Transparência",
+                "audit_scope": "comprehensive"
+            },
+            sender="master",
+            metadata={}
+        )
+        
+        security_result = await maria_quiteria.process(security_audit_msg, investigation_context)
+        
+        # Step 2: Based on security findings, get policy recommendations
+        policy_request_msg = AgentMessage(
+            type="policy_analysis",
+            data={
+                "policy_name": "Política de Segurança Digital",
+                "security_findings": security_result.data["security_assessment"],
+                "focus_area": "security_improvements"
+            },
+            sender="maria_quiteria",
+            metadata={"triggered_by": "security_audit"}
+        )
+        
+        policy_result = await bonifacio.process(policy_request_msg, investigation_context)
+        
+        # Verify recommendations address security issues
+        recommendations = policy_result.data["strategic_recommendations"]
+        assert len(recommendations) > 0
+        
+        # At least one recommendation should address security
+        security_related = any(
+            "security" in rec.get("area", "").lower() or 
+            "compliance" in rec.get("area", "").lower()
+            for rec in recommendations
+        )
+        assert security_related is True
+    
+    @pytest.mark.integration
+    @pytest.mark.asyncio
+    async def test_parallel_agent_execution(self, investigation_context):
+        """Test parallel execution of Bonifácio and Maria Quitéria."""
+        
+        bonifacio = BonifacioAgent()
+        maria_quiteria = MariaQuiteriaAgent()
+        
+        # Create messages for parallel execution
+        policy_msg = AgentMessage(
+            type="policy_analysis",
+            data="Programa Nacional de Cibersegurança",
+            sender="master",
+            metadata={}
+        )
+        
+        security_msg = AgentMessage(
+            type="security_audit",
+            data="Sistema Nacional de Cibersegurança",
+            sender="master",
+            metadata={}
+        )
+        
+        # Execute agents in parallel
+        start_time = datetime.utcnow()
+        
+        policy_task = asyncio.create_task(
+            bonifacio.process(policy_msg, investigation_context)
+        )
+        security_task = asyncio.create_task(
+            maria_quiteria.process(security_msg, investigation_context)
+        )
+        
+        # Wait for both to complete
+        policy_response, security_response = await asyncio.gather(
+            policy_task, security_task
+        )
+        
+        end_time = datetime.utcnow()
+        execution_time = (end_time - start_time).total_seconds()
+        
+        # Verify both completed successfully
+        assert policy_response.success is True
+        assert security_response.success is True
+        
+        # Verify parallel execution (should take less time than sequential)
+        # Both agents have ~2-3 second simulated delays
+        assert execution_time < 5  # Should complete in under 5 seconds if parallel
+    
+    @pytest.mark.integration
+    @pytest.mark.asyncio
+    async def test_agent_error_recovery(self, investigation_context):
+        """Test error handling and recovery between agents."""
+        
+        bonifacio = BonifacioAgent()
+        maria_quiteria = MariaQuiteriaAgent()
+        
+        # Force an error in Bonifácio
+        with patch.object(bonifacio, '_evaluate_policy', side_effect=Exception("Policy database error")):
+            policy_msg = AgentMessage(
+                type="policy_analysis",
+                data={"policy_name": "Test Policy"},
+                sender="master",
+                metadata={}
+            )
+            
+            policy_response = await bonifacio.process(policy_msg, investigation_context)
+            assert policy_response.success is False
+        
+        # Maria Quitéria should still work independently
+        security_msg = AgentMessage(
+            type="security_audit",
+            data={"system_name": "Test System"},
+            sender="master",
+            metadata={"note": "bonifacio_failed"}
+        )
+        
+        security_response = await maria_quiteria.process(security_msg, investigation_context)
+        assert security_response.success is True
+    
+    @pytest.mark.integration
+    @pytest.mark.asyncio
+    async def test_comprehensive_compliance_workflow(self, investigation_context):
+        """Test complete compliance verification workflow."""
+        
+        # This tests the full cycle:
+        # 1. Zumbi detects anomaly
+        # 2. Maria Quitéria performs security audit
+        # 3. Bonifácio analyzes policy compliance
+        # 4. Results are consolidated
+        
+        zumbi = ZumbiAgent()
+        maria_quiteria = MariaQuiteriaAgent()
+        bonifacio = BonifacioAgent()
+        
+        # Step 1: Anomaly detection
+        anomaly_msg = AgentMessage(
+            type="analyze",
+            data={
+                "contract_data": {
+                    "valor": 10_000_000,
+                    "objeto": "Sistema de Compliance Integrado",
+                    "fornecedor": "ComplianceTech"
+                }
+            },
+            sender="master",
+            metadata={}
+        )
+        
+        with patch("src.agents.zumbi.ZumbiAgent._fetch_contract_details") as mock_fetch:
+            mock_fetch.return_value = {
+                "id": "123",
+                "valor": 10_000_000,
+                "objeto": "Sistema de Compliance Integrado"
+            }
+            
+            anomaly_response = await zumbi.process(anomaly_msg, investigation_context)
+        
+        # Step 2: Security audit based on anomaly
+        if anomaly_response.data.get("anomalies_detected", 0) > 0:
+            security_msg = AgentMessage(
+                type="security_audit",
+                data={
+                    "system_name": "Sistema de Compliance Integrado",
+                    "triggered_by": "anomaly_detection",
+                    "anomaly_details": anomaly_response.data
+                },
+                sender="zumbi",
+                metadata={}
+            )
+            
+            security_response = await maria_quiteria.process(security_msg, investigation_context)
+            
+            # Step 3: Policy compliance check
+            policy_msg = AgentMessage(
+                type="policy_analysis",
+                data={
+                    "policy_name": "Política de Compliance e Segurança",
+                    "security_assessment": security_response.data,
+                    "contract_value": 10_000_000
+                },
+                sender="maria_quiteria",
+                metadata={}
+            )
+            
+            policy_response = await bonifacio.process(policy_msg, investigation_context)
+            
+            # Verify complete workflow
+            assert anomaly_response.success is True
+            assert security_response.success is True
+            assert policy_response.success is True
+            
+            # Results should be interconnected
+            assert "security_assessment" in security_response.data
+            assert "policy_evaluation" in policy_response.data
+
+
+class TestAgentCoordinationPatterns:
+    """Test various agent coordination patterns."""
+    
+    @pytest.mark.integration
+    @pytest.mark.asyncio
+    async def test_sequential_agent_pipeline(self, investigation_context):
+        """Test sequential processing pipeline with data passing."""
+        
+        agents = [
+            ZumbiAgent(),
+            MariaQuiteriaAgent(),
+            BonifacioAgent()
+        ]
+        
+        # Initial data
+        current_data = {
+            "investigation_subject": "Contrato de Software de Segurança",
+            "initial_value": 5_000_000
+        }
+        
+        # Process through pipeline
+        for i, agent in enumerate(agents):
+            message = AgentMessage(
+                type="analyze",
+                data=current_data,
+                sender=f"agent_{i-1}" if i > 0 else "master",
+                metadata={"pipeline_step": i}
+            )
+            
+            response = await agent.process(message, investigation_context)
+            assert response.success is True
+            
+            # Pass data forward
+            current_data.update({
+                f"{agent.name}_result": response.data
+            })
+        
+        # Verify all agents contributed
+        assert "InvestigatorAgent_result" in current_data
+        assert "MariaQuiteriaAgent_result" in current_data
+        assert "BonifacioAgent_result" in current_data
+    
+    @pytest.mark.integration
+    @pytest.mark.asyncio
+    async def test_fan_out_fan_in_pattern(self, investigation_context):
+        """Test fan-out/fan-in pattern with result aggregation."""
+        
+        # Master coordinates multiple specialized agents
+        master = MasterAgent()
+        
+        # Create complex investigation request
+        investigation_msg = AgentMessage(
+            type="investigate",
+            data={
+                "query": "Análise completa de contrato com aspectos de segurança e compliance",
+                "contract_id": "complex-123",
+                "include_analysis": ["anomaly", "security", "policy"]
+            },
+            sender="user",
+            metadata={}
+        )
+        
+        # Mock the investigation service to control agent responses
+        with patch("src.agents.abaporu.InvestigationService") as mock_service:
+            mock_service.return_value.create_investigation.return_value = {
+                "investigation_id": "test-123",
+                "status": "completed"
+            }
+            
+            response = await master.process(investigation_msg, investigation_context)
+            
+            assert response.success is True
+            assert "investigation_id" in response.data

tests/multiagent/test_advanced_orchestration.py

@@ -0,0 +1,522 @@
+"""
+Advanced orchestration tests for multi-agent system.
+Tests complex coordination patterns, failure handling, and performance.
+"""
+
+import pytest
+import asyncio
+from datetime import datetime, timedelta
+from unittest.mock import AsyncMock, MagicMock, patch
+from uuid import uuid4
+import numpy as np
+
+from src.agents import (
+    MasterAgent,
+    ZumbiAgent,
+    AnitaAgent,
+    TiradentesAgent,
+    BonifacioAgent,
+    MariaQuiteriaAgent,
+    AgentContext,
+    AgentMessage,
+    AgentResponse
+)
+from src.services.agent_orchestrator import AgentOrchestrator
+from src.models.agent import AgentStatus
+
+
+@pytest.fixture
+async def orchestrator():
+    """Create agent orchestrator for tests."""
+    orch = AgentOrchestrator()
+    await orch.initialize()
+    return orch
+
+
+@pytest.fixture
+def orchestration_context():
+    """Create orchestration context."""
+    return AgentContext(
+        investigation_id=str(uuid4()),
+        user_id="orchestration-tester",
+        session_id=str(uuid4()),
+        metadata={
+            "test_type": "orchestration",
+            "timestamp": datetime.utcnow().isoformat()
+        }
+    )
+
+
+class TestAdvancedOrchestration:
+    """Test advanced orchestration patterns."""
+    
+    @pytest.mark.asyncio
+    @pytest.mark.integration
+    async def test_dynamic_agent_selection(self, orchestrator, orchestration_context):
+        """Test dynamic agent selection based on task requirements."""
+        
+        # Define tasks with different requirements
+        tasks = [
+            {
+                "type": "anomaly_detection",
+                "data": {"contract_value": 1_000_000},
+                "required_capabilities": ["anomaly_detection", "pattern_analysis"]
+            },
+            {
+                "type": "security_audit", 
+                "data": {"system_name": "Portal"},
+                "required_capabilities": ["security_audit", "threat_detection"]
+            },
+            {
+                "type": "policy_analysis",
+                "data": {"policy_name": "Digital Gov"},
+                "required_capabilities": ["policy_analysis", "governance"]
+            }
+        ]
+        
+        # Execute dynamic routing
+        results = []
+        for task in tasks:
+            agent = await orchestrator.select_best_agent(
+                task["required_capabilities"]
+            )
+            
+            assert agent is not None
+            
+            message = AgentMessage(
+                type=task["type"],
+                data=task["data"],
+                sender="orchestrator",
+                metadata={"dynamic_routing": True}
+            )
+            
+            response = await agent.process(message, orchestration_context)
+            results.append({
+                "task": task["type"],
+                "agent": agent.name,
+                "success": response.success
+            })
+        
+        # Verify correct agent selection
+        assert results[0]["agent"] in ["InvestigatorAgent", "AnalystAgent"]  # Anomaly detection
+        assert results[1]["agent"] == "MariaQuiteriaAgent"  # Security audit
+        assert results[2]["agent"] == "BonifacioAgent"  # Policy analysis
+    
+    @pytest.mark.asyncio
+    @pytest.mark.integration
+    async def test_adaptive_retry_with_fallback(self, orchestrator, orchestration_context):
+        """Test adaptive retry mechanism with agent fallback."""
+        
+        primary_agent = MariaQuiteriaAgent()
+        fallback_agent = ZumbiAgent()
+        
+        # Mock primary agent to fail initially
+        call_count = 0
+        original_process = primary_agent.process
+        
+        async def failing_process(message, context):
+            nonlocal call_count
+            call_count += 1
+            if call_count < 3:
+                raise Exception("Temporary failure")
+            return await original_process(message, context)
+        
+        primary_agent.process = failing_process
+        
+        # Configure orchestrator with retry and fallback
+        orchestrator.configure_retry_policy({
+            "max_retries": 2,
+            "backoff_multiplier": 1.5,
+            "fallback_agents": {
+                "MariaQuiteriaAgent": "InvestigatorAgent"
+            }
+        })
+        
+        message = AgentMessage(
+            type="security_audit",
+            data={"system_name": "Test System"},
+            sender="orchestrator",
+            metadata={}
+        )
+        
+        # Execute with retry logic
+        result = await orchestrator.execute_with_retry(
+            primary_agent, 
+            message, 
+            orchestration_context,
+            fallback_agent=fallback_agent
+        )
+        
+        # Should succeed after retries
+        assert result.success is True
+        assert call_count == 3  # Failed twice, succeeded on third
+    
+    @pytest.mark.asyncio
+    @pytest.mark.integration
+    async def test_conditional_workflow_branching(self, orchestrator, orchestration_context):
+        """Test conditional workflow branching based on intermediate results."""
+        
+        # Define workflow with conditions
+        workflow = {
+            "start": "anomaly_detection",
+            "steps": {
+                "anomaly_detection": {
+                    "agent": "zumbi",
+                    "next": {
+                        "condition": "anomalies_found",
+                        "true": "security_audit",
+                        "false": "generate_report"
+                    }
+                },
+                "security_audit": {
+                    "agent": "maria_quiteria",
+                    "next": {
+                        "condition": "high_risk",
+                        "true": "policy_review",
+                        "false": "generate_report"
+                    }
+                },
+                "policy_review": {
+                    "agent": "bonifacio",
+                    "next": "generate_report"
+                },
+                "generate_report": {
+                    "agent": "tiradentes",
+                    "next": None
+                }
+            }
+        }
+        
+        # Execute conditional workflow
+        initial_data = {
+            "contract_id": "test-123",
+            "value": 10_000_000
+        }
+        
+        execution_path = await orchestrator.execute_conditional_workflow(
+            workflow,
+            initial_data,
+            orchestration_context
+        )
+        
+        # Verify execution followed correct path
+        assert len(execution_path) >= 2  # At least start and report
+        assert execution_path[0]["step"] == "anomaly_detection"
+        assert execution_path[-1]["step"] == "generate_report"
+    
+    @pytest.mark.asyncio
+    @pytest.mark.integration
+    async def test_parallel_map_reduce_pattern(self, orchestrator, orchestration_context):
+        """Test map-reduce pattern for parallel data processing."""
+        
+        # Data to process in parallel
+        contracts = [
+            {"id": f"contract-{i}", "value": np.random.randint(100_000, 10_000_000)}
+            for i in range(5)
+        ]
+        
+        # Map phase: Process each contract with appropriate agent
+        async def process_contract(contract):
+            agent = ZumbiAgent()
+            message = AgentMessage(
+                type="analyze",
+                data={"contract_data": contract},
+                sender="mapper",
+                metadata={"map_task": True}
+            )
+            return await agent.process(message, orchestration_context)
+        
+        # Execute map phase in parallel
+        map_results = await asyncio.gather(
+            *[process_contract(c) for c in contracts]
+        )
+        
+        # Reduce phase: Aggregate results
+        aggregator = AnitaAgent()
+        reduce_message = AgentMessage(
+            type="aggregate_analysis",
+            data={
+                "individual_results": [r.data for r in map_results],
+                "aggregation_type": "anomaly_summary"
+            },
+            sender="reducer",
+            metadata={"reduce_task": True}
+        )
+        
+        final_result = await aggregator.process(reduce_message, orchestration_context)
+        
+        # Verify map-reduce completed
+        assert all(r.success for r in map_results)
+        assert final_result.success is True
+        assert len(map_results) == len(contracts)
+    
+    @pytest.mark.asyncio
+    @pytest.mark.integration
+    async def test_agent_capability_discovery(self, orchestrator):
+        """Test dynamic agent capability discovery and registration."""
+        
+        # Get all registered agents
+        available_agents = await orchestrator.discover_agents()
+        
+        # Verify core agents are discovered
+        agent_names = [a["name"] for a in available_agents]
+        assert "InvestigatorAgent" in agent_names or "zumbi" in agent_names
+        assert "MariaQuiteriaAgent" in agent_names or "maria_quiteria" in agent_names
+        assert "BonifacioAgent" in agent_names or "bonifacio" in agent_names
+        
+        # Test capability search
+        security_agents = await orchestrator.find_agents_with_capability("security_audit")
+        assert len(security_agents) >= 1
+        assert any("maria" in a["name"].lower() for a in security_agents)
+        
+        policy_agents = await orchestrator.find_agents_with_capability("policy_analysis")
+        assert len(policy_agents) >= 1
+        assert any("bonifacio" in a["name"].lower() for a in policy_agents)
+    
+    @pytest.mark.asyncio
+    @pytest.mark.integration
+    async def test_circuit_breaker_pattern(self, orchestrator, orchestration_context):
+        """Test circuit breaker pattern for failing agents."""
+        
+        agent = MariaQuiteriaAgent()
+        
+        # Configure circuit breaker
+        orchestrator.configure_circuit_breaker({
+            "failure_threshold": 3,
+            "recovery_timeout": 5,
+            "half_open_requests": 1
+        })
+        
+        # Mock agent to fail consistently
+        agent.process = AsyncMock(side_effect=Exception("Service unavailable"))
+        
+        message = AgentMessage(
+            type="security_audit",
+            data={"test": True},
+            sender="test",
+            metadata={}
+        )
+        
+        # Attempt multiple requests
+        results = []
+        for i in range(5):
+            try:
+                result = await orchestrator.execute_with_circuit_breaker(
+                    agent, message, orchestration_context
+                )
+                results.append(("success", result))
+            except Exception as e:
+                results.append(("failure", str(e)))
+            
+            await asyncio.sleep(0.1)
+        
+        # Circuit should open after threshold
+        failures = [r for r in results if r[0] == "failure"]
+        assert len(failures) >= 3
+        
+        # Later requests should fail fast
+        assert any("Circuit breaker open" in r[1] for r in failures[3:])
+    
+    @pytest.mark.asyncio
+    @pytest.mark.integration
+    async def test_agent_performance_monitoring(self, orchestrator, orchestration_context):
+        """Test agent performance monitoring and optimization."""
+        
+        agents = [
+            ZumbiAgent(),
+            AnitaAgent(),
+            MariaQuiteriaAgent(),
+            BonifacioAgent()
+        ]
+        
+        # Execute multiple requests and monitor performance
+        performance_stats = {}
+        
+        for agent in agents:
+            stats = {
+                "response_times": [],
+                "success_rate": 0,
+                "total_requests": 10
+            }
+            
+            success_count = 0
+            for i in range(stats["total_requests"]):
+                message = AgentMessage(
+                    type="test_performance",
+                    data={"iteration": i},
+                    sender="performance_monitor",
+                    metadata={}
+                )
+                
+                start_time = datetime.utcnow()
+                try:
+                    response = await agent.process(message, orchestration_context)
+                    if response.success:
+                        success_count += 1
+                except:
+                    pass
+                
+                elapsed = (datetime.utcnow() - start_time).total_seconds()
+                stats["response_times"].append(elapsed)
+            
+            stats["success_rate"] = success_count / stats["total_requests"]
+            stats["avg_response_time"] = np.mean(stats["response_times"])
+            stats["p95_response_time"] = np.percentile(stats["response_times"], 95)
+            
+            performance_stats[agent.name] = stats
+        
+        # Verify performance metrics
+        for agent_name, stats in performance_stats.items():
+            assert stats["success_rate"] >= 0.9  # 90% success rate
+            assert stats["avg_response_time"] < 5  # Under 5 seconds average
+            assert stats["p95_response_time"] < 10  # P95 under 10 seconds
+    
+    @pytest.mark.asyncio
+    @pytest.mark.integration
+    async def test_distributed_transaction_pattern(self, orchestrator, orchestration_context):
+        """Test distributed transaction pattern with compensation."""
+        
+        # Define transaction steps
+        transaction_steps = [
+            {
+                "agent": ZumbiAgent(),
+                "action": "reserve_analysis_slot",
+                "compensation": "release_analysis_slot"
+            },
+            {
+                "agent": MariaQuiteriaAgent(),
+                "action": "allocate_security_resources",
+                "compensation": "deallocate_security_resources"
+            },
+            {
+                "agent": BonifacioAgent(),
+                "action": "lock_policy_review",
+                "compensation": "unlock_policy_review"
+            }
+        ]
+        
+        completed_steps = []
+        
+        try:
+            # Execute transaction steps
+            for step in transaction_steps:
+                message = AgentMessage(
+                    type=step["action"],
+                    data={"transaction_id": "tx-123"},
+                    sender="transaction_manager",
+                    metadata={"transaction": True}
+                )
+                
+                response = await step["agent"].process(message, orchestration_context)
+                
+                if not response.success:
+                    raise Exception(f"Transaction step failed: {step['action']}")
+                
+                completed_steps.append(step)
+                
+                # Simulate failure on third step
+                if len(completed_steps) == 2:
+                    raise Exception("Simulated transaction failure")
+            
+            # Commit transaction (not reached in this test)
+            await orchestrator.commit_transaction("tx-123")
+            
+        except Exception as e:
+            # Compensate completed steps in reverse order
+            for step in reversed(completed_steps):
+                compensation_message = AgentMessage(
+                    type=step["compensation"],
+                    data={"transaction_id": "tx-123"},
+                    sender="transaction_manager",
+                    metadata={"compensation": True}
+                )
+                
+                await step["agent"].process(compensation_message, orchestration_context)
+            
+            # Verify compensation occurred
+            assert len(completed_steps) == 2  # Two steps completed before failure
+
+
+class TestOrchestrationPatterns:
+    """Test specific orchestration patterns."""
+    
+    @pytest.mark.asyncio
+    @pytest.mark.integration
+    async def test_saga_pattern(self, orchestrator, orchestration_context):
+        """Test saga pattern for long-running transactions."""
+        
+        saga_definition = {
+            "name": "investigation_saga",
+            "steps": [
+                {"service": "anomaly_detection", "agent": "zumbi"},
+                {"service": "pattern_analysis", "agent": "anita"},
+                {"service": "security_check", "agent": "maria_quiteria"},
+                {"service": "policy_review", "agent": "bonifacio"},
+                {"service": "report_generation", "agent": "tiradentes"}
+            ]
+        }
+        
+        saga_state = await orchestrator.start_saga(
+            saga_definition,
+            {"investigation_id": "saga-123"},
+            orchestration_context
+        )
+        
+        # Process saga steps
+        while not saga_state["completed"]:
+            next_step = saga_state["current_step"]
+            if next_step >= len(saga_definition["steps"]):
+                break
+                
+            step = saga_definition["steps"][next_step]
+            saga_state = await orchestrator.execute_saga_step(
+                saga_state,
+                step,
+                orchestration_context
+            )
+        
+        # Verify saga completed
+        assert saga_state["completed"] is True
+        assert len(saga_state["completed_steps"]) == len(saga_definition["steps"])
+    
+    @pytest.mark.asyncio
+    @pytest.mark.integration  
+    async def test_event_driven_choreography(self, orchestrator, orchestration_context):
+        """Test event-driven agent choreography."""
+        
+        # Setup event bus
+        event_bus = orchestrator.get_event_bus()
+        
+        # Register agent event handlers
+        agents_triggered = []
+        
+        async def on_anomaly_detected(event):
+            agents_triggered.append("security_audit")
+            await event_bus.emit("security_audit_required", event.data)
+        
+        async def on_security_audit_required(event):
+            agents_triggered.append("policy_review")
+            await event_bus.emit("policy_review_required", event.data)
+        
+        async def on_policy_review_required(event):
+            agents_triggered.append("report_generation")
+            await event_bus.emit("report_ready", event.data)
+        
+        event_bus.on("anomaly_detected", on_anomaly_detected)
+        event_bus.on("security_audit_required", on_security_audit_required)
+        event_bus.on("policy_review_required", on_policy_review_required)
+        
+        # Trigger initial event
+        await event_bus.emit("anomaly_detected", {
+            "severity": "high",
+            "contract_id": "test-123"
+        })
+        
+        # Allow events to propagate
+        await asyncio.sleep(0.5)
+        
+        # Verify choreography executed
+        assert "security_audit" in agents_triggered
+        assert "policy_review" in agents_triggered
+        assert "report_generation" in agents_triggered
+        assert len(agents_triggered) == 3

tests/performance/test_agent_performance.py

@@ -0,0 +1,495 @@
+"""
+Performance tests for agent system.
+Tests agent response times, throughput, and resource usage.
+"""
+
+import pytest
+import asyncio
+import time
+import psutil
+import statistics
+from datetime import datetime
+from concurrent.futures import ThreadPoolExecutor
+from unittest.mock import patch
+import numpy as np
+
+from src.agents import (
+    ZumbiAgent,
+    AnitaAgent, 
+    TiradentesAgent,
+    BonifacioAgent,
+    MariaQuiteriaAgent,
+    AgentContext,
+    AgentMessage
+)
+from src.services.agent_pool import AgentPool
+
+
+class TestAgentPerformance:
+    """Performance tests for individual agents."""
+    
+    @pytest.mark.performance
+    @pytest.mark.asyncio
+    async def test_agent_response_times(self):
+        """Test response times for all agents."""
+        agents = [
+            ("zumbi", ZumbiAgent()),
+            ("anita", AnitaAgent()),
+            ("tiradentes", TiradentesAgent()),
+            ("bonifacio", BonifacioAgent()),
+            ("maria_quiteria", MariaQuiteriaAgent())
+        ]
+        
+        context = AgentContext(
+            investigation_id="perf-test",
+            user_id="perf-tester",
+            session_id="perf-session"
+        )
+        
+        results = {}
+        
+        for agent_name, agent in agents:
+            response_times = []
+            
+            # Warm up
+            message = AgentMessage(
+                type="test",
+                data={"test": True},
+                sender="performance_tester",
+                metadata={}
+            )
+            await agent.process(message, context)
+            
+            # Measure response times
+            for i in range(20):
+                start = time.time()
+                
+                message = AgentMessage(
+                    type="analyze",
+                    data={
+                        "iteration": i,
+                        "data": {"value": np.random.randint(1000, 1000000)}
+                    },
+                    sender="performance_tester",
+                    metadata={"test_run": i}
+                )
+                
+                response = await agent.process(message, context)
+                
+                end = time.time()
+                response_time = (end - start) * 1000  # Convert to milliseconds
+                response_times.append(response_time)
+            
+            results[agent_name] = {
+                "mean": statistics.mean(response_times),
+                "median": statistics.median(response_times),
+                "p95": np.percentile(response_times, 95),
+                "p99": np.percentile(response_times, 99),
+                "min": min(response_times),
+                "max": max(response_times)
+            }
+        
+        # Verify performance targets
+        for agent_name, metrics in results.items():
+            assert metrics["mean"] < 2000  # Mean under 2 seconds
+            assert metrics["p95"] < 3000   # P95 under 3 seconds
+            assert metrics["p99"] < 5000   # P99 under 5 seconds
+            
+            print(f"\n{agent_name} Performance:")
+            print(f"  Mean: {metrics['mean']:.2f}ms")
+            print(f"  P95: {metrics['p95']:.2f}ms")
+            print(f"  P99: {metrics['p99']:.2f}ms")
+    
+    @pytest.mark.performance
+    @pytest.mark.asyncio
+    async def test_concurrent_agent_execution(self):
+        """Test agent performance under concurrent load."""
+        agent = ZumbiAgent()
+        context = AgentContext(
+            investigation_id="concurrent-test",
+            user_id="concurrent-tester",
+            session_id="concurrent-session"
+        )
+        
+        async def process_request(request_id):
+            message = AgentMessage(
+                type="analyze",
+                data={
+                    "request_id": request_id,
+                    "contract_value": np.random.randint(100000, 10000000)
+                },
+                sender="load_tester",
+                metadata={"concurrent": True}
+            )
+            
+            start = time.time()
+            response = await agent.process(message, context)
+            elapsed = time.time() - start
+            
+            return {
+                "request_id": request_id,
+                "success": response.success,
+                "response_time": elapsed
+            }
+        
+        # Test with different concurrency levels
+        concurrency_levels = [1, 5, 10, 20]
+        results = {}
+        
+        for concurrency in concurrency_levels:
+            tasks = [
+                process_request(f"req-{i}")
+                for i in range(concurrency * 10)
+            ]
+            
+            start_time = time.time()
+            responses = await asyncio.gather(*tasks)
+            total_time = time.time() - start_time
+            
+            success_rate = sum(1 for r in responses if r["success"]) / len(responses)
+            avg_response_time = statistics.mean(r["response_time"] for r in responses)
+            throughput = len(responses) / total_time
+            
+            results[concurrency] = {
+                "success_rate": success_rate,
+                "avg_response_time": avg_response_time,
+                "throughput": throughput,
+                "total_requests": len(responses)
+            }
+        
+        # Verify performance doesn't degrade significantly
+        for concurrency, metrics in results.items():
+            assert metrics["success_rate"] >= 0.95  # 95% success rate
+            assert metrics["avg_response_time"] < 5  # Under 5 seconds
+            
+            print(f"\nConcurrency {concurrency}:")
+            print(f"  Success Rate: {metrics['success_rate']:.2%}")
+            print(f"  Avg Response: {metrics['avg_response_time']:.2f}s")
+            print(f"  Throughput: {metrics['throughput']:.2f} req/s")
+    
+    @pytest.mark.performance
+    @pytest.mark.asyncio
+    async def test_agent_pool_performance(self):
+        """Test agent pool initialization and management performance."""
+        pool = AgentPool(
+            min_instances=1,
+            max_instances=10,
+            idle_timeout=60
+        )
+        
+        await pool.initialize()
+        
+        # Measure pool scaling performance
+        scaling_times = []
+        
+        for i in range(5):
+            start = time.time()
+            
+            # Request multiple agents to trigger scaling
+            agents = await asyncio.gather(*[
+                pool.get_agent("zumbi") for _ in range(5)
+            ])
+            
+            scaling_time = time.time() - start
+            scaling_times.append(scaling_time)
+            
+            # Return agents to pool
+            for agent in agents:
+                await pool.return_agent(agent)
+        
+        # Verify pool performance
+        avg_scaling_time = statistics.mean(scaling_times)
+        assert avg_scaling_time < 1.0  # Scaling should be fast
+        
+        stats = await pool.get_stats()
+        assert stats["total_instances"] <= 10  # Respects max instances
+        assert stats["cache_hit_rate"] > 0.5  # Good cache utilization
+    
+    @pytest.mark.performance
+    @pytest.mark.asyncio
+    async def test_memory_usage_under_load(self):
+        """Test memory usage patterns under sustained load."""
+        process = psutil.Process()
+        initial_memory = process.memory_info().rss / 1024 / 1024  # MB
+        
+        agents = [
+            ZumbiAgent(),
+            MariaQuiteriaAgent(),
+            BonifacioAgent()
+        ]
+        
+        context = AgentContext(
+            investigation_id="memory-test",
+            user_id="memory-tester",
+            session_id="memory-session"
+        )
+        
+        # Generate sustained load
+        memory_samples = []
+        
+        for iteration in range(10):
+            # Process batch of requests
+            tasks = []
+            for agent in agents:
+                for i in range(20):
+                    message = AgentMessage(
+                        type="analyze",
+                        data={
+                            "iteration": iteration,
+                            "request": i,
+                            "large_data": "x" * 10000  # 10KB payload
+                        },
+                        sender="memory_tester",
+                        metadata={}
+                    )
+                    tasks.append(agent.process(message, context))
+            
+            await asyncio.gather(*tasks)
+            
+            # Sample memory usage
+            current_memory = process.memory_info().rss / 1024 / 1024  # MB
+            memory_samples.append(current_memory)
+            
+            # Allow garbage collection
+            await asyncio.sleep(0.1)
+        
+        # Analyze memory usage
+        memory_increase = max(memory_samples) - initial_memory
+        memory_variance = statistics.variance(memory_samples)
+        
+        # Verify no significant memory leaks
+        assert memory_increase < 500  # Less than 500MB increase
+        assert memory_variance < 10000  # Stable memory usage
+        
+        print(f"\nMemory Usage:")
+        print(f"  Initial: {initial_memory:.2f}MB")
+        print(f"  Peak: {max(memory_samples):.2f}MB")
+        print(f"  Increase: {memory_increase:.2f}MB")
+    
+    @pytest.mark.performance
+    @pytest.mark.asyncio
+    async def test_agent_startup_times(self):
+        """Test agent initialization and startup times."""
+        agent_classes = [
+            ("zumbi", ZumbiAgent),
+            ("anita", AnitaAgent),
+            ("tiradentes", TiradentesAgent),
+            ("bonifacio", BonifacioAgent),
+            ("maria_quiteria", MariaQuiteriaAgent)
+        ]
+        
+        results = {}
+        
+        for agent_name, agent_class in agent_classes:
+            startup_times = []
+            
+            for i in range(10):
+                start = time.time()
+                agent = agent_class()
+                if hasattr(agent, 'initialize'):
+                    await agent.initialize()
+                startup_time = (time.time() - start) * 1000  # ms
+                startup_times.append(startup_time)
+            
+            results[agent_name] = {
+                "mean": statistics.mean(startup_times),
+                "max": max(startup_times),
+                "min": min(startup_times)
+            }
+        
+        # Verify fast startup
+        for agent_name, metrics in results.items():
+            assert metrics["mean"] < 100  # Under 100ms average
+            assert metrics["max"] < 200   # Under 200ms worst case
+            
+            print(f"\n{agent_name} Startup:")
+            print(f"  Mean: {metrics['mean']:.2f}ms")
+            print(f"  Max: {metrics['max']:.2f}ms")
+    
+    @pytest.mark.performance
+    @pytest.mark.asyncio
+    async def test_agent_throughput_limits(self):
+        """Test maximum throughput for each agent."""
+        agents = [
+            ("zumbi", ZumbiAgent()),
+            ("maria_quiteria", MariaQuiteriaAgent()),
+            ("bonifacio", BonifacioAgent())
+        ]
+        
+        context = AgentContext(
+            investigation_id="throughput-test",
+            user_id="throughput-tester",
+            session_id="throughput-session"
+        )
+        
+        results = {}
+        
+        for agent_name, agent in agents:
+            # Test duration
+            test_duration = 10  # seconds
+            request_count = 0
+            error_count = 0
+            
+            start_time = time.time()
+            
+            while time.time() - start_time < test_duration:
+                message = AgentMessage(
+                    type="analyze",
+                    data={"request": request_count},
+                    sender="throughput_tester",
+                    metadata={}
+                )
+                
+                try:
+                    response = await agent.process(message, context)
+                    if not response.success:
+                        error_count += 1
+                except:
+                    error_count += 1
+                
+                request_count += 1
+            
+            elapsed = time.time() - start_time
+            throughput = request_count / elapsed
+            error_rate = error_count / request_count if request_count > 0 else 0
+            
+            results[agent_name] = {
+                "throughput": throughput,
+                "total_requests": request_count,
+                "error_rate": error_rate
+            }
+        
+        # Verify minimum throughput
+        for agent_name, metrics in results.items():
+            assert metrics["throughput"] >= 10  # At least 10 req/s
+            assert metrics["error_rate"] < 0.01  # Less than 1% errors
+            
+            print(f"\n{agent_name} Throughput:")
+            print(f"  Rate: {metrics['throughput']:.2f} req/s")
+            print(f"  Total: {metrics['total_requests']}")
+            print(f"  Errors: {metrics['error_rate']:.2%}")
+
+
+class TestMultiAgentPerformance:
+    """Performance tests for multi-agent scenarios."""
+    
+    @pytest.mark.performance
+    @pytest.mark.asyncio
+    async def test_multi_agent_pipeline_performance(self):
+        """Test performance of multi-agent processing pipeline."""
+        # Create pipeline
+        pipeline = [
+            ZumbiAgent(),
+            AnitaAgent(),
+            TiradentesAgent()
+        ]
+        
+        context = AgentContext(
+            investigation_id="pipeline-test",
+            user_id="pipeline-tester",
+            session_id="pipeline-session"
+        )
+        
+        # Test different data sizes
+        data_sizes = [1, 10, 100]  # KB
+        results = {}
+        
+        for size_kb in data_sizes:
+            processing_times = []
+            
+            for i in range(20):
+                # Create data payload
+                data = {
+                    "iteration": i,
+                    "payload": "x" * (size_kb * 1024),
+                    "results": {}
+                }
+                
+                start = time.time()
+                
+                # Process through pipeline
+                for agent in pipeline:
+                    message = AgentMessage(
+                        type="process",
+                        data=data,
+                        sender="pipeline",
+                        metadata={"stage": agent.name}
+                    )
+                    
+                    response = await agent.process(message, context)
+                    data["results"][agent.name] = response.data
+                
+                elapsed = time.time() - start
+                processing_times.append(elapsed)
+            
+            results[f"{size_kb}KB"] = {
+                "mean": statistics.mean(processing_times),
+                "p95": np.percentile(processing_times, 95),
+                "throughput": 1 / statistics.mean(processing_times)
+            }
+        
+        # Verify performance scales reasonably
+        for size, metrics in results.items():
+            print(f"\nPipeline Performance ({size}):")
+            print(f"  Mean: {metrics['mean']:.3f}s")
+            print(f"  P95: {metrics['p95']:.3f}s")
+            print(f"  Throughput: {metrics['throughput']:.2f} ops/s")
+    
+    @pytest.mark.performance
+    @pytest.mark.asyncio
+    async def test_agent_orchestration_overhead(self):
+        """Test overhead of agent orchestration layer."""
+        direct_times = []
+        orchestrated_times = []
+        
+        agent = ZumbiAgent()
+        context = AgentContext(
+            investigation_id="overhead-test",
+            user_id="overhead-tester",
+            session_id="overhead-session"
+        )
+        
+        # Direct agent calls
+        for i in range(50):
+            message = AgentMessage(
+                type="analyze",
+                data={"test": i},
+                sender="direct",
+                metadata={}
+            )
+            
+            start = time.time()
+            await agent.process(message, context)
+            direct_times.append(time.time() - start)
+        
+        # Orchestrated calls (with mock orchestrator overhead)
+        for i in range(50):
+            message = AgentMessage(
+                type="analyze",
+                data={"test": i},
+                sender="orchestrated",
+                metadata={}
+            )
+            
+            start = time.time()
+            
+            # Simulate orchestration overhead
+            await asyncio.sleep(0.001)  # 1ms overhead
+            await agent.process(message, context)
+            await asyncio.sleep(0.001)  # Post-processing
+            
+            orchestrated_times.append(time.time() - start)
+        
+        # Calculate overhead
+        direct_avg = statistics.mean(direct_times)
+        orchestrated_avg = statistics.mean(orchestrated_times)
+        overhead = orchestrated_avg - direct_avg
+        overhead_percentage = (overhead / direct_avg) * 100
+        
+        # Verify acceptable overhead
+        assert overhead_percentage < 10  # Less than 10% overhead
+        
+        print(f"\nOrchestration Overhead:")
+        print(f"  Direct: {direct_avg*1000:.2f}ms")
+        print(f"  Orchestrated: {orchestrated_avg*1000:.2f}ms")
+        print(f"  Overhead: {overhead*1000:.2f}ms ({overhead_percentage:.1f}%)")