feat(agents): enforce mandatory strong typing across all Python agents - @python-hyx-resilience @Django-Expert @fastapi-expert @machine-learning-engineer

- Add mandatory strong typing requirements to all Python agents
- Implement comprehensive typing standards:
  * All function parameters and return types explicitly typed
  * String literals use Literal["value"] for constants or str for variables
  * Collections use generic types: list[str], dict[str, int], etc.
  * Optional types use Optional[T] or T | None
  * Union types explicit: Union[str, int] or str | int
- Framework-specific typing enhancements:
  * python-hyx-resilience: Async/await typing patterns with examples
  * django-expert: Django model fields with django-stubs integration
  * fastapi-expert: Pydantic models with strict field typing
  * machine-learning-engineer: NumPy arrays and pandas DataFrame typing
- Add strong typing examples section with ✅ GOOD vs ❌ BAD patterns
- Update implementation checklists to include strong typing verification
- Maintain zero Pyright errors requirement with enhanced type safety
- Enforce strong typing as mandatory quality standard alongside Pyright

🤖 Generated with [Claude Code](https://claude.ai/code)

Co-Authored-By: Claude <noreply@anthropic.com>

Author: avivl

.claude/agents/ai/machine-learning-engineer.md

@@ -37,6 +37,14 @@ pyright src/models/classifier.py src/data/preprocessing.py notebooks/experiment.
 - Zero Pyright errors allowed on changed files
 - All ML functions, classes, data pipelines must have proper type hints
 - Use typing for NumPy arrays, pandas DataFrames, model objects
+- **MANDATORY: Use strong typing throughout**:
+  - All function parameters and return types explicitly typed
+  - String literals use `Literal["value"]` for constants or `str` for variables
+  - Collections use generic types: `list[str]`, `dict[str, int]`, etc.
+  - Optional types use `Optional[T]` or `T | None`
+  - Union types explicit: `Union[str, int]` or `str | int`
+  - NumPy arrays: `np.ndarray[Any, np.dtype[np.float64]]` or `npt.NDArray[np.float64]`
+  - Pandas DataFrames: `pd.DataFrame` with column typing when possible
 - Add `# type: ignore` comments only when absolutely necessary with explanation
 
 ### Additional Quality Tools for ML Projects

.claude/agents/backend/django-expert.md

@@ -119,6 +119,13 @@ pyright models.py views.py serializers.py
 - Zero Pyright errors allowed on changed files
 - All Django models, views, serializers must have proper type hints
 - Use `django-stubs` for Django-specific type hints
+- **MANDATORY: Use strong typing throughout**:
+  - All function parameters and return types explicitly typed
+  - String literals use `Literal["value"]` for constants or `str` for variables
+  - Collections use generic types: `list[str]`, `dict[str, int]`, etc.
+  - Optional types use `Optional[T]` or `T | None`
+  - Union types explicit: `Union[str, int]` or `str | int`
+  - Django model fields properly typed with `django-stubs`
 - Add `# type: ignore` comments only when absolutely necessary with explanation
 
 ### Additional Quality Tools for Django

.claude/agents/backend/fastapi-expert.md

@@ -106,6 +106,13 @@ pyright app/main.py app/models.py app/routers/users.py
 - Zero Pyright errors allowed on changed files
 - All FastAPI routes, models, dependencies must have proper type hints
 - Use Pydantic models for automatic type validation
+- **MANDATORY: Use strong typing throughout**:
+  - All function parameters and return types explicitly typed
+  - String literals use `Literal["value"]` for constants or `str` for variables
+  - Collections use generic types: `list[str]`, `dict[str, int]`, etc.
+  - Optional types use `Optional[T]` or `T | None`
+  - Union types explicit: `Union[str, int]` or `str | int`
+  - Pydantic models with strict field typing
 - Add `# type: ignore` comments only when absolutely necessary with explanation
 
 ### Additional Quality Tools for FastAPI

.claude/agents/backend/python-hyx-resilience.md

@@ -444,6 +444,7 @@ You are a Python resilience engineering specialist with deep expertise in Hyx an
   - [ ] Comprehensive tests cover all resilience behaviors
   - [ ] Documentation includes configuration examples and usage patterns
   - [ ] **Pyright type checking passes** with zero errors (run `pyright` before committing)
+  - [ ] **Strong typing implemented** throughout all Python code
 
   ## Common Python-Specific Anti-Patterns to Avoid
 
@@ -477,6 +478,12 @@ pyright file1.py file2.py module/changed_file.py
 - Zero Pyright errors allowed on changed files
 - All functions must have proper type hints
 - Use `typing` imports for complex types
+- **MANDATORY: Use strong typing throughout**:
+  - All function parameters and return types explicitly typed
+  - String literals use `Literal["value"]` for constants or `str` for variables
+  - Collections use generic types: `list[str]`, `dict[str, int]`, etc.
+  - Optional types use `Optional[T]` or `T | None`
+  - Union types explicit: `Union[str, int]` or `str | int`
 - Add `# type: ignore` comments only when absolutely necessary with explanation
 
 ### Additional Quality Tools
@@ -506,10 +513,59 @@ echo "$CHANGED_FILES" | xargs bandit -ll
 
 **Quality Standards**:
 - Pyright type checking: **ZERO ERRORS**
+- **Strong typing: MANDATORY** (all functions, parameters, returns)
 - Code formatting: black + isort compliance
 - Linting: ruff clean (no warnings)
 - Security: bandit clean (no high/medium severity issues)
 
+### Strong Typing Examples
+```python
+from typing import Literal, Optional, Union, Any
+from collections.abc import Awaitable, Callable
+import numpy as np
+import pandas as pd
+
+# ✅ GOOD: Strong typing examples
+def process_data(
+    data: list[dict[str, Any]], 
+    mode: Literal["strict", "relaxed"],
+    timeout: Optional[float] = None
+) -> dict[str, Union[int, str]]:
+    """Process data with strong typing."""
+    pass
+
+async def fetch_user(
+    user_id: str, 
+    include_profile: bool = False
+) -> Optional[dict[str, Any]]:
+    """Fetch user with optional profile data."""
+    pass
+
+# ✅ GOOD: Class with strong typing
+class DataProcessor:
+    def __init__(
+        self, 
+        config: dict[str, Any],
+        processors: list[Callable[[Any], Any]]
+    ) -> None:
+        self.config: dict[str, Any] = config
+        self.processors: list[Callable[[Any], Any]] = processors
+    
+    async def process(
+        self, 
+        items: list[dict[str, Any]]
+    ) -> list[dict[str, Any]]:
+        """Process items asynchronously."""
+        pass
+
+# ❌ BAD: Weak typing (avoid these patterns)
+def bad_function(data, mode=None):  # No type hints
+    pass
+
+def poor_typing(data: Any) -> Any:  # Too generic
+    pass
+```
+
 ## Advanced Python Specialization
 
 ### Modern Python Idioms and Best Practices