diff --git a/apps/coordinator-api/src/app/services/adaptive_learning_app.py b/apps/coordinator-api/src/app/services/adaptive_learning_app.py
index 4adc8490..e4c5f674 100755
--- a/apps/coordinator-api/src/app/services/adaptive_learning_app.py
+++ b/apps/coordinator-api/src/app/services/adaptive_learning_app.py
@@ -41,7 +41,7 @@ app.include_router(health_router, tags=["health"])
 
 
 @app.get("/health")
-async def health():
+async def health() -> dict[str, Any]:
     return {"status": "ok", "service": "adaptive-learning"}
 
 
diff --git a/apps/coordinator-api/src/app/services/advanced_ai_service.py b/apps/coordinator-api/src/app/services/advanced_ai_service.py
index aab5ba47..9d7cffd2 100755
--- a/apps/coordinator-api/src/app/services/advanced_ai_service.py
+++ b/apps/coordinator-api/src/app/services/advanced_ai_service.py
@@ -96,7 +96,7 @@ advanced_learning = AdvancedLearningService({})
 
 
 @app.on_event("startup")
-async def startup_event():
+async def startup_event() -> None:
     """Initialize the Advanced AI Service"""
     logger.info("Starting Advanced AI Service on port 8009")
 
@@ -109,7 +109,7 @@ async def startup_event():
 
 
 @app.get("/")
-async def root():
+async def root() -> dict[str, Any]:
     """Root endpoint"""
     return {
         "service": "Advanced AI Service",
@@ -127,7 +127,7 @@ async def root():
 
 
 @app.get("/health")
-async def health_check():
+async def health_check() -> dict[str, Any]:
     """Health check endpoint"""
     return {
         "status": "healthy",
@@ -138,7 +138,7 @@ async def health_check():
 
 
 @app.post("/rl/train")
-async def train_rl_agent(request: RLTrainingRequest, background_tasks: BackgroundTasks):
+async def train_rl_agent(request: RLTrainingRequest, background_tasks: BackgroundTasks) -> Any:
     """Train a reinforcement learning agent"""
 
     try:
@@ -175,7 +175,7 @@ async def _train_rl_agent_background(
     algorithm: str,
     training_config: dict[str, Any] | None,
     training_data: list[dict[str, Any]],
-):
+) -> None:
     """Background task for RL training"""
 
     try:
@@ -200,7 +200,7 @@ async def _train_rl_agent_background(
 
 
 @app.post("/fusion/process")
-async def process_multi_modal_fusion(request: MultiModalFusionRequest):
+async def process_multi_modal_fusion(request: MultiModalFusionRequest) -> Any:
     """Process multi-modal fusion"""
 
     try:
@@ -239,7 +239,7 @@ async def process_multi_modal_fusion(request: MultiModalFusionRequest):
 
 
 @app.post("/gpu/optimize")
-async def optimize_gpu_processing(request: GPUOptimizationRequest):
+async def optimize_gpu_processing(request: GPUOptimizationRequest) -> Any:
     """Perform GPU-optimized processing"""
 
     try:
@@ -262,7 +262,7 @@ async def optimize_gpu_processing(request: GPUOptimizationRequest):
 
 
 @app.post("/process")
-async def advanced_ai_processing(request: AdvancedAIRequest):
+async def advanced_ai_processing(request: AdvancedAIRequest) -> Any:
     """Unified advanced AI processing endpoint"""
 
     try:
@@ -292,32 +292,32 @@ async def advanced_ai_processing(request: AdvancedAIRequest):
         raise HTTPException(status_code=500, detail=str(e))
 
 
-async def _handle_rl_training(input_data: dict[str, Any], config: dict[str, Any] | None):
+async def _handle_rl_training(input_data: dict[str, Any], config: dict[str, Any] | None) -> Any:
     """Handle RL training request"""
     # Implementation for unified RL training
     return {"status": "rl_training_initiated", "details": input_data}
 
 
-async def _handle_fusion_processing(input_data: dict[str, Any], config: dict[str, Any] | None):
+async def _handle_fusion_processing(input_data: dict[str, Any], config: dict[str, Any] | None) -> Any:
     """Handle fusion processing request"""
     # Implementation for unified fusion processing
     return {"status": "fusion_processing_initiated", "details": input_data}
 
 
-async def _handle_gpu_optimization(input_data: dict[str, Any], config: dict[str, Any] | None):
+async def _handle_gpu_optimization(input_data: dict[str, Any], config: dict[str, Any] | None) -> Any:
     """Handle GPU optimization request"""
     # Implementation for unified GPU optimization
     return {"status": "gpu_optimization_initiated", "details": input_data}
 
 
-async def _handle_meta_learning(input_data: dict[str, Any], config: dict[str, Any] | None):
+async def _handle_meta_learning(input_data: dict[str, Any], config: dict[str, Any] | None) -> Any:
     """Handle meta-learning request"""
     # Implementation for meta-learning
     return {"status": "meta_learning_initiated", "details": input_data}
 
 
 @app.get("/metrics")
-async def get_performance_metrics():
+async def get_performance_metrics() -> Any:
     """Get service performance metrics"""
 
     try:
@@ -358,7 +358,7 @@ async def get_performance_metrics():
 
 
 @app.get("/models")
-async def list_available_models():
+async def list_available_models() -> Any:
     """List available trained models"""
 
     try:
@@ -373,7 +373,7 @@ async def list_available_models():
 
 
 @app.delete("/models/{model_id}")
-async def delete_model(model_id: str):
+async def delete_model(model_id: str) -> Any:
     """Delete a trained model"""
 
     try:
diff --git a/apps/coordinator-api/src/app/services/agent_coordination/agent_service.py b/apps/coordinator-api/src/app/services/agent_coordination/agent_service.py
index d3abc24a..7d12d67d 100755
--- a/apps/coordinator-api/src/app/services/agent_coordination/agent_service.py
+++ b/apps/coordinator-api/src/app/services/agent_coordination/agent_service.py
@@ -37,7 +37,7 @@ class CoordinatorClient:
 class AgentStateManager:
     """Manages persistent state for AI agent executions"""
 
-    def __init__(self, session: Session):
+    def __init__(self, session: Session) -> None:
         self.session = session
 
     async def create_execution(
@@ -59,7 +59,7 @@ class AgentStateManager:
 
         stmt = (
             update(AgentExecution)
-            .where(AgentExecution.id == execution_id)
+            .where(AgentExecution.id == execution_id)  # type: ignore[arg-type]
             .values(status=status, updated_at=datetime.now(timezone.utc), **kwargs)
         )
 
@@ -81,7 +81,7 @@ class AgentStateManager:
 
     async def get_workflow_steps(self, workflow_id: str) -> list[AgentStep]:
         """Get all steps for a workflow"""
-        stmt = select(AgentStep).where(AgentStep.workflow_id == workflow_id).order_by(AgentStep.step_order)
+        stmt = select(AgentStep).where(AgentStep.workflow_id == workflow_id).order_by(AgentStep.step_order)  # type: ignore[arg-type]
         return self.session.execute(stmt).all()
 
     async def create_step_execution(self, execution_id: str, step_id: str) -> AgentStepExecution:
@@ -100,7 +100,7 @@ class AgentStateManager:
 
         stmt = (
             update(AgentStepExecution)
-            .where(AgentStepExecution.id == step_execution_id)
+            .where(AgentStepExecution.id == step_execution_id)  # type: ignore[arg-type]
             .values(updated_at=datetime.now(timezone.utc), **kwargs)
         )
 
@@ -114,7 +114,7 @@ class AgentStateManager:
 class AgentVerifier:
     """Handles verification of agent executions"""
 
-    def __init__(self, cuda_accelerator=None):
+    def __init__(self, cuda_accelerator=None) -> None:
         self.cuda_accelerator = cuda_accelerator
 
     async def verify_step_execution(
@@ -223,7 +223,7 @@ class AgentVerifier:
 class AIAgentOrchestrator:
     """Orchestrates execution of AI agent workflows"""
 
-    def __init__(self, session: Session, coordinator_client: CoordinatorClient):
+    def __init__(self, session: Session, coordinator_client: CoordinatorClient) -> None:
         self.session = session
         self.coordinator = coordinator_client
         self.state_manager = AgentStateManager(session)
diff --git a/apps/coordinator-api/src/app/services/agent_coordination/performance.py b/apps/coordinator-api/src/app/services/agent_coordination/performance.py
index 6f32a875..d62787a7 100755
--- a/apps/coordinator-api/src/app/services/agent_coordination/performance.py
+++ b/apps/coordinator-api/src/app/services/agent_coordination/performance.py
@@ -29,7 +29,7 @@ from ...domain.agent_performance import (
 class MetaLearningEngine:
     """Advanced meta-learning system for rapid skill acquisition"""
 
-    def __init__(self):
+    def __init__(self) -> None:
         self.meta_algorithms = {
             "model_agnostic_meta_learning": self.maml_algorithm,
             "reptile": self.reptile_algorithm,
@@ -307,7 +307,7 @@ class MetaLearningEngine:
 class ResourceManager:
     """Self-optimizing resource management system"""
 
-    def __init__(self):
+    def __init__(self) -> None:
         self.optimization_algorithms = {
             "genetic_algorithm": self.genetic_optimization,
             "simulated_annealing": self.simulated_annealing,
@@ -546,7 +546,7 @@ class ResourceManager:
 class PerformanceOptimizer:
     """Advanced performance optimization system"""
 
-    def __init__(self):
+    def __init__(self) -> None:
         self.optimization_techniques = {
             "hyperparameter_tuning": self.tune_hyperparameters,
             "architecture_optimization": self.optimize_architecture,
@@ -842,7 +842,7 @@ class PerformanceOptimizer:
 class AgentPerformanceService:
     """Main service for advanced agent performance management"""
 
-    def __init__(self, session: Session):
+    def __init__(self, session: Session) -> None:
         self.session = session
         self.meta_learning_engine = MetaLearningEngine()
         self.resource_manager = ResourceManager()
@@ -881,7 +881,7 @@ class AgentPerformanceService:
         """Update agent performance metrics"""
 
         profile = self.session.execute(
-            select(AgentPerformanceProfile).where(AgentPerformanceProfile.agent_id == agent_id)
+            select(AgentPerformanceProfile).where(AgentPerformanceProfile.agent_id == agent_id)  # type: ignore[arg-type]
         ).first()
 
         if not profile:
@@ -960,7 +960,7 @@ class AgentPerformanceService:
         """Get comprehensive agent performance profile"""
 
         profile = self.session.execute(
-            select(AgentPerformanceProfile).where(AgentPerformanceProfile.agent_id == agent_id)
+            select(AgentPerformanceProfile).where(AgentPerformanceProfile.agent_id == agent_id)  # type: ignore[arg-type]
         ).first()
 
         if not profile:
diff --git a/apps/coordinator-api/src/app/services/agent_coordination/portfolio.py b/apps/coordinator-api/src/app/services/agent_coordination/portfolio.py
index d5a144ab..67267404 100755
--- a/apps/coordinator-api/src/app/services/agent_coordination/portfolio.py
+++ b/apps/coordinator-api/src/app/services/agent_coordination/portfolio.py
@@ -68,7 +68,7 @@ class AgentPortfolioManager:
 
             # Check if portfolio already exists
             existing_portfolio = self.session.execute(
-                select(AgentPortfolio).where(AgentPortfolio.agent_address == agent_address)
+                select(AgentPortfolio).where(AgentPortfolio.agent_address == agent_address)  # type: ignore[arg-type]
             ).first()
 
             if existing_portfolio:
@@ -241,7 +241,7 @@ class AgentPortfolioManager:
 
             # Update risk metrics in database
             existing_metrics = self.session.execute(
-                select(RiskMetrics).where(RiskMetrics.portfolio_id == portfolio.id)
+                select(RiskMetrics).where(RiskMetrics.portfolio_id == portfolio.id)  # type: ignore[arg-type]
             ).first()
 
             if existing_metrics:
@@ -321,7 +321,7 @@ class AgentPortfolioManager:
 
     def _get_agent_portfolio(self, agent_address: str) -> AgentPortfolio:
         """Get portfolio for agent address"""
-        portfolio = self.session.execute(select(AgentPortfolio).where(AgentPortfolio.agent_address == agent_address)).first()
+        portfolio = self.session.execute(select(AgentPortfolio).where(AgentPortfolio.agent_address == agent_address)).first()  # type: ignore[arg-type]
 
         if not portfolio:
             raise HTTPException(status_code=404, detail="Portfolio not found")
@@ -442,7 +442,7 @@ class AgentPortfolioManager:
         portfolio_value = await self._calculate_portfolio_value(portfolio)
 
         # Update current allocations
-        assets = self.session.execute(select(PortfolioAsset).where(PortfolioAsset.portfolio_id == portfolio.id)).all()
+        assets = self.session.execute(select(PortfolioAsset).where(PortfolioAsset.portfolio_id == portfolio.id)).all()  # type: ignore[arg-type]
 
         for asset in assets:
             if asset.balance > 0:
@@ -457,7 +457,7 @@ class AgentPortfolioManager:
     async def _calculate_portfolio_value(self, portfolio: AgentPortfolio) -> float:
         """Calculate total portfolio value"""
 
-        assets = self.session.execute(select(PortfolioAsset).where(PortfolioAsset.portfolio_id == portfolio.id)).all()
+        assets = self.session.execute(select(PortfolioAsset).where(PortfolioAsset.portfolio_id == portfolio.id)).all()  # type: ignore[arg-type]
 
         total_value = 0.0
         for asset in assets:
@@ -480,7 +480,7 @@ class AgentPortfolioManager:
             return True
 
         # Check threshold-based rebalancing
-        assets = self.session.execute(select(PortfolioAsset).where(PortfolioAsset.portfolio_id == portfolio.id)).all()
+        assets = self.session.execute(select(PortfolioAsset).where(PortfolioAsset.portfolio_id == portfolio.id)).all()  # type: ignore[arg-type]
 
         for asset in assets:
             if asset.balance > 0:
@@ -496,7 +496,7 @@ class AgentPortfolioManager:
         """Generate rebalancing trades"""
 
         trades = []
-        assets = self.session.execute(select(PortfolioAsset).where(PortfolioAsset.portfolio_id == portfolio.id)).all()
+        assets = self.session.execute(select(PortfolioAsset).where(PortfolioAsset.portfolio_id == portfolio.id)).all()  # type: ignore[arg-type]
 
         # Calculate current vs target allocations
         for asset in assets:
@@ -532,8 +532,8 @@ class AgentPortfolioManager:
         # Get historical trades
         trades = self.session.execute(
             select(PortfolioTrade)
-            .where(PortfolioTrade.portfolio_id == portfolio.id)
-            .order_by(PortfolioTrade.executed_at.desc())
+            .where(PortfolioTrade.portfolio_id == portfolio.id)  # type: ignore[arg-type]
+            .order_by(PortfolioTrade.executed_at.desc())  # type: ignore[arg-type]
         ).all()
 
         # Calculate returns, volatility, etc.
@@ -555,6 +555,6 @@ class AgentPortfolioManager:
 class ValidationResult:
     """Validation result for trade requests"""
 
-    def __init__(self, is_valid: bool, error_message: str = ""):
+    def __init__(self, is_valid: bool, error_message: str = "") -> None:
         self.is_valid = is_valid
         self.error_message = error_message
diff --git a/apps/coordinator-api/src/app/services/bounty_service.py b/apps/coordinator-api/src/app/services/bounty_service.py
index a035d478..b5d34dc7 100755
--- a/apps/coordinator-api/src/app/services/bounty_service.py
+++ b/apps/coordinator-api/src/app/services/bounty_service.py
@@ -26,7 +26,7 @@ from ..domain.bounty import (
 class BountyService:
     """Service for managing AI agent bounties"""
 
-    def __init__(self, session: Session = None):
+    def __init__(self, session: Session = None) -> None:  # type: ignore[assignment]
         self.session = session
 
     async def create_bounty(
@@ -90,7 +90,7 @@ class BountyService:
     async def get_bounty(self, bounty_id: str) -> Bounty | None:
         """Get bounty by ID"""
         try:
-            stmt = select(Bounty).where(Bounty.bounty_id == bounty_id)
+            stmt = select(Bounty).where(Bounty.bounty_id == bounty_id)  # type: ignore[arg-type]
             result = self.session.execute(stmt).scalar_one_or_none()
             return result
 
@@ -119,31 +119,31 @@ class BountyService:
 
             # Apply filters
             if status:
-                query = query.where(Bounty.status == status)
+                query = query.where(Bounty.status == status)  # type: ignore[arg-type]
             if tier:
-                query = query.where(Bounty.tier == tier)
+                query = query.where(Bounty.tier == tier)  # type: ignore[arg-type]
             if creator_id:
-                query = query.where(Bounty.creator_id == creator_id)
+                query = query.where(Bounty.creator_id == creator_id)  # type: ignore[arg-type]
             if category:
-                query = query.where(Bounty.category == category)
+                query = query.where(Bounty.category == category)  # type: ignore[arg-type]
             if min_reward:
-                query = query.where(Bounty.reward_amount >= min_reward)
+                query = query.where(Bounty.reward_amount >= min_reward)  # type: ignore[arg-type]
             if max_reward:
-                query = query.where(Bounty.reward_amount <= max_reward)
+                query = query.where(Bounty.reward_amount <= max_reward)  # type: ignore[arg-type]
             if deadline_before:
-                query = query.where(Bounty.deadline <= deadline_before)
+                query = query.where(Bounty.deadline <= deadline_before)  # type: ignore[arg-type]
             if deadline_after:
-                query = query.where(Bounty.deadline >= deadline_after)
+                query = query.where(Bounty.deadline >= deadline_after)  # type: ignore[arg-type]
             if requires_zk_proof is not None:
-                query = query.where(Bounty.requires_zk_proof == requires_zk_proof)
+                query = query.where(Bounty.requires_zk_proof == requires_zk_proof)  # type: ignore[arg-type]
 
             # Apply tag filtering
             if tags:
                 for tag in tags:
-                    query = query.where(Bounty.tags.contains([tag]))
+                    query = query.where(Bounty.tags.contains([tag]))  # type: ignore[arg-type]
 
             # Order by creation time (newest first)
-            query = query.order_by(Bounty.creation_time.desc())
+            query = query.order_by(Bounty.creation_time.desc())  # type: ignore[arg-type]
 
             # Apply pagination
             offset = (page - 1) * limit
@@ -187,7 +187,7 @@ class BountyService:
 
             # Check if user has already submitted
             existing_stmt = select(BountySubmission).where(
-                and_(BountySubmission.bounty_id == bounty_id, BountySubmission.submitter_address == submitter_address)
+                and_(BountySubmission.bounty_id == bounty_id, BountySubmission.submitter_address == submitter_address)  # type: ignore[arg-type]
             )
             existing = self.session.execute(existing_stmt).scalar_one_or_none()
             if existing:
@@ -227,8 +227,8 @@ class BountyService:
         try:
             stmt = (
                 select(BountySubmission)
-                .where(BountySubmission.bounty_id == bounty_id)
-                .order_by(BountySubmission.submission_time.desc())
+                .where(BountySubmission.bounty_id == bounty_id)  # type: ignore[arg-type]
+                .order_by(BountySubmission.submission_time.desc())  # type: ignore[arg-type]
             )
 
             result = self.session.execute(stmt).scalars().all()
@@ -249,7 +249,7 @@ class BountyService:
         """Verify a bounty submission"""
         try:
             stmt = select(BountySubmission).where(
-                and_(BountySubmission.submission_id == submission_id, BountySubmission.bounty_id == bounty_id)
+                and_(BountySubmission.submission_id == submission_id, BountySubmission.bounty_id == bounty_id)  # type: ignore[arg-type]
             )
             submission = self.session.execute(stmt).scalar_one_or_none()
 
@@ -291,7 +291,7 @@ class BountyService:
         """Create a dispute for a submission"""
         try:
             stmt = select(BountySubmission).where(
-                and_(BountySubmission.submission_id == submission_id, BountySubmission.bounty_id == bounty_id)
+                and_(BountySubmission.submission_id == submission_id, BountySubmission.bounty_id == bounty_id)  # type: ignore[arg-type]
             )
             submission = self.session.execute(stmt).scalar_one_or_none()
 
@@ -329,12 +329,12 @@ class BountyService:
     ) -> list[Bounty]:
         """Get bounties created by a user"""
         try:
-            query = select(Bounty).where(Bounty.creator_id == user_address)
+            query = select(Bounty).where(Bounty.creator_id == user_address)  # type: ignore[arg-type]
 
             if status:
-                query = query.where(Bounty.status == status)
+                query = query.where(Bounty.status == status)  # type: ignore[arg-type]
 
-            query = query.order_by(Bounty.creation_time.desc())
+            query = query.order_by(Bounty.creation_time.desc())  # type: ignore[arg-type]
 
             offset = (page - 1) * limit
             query = query.offset(offset).limit(limit)
@@ -351,12 +351,12 @@ class BountyService:
     ) -> list[BountySubmission]:
         """Get submissions made by a user"""
         try:
-            query = select(BountySubmission).where(BountySubmission.submitter_address == user_address)
+            query = select(BountySubmission).where(BountySubmission.submitter_address == user_address)  # type: ignore[arg-type]
 
             if status:
-                query = query.where(BountySubmission.status == status)
+                query = query.where(BountySubmission.status == status)  # type: ignore[arg-type]
 
-            query = query.order_by(BountySubmission.submission_time.desc())
+            query = query.order_by(BountySubmission.submission_time.desc())  # type: ignore[arg-type]
 
             offset = (page - 1) * limit
             query = query.offset(offset).limit(limit)
@@ -391,7 +391,7 @@ class BountyService:
                 )
                 .join(Bounty)
                 .where(
-                    and_(BountySubmission.status == SubmissionStatus.VERIFIED, BountySubmission.submission_time >= start_date)
+                    and_(BountySubmission.status == SubmissionStatus.VERIFIED, BountySubmission.submission_time >= start_date)  # type: ignore[arg-type]
                 )
                 .group_by(BountySubmission.submitter_address)
                 .order_by(func.sum(Bounty.reward_amount).desc())
@@ -432,25 +432,25 @@ class BountyService:
                 start_date = datetime.now(timezone.utc) - timedelta(days=30)
 
             # Get statistics
-            total_stmt = select(func.count(Bounty.bounty_id)).where(Bounty.creation_time >= start_date)
+            total_stmt = select(func.count(Bounty.bounty_id)).where(Bounty.creation_time >= start_date)  # type: ignore[arg-type]
             total_bounties = self.session.execute(total_stmt).scalar() or 0
 
             active_stmt = select(func.count(Bounty.bounty_id)).where(
-                and_(Bounty.creation_time >= start_date, Bounty.status == BountyStatus.ACTIVE)
+                and_(Bounty.creation_time >= start_date, Bounty.status == BountyStatus.ACTIVE)  # type: ignore[arg-type]
             )
             active_bounties = self.session.execute(active_stmt).scalar() or 0
 
             completed_stmt = select(func.count(Bounty.bounty_id)).where(
-                and_(Bounty.creation_time >= start_date, Bounty.status == BountyStatus.COMPLETED)
+                and_(Bounty.creation_time >= start_date, Bounty.status == BountyStatus.COMPLETED)  # type: ignore[arg-type]
             )
             completed_bounties = self.session.execute(completed_stmt).scalar() or 0
 
             # Financial metrics
-            total_locked_stmt = select(func.sum(Bounty.reward_amount)).where(Bounty.creation_time >= start_date)
+            total_locked_stmt = select(func.sum(Bounty.reward_amount)).where(Bounty.creation_time >= start_date)  # type: ignore[arg-type]
             total_value_locked = self.session.execute(total_locked_stmt).scalar() or 0.0
 
             total_rewards_stmt = select(func.sum(Bounty.reward_amount)).where(
-                and_(Bounty.creation_time >= start_date, Bounty.status == BountyStatus.COMPLETED)
+                and_(Bounty.creation_time >= start_date, Bounty.status == BountyStatus.COMPLETED)  # type: ignore[arg-type]
             )
             total_rewards_paid = self.session.execute(total_rewards_stmt).scalar() or 0.0
 
@@ -463,7 +463,7 @@ class BountyService:
             # Tier distribution
             tier_stmt = (
                 select(Bounty.tier, func.count(Bounty.bounty_id).label("count"))
-                .where(Bounty.creation_time >= start_date)
+                .where(Bounty.creation_time >= start_date)  # type: ignore[arg-type]
                 .group_by(Bounty.tier)
             )
 
@@ -472,18 +472,18 @@ class BountyService:
 
             # Expired bounties counting
             expired_stmt = select(func.count(Bounty.bounty_id)).where(
-                and_(Bounty.creation_time >= start_date, Bounty.status == BountyStatus.EXPIRED)
+                and_(Bounty.creation_time >= start_date, Bounty.status == BountyStatus.EXPIRED)  # type: ignore[arg-type]
             )
             expired_bounties = self.session.execute(expired_stmt).scalar() or 0
 
             # Disputed bounties counting
             disputed_stmt = select(func.count(Bounty.bounty_id)).where(
-                and_(Bounty.creation_time >= start_date, Bounty.status == BountyStatus.DISPUTED)
+                and_(Bounty.creation_time >= start_date, Bounty.status == BountyStatus.DISPUTED)  # type: ignore[arg-type]
             )
             disputed_bounties = self.session.execute(disputed_stmt).scalar() or 0
 
             # Calculate fees collected
-            fees_stmt = select(func.sum(Bounty.platform_fee + Bounty.creation_fee)).where(Bounty.creation_time >= start_date)
+            fees_stmt = select(func.sum(Bounty.platform_fee + Bounty.creation_fee)).where(Bounty.creation_time >= start_date)  # type: ignore[arg-type]
             total_fees_collected = self.session.execute(fees_stmt).scalar() or 0.0
 
             stats = BountyStats(
@@ -512,7 +512,7 @@ class BountyService:
     async def get_categories(self) -> list[str]:
         """Get all bounty categories"""
         try:
-            stmt = select(Bounty.category).where(and_(Bounty.category.isnot(None), Bounty.category != "")).distinct()
+            stmt = select(Bounty.category).where(and_(Bounty.category.isnot(None), Bounty.category != "")).distinct()  # type: ignore[arg-type]
 
             result = self.session.execute(stmt).scalars().all()
             return list(result)
@@ -526,7 +526,7 @@ class BountyService:
         try:
             # This is a simplified implementation
             # In production, you'd want to count tag usage
-            stmt = select(Bounty.tags).where(func.array_length(Bounty.tags, 1) > 0).limit(limit)
+            stmt = select(Bounty.tags).where(func.array_length(Bounty.tags, 1) > 0).limit(limit)  # type: ignore[arg-type]
 
             result = self.session.execute(stmt).scalars().all()
 
@@ -550,8 +550,8 @@ class BountyService:
 
             stmt = (
                 select(Bounty)
-                .where(or_(Bounty.title.ilike(search_pattern), Bounty.description.ilike(search_pattern)))
-                .order_by(Bounty.creation_time.desc())
+                .where(or_(Bounty.title.ilike(search_pattern), Bounty.description.ilike(search_pattern)))  # type: ignore[arg-type]
+                .order_by(Bounty.creation_time.desc())  # type: ignore[arg-type]
             )
 
             offset = (page - 1) * limit
diff --git a/apps/coordinator-api/src/app/services/community_service.py b/apps/coordinator-api/src/app/services/community_service.py
index c17363aa..5b3392dd 100755
--- a/apps/coordinator-api/src/app/services/community_service.py
+++ b/apps/coordinator-api/src/app/services/community_service.py
@@ -42,7 +42,7 @@ class DeveloperEcosystemService:
 
     async def get_developer_profile(self, developer_id: str) -> DeveloperProfile | None:
         """Get developer profile by ID"""
-        return self.session.execute(select(DeveloperProfile).where(DeveloperProfile.developer_id == developer_id)).first()
+        return self.session.execute(select(DeveloperProfile).where(DeveloperProfile.developer_id == developer_id)).first()  # type: ignore[arg-type]
 
     async def get_sdk_release_info(self) -> dict[str, Any]:
         """Get latest SDK information for developers"""
@@ -115,7 +115,7 @@ class ThirdPartySolutionService:
 
     async def list_published_solutions(self, category: str = None, limit: int = 50) -> list[AgentSolution]:
         """List published solutions, optionally filtered by capability/category"""
-        query = select(AgentSolution).where(AgentSolution.status == SolutionStatus.PUBLISHED)
+        query = select(AgentSolution).where(AgentSolution.status == SolutionStatus.PUBLISHED)  # type: ignore[arg-type]
 
         # Filtering by JSON column capability (simplified)
         # In a real app, we might use PostgreSQL specific operators
@@ -128,7 +128,7 @@ class ThirdPartySolutionService:
 
     async def purchase_solution(self, buyer_id: str, solution_id: str) -> dict[str, Any]:
         """Purchase or download a third-party solution"""
-        solution = self.session.execute(select(AgentSolution).where(AgentSolution.solution_id == solution_id)).first()
+        solution = self.session.execute(select(AgentSolution).where(AgentSolution.solution_id == solution_id)).first()  # type: ignore[arg-type]
 
         if not solution or solution.status != SolutionStatus.PUBLISHED:
             raise ValueError("Solution not found or not available")
@@ -140,7 +140,7 @@ class ThirdPartySolutionService:
         # Update developer earnings if paid
         if solution.price_amount > 0:
             dev = self.session.execute(
-                select(DeveloperProfile).where(DeveloperProfile.developer_id == solution.developer_id)
+                select(DeveloperProfile).where(DeveloperProfile.developer_id == solution.developer_id)  # type: ignore[arg-type]
             ).first()
             if dev:
                 dev.total_earnings += solution.price_amount
@@ -181,7 +181,7 @@ class InnovationLabService:
 
     async def join_lab(self, lab_id: str, developer_id: str) -> InnovationLab:
         """Join an active innovation lab"""
-        lab = self.session.execute(select(InnovationLab).where(InnovationLab.lab_id == lab_id)).first()
+        lab = self.session.execute(select(InnovationLab).where(InnovationLab.lab_id == lab_id)).first()  # type: ignore[arg-type]
 
         if not lab:
             raise ValueError("Lab not found")
@@ -196,7 +196,7 @@ class InnovationLabService:
 
     async def fund_lab(self, lab_id: str, amount: float) -> InnovationLab:
         """Provide funding to an innovation lab"""
-        lab = self.session.execute(select(InnovationLab).where(InnovationLab.lab_id == lab_id)).first()
+        lab = self.session.execute(select(InnovationLab).where(InnovationLab.lab_id == lab_id)).first()  # type: ignore[arg-type]
 
         if not lab:
             raise ValueError("Lab not found")
@@ -241,16 +241,16 @@ class CommunityPlatformService:
 
     async def get_feed(self, category: str = None, limit: int = 20) -> list[CommunityPost]:
         """Get the community feed"""
-        query = select(CommunityPost).where(CommunityPost.parent_post_id is None)
+        query = select(CommunityPost).where(CommunityPost.parent_post_id is None)  # type: ignore[arg-type]
         if category:
-            query = query.where(CommunityPost.category == category)
+            query = query.where(CommunityPost.category == category)  # type: ignore[arg-type]
 
-        query = query.order_by(CommunityPost.created_at.desc()).limit(limit)
+        query = query.order_by(CommunityPost.created_at.desc()).limit(limit)  # type: ignore[arg-type]
         return self.session.execute(query).all()
 
     async def upvote_post(self, post_id: str) -> CommunityPost:
         """Upvote a post and reward the author"""
-        post = self.session.execute(select(CommunityPost).where(CommunityPost.post_id == post_id)).first()
+        post = self.session.execute(select(CommunityPost).where(CommunityPost.post_id == post_id)).first()  # type: ignore[arg-type]
         if not post:
             raise ValueError("Post not found")
 
@@ -268,7 +268,7 @@ class CommunityPlatformService:
     async def create_hackathon(self, organizer_id: str, data: dict[str, Any]) -> Hackathon:
         """Create a new agent innovation hackathon"""
         # Verify organizer is an expert or partner
-        dev = self.session.execute(select(DeveloperProfile).where(DeveloperProfile.developer_id == organizer_id)).first()
+        dev = self.session.execute(select(DeveloperProfile).where(DeveloperProfile.developer_id == organizer_id)).first()  # type: ignore[arg-type]
         if not dev or dev.tier not in [DeveloperTier.EXPERT, DeveloperTier.MASTER, DeveloperTier.PARTNER]:
             raise ValueError("Only high-tier developers can organize hackathons")
 
@@ -291,7 +291,7 @@ class CommunityPlatformService:
 
     async def register_for_hackathon(self, hackathon_id: str, developer_id: str) -> Hackathon:
         """Register a developer for a hackathon"""
-        hackathon = self.session.execute(select(Hackathon).where(Hackathon.hackathon_id == hackathon_id)).first()
+        hackathon = self.session.execute(select(Hackathon).where(Hackathon.hackathon_id == hackathon_id)).first()  # type: ignore[arg-type]
 
         if not hackathon:
             raise ValueError("Hackathon not found")
diff --git a/apps/coordinator-api/src/app/services/developer_platform_service.py b/apps/coordinator-api/src/app/services/developer_platform_service.py
index bf1ffc3f..c41e1f13 100755
--- a/apps/coordinator-api/src/app/services/developer_platform_service.py
+++ b/apps/coordinator-api/src/app/services/developer_platform_service.py
@@ -28,12 +28,12 @@ logger = get_logger(__name__)
 
 
 class DeveloperPlatformService:
-    def __init__(self, session: Session):
+    def __init__(self, session: Session) -> None:
         self.session = session
 
     async def register_developer(self, request: DeveloperCreate) -> DeveloperProfile:
         existing = self.session.execute(
-            select(DeveloperProfile).where(DeveloperProfile.wallet_address == request.wallet_address)
+            select(DeveloperProfile).where(DeveloperProfile.wallet_address == request.wallet_address)  # type: ignore[arg-type]
         ).first()
 
         if existing:
@@ -173,7 +173,7 @@ class DeveloperPlatformService:
 
     async def get_developer_profile(self, wallet_address: str) -> DeveloperProfile | None:
         """Get developer profile by wallet address"""
-        return self.session.execute(select(DeveloperProfile).where(DeveloperProfile.wallet_address == wallet_address)).first()
+        return self.session.execute(select(DeveloperProfile).where(DeveloperProfile.wallet_address == wallet_address)).first()  # type: ignore[arg-type]
 
     async def update_developer_profile(self, wallet_address: str, updates: dict) -> DeveloperProfile:
         """Update developer profile"""
@@ -195,8 +195,8 @@ class DeveloperPlatformService:
         """Get developer leaderboard sorted by reputation score"""
         return self.session.execute(
             select(DeveloperProfile)
-            .where(DeveloperProfile.is_active)
-            .order_by(DeveloperProfile.reputation_score.desc())
+            .where(DeveloperProfile.is_active)  # type: ignore[arg-type]
+            .order_by(DeveloperProfile.reputation_score.desc())  # type: ignore[arg-type]
             .offset(offset)
             .limit(limit)
         ).all()
@@ -209,12 +209,12 @@ class DeveloperPlatformService:
 
         # Get bounty statistics
         completed_bounties = self.session.execute(
-            select(BountySubmission).where(BountySubmission.developer_id == profile.id, BountySubmission.is_approved)
+            select(BountySubmission).where(BountySubmission.developer_id == profile.id, BountySubmission.is_approved)  # type: ignore[arg-type]
         ).all()
 
         # Get certification statistics
         certifications = self.session.execute(
-            select(DeveloperCertification).where(DeveloperCertification.developer_id == profile.id)
+            select(DeveloperCertification).where(DeveloperCertification.developer_id == profile.id)  # type: ignore[arg-type]
         ).all()
 
         return {
@@ -235,9 +235,9 @@ class DeveloperPlatformService:
         """List bounty tasks with optional status filter"""
         query = select(BountyTask)
         if status:
-            query = query.where(BountyTask.status == status)
+            query = query.where(BountyTask.status == status)  # type: ignore[arg-type]
 
-        return self.session.execute(query.order_by(BountyTask.created_at.desc()).offset(offset).limit(limit)).all()
+        return self.session.execute(query.order_by(BountyTask.created_at.desc()).offset(offset).limit(limit)).all()  # type: ignore[arg-type]
 
     async def get_bounty_details(self, bounty_id: str) -> BountyTask | None:
         """Get detailed bounty information"""
@@ -247,7 +247,7 @@ class DeveloperPlatformService:
 
         # Get submissions count
         submissions_count = self.session.execute(
-            select(BountySubmission).where(BountySubmission.bounty_id == bounty_id)
+            select(BountySubmission).where(BountySubmission.bounty_id == bounty_id)  # type: ignore[arg-type]
         ).count()
 
         return {**bounty.__dict__, "submissions_count": submissions_count}
@@ -256,8 +256,8 @@ class DeveloperPlatformService:
         """Get all submissions by a developer"""
         return self.session.execute(
             select(BountySubmission)
-            .where(BountySubmission.developer_id == developer_id)
-            .order_by(BountySubmission.submitted_at.desc())
+            .where(BountySubmission.developer_id == developer_id)  # type: ignore[arg-type]
+            .order_by(BountySubmission.submitted_at.desc())  # type: ignore[arg-type]
         ).all()
 
     async def create_regional_hub(self, name: str, region: str, description: str, manager_address: str) -> RegionalHub:
@@ -273,7 +273,7 @@ class DeveloperPlatformService:
 
     async def get_regional_hubs(self) -> list[RegionalHub]:
         """Get all regional developer hubs"""
-        return self.session.execute(select(RegionalHub).where(RegionalHub.is_active)).all()
+        return self.session.execute(select(RegionalHub).where(RegionalHub.is_active)).all()  # type: ignore[arg-type]
 
     async def get_hub_developers(self, hub_id: str) -> list[DeveloperProfile]:
         """Get developers in a regional hub"""
@@ -284,7 +284,7 @@ class DeveloperPlatformService:
             raise HTTPException(status_code=404, detail="Regional hub not found")
 
         # Mock implementation - in reality would use hub membership table
-        return self.session.execute(select(DeveloperProfile).where(DeveloperProfile.is_active)).all()
+        return self.session.execute(select(DeveloperProfile).where(DeveloperProfile.is_active)).all()  # type: ignore[arg-type]
 
     async def stake_on_developer(self, staker_address: str, developer_address: str, amount: float) -> dict:
         """Stake AITBC tokens on a developer"""
@@ -376,12 +376,12 @@ class DeveloperPlatformService:
     async def get_bounty_statistics(self) -> dict:
         """Get comprehensive bounty statistics"""
         total_bounties = self.session.execute(select(BountyTask)).count()
-        open_bounties = self.session.execute(select(BountyTask).where(BountyTask.status == BountyStatus.OPEN)).count()
+        open_bounties = self.session.execute(select(BountyTask).where(BountyTask.status == BountyStatus.OPEN)).count()  # type: ignore[arg-type]
         completed_bounties = self.session.execute(
-            select(BountyTask).where(BountyTask.status == BountyStatus.COMPLETED)
+            select(BountyTask).where(BountyTask.status == BountyStatus.COMPLETED)  # type: ignore[arg-type]
         ).count()
 
-        total_rewards = self.session.execute(select(BountyTask).where(BountyTask.status == BountyStatus.COMPLETED)).all()
+        total_rewards = self.session.execute(select(BountyTask).where(BountyTask.status == BountyStatus.COMPLETED)).all()  # type: ignore[arg-type]
         total_reward_amount = sum(bounty.reward_amount for bounty in total_rewards)
 
         return {
diff --git a/apps/coordinator-api/src/app/services/distributed_framework.py b/apps/coordinator-api/src/app/services/distributed_framework.py
index c8ee4bbc..d82d0d02 100755
--- a/apps/coordinator-api/src/app/services/distributed_framework.py
+++ b/apps/coordinator-api/src/app/services/distributed_framework.py
@@ -331,7 +331,7 @@ class DistributedProcessingCoordinator:
         except Exception as e:
             self.report_task_failure(task.task_id, str(e))
 
-    def report_task_success(self, task_id: str, result: Any) -> None:
+    def report_task_success(self, task_id: str, result: Any) -> Any:
         """Called by a worker when a task completes successfully"""
         if task_id not in self.tasks:
             return
diff --git a/apps/coordinator-api/src/app/services/ecosystem_service.py b/apps/coordinator-api/src/app/services/ecosystem_service.py
index c929d10f..ff274394 100755
--- a/apps/coordinator-api/src/app/services/ecosystem_service.py
+++ b/apps/coordinator-api/src/app/services/ecosystem_service.py
@@ -25,7 +25,7 @@ from ..domain.bounty import (
 class EcosystemService:
     """Service for ecosystem analytics and metrics"""
 
-    def __init__(self, session: Session):
+    def __init__(self, session: Session) -> None:
         self.session = session
 
     async def get_developer_earnings(self, period: str = "monthly") -> dict[str, Any]:
@@ -46,7 +46,7 @@ class EcosystemService:
                 func.sum(Bounty.reward_amount).label("total_earnings"),
                 func.count(func.distinct(Bounty.winner_address)).label("unique_earners"),
                 func.avg(Bounty.reward_amount).label("average_earnings"),
-            ).where(and_(Bounty.status == BountyStatus.COMPLETED, Bounty.creation_time >= start_date))
+            ).where(and_(Bounty.status == BountyStatus.COMPLETED, Bounty.creation_time >= start_date))  # type: ignore[arg-type]
 
             earnings_result = self.session.execute(earnings_stmt).first()
 
@@ -62,7 +62,7 @@ class EcosystemService:
                     func.count(Bounty.bounty_id).label("bounties_won"),
                 )
                 .where(
-                    and_(
+                    and_(  # type: ignore[arg-type]
                         Bounty.status == BountyStatus.COMPLETED,
                         Bounty.creation_time >= start_date,
                         Bounty.winner_address.isnot(None),
@@ -88,7 +88,7 @@ class EcosystemService:
             # Calculate earnings growth (compare with previous period)
             previous_start = start_date - timedelta(days=30) if period == "monthly" else start_date - timedelta(days=7)
             previous_earnings_stmt = select(func.sum(Bounty.reward_amount)).where(
-                and_(
+                and_(  # type: ignore[arg-type]
                     Bounty.status == BountyStatus.COMPLETED,
                     Bounty.creation_time >= previous_start,
                     Bounty.creation_time < start_date,
@@ -130,7 +130,7 @@ class EcosystemService:
                 func.count(AgentMetrics.agent_wallet).label("total_agents"),
                 func.sum(AgentMetrics.total_submissions).label("total_submissions"),
                 func.avg(AgentMetrics.average_accuracy).label("avg_accuracy"),
-            ).where(AgentMetrics.last_update_time >= start_date)
+            ).where(AgentMetrics.last_update_time >= start_date)  # type: ignore[arg-type]
 
             agents_result = self.session.execute(agents_stmt).first()
 
@@ -153,7 +153,7 @@ class EcosystemService:
                     func.count(BountySubmission.submission_id).label("submissions"),
                     func.avg(BountySubmission.accuracy).label("avg_accuracy"),
                 )
-                .where(BountySubmission.submission_time >= start_date)
+                .where(BountySubmission.submission_time >= start_date)  # type: ignore[arg-type]
                 .group_by(BountySubmission.submitter_address)
                 .order_by(func.count(BountySubmission.submission_id).desc())
                 .limit(10)
@@ -174,7 +174,7 @@ class EcosystemService:
             # Get performance distribution
             performance_stmt = (
                 select(AgentMetrics.current_tier, func.count(AgentMetrics.agent_wallet).label("count"))
-                .where(AgentMetrics.last_update_time >= start_date)
+                .where(AgentMetrics.last_update_time >= start_date)  # type: ignore[arg-type]
                 .group_by(AgentMetrics.current_tier)
             )
 
@@ -210,13 +210,13 @@ class EcosystemService:
             # Get bounty fees (treasury inflow)
             inflow_stmt = select(
                 func.sum(Bounty.creation_fee + Bounty.success_fee + Bounty.platform_fee).label("total_inflow")
-            ).where(Bounty.creation_time >= start_date)
+            ).where(Bounty.creation_time >= start_date)  # type: ignore[arg-type]
 
             total_inflow = self.session.execute(inflow_stmt).scalar() or 0.0
 
             # Get rewards paid (treasury outflow)
             outflow_stmt = select(func.sum(Bounty.reward_amount).label("total_outflow")).where(
-                and_(Bounty.status == BountyStatus.COMPLETED, Bounty.creation_time >= start_date)
+                and_(Bounty.status == BountyStatus.COMPLETED, Bounty.creation_time >= start_date)  # type: ignore[arg-type]
             )
 
             total_outflow = self.session.execute(outflow_stmt).scalar() or 0.0
@@ -268,7 +268,7 @@ class EcosystemService:
                 func.sum(AgentStake.amount).label("total_staked"),
                 func.count(func.distinct(AgentStake.staker_address)).label("total_stakers"),
                 func.avg(AgentStake.current_apy).label("avg_apy"),
-            ).where(AgentStake.start_time >= start_date)
+            ).where(AgentStake.start_time >= start_date)  # type: ignore[arg-type]
 
             staking_result = self.session.execute(staking_stmt).first()
 
@@ -291,7 +291,7 @@ class EcosystemService:
                     func.count(AgentStake.stake_id).label("stake_count"),
                     func.avg(AgentStake.current_apy).label("avg_apy"),
                 )
-                .where(AgentStake.start_time >= start_date)
+                .where(AgentStake.start_time >= start_date)  # type: ignore[arg-type]
                 .group_by(AgentStake.agent_wallet)
                 .order_by(func.sum(AgentStake.amount).desc())
                 .limit(10)
@@ -313,7 +313,7 @@ class EcosystemService:
             # Get tier distribution
             tier_stmt = (
                 select(AgentStake.agent_tier, func.count(AgentStake.stake_id).label("count"))
-                .where(AgentStake.start_time >= start_date)
+                .where(AgentStake.start_time >= start_date)  # type: ignore[arg-type]
                 .group_by(AgentStake.agent_tier)
             )
 
@@ -352,7 +352,7 @@ class EcosystemService:
                 func.count(func.distinct(Bounty.bounty_id))
                 .filter(Bounty.status == BountyStatus.ACTIVE)
                 .label("active_bounties"),
-            ).where(Bounty.creation_time >= start_date)
+            ).where(Bounty.creation_time >= start_date)  # type: ignore[arg-type]
 
             bounty_result = self.session.execute(bounty_stmt).first()
 
@@ -361,7 +361,7 @@ class EcosystemService:
 
             # Get completion rate
             completed_stmt = select(func.count(Bounty.bounty_id)).where(
-                and_(Bounty.creation_time >= start_date, Bounty.status == BountyStatus.COMPLETED)
+                and_(Bounty.creation_time >= start_date, Bounty.status == BountyStatus.COMPLETED)  # type: ignore[arg-type]
             )
 
             completed_bounties = self.session.execute(completed_stmt).scalar() or 0
@@ -370,7 +370,7 @@ class EcosystemService:
             # Get average reward and volume
             reward_stmt = select(
                 func.avg(Bounty.reward_amount).label("avg_reward"), func.sum(Bounty.reward_amount).label("total_volume")
-            ).where(Bounty.creation_time >= start_date)
+            ).where(Bounty.creation_time >= start_date)  # type: ignore[arg-type]
 
             reward_result = self.session.execute(reward_stmt).first()
 
@@ -380,7 +380,7 @@ class EcosystemService:
             # Get category distribution
             category_stmt = (
                 select(Bounty.category, func.count(Bounty.bounty_id).label("count"))
-                .where(and_(Bounty.creation_time >= start_date, Bounty.category.isnot(None), Bounty.category != ""))
+                .where(and_(Bounty.creation_time >= start_date, Bounty.category.isnot(None), Bounty.category != ""))  # type: ignore[arg-type]
                 .group_by(Bounty.category)
             )
 
@@ -390,7 +390,7 @@ class EcosystemService:
             # Get difficulty distribution
             difficulty_stmt = (
                 select(Bounty.difficulty, func.count(Bounty.bounty_id).label("count"))
-                .where(and_(Bounty.creation_time >= start_date, Bounty.difficulty.isnot(None), Bounty.difficulty != ""))
+                .where(and_(Bounty.creation_time >= start_date, Bounty.difficulty.isnot(None), Bounty.difficulty != ""))  # type: ignore[arg-type]
                 .group_by(Bounty.difficulty)
             )
 
diff --git a/apps/coordinator-api/src/app/services/enterprise_integration/load_balancer.py b/apps/coordinator-api/src/app/services/enterprise_integration/load_balancer.py
index bcdaa775..4d782723 100755
--- a/apps/coordinator-api/src/app/services/enterprise_integration/load_balancer.py
+++ b/apps/coordinator-api/src/app/services/enterprise_integration/load_balancer.py
@@ -93,14 +93,14 @@ class TrafficPattern:
 class PredictiveScaler:
     """AI-powered predictive auto-scaling"""
 
-    def __init__(self):
+    def __init__(self) -> None:
         self.traffic_history = []
         self.scaling_predictions = {}
         self.traffic_patterns = {}
         self.model_weights = {}
         self.logger = get_logger("predictive_scaler")
 
-    async def record_traffic(self, timestamp: datetime, request_count: int, response_time_ms: float, error_rate: float):
+    async def record_traffic(self, timestamp: datetime, request_count: int, response_time_ms: float, error_rate: float) -> None:
         """Record traffic metrics"""
 
         traffic_record = {
@@ -123,7 +123,7 @@ class PredictiveScaler:
         # Update traffic patterns
         await self._update_traffic_patterns()
 
-    async def _update_traffic_patterns(self):
+    async def _update_traffic_patterns(self) -> None:
         """Update traffic patterns based on historical data"""
 
         if len(self.traffic_history) < 168:  # Need at least 1 week of data
@@ -336,7 +336,7 @@ class PredictiveScaler:
 class AdvancedLoadBalancer:
     """Advanced load balancer with multiple algorithms and AI optimization"""
 
-    def __init__(self):
+    def __init__(self) -> None:
         self.backends = {}
         self.algorithm = LoadBalancingAlgorithm.ADAPTIVE
         self.current_index = 0
@@ -698,7 +698,7 @@ class AdvancedLoadBalancer:
             self.logger.error(f"Metrics retrieval failed: {e}")
             return {"error": str(e)}
 
-    async def set_algorithm(self, algorithm: LoadBalancingAlgorithm):
+    async def set_algorithm(self, algorithm: LoadBalancingAlgorithm) -> None:
         """Set load balancing algorithm"""
 
         self.algorithm = algorithm
diff --git a/apps/coordinator-api/src/app/services/enterprise_integration/security.py b/apps/coordinator-api/src/app/services/enterprise_integration/security.py
index 258beb32..fa545170 100755
--- a/apps/coordinator-api/src/app/services/enterprise_integration/security.py
+++ b/apps/coordinator-api/src/app/services/enterprise_integration/security.py
@@ -82,7 +82,7 @@ class SecurityEvent:
 class HSMManager:
     """Hardware Security Module manager for enterprise key management"""
 
-    def __init__(self, hsm_config: dict[str, Any]):
+    def __init__(self, hsm_config: dict[str, Any]) -> None:
         self.hsm_config = hsm_config
         self.backend = default_backend()
         self.key_store = {}  # In production, use actual HSM
@@ -167,7 +167,7 @@ class HSMManager:
 class EnterpriseEncryption:
     """Enterprise-grade encryption service"""
 
-    def __init__(self, hsm_manager: HSMManager):
+    def __init__(self, hsm_manager: HSMManager) -> None:
         self.hsm_manager = hsm_manager
         self.backend = default_backend()
         self.logger = get_logger("enterprise_encryption")
@@ -377,7 +377,7 @@ class EnterpriseEncryption:
 class ZeroTrustArchitecture:
     """Zero-trust security architecture implementation"""
 
-    def __init__(self, hsm_manager: HSMManager, encryption: EnterpriseEncryption):
+    def __init__(self, hsm_manager: HSMManager, encryption: EnterpriseEncryption) -> None:
         self.hsm_manager = hsm_manager
         self.encryption = encryption
         self.trust_policies = {}
@@ -483,7 +483,7 @@ class ZeroTrustArchitecture:
 
         return thresholds.get(security_level, 0.5)
 
-    async def _log_trust_decision(self, user_id: str, resource_id: str, action: str, trust_score: float, decision: bool):
+    async def _log_trust_decision(self, user_id: str, resource_id: str, action: str, trust_score: float, decision: bool) -> None:
         """Log trust decision for audit"""
 
         SecurityEvent(
@@ -504,13 +504,13 @@ class ZeroTrustArchitecture:
 class ThreatDetectionSystem:
     """Advanced threat detection and response system"""
 
-    def __init__(self):
+    def __init__(self) -> None:
         self.threat_patterns = {}
         self.active_threats = {}
         self.response_actions = {}
         self.logger = get_logger("threat_detection")
 
-    async def register_threat_pattern(self, pattern_id: str, pattern_config: dict[str, Any]):
+    async def register_threat_pattern(self, pattern_id: str, pattern_config: dict[str, Any]) -> None:
         """Register threat detection pattern"""
 
         self.threat_patterns[pattern_id] = {
@@ -571,7 +571,7 @@ class ThreatDetectionSystem:
 
         return min(score, 1.0)
 
-    async def _trigger_response_actions(self, pattern_id: str, threat_event: SecurityEvent):
+    async def _trigger_response_actions(self, pattern_id: str, threat_event: SecurityEvent) -> None:
         """Trigger automated response actions"""
 
         pattern = self.threat_patterns[pattern_id]
@@ -583,7 +583,7 @@ class ThreatDetectionSystem:
             except Exception as e:
                 self.logger.error(f"Response action failed: {action} - {e}")
 
-    async def _execute_response_action(self, action: str, threat_event: SecurityEvent):
+    async def _execute_response_action(self, action: str, threat_event: SecurityEvent) -> None:
         """Execute specific response action"""
 
         if action == "block_user":
@@ -597,22 +597,22 @@ class ThreatDetectionSystem:
 
         self.logger.info(f"Response action executed: {action}")
 
-    async def _block_user(self, user_id: str):
+    async def _block_user(self, user_id: str) -> None:
         """Block user account"""
         # In production, implement actual user blocking
         self.logger.warning(f"User blocked due to threat: {user_id}")
 
-    async def _isolate_resource(self, resource_id: str):
+    async def _isolate_resource(self, resource_id: str) -> None:
         """Isolate compromised resource"""
         # In production, implement actual resource isolation
         self.logger.warning(f"Resource isolated due to threat: {resource_id}")
 
-    async def _escalate_to_admin(self, threat_event: SecurityEvent):
+    async def _escalate_to_admin(self, threat_event: SecurityEvent) -> None:
         """Escalate threat to security administrators"""
         # In production, implement actual escalation
         self.logger.error(f"Threat escalated to admin: {threat_event.event_id}")
 
-    async def _require_mfa(self, user_id: str):
+    async def _require_mfa(self, user_id: str) -> None:
         """Require multi-factor authentication"""
         # In production, implement MFA requirement
         self.logger.warning(f"MFA required for user: {user_id}")
@@ -621,7 +621,7 @@ class ThreatDetectionSystem:
 class EnterpriseSecurityFramework:
     """Main enterprise security framework"""
 
-    def __init__(self, hsm_config: dict[str, Any]):
+    def __init__(self, hsm_config: dict[str, Any]) -> None:
         self.hsm_manager = HSMManager(hsm_config)
         self.encryption = EnterpriseEncryption(self.hsm_manager)
         self.zero_trust = ZeroTrustArchitecture(self.hsm_manager, self.encryption)
@@ -649,7 +649,7 @@ class EnterpriseSecurityFramework:
             self.logger.error(f"Security framework initialization failed: {e}")
             return False
 
-    async def _register_default_threat_patterns(self):
+    async def _register_default_threat_patterns(self) -> None:
         """Register default threat detection patterns"""
 
         patterns = [
@@ -682,7 +682,7 @@ class EnterpriseSecurityFramework:
         for i, pattern in enumerate(patterns):
             await self.threat_detection.register_threat_pattern(f"default_{i}", pattern)
 
-    async def _create_default_policies(self):
+    async def _create_default_policies(self) -> None:
         """Create default trust policies"""
 
         policies = [
diff --git a/apps/coordinator-api/src/app/services/explorer.py b/apps/coordinator-api/src/app/services/explorer.py
index 46205e57..e887dd55 100755
--- a/apps/coordinator-api/src/app/services/explorer.py
+++ b/apps/coordinator-api/src/app/services/explorer.py
@@ -80,7 +80,7 @@ class ExplorerService:
         except Exception as e:
             # Fallback to fake data if RPC is unavailable
             logger.warning(f"Failed to fetch blocks from RPC: {e}, falling back to fake data")
-            statement = select(Job).order_by(Job.requested_at.desc())
+            statement = select(Job).order_by(Job.requested_at.desc())  # type: ignore[arg-type]
             jobs = self.session.execute(statement.offset(offset).limit(limit)).all()
 
             items: list[BlockSummary] = []
@@ -101,7 +101,7 @@ class ExplorerService:
             return BlockListResponse(items=items, next_offset=next_offset)
 
     def list_transactions(self, *, limit: int = 50, offset: int = 0) -> TransactionListResponse:
-        statement = select(Job).order_by(Job.requested_at.desc()).offset(offset).limit(limit)
+        statement = select(Job).order_by(Job.requested_at.desc()).offset(offset).limit(limit)  # type: ignore[arg-type]
         jobs = self.session.execute(statement).all()
 
         items: list[TransactionSummary] = []
@@ -141,7 +141,7 @@ class ExplorerService:
         return TransactionListResponse(items=items, next_offset=next_offset)
 
     def list_addresses(self, *, limit: int = 50, offset: int = 0) -> AddressListResponse:
-        statement = select(Job).order_by(Job.requested_at.desc())
+        statement = select(Job).order_by(Job.requested_at.desc())  # type: ignore[arg-type]
         jobs = self.session.execute(statement.offset(offset).limit(limit)).all()
 
         address_map: dict[str, dict[str, object]] = defaultdict(
@@ -226,9 +226,9 @@ class ExplorerService:
         limit: int = 50,
         offset: int = 0,
     ) -> ReceiptListResponse:
-        statement = select(JobReceipt).order_by(JobReceipt.created_at.desc())
+        statement = select(JobReceipt).order_by(JobReceipt.created_at.desc())  # type: ignore[arg-type]
         if job_id:
-            statement = statement.where(JobReceipt.job_id == job_id)
+            statement = statement.where(JobReceipt.job_id == job_id)  # type: ignore[arg-type]
 
         rows = self.session.execute(statement.offset(offset).limit(limit)).all()
         items: list[ReceiptSummary] = []
diff --git a/apps/coordinator-api/src/app/services/gpu_multimodal.py b/apps/coordinator-api/src/app/services/gpu_multimodal.py
index 1f737578..b095e5e5 100755
--- a/apps/coordinator-api/src/app/services/gpu_multimodal.py
+++ b/apps/coordinator-api/src/app/services/gpu_multimodal.py
@@ -28,7 +28,7 @@ from .multimodal_agent import ModalityType
 class CUDAKernelOptimizer:
     """Custom CUDA kernel optimization for GPU operations"""
 
-    def __init__(self):
+    def __init__(self) -> None:
         self.device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
         self.kernel_cache = {}
         self.performance_metrics = {}
@@ -89,7 +89,7 @@ class CUDAKernelOptimizer:
 class GPUFeatureCache:
     """GPU memory management and feature caching system"""
 
-    def __init__(self, max_cache_size_gb: float = 4.0):
+    def __init__(self, max_cache_size_gb: float = 4.0) -> None:
         self.device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
         self.max_cache_size = max_cache_size_gb * 1024**3  # Convert to bytes
         self.current_cache_size = 0
@@ -156,7 +156,7 @@ class GPUFeatureCache:
 class GPUAttentionOptimizer:
     """GPU-optimized attention mechanisms"""
 
-    def __init__(self):
+    def __init__(self) -> None:
         self.device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
         self.cuda_optimizer = CUDAKernelOptimizer()
 
@@ -567,7 +567,7 @@ class GPUAcceleratedMultiModal:
 class GPUAttentionOptimizer:
     """GPU attention optimization strategies"""
 
-    def __init__(self):
+    def __init__(self) -> None:
         self._optimization_cache = {}
 
     async def optimize_attention_config(
@@ -677,7 +677,7 @@ class GPUAttentionOptimizer:
 class GPUFeatureCache:
     """GPU feature caching for performance optimization"""
 
-    def __init__(self):
+    def __init__(self) -> None:
         self._cache = {}
         self._cache_stats = {"hits": 0, "misses": 0, "evictions": 0}
 
diff --git a/apps/coordinator-api/src/app/services/gpu_worker.py b/apps/coordinator-api/src/app/services/gpu_worker.py
index 95ccc0c5..b880dbf0 100644
--- a/apps/coordinator-api/src/app/services/gpu_worker.py
+++ b/apps/coordinator-api/src/app/services/gpu_worker.py
@@ -420,7 +420,7 @@ class GPUWorker:
 
 
 # Standalone worker runner
-async def run_worker(worker_id: str, api_key: str, coordinator_url: str = "http://localhost:8011"):
+async def run_worker(worker_id: str, api_key: str, coordinator_url: str = "http://localhost:8011") -> None:
     """Run a GPU worker instance"""
     worker = GPUWorker(
         worker_id=worker_id,
diff --git a/apps/coordinator-api/src/app/services/jobs.py b/apps/coordinator-api/src/app/services/jobs.py
index f20aef3d..4389f52c 100755
--- a/apps/coordinator-api/src/app/services/jobs.py
+++ b/apps/coordinator-api/src/app/services/jobs.py
@@ -56,7 +56,7 @@ class JobService:
 
     def list_jobs(self, client_id: str | None = None, limit: int = 20, offset: int = 0, **filters) -> list[Job]:
         """List jobs with optional filtering"""
-        query = select(Job).order_by(Job.requested_at.desc())
+        query = select(Job).order_by(Job.requested_at.desc())  # type: ignore[arg-type]
 
         if client_id:
             query = query.where(Job.client_id == client_id)
@@ -118,7 +118,7 @@ class JobService:
     def acquire_next_job(self, miner: Miner) -> Job | None:
         try:
             now = datetime.now()
-            statement = select(Job).where(Job.state == JobState.queued).order_by(Job.requested_at.asc())
+            statement = select(Job).where(Job.state == JobState.queued).order_by(Job.requested_at.asc())  # type: ignore[arg-type]
 
             jobs = self.session.scalars(statement).all()
             for job in jobs:
diff --git a/apps/coordinator-api/src/app/services/market_data_collector.py b/apps/coordinator-api/src/app/services/market_data_collector.py
index c9fb6c97..8e1d3496 100755
--- a/apps/coordinator-api/src/app/services/market_data_collector.py
+++ b/apps/coordinator-api/src/app/services/market_data_collector.py
@@ -63,7 +63,7 @@ class AggregatedMarketData:
 class MarketDataCollector:
     """Collects and processes market data from multiple sources"""
 
-    def __init__(self, config: dict[str, Any]):
+    def __init__(self, config: dict[str, Any]) -> None:
         self.config = config
         self.data_callbacks: dict[DataSource, list[Callable]] = {}
         self.raw_data: list[MarketDataPoint] = []
@@ -88,7 +88,7 @@ class MarketDataCollector:
         self.websocket_port = config.get("websocket_port", 8765)
         self.websocket_server = None
 
-    async def initialize(self):
+    async def initialize(self) -> None:
         """Initialize the market data collector"""
         logger.info("Initializing Market Data Collector")
 
@@ -107,7 +107,7 @@ class MarketDataCollector:
 
         logger.info("Market Data Collector initialized")
 
-    def register_callback(self, source: DataSource, callback: Callable):
+    def register_callback(self, source: DataSource, callback: Callable) -> None:
         """Register callback for data updates"""
         if source not in self.data_callbacks:
             self.data_callbacks[source] = []
@@ -127,7 +127,7 @@ class MarketDataCollector:
 
         return [point for point in self.raw_data if point.source == source and point.timestamp >= cutoff_time]
 
-    async def _collect_data_source(self, source: DataSource):
+    async def _collect_data_source(self, source: DataSource) -> None:
         """Collect data from a specific source"""
 
         interval = self.collection_intervals[source]
@@ -140,7 +140,7 @@ class MarketDataCollector:
                 logger.error(f"Error collecting data from {source.value}: {e}")
                 await asyncio.sleep(60)  # Wait 1 minute on error
 
-    async def _collect_from_source(self, source: DataSource):
+    async def _collect_from_source(self, source: DataSource) -> None:
         """Collect data from a specific source"""
 
         if source == DataSource.GPU_METRICS:
@@ -156,7 +156,7 @@ class MarketDataCollector:
         elif source == DataSource.MARKET_SENTIMENT:
             await self._collect_market_sentiment()
 
-    async def _collect_gpu_metrics(self):
+    async def _collect_gpu_metrics(self) -> None:
         """Collect GPU utilization and performance metrics"""
 
         try:
@@ -189,7 +189,7 @@ class MarketDataCollector:
         except Exception as e:
             logger.error(f"Error collecting GPU metrics: {e}")
 
-    async def _collect_booking_data(self):
+    async def _collect_booking_data(self) -> None:
         """Collect booking and transaction data"""
 
         try:
@@ -224,7 +224,7 @@ class MarketDataCollector:
         except Exception as e:
             logger.error(f"Error collecting booking data: {e}")
 
-    async def _collect_regional_demand(self):
+    async def _collect_regional_demand(self) -> None:
         """Collect regional demand patterns"""
 
         try:
@@ -270,7 +270,7 @@ class MarketDataCollector:
         except Exception as e:
             logger.error(f"Error collecting regional demand: {e}")
 
-    async def _collect_competitor_prices(self):
+    async def _collect_competitor_prices(self) -> None:
         """Collect competitor pricing data"""
 
         try:
@@ -304,7 +304,7 @@ class MarketDataCollector:
         except Exception as e:
             logger.error(f"Error collecting competitor prices: {e}")
 
-    async def _collect_performance_data(self):
+    async def _collect_performance_data(self) -> None:
         """Collect provider performance metrics"""
 
         try:
@@ -338,7 +338,7 @@ class MarketDataCollector:
         except Exception as e:
             logger.error(f"Error collecting performance data: {e}")
 
-    async def _collect_market_sentiment(self):
+    async def _collect_market_sentiment(self) -> None:
         """Collect market sentiment data"""
 
         try:
@@ -370,7 +370,7 @@ class MarketDataCollector:
         except Exception as e:
             logger.error(f"Error collecting market sentiment: {e}")
 
-    async def _add_data_point(self, data_point: MarketDataPoint):
+    async def _add_data_point(self, data_point: MarketDataPoint) -> None:
         """Add a data point and notify callbacks"""
 
         # Add to raw data
@@ -391,7 +391,7 @@ class MarketDataCollector:
         # Broadcast via WebSocket
         await self._broadcast_data_point(data_point)
 
-    async def _aggregate_market_data(self):
+    async def _aggregate_market_data(self) -> None:
         """Aggregate raw market data into useful metrics"""
 
         while True:
@@ -402,7 +402,7 @@ class MarketDataCollector:
                 logger.error(f"Error aggregating market data: {e}")
                 await asyncio.sleep(30)
 
-    async def _perform_aggregation(self):
+    async def _perform_aggregation(self) -> None:
         """Perform the actual data aggregation"""
 
         regions = ["us_west", "us_east", "europe", "asia", "global"]
@@ -616,7 +616,7 @@ class MarketDataCollector:
 
         return max(0.1, min(0.95, overall_confidence))
 
-    async def _cleanup_old_data(self):
+    async def _cleanup_old_data(self) -> None:
         """Clean up old data points"""
 
         while True:
@@ -636,7 +636,7 @@ class MarketDataCollector:
                 logger.error(f"Error cleaning up old data: {e}")
                 await asyncio.sleep(300)
 
-    async def _start_websocket_server(self):
+    async def _start_websocket_server(self) -> None:
         """Start WebSocket server for real-time data streaming"""
 
         async def handle_websocket(websocket, path):
@@ -670,7 +670,7 @@ class MarketDataCollector:
         except Exception as e:
             logger.error(f"Failed to start WebSocket server: {e}")
 
-    async def _broadcast_data_point(self, data_point: MarketDataPoint):
+    async def _broadcast_data_point(self, data_point: MarketDataPoint) -> None:
         """Broadcast data point to all connected WebSocket clients"""
 
         if not self.websocket_connections:
diff --git a/apps/coordinator-api/src/app/services/marketplace_cache_optimizer.py b/apps/coordinator-api/src/app/services/marketplace_cache_optimizer.py
index 6ba28738..3b6bcedd 100755
--- a/apps/coordinator-api/src/app/services/marketplace_cache_optimizer.py
+++ b/apps/coordinator-api/src/app/services/marketplace_cache_optimizer.py
@@ -19,7 +19,7 @@ logger = get_logger(__name__)
 class LFU_LRU_Cache:
     """Hybrid Least-Frequently/Least-Recently Used Cache for in-memory optimization"""
     
-    def __init__(self, capacity: int):
+    def __init__(self, capacity: int) -> None:
         self.capacity = capacity
         self.cache = {}
         self.frequencies = {}
@@ -48,7 +48,7 @@ class LFU_LRU_Cache:
         
         return val
         
-    def put(self, key: str, value: Any):
+    def put(self, key: str, value: Any) -> None:
         if self.capacity == 0:
             return
             
@@ -75,7 +75,7 @@ class LFU_LRU_Cache:
 class MarketplaceDataOptimizer:
     """Advanced optimization engine for marketplace data access"""
     
-    def __init__(self, redis_url: str = "redis://localhost:6379/0"):
+    def __init__(self, redis_url: str = "redis://localhost:6379/0") -> None:
         self.redis_url = redis_url
         self.redis_client = None
         
@@ -91,7 +91,7 @@ class MarketplaceDataOptimizer:
             'historical_data': 3600   # 1 hour
         }
         
-    async def connect(self):
+    async def connect(self) -> None:
         """Establish connection to Redis L2 cache"""
         try:
             self.redis_client = redis.from_url(self.redis_url, decode_responses=True)
@@ -102,7 +102,7 @@ class MarketplaceDataOptimizer:
             logger.error(f"Failed to connect to Redis: {e}. Falling back to L1 cache only.")
             self.is_connected = False
             
-    async def disconnect(self):
+    async def disconnect(self) -> None:
         """Close Redis connection"""
         if self.redis_client:
             await self.redis_client.close()
@@ -146,7 +146,7 @@ class MarketplaceDataOptimizer:
                 
         return None
         
-    async def set_cached_data(self, namespace: str, params: Dict[str, Any], data: Any, custom_ttl: int = None):
+    async def set_cached_data(self, namespace: str, params: Dict[str, Any], data: Any, custom_ttl: int = None) -> None:
         """Store data in the multi-tier cache"""
         key = self._generate_cache_key(namespace, params)
         ttl = custom_ttl or self.ttls.get(namespace, 60)
@@ -170,7 +170,7 @@ class MarketplaceDataOptimizer:
             except Exception as e:
                 logger.warning(f"Redis set failed: {e}")
                 
-    async def invalidate_namespace(self, namespace: str):
+    async def invalidate_namespace(self, namespace: str) -> None:
         """Invalidate all cached items for a specific namespace"""
         if self.is_connected:
             try:
diff --git a/apps/coordinator-api/src/app/services/multi_chain_transaction_manager.py b/apps/coordinator-api/src/app/services/multi_chain_transaction_manager.py
index e6eef820..094bf9c8 100755
--- a/apps/coordinator-api/src/app/services/multi_chain_transaction_manager.py
+++ b/apps/coordinator-api/src/app/services/multi_chain_transaction_manager.py
@@ -302,12 +302,12 @@ class MultiChainTransactionManager:
             if priority:
                 stmt = stmt.where(MultiChainTransaction.priority == priority)
             if from_date:
-                stmt = stmt.where(MultiChainTransaction.created_at >= from_date)
+                stmt = stmt.where(MultiChainTransaction.created_at >= from_date)  # type: ignore[operator]
             if to_date:
-                stmt = stmt.where(MultiChainTransaction.created_at <= to_date)
+                stmt = stmt.where(MultiChainTransaction.created_at <= to_date)  # type: ignore[operator]
 
             # Sort by creation time (descending)
-            stmt = stmt.order_by(MultiChainTransaction.created_at.desc())
+            stmt = stmt.order_by(MultiChainTransaction.created_at.desc())  # type: ignore[arg-type]
 
             # Apply pagination
             stmt = stmt.offset(offset).limit(limit)
@@ -354,7 +354,7 @@ class MultiChainTransactionManager:
             cutoff_time = datetime.now(timezone.utc) - timedelta(hours=time_period_hours)
 
             # Query from database
-            stmt = select(MultiChainTransaction).where(MultiChainTransaction.created_at >= cutoff_time)
+            stmt = select(MultiChainTransaction).where(MultiChainTransaction.created_at >= cutoff_time)  # type: ignore[operator]
             if chain_id:
                 stmt = stmt.where(MultiChainTransaction.chain_id == chain_id)
 
diff --git a/apps/coordinator-api/src/app/services/python_13_optimized.py b/apps/coordinator-api/src/app/services/python_13_optimized.py
index 7cc45f1d..6bb157e5 100755
--- a/apps/coordinator-api/src/app/services/python_13_optimized.py
+++ b/apps/coordinator-api/src/app/services/python_13_optimized.py
@@ -313,7 +313,7 @@ class ServiceFactory:
 # Usage Examples
 # ============================================================================
 
-def demo_optimized_services():
+def demo_optimized_services() -> None:
     logger.info("Python 3.13.5 Optimized Services Demo")
     logger.info("Features:")
     logger.info("  - @override decorators for method safety")
diff --git a/apps/coordinator-api/src/app/services/regulatory_reporting.py b/apps/coordinator-api/src/app/services/regulatory_reporting.py
index 36c2b4f9..1d2450bc 100755
--- a/apps/coordinator-api/src/app/services/regulatory_reporting.py
+++ b/apps/coordinator-api/src/app/services/regulatory_reporting.py
@@ -773,7 +773,7 @@ def list_reports(report_type: str | None = None, status: str | None = None) -> l
 
 
 # Test function
-async def test_regulatory_reporting():
+async def test_regulatory_reporting() -> None:
     """Test regulatory reporting system"""
     logger.info("Testing Regulatory Reporting System")
 
diff --git a/apps/coordinator-api/src/app/services/tenant_management.py b/apps/coordinator-api/src/app/services/tenant_management.py
index a44eb926..9da61c12 100755
--- a/apps/coordinator-api/src/app/services/tenant_management.py
+++ b/apps/coordinator-api/src/app/services/tenant_management.py
@@ -58,7 +58,7 @@ except ImportError:
 class TenantManagementService:
     """Service for managing tenants in multi-tenant environment"""
 
-    def __init__(self, db: Session):
+    def __init__(self, db: Session) -> None:
         self.db = db
         self.logger = __import__("logging").getLogger(f"aitbc.{self.__class__.__name__}")
 
@@ -119,17 +119,17 @@ class TenantManagementService:
 
     async def get_tenant(self, tenant_id: str) -> Tenant | None:
         """Get tenant by ID"""
-        stmt = select(Tenant).where(Tenant.id == tenant_id)
+        stmt = select(Tenant).where(Tenant.id == tenant_id)  # type: ignore[arg-type]
         return self.db.execute(stmt).scalar_one_or_none()
 
     async def get_tenant_by_slug(self, slug: str) -> Tenant | None:
         """Get tenant by slug"""
-        stmt = select(Tenant).where(Tenant.slug == slug)
+        stmt = select(Tenant).where(Tenant.slug == slug)  # type: ignore[arg-type]
         return self.db.execute(stmt).scalar_one_or_none()
 
     async def get_tenant_by_domain(self, domain: str) -> Tenant | None:
         """Get tenant by domain"""
-        stmt = select(Tenant).where(Tenant.domain == domain)
+        stmt = select(Tenant).where(Tenant.domain == domain)  # type: ignore[arg-type]
         return self.db.execute(stmt).scalar_one_or_none()
 
     async def update_tenant(self, tenant_id: str, updates: dict[str, Any], actor_id: str, actor_type: str = "user") -> Tenant:
@@ -285,7 +285,7 @@ class TenantManagementService:
         """Add a user to a tenant"""
 
         # Check if user already exists
-        stmt = select(TenantUser).where(and_(TenantUser.tenant_id == tenant_id, TenantUser.user_id == user_id))
+        stmt = select(TenantUser).where(and_(TenantUser.tenant_id == tenant_id, TenantUser.user_id == user_id))  # type: ignore[arg-type]
         existing = self.db.execute(stmt).scalar_one_or_none()
 
         if existing:
@@ -318,7 +318,7 @@ class TenantManagementService:
     async def remove_user_from_tenant(self, tenant_id: str, user_id: str, actor_id: str = "system") -> bool:
         """Remove a user from a tenant"""
 
-        stmt = select(TenantUser).where(and_(TenantUser.tenant_id == tenant_id, TenantUser.user_id == user_id))
+        stmt = select(TenantUser).where(and_(TenantUser.tenant_id == tenant_id, TenantUser.user_id == user_id))  # type: ignore[arg-type]
         tenant_user = self.db.execute(stmt).scalar_one_or_none()
 
         if not tenant_user:
@@ -409,7 +409,7 @@ class TenantManagementService:
         """Revoke an API key"""
 
         stmt = select(TenantApiKey).where(
-            and_(TenantApiKey.tenant_id == tenant_id, TenantApiKey.key_id == key_id, TenantApiKey.is_active)
+            and_(TenantApiKey.tenant_id == tenant_id, TenantApiKey.key_id == key_id, TenantApiKey.is_active)  # type: ignore[arg-type]
         )
         api_key = self.db.execute(stmt).scalar_one_or_none()
 
@@ -460,11 +460,11 @@ class TenantManagementService:
             func.sum(UsageRecord.total_cost).label("total_cost"),
             func.count(UsageRecord.id).label("record_count"),
         ).where(
-            and_(UsageRecord.tenant_id == tenant_id, UsageRecord.usage_start >= start_date, UsageRecord.usage_end <= end_date)
+            and_(UsageRecord.tenant_id == tenant_id, UsageRecord.usage_start >= start_date, UsageRecord.usage_end <= end_date)  # type: ignore[arg-type]
         )
 
         if resource_type:
-            stmt = stmt.where(UsageRecord.resource_type == resource_type)
+            stmt = stmt.where(UsageRecord.resource_type == resource_type)  # type: ignore[arg-type]
 
         stmt = stmt.group_by(UsageRecord.resource_type)
 
@@ -485,7 +485,7 @@ class TenantManagementService:
     async def get_tenant_quotas(self, tenant_id: str) -> list[TenantQuota]:
         """Get all quotas for a tenant"""
 
-        stmt = select(TenantQuota).where(and_(TenantQuota.tenant_id == tenant_id, TenantQuota.is_active))
+        stmt = select(TenantQuota).where(and_(TenantQuota.tenant_id == tenant_id, TenantQuota.is_active))  # type: ignore[arg-type]
 
         return self.db.execute(stmt).scalars().all()
 
@@ -494,7 +494,7 @@ class TenantManagementService:
 
         # Get current quota
         stmt = select(TenantQuota).where(
-            and_(
+            and_(  # type: ignore[arg-type]
                 TenantQuota.tenant_id == tenant_id,
                 TenantQuota.resource_type == resource_type,
                 TenantQuota.is_active,
@@ -517,12 +517,12 @@ class TenantManagementService:
 
         return True
 
-    async def update_quota_usage(self, tenant_id: str, resource_type: str, quantity: float):
+    async def update_quota_usage(self, tenant_id: str, resource_type: str, quantity: float) -> None:
         """Update quota usage for a tenant"""
 
         # Get current quota
         stmt = select(TenantQuota).where(
-            and_(
+            and_(  # type: ignore[arg-type]
                 TenantQuota.tenant_id == tenant_id,
                 TenantQuota.resource_type == resource_type,
                 TenantQuota.is_active,
@@ -561,12 +561,12 @@ class TenantManagementService:
         if not conditions:
             return False
 
-        stmt = select(func.count(Tenant.id)).where(or_(*conditions))
+        stmt = select(func.count(Tenant.id)).where(or_(*conditions))  # type: ignore[arg-type]
         count = self.db.execute(stmt).scalar()
 
         return count > 0
 
-    async def _create_default_quotas(self, tenant_id: str, plan: str):
+    async def _create_default_quotas(self, tenant_id: str, plan: str) -> None:
         """Create default quotas based on plan"""
 
         # Define quota templates by plan
@@ -612,12 +612,12 @@ class TenantManagementService:
             )
             self.db.add(quota)
 
-    async def _revoke_all_api_keys(self, tenant_id: str):
+    async def _revoke_all_api_keys(self, tenant_id: str) -> None:
         """Revoke all API keys for a tenant"""
 
         stmt = (
             update(TenantApiKey)
-            .where(and_(TenantApiKey.tenant_id == tenant_id, TenantApiKey.is_active))
+            .where(and_(TenantApiKey.tenant_id == tenant_id, TenantApiKey.is_active))  # type: ignore[arg-type]
             .values(is_active=False, revoked_at=datetime.now(timezone.utc))
         )
 
diff --git a/apps/coordinator-api/src/app/services/usage_tracking.py b/apps/coordinator-api/src/app/services/usage_tracking.py
index af42f219..2ad684b4 100755
--- a/apps/coordinator-api/src/app/services/usage_tracking.py
+++ b/apps/coordinator-api/src/app/services/usage_tracking.py
@@ -46,7 +46,7 @@ class BillingEvent:
 class UsageTrackingService:
     """Service for tracking usage and generating billing metrics"""
 
-    def __init__(self, db: Session):
+    def __init__(self, db: Session) -> None:
         self.db = db
         self.logger = __import__("logging").getLogger(f"aitbc.{self.__class__.__name__}")
         self.executor = ThreadPoolExecutor(max_workers=4)
@@ -152,11 +152,11 @@ class UsageTrackingService:
             func.count(UsageRecord.id).label("record_count"),
             func.avg(UsageRecord.unit_price).label("avg_unit_price"),
         ).where(
-            and_(UsageRecord.tenant_id == tenant_id, UsageRecord.usage_start >= start_date, UsageRecord.usage_end <= end_date)
+            and_(UsageRecord.tenant_id == tenant_id, UsageRecord.usage_start >= start_date, UsageRecord.usage_end <= end_date)  # type: ignore[arg-type]
         )
 
         if resource_type:
-            stmt = stmt.where(UsageRecord.resource_type == resource_type)
+            stmt = stmt.where(UsageRecord.resource_type == resource_type)  # type: ignore[arg-type]
 
         stmt = stmt.group_by(UsageRecord.resource_type)
 
@@ -264,7 +264,7 @@ class UsageTrackingService:
             func.sum(UsageRecord.total_cost).label("total_cost"),
             func.count(UsageRecord.id).label("total_records"),
             func.count(func.distinct(UsageRecord.tenant_id)).label("active_tenants"),
-        ).where(and_(*base_conditions))
+        ).where(and_(*base_conditions))  # type: ignore[arg-type]
 
         totals = self.db.execute(stmt).first()
 
@@ -275,7 +275,7 @@ class UsageTrackingService:
                 func.sum(UsageRecord.quantity).label("quantity"),
                 func.sum(UsageRecord.total_cost).label("cost"),
             )
-            .where(and_(*base_conditions))
+            .where(and_(*base_conditions))  # type: ignore[arg-type]
             .group_by(UsageRecord.resource_type)
         )
 
@@ -285,7 +285,7 @@ class UsageTrackingService:
         if not tenant_id:
             stmt = (
                 select(UsageRecord.tenant_id, func.sum(UsageRecord.total_cost).label("total_cost"))
-                .where(and_(*base_conditions))
+                .where(and_(*base_conditions))  # type: ignore[arg-type]
                 .group_by(UsageRecord.tenant_id)
                 .order_by(desc("total_cost"))
                 .limit(10)
@@ -298,7 +298,7 @@ class UsageTrackingService:
         # Daily usage trend
         stmt = (
             select(func.date(UsageRecord.usage_start).label("date"), func.sum(UsageRecord.total_cost).label("daily_cost"))
-            .where(and_(*base_conditions))
+            .where(and_(*base_conditions))  # type: ignore[arg-type]
             .group_by(func.date(UsageRecord.usage_start))
             .order_by("date")
         )
@@ -349,7 +349,7 @@ class UsageTrackingService:
         stmt = (
             select(UsageRecord)
             .where(
-                and_(
+                and_(  # type: ignore[arg-type]
                     UsageRecord.tenant_id == tenant_id,
                     UsageRecord.usage_start >= start_date,
                     UsageRecord.usage_end <= end_date,
@@ -405,7 +405,7 @@ class UsageTrackingService:
         }
         return unit_map.get(resource_type, "units")
 
-    async def _emit_billing_event(self, event: BillingEvent):
+    async def _emit_billing_event(self, event: BillingEvent) -> None:
         """Emit billing event for processing"""
         # In a real implementation, this would publish to a message queue
         # For now, we'll just log it
@@ -415,7 +415,7 @@ class UsageTrackingService:
         """Check if invoice already exists for period"""
 
         stmt = select(Invoice).where(
-            and_(Invoice.tenant_id == tenant_id, Invoice.period_start == period_start, Invoice.period_end == period_end)
+            and_(Invoice.tenant_id == tenant_id, Invoice.period_start == period_start, Invoice.period_end == period_end)  # type: ignore[arg-type]
         )
 
         return self.db.execute(stmt).scalar_one_or_none()
@@ -424,7 +424,7 @@ class UsageTrackingService:
         """Generate unique invoice number"""
 
         # Get tenant info
-        stmt = select(Tenant).where(Tenant.id == tenant_id)
+        stmt = select(Tenant).where(Tenant.id == tenant_id)  # type: ignore[arg-type]
         tenant = self.db.execute(stmt).scalar_one_or_none()
 
         if not tenant:
@@ -437,15 +437,15 @@ class UsageTrackingService:
         # In a real implementation, use Redis or sequence table
         # For now, use a simple counter
         stmt = select(func.count(Invoice.id)).where(
-            and_(Invoice.tenant_id == tenant_id, func.date(Invoice.created_at) == func.current_date())
+            and_(Invoice.tenant_id == tenant_id, func.date(Invoice.created_at) == func.current_date())  # type: ignore[arg-type]
         )
         seq = self.db.execute(stmt).scalar() + 1
 
         return f"INV-{tenant.slug}-{date_str}-{seq:04d}"
 
-    async def _apply_credit(self, event: BillingEvent):
+    async def _apply_credit(self, event: BillingEvent) -> None:
         """Apply credit to tenant account"""
-        tenant = self.db.execute(select(Tenant).where(Tenant.id == event.tenant_id)).scalar_one_or_none()
+        tenant = self.db.execute(select(Tenant).where(Tenant.id == event.tenant_id)).scalar_one_or_none()  # type: ignore[arg-type]
         if not tenant:
             raise BillingError(f"Tenant not found: {event.tenant_id}")
         if event.total_amount <= 0:
@@ -468,9 +468,9 @@ class UsageTrackingService:
         self.db.commit()
         self.logger.info(f"Applied credit: tenant={event.tenant_id}, amount={event.total_amount}")
 
-    async def _apply_charge(self, event: BillingEvent):
+    async def _apply_charge(self, event: BillingEvent) -> None:
         """Apply charge to tenant account"""
-        tenant = self.db.execute(select(Tenant).where(Tenant.id == event.tenant_id)).scalar_one_or_none()
+        tenant = self.db.execute(select(Tenant).where(Tenant.id == event.tenant_id)).scalar_one_or_none()  # type: ignore[arg-type]
         if not tenant:
             raise BillingError(f"Tenant not found: {event.tenant_id}")
         if event.total_amount <= 0:
@@ -492,13 +492,13 @@ class UsageTrackingService:
         self.db.commit()
         self.logger.info(f"Applied charge: tenant={event.tenant_id}, amount={event.total_amount}")
 
-    async def _adjust_quota(self, event: BillingEvent):
+    async def _adjust_quota(self, event: BillingEvent) -> None:
         """Adjust quota based on billing event"""
         if not event.resource_type:
             raise BillingError("resource_type required for quota adjustment")
 
         stmt = select(TenantQuota).where(
-            and_(
+            and_(  # type: ignore[arg-type]
                 TenantQuota.tenant_id == event.tenant_id,
                 TenantQuota.resource_type == event.resource_type,
                 TenantQuota.is_active,
@@ -573,12 +573,12 @@ class UsageTrackingService:
 class BillingScheduler:
     """Scheduler for automated billing processes"""
 
-    def __init__(self, usage_service: UsageTrackingService):
+    def __init__(self, usage_service: UsageTrackingService) -> None:
         self.usage_service = usage_service
         self.logger = __import__("logging").getLogger(f"aitbc.{self.__class__.__name__}")
         self.running = False
 
-    async def start(self):
+    async def start(self) -> None:
         """Start billing scheduler"""
         if self.running:
             return
@@ -592,12 +592,12 @@ class BillingScheduler:
         # Schedule monthly invoicing
         asyncio.create_task(self._monthly_invoicing())
 
-    async def stop(self):
+    async def stop(self) -> None:
         """Stop billing scheduler"""
         self.running = False
         self.logger.info("Billing scheduler stopped")
 
-    async def _daily_tasks(self):
+    async def _daily_tasks(self) -> None:
         """Run daily billing tasks"""
         while self.running:
             try:
@@ -617,7 +617,7 @@ class BillingScheduler:
                 self.logger.error(f"Error in daily tasks: {e}")
                 await asyncio.sleep(3600)  # Retry in 1 hour
 
-    async def _monthly_invoicing(self):
+    async def _monthly_invoicing(self) -> None:
         """Generate monthly invoices"""
         while self.running:
             try:
@@ -643,14 +643,14 @@ class BillingScheduler:
                 self.logger.error(f"Error in monthly invoicing: {e}")
                 await asyncio.sleep(86400)  # Retry in 1 day
 
-    async def _reset_daily_quotas(self):
+    async def _reset_daily_quotas(self) -> None:
         """Reset used_value to 0 for all expired daily quotas and advance their period."""
         now = datetime.now(timezone.utc)
         stmt = select(TenantQuota).where(
-            and_(
+            and_(  # type: ignore[arg-type]
                 TenantQuota.period_type == "daily",
                 TenantQuota.is_active,
-                TenantQuota.period_end <= now,
+                TenantQuota.period_end <= now  # type: ignore[operator],
             )
         )
         expired = self.usage_service.db.execute(stmt).scalars().all()
@@ -662,14 +662,14 @@ class BillingScheduler:
             self.usage_service.db.commit()
         self.logger.info(f"Reset {len(expired)} expired daily quotas")
 
-    async def _process_pending_events(self):
+    async def _process_pending_events(self) -> None:
         """Process pending billing events from the billing_events table."""
         # In a production system this would read from a message queue or
         # a pending_billing_events table.  For now we delegate to the
         # usage service's batch processor which handles credit/charge/quota.
         self.logger.info("Processing pending billing events")
 
-    async def _generate_monthly_invoices(self):
+    async def _generate_monthly_invoices(self) -> None:
         """Generate invoices for all active tenants for the previous month."""
         now = datetime.now(timezone.utc)
         # Previous month boundaries
@@ -678,7 +678,7 @@ class BillingScheduler:
         last_month_start = last_month_end.replace(day=1, hour=0, minute=0, second=0, microsecond=0)
 
         # Get all active tenants
-        stmt = select(Tenant).where(Tenant.status == "active")
+        stmt = select(Tenant).where(Tenant.status == "active")  # type: ignore[arg-type]
         tenants = self.usage_service.db.execute(stmt).scalars().all()
 
         generated = 0