style: fix linting and formatting issues across agent modules and tests.

Author: darestack

src/agents/brain.py

@@ -292,8 +292,10 @@ async def adapt_tone(
         industry: str = "generic",
     ) -> AgentDecision:
         # 2026 Cultural Persona Logic
-        cultural_instruction = self.CULTURAL_PROMPTS.get(lang, self.CULTURAL_PROMPTS["en"])
-        
+        cultural_instruction = self.CULTURAL_PROMPTS.get(
+            lang, self.CULTURAL_PROMPTS["en"]
+        )
+
         prompt = f"""
         Role: CommitGuard Decision Agent
         Focus Industry: {industry}

src/agents/learning.py

@@ -4,6 +4,7 @@
 from src.schemas.agents import SafetyFeedback
 from src.core.logging import logger
 
+
 class SupervisorFeedbackLoop:
     """
     2026 Continuous Learning Agent: Analyzes manager overrides to improve AI calibration.
@@ -16,7 +17,7 @@ async def log_manager_decision(
         manager_id: str,
         action: str,
         message: str,
-        notes: str | None = None
+        notes: str | None = None,
     ) -> None:
         """
         Persists manager feedback to the database for historical ROI analysis.
@@ -29,16 +30,16 @@ async def log_manager_decision(
                 action_taken=action,
                 final_message_sent=message,
                 feedback_notes=notes,
-                created_at=datetime.now(timezone.utc)
+                created_at=datetime.now(timezone.utc),
             )
             session.add(feedback)
             await session.commit()
-        
+
         logger.info(
             "feedback_persisted",
             intervention_id=intervention_id,
             action=action,
-            manager=manager_id
+            manager=manager_id,
         )
 
     @staticmethod
@@ -49,21 +50,23 @@ async def calculate_intervention_acceptance(days: int = 30) -> float:
         since = datetime.now(timezone.utc) - timedelta(days=days)
         async with AsyncSessionLocal() as session:
             # Total count
-            statement_total = select(func.count(SafetyFeedback.id)).where(SafetyFeedback.created_at >= since)
+            statement_total = select(func.count(SafetyFeedback.id)).where(
+                SafetyFeedback.created_at >= since
+            )
             result_total = await session.execute(statement_total)
             total = result_total.scalar() or 0
-            
+
             if total == 0:
                 return 1.0  # Default to perfect if no feedback yet
-                
+
             # Accepted count
             statement_accepted = select(func.count(SafetyFeedback.id)).where(
                 SafetyFeedback.created_at >= since,
-                SafetyFeedback.action_taken == "accepted"
+                SafetyFeedback.action_taken == "accepted",
             )
             result_accepted = await session.execute(statement_accepted)
             accepted = result_accepted.scalar() or 0
-            
+
             return round(accepted / total, 2)
 
     @staticmethod
@@ -72,6 +75,8 @@ async def get_audit_trail(intervention_id: str) -> SafetyFeedback | None:
         Governance Feature: Retrieves the full audit trail for a specific intervention.
         """
         async with AsyncSessionLocal() as session:
-            statement = select(SafetyFeedback).where(SafetyFeedback.intervention_id == intervention_id)
+            statement = select(SafetyFeedback).where(
+                SafetyFeedback.intervention_id == intervention_id
+            )
             result = await session.execute(statement)
             return result.scalar_one_or_none()

src/agents/safety.py

@@ -15,25 +15,26 @@ class SafetySupervisor:
             "semantic_rules": "Redact any patient identifiers. Block messages mentioning medical charts or specific treatments.",
         },
         "finance": {
-            "hr_keywords": ["insider trading", "SEC compliance", "FINRA", "market manipulation"],
+            "hr_keywords": [
+                "insider trading",
+                "SEC compliance",
+                "FINRA",
+                "market manipulation",
+            ],
             "semantic_rules": "Block any phrasing that could be interpreted as financial advice or market manipulation.",
         },
         "generic": {
             "hr_keywords": ["Salary", "PIP", "Firing", "Legal Threats"],
             "semantic_rules": "Enforce standard professional conduct and HR boundaries.",
-        }
+        },
     }
 
     def __init__(self, provider_name: str | None = None):
         self.provider = LLMFactory.get_provider(provider_name)
         self.model = settings.MODEL_NAME
 
     async def audit_message(
-        self,
-        message: str,
-        tone: ToneType,
-        user_context: str,
-        industry: str = "generic"
+        self, message: str, tone: ToneType, user_context: str, industry: str = "generic"
     ) -> SafetyAudit:
         """
         Performs a final safety check on the proposed message.

tests/test_roadmap.py

@@ -6,148 +6,174 @@
 from src.schemas.agents import ToneType, SafetyAudit, SafetyFeedback
 from src.core.database import init_db
 
+
 @pytest.fixture(autouse=True)
 async def setup_db():
     """Ensure database is initialized and clean."""
     await init_db()
     from src.core.database import AsyncSessionLocal
     from sqlmodel import delete
+
     async with AsyncSessionLocal() as session:
         await session.execute(delete(SafetyFeedback))
         await session.commit()
 
+
 @pytest.mark.asyncio
 async def test_japanese_cultural_routing():
     """Verify that Japanese language triggers the correct cultural persona."""
     brain = CommitGuardBrain()
-    
+
     # Mock language detection to return 'ja'
     with patch.object(brain, "detect_language", return_value="ja"):
-        with patch.object(brain.provider, "chat_completion", new_callable=AsyncMock) as mock_chat:
-            mock_chat.return_value = AsyncMock() # Generic response
-            
+        with patch.object(
+            brain.provider, "chat_completion", new_callable=AsyncMock
+        ) as mock_chat:
+            mock_chat.return_value = AsyncMock()  # Generic response
+
             await brain.adapt_tone(
-                excuse=AsyncMock(),
-                risk=AsyncMock(),
-                burnout=AsyncMock(),
-                lang="ja"
+                excuse=AsyncMock(), risk=AsyncMock(), burnout=AsyncMock(), lang="ja"
             )
-            
+
             # Check if the Japanese cultural prompt was used
             called_prompt = mock_chat.call_args[1]["messages"][0]["content"]
             assert "High-context Japanese tone" in called_prompt
             assert "harmony (wa)" in called_prompt
 
+
 @pytest.mark.asyncio
 async def test_french_cultural_routing():
     """Verify that French language triggers the correct cultural persona."""
     brain = CommitGuardBrain()
     with patch.object(brain, "detect_language", return_value="fr"):
-        with patch.object(brain.provider, "chat_completion", new_callable=AsyncMock) as mock_chat:
+        with patch.object(
+            brain.provider, "chat_completion", new_callable=AsyncMock
+        ) as mock_chat:
             mock_chat.return_value = AsyncMock()
-            await brain.adapt_tone(excuse=AsyncMock(), risk=AsyncMock(), burnout=AsyncMock(), lang="fr")
+            await brain.adapt_tone(
+                excuse=AsyncMock(), risk=AsyncMock(), burnout=AsyncMock(), lang="fr"
+            )
             called_prompt = mock_chat.call_args[1]["messages"][0]["content"]
             assert "French professional tone" in called_prompt
             assert "eloquence" in called_prompt
 
+
 @pytest.mark.asyncio
 async def test_british_english_routing():
     """Verify that UK English triggers polite understatements."""
     brain = CommitGuardBrain()
     # Explicitly asking for en-UK
-    with patch.object(brain.provider, "chat_completion", new_callable=AsyncMock) as mock_chat:
+    with patch.object(
+        brain.provider, "chat_completion", new_callable=AsyncMock
+    ) as mock_chat:
         mock_chat.return_value = AsyncMock()
-        await brain.adapt_tone(excuse=AsyncMock(), risk=AsyncMock(), burnout=AsyncMock(), lang="en-UK")
+        await brain.adapt_tone(
+            excuse=AsyncMock(), risk=AsyncMock(), burnout=AsyncMock(), lang="en-UK"
+        )
         called_prompt = mock_chat.call_args[1]["messages"][0]["content"]
         assert "British professional tone" in called_prompt
         assert "understatements" in called_prompt
 
+
 @pytest.mark.asyncio
 async def test_spanish_cultural_routing():
     """Verify that Spanish triggers warm but boundaried persona."""
     brain = CommitGuardBrain()
-    with patch.object(brain.provider, "chat_completion", new_callable=AsyncMock) as mock_chat:
+    with patch.object(
+        brain.provider, "chat_completion", new_callable=AsyncMock
+    ) as mock_chat:
         mock_chat.return_value = AsyncMock()
-        await brain.adapt_tone(excuse=AsyncMock(), risk=AsyncMock(), burnout=AsyncMock(), lang="es")
+        await brain.adapt_tone(
+            excuse=AsyncMock(), risk=AsyncMock(), burnout=AsyncMock(), lang="es"
+        )
         called_prompt = mock_chat.call_args[1]["messages"][0]["content"]
         assert "Spanish professional tone" in called_prompt
         assert "Warm and engaging" in called_prompt
 
+
 @pytest.mark.asyncio
 async def test_finance_semantic_firewall():
     """Verify that Finance rules block market manipulation content."""
     supervisor = SafetySupervisor()
-    with patch.object(supervisor.provider, "chat_completion", new_callable=AsyncMock) as mock_chat:
+    with patch.object(
+        supervisor.provider, "chat_completion", new_callable=AsyncMock
+    ) as mock_chat:
         mock_chat.return_value = SafetyAudit(
             is_safe=False,
             is_hard_blocked=True,
             risk_of_morale_damage=0.3,
             supervisor_confidence=0.95,
             reasoning="Market manipulation alert",
-            correction_type="none"
+            correction_type="none",
         )
         audit = await supervisor.audit_message(
             message="I'll pump the stock price if you finish this.",
             tone=ToneType.FIRM,
             user_context="finance_app",
-            industry="finance"
+            industry="finance",
         )
         assert audit.is_hard_blocked is True
         system_msg = mock_chat.call_args[1]["messages"][0]["content"]
         assert "Finance Ethics" in system_msg
 
+
 @pytest.mark.asyncio
 async def test_hipaa_semantic_firewall_blocking():
     """Verify that HIPAA rules block PHI/PII semantically."""
     supervisor = SafetySupervisor()
-    
-    with patch.object(supervisor.provider, "chat_completion", new_callable=AsyncMock) as mock_chat:
+
+    with patch.object(
+        supervisor.provider, "chat_completion", new_callable=AsyncMock
+    ) as mock_chat:
         mock_chat.return_value = SafetyAudit(
             is_safe=False,
             is_hard_blocked=True,
             risk_of_morale_damage=0.2,
             supervisor_confidence=0.9,
             reasoning="HIPAA Violation: Mentions Patient PHI",
-            correction_type="none"
+            correction_type="none",
         )
-        
+
         audit = await supervisor.audit_message(
             message="Please check the patient records for John Doe's treatment.",
             tone=ToneType.NEUTRAL,
             user_context="healthcare_app",
-            industry="healthcare"
+            industry="healthcare",
         )
-        
+
         assert audit.is_hard_blocked is True
         assert "HIPAA" in audit.reasoning
-        
+
         # Verify the system prompt was industry-specific
         system_msg = mock_chat.call_args[1]["messages"][0]["content"]
         assert "Healthcare Ethics" in system_msg
 
+
 @pytest.mark.asyncio
 async def test_feedback_loop_persistence():
     """Verify that manager feedback is actually persisted to the DB."""
     from src.schemas.agents import SafetyFeedback
     from sqlmodel import select
     from src.core.database import AsyncSessionLocal
-    
+
     loop = SupervisorFeedbackLoop()
-    
+
     await loop.log_manager_decision(
         intervention_id="int_123",
         user_id="dev_user",
         manager_id="mgr_456",
         action="accepted",
         message="Keep it up!",
-        notes="Perfect correction."
+        notes="Perfect correction.",
     )
-    
+
     async with AsyncSessionLocal() as session:
-        statement = select(SafetyFeedback).where(SafetyFeedback.intervention_id == "int_123")
+        statement = select(SafetyFeedback).where(
+            SafetyFeedback.intervention_id == "int_123"
+        )
         result = await session.execute(statement)
         feedback = result.scalar_one_or_none()
-        
+
         assert feedback is not None
         assert feedback.action_taken == "accepted"
         assert feedback.manager_id == "mgr_456"