fix: resolve all ty and ruff static analysis errors

Fix 4 type checker diagnostics and 19 linter errors:
- Remove duplicate DifficultyEstimate import (F811)
- Simplify conditional returns (SIM103)
- Remove unused variables (F841)
- Move imports to top of file (E402)
- Chain exceptions properly (B904)
- Add unreachable guards for implicit None returns (ty)
- Guard .get() on possibly-None dict (ty)
- Suppress proxy pattern type mismatch (ty)

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

Author: rand

src/__init__.py

@@ -204,7 +204,6 @@
 # Learned routing (SPEC-06.20-06.26)
 from .learned_routing import (
     CascadingRouter,
-    DifficultyEstimate,
     DifficultyEstimator,
     LearnedRouter,
     ModelProfile,

src/circuit_breaker.py

@@ -155,12 +155,7 @@ def allow_request(self) -> bool:
         Returns:
             True if request is allowed
         """
-        if self._state == CircuitState.CLOSED:
-            return True
-        elif self._state == CircuitState.HALF_OPEN:
-            return True  # Allow probe request
-        else:  # OPEN
-            return False
+        return self._state in (CircuitState.CLOSED, CircuitState.HALF_OPEN)
 
     def record_failure(
         self,

src/context_enrichment.py

@@ -234,8 +234,6 @@ def gather_types(self, content: str) -> dict[str, Any]:
         class_pattern = r"class\s+(\w+)(?:\([^)]*\))?:"
         for match in re.finditer(class_pattern, content):
             class_name = match.group(1)
-            # Find class body (simplified)
-            start = match.end()
             types[class_name] = {"kind": "class", "position": match.start()}
 
         # Match type annotations
@@ -462,9 +460,6 @@ def enrich(
         # Classify intent
         intent = self.classifier.classify(query)
 
-        # Get strategy for intent
-        strategy = EnrichmentStrategy.for_intent(intent)
-
         # Gather enrichment data
         enriched = dict(context)
         additions: list[str] = []

src/memory_store.py

@@ -397,7 +397,7 @@ def _get_connection(self) -> sqlite3.Connection:
             and threading.get_ident() == self._owner_thread_id
         ):
             self._persistent_conn.row_factory = sqlite3.Row
-            return _NoCloseConnection(self._persistent_conn)
+            return _NoCloseConnection(self._persistent_conn)  # type: ignore[return-value]
 
         # Use thread-local connections for non-owner threads to avoid sqlite
         # thread-affinity errors when tests exercise concurrent session access.

src/orchestrator.py

@@ -658,6 +658,7 @@ async def execute_op_bounded(op: DeferredOperation) -> tuple[str, Any, dict[str,
                                 "error": str(e),
                             }
                         await asyncio.sleep(retry_backoff_s * attempt)
+            raise RuntimeError(f"Unreachable: max_attempts={max_attempts}")
 
         # Execute all operations in parallel with bounded concurrency
         results = await asyncio.gather(*[execute_op_bounded(op) for op in all_ops])

src/orchestrator/core.py

@@ -20,11 +20,33 @@
 from collections.abc import AsyncIterator
 from dataclasses import dataclass, field
 from enum import Enum
-from typing import TYPE_CHECKING, Any
+from typing import Any
 
 from ..api_client import ClaudeClient, Provider, init_client
+from ..complexity_classifier import should_activate_rlm
+from ..config import RLMConfig, default_config
+from ..context_manager import externalize_context
+from ..cost_tracker import CostComponent, get_cost_tracker
+from ..epistemic import (
+    ClaimExtractor,
+    EvidenceAuditor,
+    HallucinationReport,
+    VerificationConfig,
+)
 from ..memory_store import MemoryStore
+from ..prompts import build_rlm_system_prompt
+from ..recursive_handler import RecursiveREPL
+from ..repl_environment import RLMEnvironment
+from ..response_parser import ResponseAction, ResponseParser
+from ..smart_router import SmartRouter
 from ..state_persistence import StatePersistence
+from ..trajectory import (
+    StreamingTrajectory,
+    TrajectoryEvent,
+    TrajectoryEventType,
+    TrajectoryRenderer,
+)
+from ..types import DeferredOperation, SessionContext
 
 # ============================================================================
 # Error Recovery (SPEC-12.10)
@@ -65,36 +87,6 @@ class Checkpoint:
     repl_state: dict[str, Any]
 
 
-# ============================================================================
-# Core Imports
-# ============================================================================
-
-from ..complexity_classifier import should_activate_rlm
-from ..config import RLMConfig, default_config
-from ..context_manager import externalize_context
-from ..cost_tracker import CostComponent, get_cost_tracker
-from ..epistemic import (
-    ClaimExtractor,
-    EvidenceAuditor,
-    HallucinationReport,
-    VerificationConfig,
-)
-from ..prompts import build_rlm_system_prompt
-from ..recursive_handler import RecursiveREPL
-from ..repl_environment import RLMEnvironment
-from ..response_parser import ResponseAction, ResponseParser
-from ..smart_router import SmartRouter
-from ..trajectory import (
-    StreamingTrajectory,
-    TrajectoryEvent,
-    TrajectoryEventType,
-    TrajectoryRenderer,
-)
-from ..types import DeferredOperation, SessionContext
-
-if TYPE_CHECKING:
-    pass
-
 
 @dataclass
 class OrchestrationState:
@@ -833,6 +825,7 @@ async def execute_op_bounded(op: DeferredOperation) -> tuple[str, Any, dict[str,
                                 "error": str(e),
                             }
                         await asyncio.sleep(retry_backoff_s * attempt)
+            raise RuntimeError(f"Unreachable: max_attempts={max_attempts}")
 
         # Execute all operations in parallel with bounded concurrency
         results = await asyncio.gather(*[execute_op_bounded(op) for op in all_ops])

src/orchestrator/steering.py

@@ -291,10 +291,7 @@ def should_present_steering(
         if cost_usd is not None and cost_usd > 0.5:
             return True
 
-        if turn in {10, 20, 30, 40}:
-            return True
-
-        return False
+        return turn in {10, 20, 30, 40}
 
     def should_steer(
         self,

src/proactive_computation.py

@@ -244,7 +244,7 @@ def calc(self, expression: str) -> Any:
             tree = ast.parse(expression, mode="eval")
             return self._eval_node(tree.body)
         except (SyntaxError, TypeError) as e:
-            raise ValueError(f"Invalid expression: {e}")
+            raise ValueError(f"Invalid expression: {e}") from e
 
     def _eval_node(self, node: ast.AST) -> Any:
         """Recursively evaluate an AST node."""
@@ -530,7 +530,6 @@ def _generate_code(
             # Extract numbers and operations from query
             numbers = re.findall(r"\d+(?:\.\d+)?", query)
             if len(numbers) >= 2:
-                expr = query
                 # Try to find the expression
                 match = re.search(r"(\d+(?:\.\d+)?)\s*([+\-*/^])\s*(\d+(?:\.\d+)?)", query)
                 if match:

src/repl_environment.py

@@ -734,7 +734,7 @@ def _validate_submit_outputs(self, outputs: Any) -> list[dict[str, Any]]:
                 }
             ]
 
-        output_fields = self._signature_registration.get("output_fields", [])
+        output_fields = (self._signature_registration or {}).get("output_fields", [])
         for field_spec in output_fields:
             field_name = field_spec.get("name", "")
             field_type = field_spec.get("field_type", {"type": "custom", "value": "unknown"})