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/agents/reasoner.py

@@ -10,23 +10,23 @@ The Reasoner agent:
 from __future__ import annotations
 
 import json
-from typing import Any, TYPE_CHECKING
+from typing import TYPE_CHECKING, Any
 
-from fusionagi.agents.base_agent import BaseAgent
-from fusionagi.adapters.base import LLMAdapter
-from fusionagi.schemas.messages import AgentMessage, AgentMessageEnvelope
-from fusionagi.reasoning import run_chain_of_thought
 from fusionagi._logger import logger
+from fusionagi.adapters.base import LLMAdapter
+from fusionagi.agents.base_agent import BaseAgent
+from fusionagi.reasoning import run_chain_of_thought
+from fusionagi.schemas.messages import AgentMessage, AgentMessageEnvelope
 
 if TYPE_CHECKING:
-    from fusionagi.memory.working import WorkingMemory
     from fusionagi.memory.episodic import EpisodicMemory
+    from fusionagi.memory.working import WorkingMemory
 
 
 class ReasonerAgent(BaseAgent):
     """
     Reasoner agent: runs Chain-of-Thought reasoning and returns recommendations.
-    
+
     Features:
     - LLM-powered reasoning via CoT
     - WorkingMemory integration for context enrichment
@@ -43,7 +43,7 @@ class ReasonerAgent(BaseAgent):
     ) -> None:
         """
         Initialize the Reasoner agent.
-        
+
         Args:
             identity: Agent identifier.
             adapter: LLM adapter for reasoning.
@@ -65,36 +65,36 @@ class ReasonerAgent(BaseAgent):
         """On reason_request, run CoT and return recommendation_ready."""
         if envelope.message.intent != "reason_request":
             return None
-        
+
         logger.info(
             "Reasoner handle_message",
             extra={"recipient": self.identity, "intent": envelope.message.intent},
         )
-        
+
         payload = envelope.message.payload
         task_id = envelope.task_id or ""
         step_id = payload.get("step_id")
         subgoal = payload.get("subgoal", "")
         context = payload.get("context", "")
-        
+
         # Enrich context with working memory if available
         enriched_context = self._enrich_context(task_id, context)
-        
+
         query = subgoal or f"Consider step: {step_id}. What should we do next?"
-        
+
         if not self._adapter:
             return self._respond_without_llm(envelope, step_id)
-        
+
         # Run chain-of-thought reasoning
         response, trace = run_chain_of_thought(
             self._adapter,
             query,
             context=enriched_context or None,
         )
-        
+
         # Calculate confidence based on trace quality
         confidence = self._calculate_confidence(trace)
-        
+
         # Store reasoning in working memory
         if self._working_memory and task_id:
             self._working_memory.append(
@@ -107,7 +107,7 @@ class ReasonerAgent(BaseAgent):
                     "confidence": confidence,
                 },
             )
-        
+
         # Record to episodic memory
         if self._episodic_memory and task_id:
             self._episodic_memory.append(
@@ -122,7 +122,7 @@ class ReasonerAgent(BaseAgent):
                 },
                 event_type="reasoning_complete",
             )
-        
+
         logger.info(
             "Reasoner response",
             extra={
@@ -131,7 +131,7 @@ class ReasonerAgent(BaseAgent):
                 "confidence": confidence,
             },
         )
-        
+
         return AgentMessageEnvelope(
             message=AgentMessage(
                 sender=self.identity,
@@ -153,40 +153,40 @@ class ReasonerAgent(BaseAgent):
         """Enrich context with working memory data."""
         if not self._working_memory or not task_id:
             return base_context
-        
+
         # Get context summary from working memory
         context_summary = self._working_memory.get_context_summary(task_id, max_items=5)
-        
+
         if not context_summary:
             return base_context
-        
+
         # Get recent reasoning history
         reasoning_history = self._working_memory.get_list(task_id, "reasoning_history")
         recent_reasoning = reasoning_history[-3:] if reasoning_history else []
-        
+
         enriched_parts = [base_context] if base_context else []
-        
+
         if context_summary:
             enriched_parts.append(f"\nWorking memory context: {json.dumps(context_summary, default=str)[:500]}")
-        
+
         if recent_reasoning:
             recent_summaries = [
                 f"- Step {r.get('step_id', '?')}: {r.get('response', '')[:100]}"
                 for r in recent_reasoning
             ]
-            enriched_parts.append(f"\nRecent reasoning:\n" + "\n".join(recent_summaries))
-        
+            enriched_parts.append("\nRecent reasoning:\n" + "\n".join(recent_summaries))
+
         return "\n".join(enriched_parts)
 
-    def _calculate_confidence(self, trace: list[dict[str, Any]]) -> float:
+    def _calculate_confidence(self, trace: list[str] | list[dict[str, Any]]) -> float:
         """Calculate confidence score based on reasoning trace."""
         if not trace:
             return 0.5  # Default confidence without trace
-        
+
         # Simple heuristic: more reasoning steps = more thorough = higher confidence
         # But diminishing returns after a point
         step_count = len(trace)
-        
+
         if step_count == 0:
             return 0.3
         elif step_count == 1: