fix: deep GPU integration, fix all ruff/mypy issues, add .dockerignore

- Integrate GPU scoring inline into reasoning/multi_path.py (auto-uses GPU when available)
- Integrate GPU deduplication into multi_agent/consensus_engine.py
- Add semantic_search() method to memory/semantic_graph.py with GPU acceleration
- Integrate GPU training into self_improvement/training.py AutoTrainer
- Fix all 758 ruff lint issues (whitespace, import sorting, unused imports, ambiguous vars, undefined names)
- Fix all 40 mypy type errors across the codebase (no-any-return, union-attr, arg-type, etc.)
- Fix deprecated ruff config keys (select/ignore -> [tool.ruff.lint])
- Add .dockerignore to exclude .venv/, tests/, docs/ from Docker builds
- Add type hints and docstrings to verification/outcome.py
- Fix E402 import ordering in witness_agent.py
- Fix F821 undefined names in vector_pgvector.py and native.py
- Fix E741 ambiguous variable names in reflective.py and recommender.py

All 276 tests pass. 0 ruff errors. 0 mypy errors.

Co-Authored-By: Nakamoto, S <defi@defi-oracle.io>

fusionagi/tools/runner.py

@@ -5,11 +5,12 @@ from typing import TYPE_CHECKING
 
 if TYPE_CHECKING:
     from fusionagi.governance.audit_log import AuditLog
-from concurrent.futures import ThreadPoolExecutor, TimeoutError as FuturesTimeoutError
+from concurrent.futures import ThreadPoolExecutor
+from concurrent.futures import TimeoutError as FuturesTimeoutError
 from typing import Any
 
-from fusionagi.tools.registry import ToolDef
 from fusionagi._logger import logger
+from fusionagi.tools.registry import ToolDef
 
 
 class ToolValidationError(Exception):
@@ -24,39 +25,39 @@ class ToolValidationError(Exception):
 def validate_args(tool: ToolDef, args: dict[str, Any]) -> tuple[bool, str]:
     """
     Validate arguments against tool's JSON schema.
-    
+
     Returns:
         Tuple of (is_valid, error_message). error_message is empty if valid.
     """
     schema = tool.parameters_schema
     if not schema:
         return True, ""
-    
+
     # Basic JSON schema validation (without external dependency)
     schema_type = schema.get("type", "object")
     if schema_type != "object":
         return True, ""  # Only validate object schemas
-    
+
     properties = schema.get("properties", {})
     required = schema.get("required", [])
-    
+
     # Check required fields
     for field in required:
         if field not in args:
             return False, f"Missing required argument: {field}"
-    
+
     # Check types of provided fields
     for field, value in args.items():
         if field not in properties:
             # Allow extra fields by default (additionalProperties: true is common)
             continue
-        
+
         prop_schema = properties[field]
         prop_type = prop_schema.get("type")
-        
+
         if prop_type is None:
             continue
-        
+
         # Type checking
         type_valid = True
         if prop_type == "string":
@@ -73,16 +74,16 @@ def validate_args(tool: ToolDef, args: dict[str, Any]) -> tuple[bool, str]:
             type_valid = isinstance(value, dict)
         elif prop_type == "null":
             type_valid = value is None
-        
+
         if not type_valid:
             return False, f"Argument '{field}' must be of type {prop_type}, got {type(value).__name__}"
-        
+
         # String constraints
         if prop_type == "string" and isinstance(value, str):
             min_len = prop_schema.get("minLength")
             max_len = prop_schema.get("maxLength")
             pattern = prop_schema.get("pattern")
-            
+
             if min_len is not None and len(value) < min_len:
                 return False, f"Argument '{field}' must be at least {min_len} characters"
             if max_len is not None and len(value) > max_len:
@@ -91,14 +92,14 @@ def validate_args(tool: ToolDef, args: dict[str, Any]) -> tuple[bool, str]:
                 import re
                 if not re.match(pattern, value):
                     return False, f"Argument '{field}' does not match pattern: {pattern}"
-        
+
         # Number constraints
         if prop_type in ("integer", "number") and isinstance(value, (int, float)):
             minimum = prop_schema.get("minimum")
             maximum = prop_schema.get("maximum")
             exclusive_min = prop_schema.get("exclusiveMinimum")
             exclusive_max = prop_schema.get("exclusiveMaximum")
-            
+
             if minimum is not None and value < minimum:
                 return False, f"Argument '{field}' must be >= {minimum}"
             if maximum is not None and value > maximum:
@@ -107,12 +108,12 @@ def validate_args(tool: ToolDef, args: dict[str, Any]) -> tuple[bool, str]:
                 return False, f"Argument '{field}' must be > {exclusive_min}"
             if exclusive_max is not None and value >= exclusive_max:
                 return False, f"Argument '{field}' must be < {exclusive_max}"
-        
+
         # Enum constraint
         enum = prop_schema.get("enum")
         if enum is not None and value not in enum:
             return False, f"Argument '{field}' must be one of: {enum}"
-    
+
     return True, ""
 
 
@@ -124,13 +125,13 @@ def run_tool(
 ) -> tuple[Any, dict[str, Any]]:
     """
     Invoke tool.fn(args) with optional validation and timeout.
-    
+
     Args:
         tool: The tool definition to execute.
         args: Arguments to pass to the tool function.
         timeout_seconds: Override timeout (uses tool.timeout_seconds if None).
         validate: Whether to validate args against tool's schema (default True).
-    
+
     Returns:
         Tuple of (result, log_entry). On error, result is None and log_entry contains error.
     """