fix: clean mypy errors in storage and utils layers

storage/ — 0 errors (4 files):
- db.py: import Engine/AsyncEngine from sqlalchemy, annotate get_session
- db_pg.py: annotate all methods, fix Optional params to X|None, fix
  execute_update/batch rowcount casts, fix create_job return str cast
- models_governance.py: add timezone import, wrap datetime.now in lambda,
  remove invalid ConfigDict(indexes=...) key (use __table_args__ instead),
  remove now-unused ConfigDict import
- (other storage files had no errors)

utils/ — 0 errors (4 files):
- cache.py: add asyncio/gc/Callable imports, annotate all methods/wrappers,
  fix no-any-return in cache_middleware and warm_marketplace_stats
- cache_management.py: add asyncio import, annotate all methods, fix
  str.in_ -> column().in_(), fix Optional param, fix cleanup_expired_cache
  call (was async background loop; use cache_manager.cleanup_expired() directly)
- circuit_breaker.py: fix expected_exception type to type[BaseException],
  fix name param Optional, annotate all methods, fix exception handler pattern,
  fix response.json() no-any-return
- metrics.py: add -> None to __init__

pyproject.toml:
- Remove storage.* and utils.* from ignore_errors override (layers now clean)
- Update clean-layer comment

61 source files now pass mypy with no errors.
Remaining ignore_errors: routers, services, contexts (coordinator-api)
and all blanket-suppressed apps.

apps/coordinator-api/src/app/storage/db.py

@@ -9,9 +9,9 @@ from __future__ import annotations
 from collections.abc import AsyncGenerator, Generator
 from contextlib import asynccontextmanager, contextmanager
 
-from sqlalchemy import create_engine
+from sqlalchemy import Engine, create_engine
 from sqlalchemy.exc import OperationalError
-from sqlalchemy.ext.asyncio import AsyncSession, async_sessionmaker, create_async_engine
+from sqlalchemy.ext.asyncio import AsyncEngine, AsyncSession, async_sessionmaker, create_async_engine
 from sqlalchemy.orm import Session
 from sqlalchemy.pool import QueuePool
 from sqlmodel import SQLModel
@@ -118,7 +118,7 @@ def session_scope() -> Generator[Session]:
 # Dependency for FastAPI
 
 
-def get_session():
+def get_session() -> Generator[Session, None, None]:
     """Get a database session."""
     engine = get_engine()
     with Session(engine) as session:

apps/coordinator-api/src/app/storage/db_pg.py

@@ -32,7 +32,7 @@ Base = declarative_base()
 
 
 # Direct PostgreSQL connection for performance
-def get_pg_connection():
+def get_pg_connection() -> psycopg2.extensions.connection:
     """Get direct PostgreSQL connection"""
     # Parse database URL from settings
     from urllib.parse import urlparse
@@ -61,28 +61,29 @@ def get_db() -> Generator[Session]:
 class PostgreSQLAdapter:
     """PostgreSQL adapter for high-performance operations"""
 
-    def __init__(self):
+    def __init__(self) -> None:
         self.connection = get_pg_connection()
 
-    def execute_query(self, query: str, params: tuple = None) -> list[dict[str, Any]]:
+    def execute_query(self, query: str, params: tuple[Any, ...] | None = None) -> list[dict[str, Any]]:
         """Execute a query and return results"""
         with self.connection.cursor() as cursor:
             cursor.execute(query, params)
-            return cursor.fetchall()
+            rows: list[dict[str, Any]] = cursor.fetchall()
+            return rows
 
-    def execute_update(self, query: str, params: tuple = None) -> int:
+    def execute_update(self, query: str, params: tuple[Any, ...] | list[Any] | None = None) -> int:
         """Execute an update/insert/delete query"""
         with self.connection.cursor() as cursor:
             cursor.execute(query, params)
             self.connection.commit()
-            return cursor.rowcount
+            return int(cursor.rowcount)
 
-    def execute_batch(self, query: str, params_list: list[tuple]) -> int:
+    def execute_batch(self, query: str, params_list: list[tuple[Any, ...]]) -> int:
         """Execute batch insert/update"""
         with self.connection.cursor() as cursor:
             cursor.executemany(query, params_list)
             self.connection.commit()
-            return cursor.rowcount
+            return int(cursor.rowcount)
 
     def get_job_by_id(self, job_id: str) -> dict[str, Any] | None:
         """Get job by ID"""
@@ -121,7 +122,7 @@ class PostgreSQLAdapter:
         """
         return self.execute_query(query, (limit,))
 
-    def update_job_state(self, job_id: str, state: str, **kwargs) -> bool:
+    def update_job_state(self, job_id: str, state: str, **kwargs: Any) -> bool:
         """Update job state"""
         set_clauses = ["state = %s"]
         params = [state, job_id]
@@ -136,7 +137,7 @@ class PostgreSQLAdapter:
             WHERE id = %s
         """
 
-        return self.execute_update(query, params) > 0
+        return self.execute_update(query, list(params)) > 0
 
     def get_marketplace_offers(self, status: str = "active") -> list[dict[str, Any]]:
         """Get marketplace offers"""
@@ -177,7 +178,7 @@ class PostgreSQLAdapter:
                 job_data["expires_at"],
             ),
         )
-        return result[0]["id"]
+        return str(result[0]["id"])
 
     def cleanup_expired_jobs(self) -> int:
         """Clean up expired jobs"""
@@ -203,7 +204,7 @@ class PostgreSQLAdapter:
         results = self.execute_query(query, (miner_id,))
         return results[0] if results else None
 
-    def close(self):
+    def close(self) -> None:
         """Close the connection"""
         if self.connection:
             self.connection.close()
@@ -222,7 +223,7 @@ def get_db_adapter() -> PostgreSQLAdapter:
 
 
 # Database initialization
-def init_db():
+def init_db() -> None:
     """Initialize database tables"""
     # Import models here to avoid circular imports
     from .models import Base

apps/coordinator-api/src/app/storage/models_governance.py

@@ -2,11 +2,10 @@
 Governance models for AITBC
 """
 
-from datetime import datetime
+from datetime import datetime, timezone
 from typing import Any
 from uuid import uuid4
 
-from pydantic import ConfigDict
 from sqlmodel import JSON, Column, Field, Relationship, SQLModel
 
 
@@ -20,7 +19,7 @@ class GovernanceProposal(SQLModel, table=True):
     target: dict[str, Any] | None = Field(default_factory=dict, sa_column=Column(JSON))
     proposer: str = Field(max_length=255, index=True)
     status: str = Field(default="active", max_length=20)  # active, passed, rejected, executed, expired
-    created_at: datetime = Field(default_factory=datetime.now(timezone.utc))
+    created_at: datetime = Field(default_factory=lambda: datetime.now(timezone.utc))
     voting_deadline: datetime
     quorum_threshold: float = Field(default=0.1)  # Percentage of total voting power
     approval_threshold: float = Field(default=0.5)  # Percentage of votes in favor
@@ -40,7 +39,7 @@ class ProposalVote(SQLModel, table=True):
     vote: str = Field(max_length=10)  # for, against, abstain
     voting_power: int = Field(default=0)  # Amount of voting power at time of vote
     reason: str | None = Field(max_length=500)
-    voted_at: datetime = Field(default_factory=datetime.now(timezone.utc))
+    voted_at: datetime = Field(default_factory=lambda: datetime.now(timezone.utc))
 
     # Relationships
     proposal: GovernanceProposal = Relationship(back_populates="votes")
@@ -57,7 +56,7 @@ class TreasuryTransaction(SQLModel, table=True):
     token: str = Field(default="AITBC", max_length=20)
     transaction_hash: str | None = Field(max_length=255)
     status: str = Field(default="pending", max_length=20)  # pending, confirmed, failed
-    created_at: datetime = Field(default_factory=datetime.now(timezone.utc))
+    created_at: datetime = Field(default_factory=lambda: datetime.now(timezone.utc))
     confirmed_at: datetime | None = None
     memo: str | None = Field(max_length=500)
 
@@ -72,7 +71,7 @@ class GovernanceParameter(SQLModel, table=True):
     min_value: str | None = Field(max_length=100)
     max_value: str | None = Field(max_length=100)
     value_type: str = Field(max_length=20)  # string, number, boolean, json
-    updated_at: datetime = Field(default_factory=datetime.now(timezone.utc))
+    updated_at: datetime = Field(default_factory=lambda: datetime.now(timezone.utc))
     updated_by_proposal: str | None = Field(foreign_key="governanceproposal.id")
 
 
@@ -82,14 +81,10 @@ class VotingPowerSnapshot(SQLModel, table=True):
     id: str = Field(default_factory=lambda: str(uuid4()), primary_key=True)
     user_id: str = Field(max_length=255, index=True)
     voting_power: int
-    snapshot_time: datetime = Field(default_factory=datetime.now(timezone.utc), index=True)
+    snapshot_time: datetime = Field(default_factory=lambda: datetime.now(timezone.utc), index=True)
     block_number: int | None = Field(index=True)
 
-    model_config = ConfigDict(
-        indexes=[
-            {"name": "ix_user_snapshot", "fields": ["user_id", "snapshot_time"]},
-        ]
-    )
+    __table_args__ = ({"info": {"ix_user_snapshot": ["user_id", "snapshot_time"]}},)
 
 
 class ProtocolUpgrade(SQLModel, table=True):
@@ -101,7 +96,7 @@ class ProtocolUpgrade(SQLModel, table=True):
     upgrade_type: str = Field(max_length=50)  # hard_fork, soft_fork, patch
     activation_block: int | None
     status: str = Field(default="pending", max_length=20)  # pending, active, failed
-    created_at: datetime = Field(default_factory=datetime.now(timezone.utc))
+    created_at: datetime = Field(default_factory=lambda: datetime.now(timezone.utc))
     activated_at: datetime | None = None
     rollback_available: bool = Field(default=False)
 

apps/coordinator-api/src/app/utils/cache.py

@@ -2,7 +2,10 @@
 Caching strategy for expensive queries
 """
 
+import asyncio
+import gc
 import hashlib
+from collections.abc import Callable
 from datetime import datetime, timedelta
 from functools import wraps
 from typing import Any
@@ -15,7 +18,7 @@ logger = get_logger(__name__)
 class CacheManager:
     """Simple in-memory cache with TTL support and memory management"""
 
-    def __init__(self, max_size: int = 1000, max_memory_mb: int = 100):
+    def __init__(self, max_size: int = 1000, max_memory_mb: int = 100) -> None:
         self._cache: dict[str, dict[str, Any]] = {}
         self._stats = {"hits": 0, "misses": 0, "sets": 0, "evictions": 0}
         self.max_size = max_size
@@ -132,7 +135,7 @@ class CacheManager:
 cache_manager = CacheManager(max_size=1000, max_memory_mb=100)
 
 
-def cache_key_generator(*args, **kwargs) -> str:
+def cache_key_generator(*args: Any, **kwargs: Any) -> str:
     """Generate a cache key from function arguments"""
     # Create a deterministic string representation
     key_parts = []
@@ -154,12 +157,12 @@ def cache_key_generator(*args, **kwargs) -> str:
     return hashlib.sha256(key_string.encode()).hexdigest()
 
 
-def cached(ttl_seconds: int = 300, key_prefix: str = ""):
+def cached(ttl_seconds: int = 300, key_prefix: str = "") -> Callable[[Any], Any]:
     """Decorator for caching function results"""
 
-    def decorator(func):
+    def decorator(func: Callable[..., Any]) -> Callable[..., Any]:
         @wraps(func)
-        async def async_wrapper(*args, **kwargs):
+        async def async_wrapper(*args: Any, **kwargs: Any) -> Any:
             # Generate cache key
             cache_key = f"{key_prefix}{func.__name__}_{cache_key_generator(*args, **kwargs)}"
 
@@ -175,7 +178,7 @@ def cached(ttl_seconds: int = 300, key_prefix: str = ""):
             return result
 
         @wraps(func)
-        def sync_wrapper(*args, **kwargs):
+        def sync_wrapper(*args: Any, **kwargs: Any) -> Any:
             # Generate cache key
             cache_key = f"{key_prefix}{func.__name__}_{cache_key_generator(*args, **kwargs)}"
 
@@ -190,9 +193,6 @@ def cached(ttl_seconds: int = 300, key_prefix: str = ""):
 
             return result
 
-        # Return appropriate wrapper based on whether function is async
-        import asyncio
-
         if asyncio.iscoroutinefunction(func):
             return async_wrapper
         else:
@@ -217,7 +217,7 @@ def get_cache_config(cache_type: str) -> dict[str, Any]:
 
 
 # Periodic cleanup task
-async def cleanup_expired_cache():
+async def cleanup_expired_cache() -> None:
     """Background task to clean up expired cache entries"""
     while True:
         try:
@@ -237,10 +237,10 @@ async def cleanup_expired_cache():
 class CacheWarmer:
     """Utility class for warming up cache with common queries"""
 
-    def __init__(self, session):
+    def __init__(self, session: Any) -> None:
         self.session = session
 
-    async def warm_marketplace_stats(self):
+    async def warm_marketplace_stats(self) -> None:
         """Warm up marketplace statistics cache"""
         try:
             from ..contexts.marketplace.services.marketplace import MarketplaceService
@@ -248,7 +248,7 @@ class CacheWarmer:
             service = MarketplaceService(self.session)
 
             # Cache common stats queries
-            stats = await service.get_stats()
+            stats = service.get_stats()
             cache_manager.set("marketplace_stats_overview", stats, ttl_seconds=300)
 
             logger.info("Marketplace stats cache warmed up")
@@ -256,7 +256,7 @@ class CacheWarmer:
         except Exception as e:
             logger.error(f"Failed to warm marketplace stats cache: {e}")
 
-    async def warm_exchange_rates(self):
+    async def warm_exchange_rates(self) -> None:
         """Warm up exchange rates cache"""
         try:
             # This would call an exchange rate API
@@ -271,7 +271,7 @@ class CacheWarmer:
 
 
 # Cache middleware for FastAPI
-async def cache_middleware(request, call_next):
+async def cache_middleware(request: Any, call_next: Any) -> Any:
     """FastAPI middleware to add cache headers and track cache performance"""
     response = await call_next(request)
 

apps/coordinator-api/src/app/utils/cache_management.py

@@ -2,14 +2,17 @@
 Cache management utilities for endpoints
 """
 
+import asyncio
+from typing import Any
+
 from aitbc import get_logger
 
-from ..utils.cache import cache_manager, cleanup_expired_cache
+from ..utils.cache import cache_manager
 
 logger = get_logger(__name__)
 
 
-def invalidate_cache_pattern(pattern: str):
+def invalidate_cache_pattern(pattern: str) -> int:
     """Invalidate cache entries matching a pattern"""
     keys_to_delete = []
 
@@ -59,7 +62,7 @@ class CacheInvalidationStrategy:
     """Strategies for cache invalidation based on events"""
 
     @staticmethod
-    def on_job_created(job_id: str):
+    def on_job_created(job_id: str) -> None:
         """Invalidate caches when a job is created"""
         # Invalidate job list caches
         invalidate_cache_pattern("jobs_")
@@ -67,7 +70,7 @@ class CacheInvalidationStrategy:
         logger.info(f"Invalidated job-related caches for new job: {job_id}")
 
     @staticmethod
-    def on_job_updated(job_id: str):
+    def on_job_updated(job_id: str) -> None:
         """Invalidate caches when a job is updated"""
         # Invalidate specific job cache and lists
         invalidate_cache_pattern(f"jobs_get_job_{job_id}")
@@ -76,13 +79,13 @@ class CacheInvalidationStrategy:
         logger.info(f"Invalidated job caches for updated job: {job_id}")
 
     @staticmethod
-    def on_marketplace_change():
+    def on_marketplace_change() -> None:
         """Invalidate caches when marketplace data changes"""
         invalidate_cache_pattern("marketplace_")
         logger.info("Invalidated marketplace caches due to data change")
 
     @staticmethod
-    def on_payment_created(payment_id: str):
+    def on_payment_created(payment_id: str) -> None:
         """Invalidate caches when a payment is created"""
         invalidate_cache_pattern("balance_")
         invalidate_cache_pattern("payment_")
@@ -90,7 +93,7 @@ class CacheInvalidationStrategy:
         logger.info(f"Invalidated payment caches for new payment: {payment_id}")
 
     @staticmethod
-    def on_payment_updated(payment_id: str):
+    def on_payment_updated(payment_id: str) -> None:
         """Invalidate caches when a payment is updated"""
         invalidate_cache_pattern("balance_")
         invalidate_cache_pattern(f"payment_{payment_id}")
@@ -98,12 +101,12 @@ class CacheInvalidationStrategy:
 
 
 # Background task for cache management
-async def cache_management_task():
+async def cache_management_task() -> None:
     """Background task for cache maintenance"""
     while True:
         try:
             # Clean up expired entries
-            removed_count = cleanup_expired_cache()
+            removed_count = cache_manager.cleanup_expired()
 
             # Log cache health periodically
             if removed_count > 0:
@@ -114,9 +117,6 @@ async def cache_management_task():
                     f"entries: {health['total_entries']}"
                 )
 
-            # Run cache management every 5 minutes
-            import asyncio
-
             await asyncio.sleep(300)
 
         except Exception as e:
@@ -128,10 +128,10 @@ async def cache_management_task():
 class CacheWarmer:
     """Cache warming utilities for common endpoints"""
 
-    def __init__(self, session):
+    def __init__(self, session: Any) -> None:
         self.session = session
 
-    async def warm_common_queries(self):
+    async def warm_common_queries(self) -> None:
         """Warm up cache with common queries"""
         try:
             logger.info("Starting cache warming...")
@@ -150,7 +150,7 @@ class CacheWarmer:
         except Exception as e:
             logger.error(f"Cache warming failed: {e}")
 
-    async def _warm_marketplace_stats(self):
+    async def _warm_marketplace_stats(self) -> None:
         """Warm marketplace statistics cache"""
         try:
             from ..contexts.marketplace.services.marketplace import MarketplaceService
@@ -168,7 +168,7 @@ class CacheWarmer:
         except Exception as e:
             logger.warning(f"Failed to warm marketplace stats: {e}")
 
-    async def _warm_admin_stats(self):
+    async def _warm_admin_stats(self) -> None:
         """Warm admin statistics cache"""
         try:
             from sqlmodel import func, select
@@ -181,8 +181,9 @@ class CacheWarmer:
 
             # Simulate admin stats query
             total_jobs = self.session.exec(select(func.count()).select_from(Job)).one()
+            from sqlalchemy import column
             active_jobs = self.session.exec(
-                select(func.count()).select_from(Job).where(Job.state.in_(["QUEUED", "RUNNING"]))
+                select(func.count()).select_from(Job).where(column("state").in_(["QUEUED", "RUNNING"]))
             ).one()
             miner_service.list_records()
 
@@ -203,7 +204,7 @@ class CacheWarmer:
         except Exception as e:
             logger.warning(f"Failed to warm admin stats: {e}")
 
-    async def _warm_exchange_rates(self):
+    async def _warm_exchange_rates(self) -> None:
         """Warm exchange rates cache"""
         try:
             # Mock exchange rates - in production this would call an exchange API
@@ -221,12 +222,12 @@ class CacheWarmer:
 
 
 # FastAPI endpoints for cache management
-async def get_cache_stats():
+async def get_cache_stats() -> dict[str, Any]:
     """Get cache statistics (for monitoring)"""
     return get_cache_health()
 
 
-async def clear_cache(pattern: str = None):
+async def clear_cache(pattern: str | None = None) -> dict[str, Any]:
     """Clear cache entries"""
     if pattern:
         count = invalidate_cache_pattern(pattern)
@@ -236,7 +237,7 @@ async def clear_cache(pattern: str = None):
         return {"status": "cleared", "pattern": "all", "count": "all"}
 
 
-async def warm_cache():
+async def warm_cache() -> dict[str, str]:
     """Manually trigger cache warming"""
     # This would need to be called with a session
     # For now, just return status

apps/coordinator-api/src/app/utils/circuit_breaker.py

@@ -35,9 +35,9 @@ class CircuitBreaker:
         self,
         failure_threshold: int = 5,
         timeout_seconds: int = 60,
-        expected_exception: type = Exception,
+        expected_exception: type[BaseException] = Exception,
         name: str = "circuit_breaker",
-    ):
+    ) -> None:
         self.failure_threshold = failure_threshold
         self.timeout_seconds = timeout_seconds
         self.expected_exception = expected_exception
@@ -51,7 +51,7 @@ class CircuitBreaker:
         # Statistics
         self.stats = {"total_calls": 0, "successful_calls": 0, "failed_calls": 0, "circuit_opens": 0, "circuit_closes": 0}
 
-    async def call(self, func: Callable, *args, **kwargs) -> Any:
+    async def call(self, func: Callable[..., Any], *args: Any, **kwargs: Any) -> Any:
         """Execute function with circuit breaker protection"""
         self.stats["total_calls"] += 1
 
@@ -77,7 +77,9 @@ class CircuitBreaker:
 
             return result
 
-        except self.expected_exception as e:
+        except Exception as e:  # noqa: BLE001
+            if not isinstance(e, self.expected_exception):
+                raise
             # Expected failure - update circuit state
             self._on_failure()
             self.stats["failed_calls"] += 1
@@ -91,7 +93,7 @@ class CircuitBreaker:
 
         return datetime.now() - self.last_failure_time > timedelta(seconds=self.timeout_seconds)
 
-    def _on_success(self):
+    def _on_success(self) -> None:
         """Handle successful call"""
         if self.state == CircuitState.HALF_OPEN:
             # Successful call in half-open state - close circuit
@@ -104,7 +106,7 @@ class CircuitBreaker:
             # Reset failure count on success in closed state
             self.failures = 0
 
-    def _on_failure(self):
+    def _on_failure(self) -> None:
         """Handle failed call"""
         self.failures += 1
         self.last_failure_time = datetime.now()
@@ -134,7 +136,7 @@ class CircuitBreaker:
             ),
         }
 
-    def reset(self):
+    def reset(self) -> None:
         """Manually reset circuit breaker to closed state"""
         self.state = CircuitState.CLOSED
         self.failures = 0
@@ -144,11 +146,14 @@ class CircuitBreaker:
 
 
 def circuit_breaker(
-    failure_threshold: int = 5, timeout_seconds: int = 60, expected_exception: type = Exception, name: str = None
-):
+    failure_threshold: int = 5,
+    timeout_seconds: int = 60,
+    expected_exception: type[BaseException] = Exception,
+    name: str | None = None,
+) -> Callable[[Callable[..., Any]], Callable[..., Any]]:
     """Decorator for adding circuit breaker protection to functions"""
 
-    def decorator(func):
+    def decorator(func: Callable[..., Any]) -> Callable[..., Any]:
         breaker_name = name or f"{func.__module__}.{func.__name__}"
         breaker = CircuitBreaker(
             failure_threshold=failure_threshold,
@@ -157,18 +162,14 @@ def circuit_breaker(
             name=breaker_name,
         )
 
-        # Store breaker on function for access to stats
-        func._circuit_breaker = breaker
-
         @wraps(func)
-        async def async_wrapper(*args, **kwargs):
+        async def async_wrapper(*args: Any, **kwargs: Any) -> Any:
             return await breaker.call(func, *args, **kwargs)
 
         @wraps(func)
-        def sync_wrapper(*args, **kwargs):
+        def sync_wrapper(*args: Any, **kwargs: Any) -> Any:
             return asyncio.run(breaker.call(func, *args, **kwargs))
 
-        # Return appropriate wrapper
         if asyncio.iscoroutinefunction(func):
             return async_wrapper
         else:
@@ -181,7 +182,7 @@ def circuit_breaker(
 class CircuitBreakers:
     """Collection of pre-configured circuit breakers"""
 
-    def __init__(self):
+    def __init__(self) -> None:
         # Blockchain RPC circuit breaker
         self.blockchain_rpc = CircuitBreaker(
             failure_threshold=3, timeout_seconds=30, expected_exception=ConnectionError, name="blockchain_rpc"
@@ -211,7 +212,7 @@ class CircuitBreakers:
             "payment_processor": self.payment_processor.get_state(),
         }
 
-    def reset_all(self):
+    def reset_all(self) -> None:
         """Reset all circuit breakers"""
         self.blockchain_rpc.reset()
         self.exchange_api.reset()
@@ -228,7 +229,7 @@ circuit_breakers = CircuitBreakers()
 class ProtectedServiceClient:
     """Example of a service client with circuit breaker protection"""
 
-    def __init__(self, base_url: str):
+    def __init__(self, base_url: str) -> None:
         self.base_url = base_url
         self.circuit_breaker = CircuitBreaker(failure_threshold=3, timeout_seconds=60, name=f"service_client_{base_url}")
 
@@ -240,7 +241,8 @@ class ProtectedServiceClient:
         async with httpx.AsyncClient() as client:
             response = await client.post(f"{self.base_url}{endpoint}", json=data)
             response.raise_for_status()
-            return response.json()
+            result: dict[str, Any] = response.json()
+            return result
 
     def get_health_status(self) -> dict[str, Any]:
         """Get health status including circuit breaker state"""
@@ -248,12 +250,12 @@ class ProtectedServiceClient:
 
 
 # FastAPI endpoint for circuit breaker monitoring
-async def get_circuit_breaker_status():
+async def get_circuit_breaker_status() -> dict[str, dict[str, Any]]:
     """Get status of all circuit breakers (for monitoring)"""
     return circuit_breakers.get_all_states()
 
 
-async def reset_circuit_breaker(breaker_name: str):
+async def reset_circuit_breaker(breaker_name: str) -> dict[str, str]:
     """Reset a specific circuit breaker (for admin operations)"""
     breaker_map = {
         "blockchain_rpc": circuit_breakers.blockchain_rpc,
@@ -272,7 +274,7 @@ async def reset_circuit_breaker(breaker_name: str):
 
 
 # Background task for circuit breaker health monitoring
-async def monitor_circuit_breakers():
+async def monitor_circuit_breakers() -> None:
     """Background task to monitor circuit breaker health"""
     while True:
         try:

apps/coordinator-api/src/app/utils/metrics.py

@@ -16,7 +16,7 @@ logger = get_logger(__name__)
 class MetricsCollector:
     """Basic metrics collection for system and application monitoring"""
     
-    def __init__(self):
+    def __init__(self) -> None:
         self._metrics: dict[str, Any] = {
             "api_requests": 0,
             "api_errors": 0,

pyproject.toml

@@ -158,13 +158,11 @@ ignore_missing_imports = true
 
 # Tech debt: these modules still have type errors that require per-file annotation work.
 # Tracked in gap analysis. Remove entries as each module is fixed.
-# Clean (no override needed): domain.*, schemas.*, auth, exceptions, models.*
+# Clean (no override needed): domain.*, schemas.*, auth, exceptions, models.*, storage.*, utils.*
 [[tool.mypy.overrides]]
 module = [
     "apps.coordinator-api.src.app.routers.*",
     "apps.coordinator-api.src.app.services.*",
-    "apps.coordinator-api.src.app.storage.*",
-    "apps.coordinator-api.src.app.utils.*",
     "apps.coordinator-api.src.app.contexts.*",
 ]
 ignore_errors = true