style: clear 94 pre-existing ruff violations so CI can pass

python-sdk CI has never passed. Every run in its visible history back to
2026-03-25 is a failure, always at the same step: `ruff check src/`. Because it
was never green, nothing in this repo has had automated enforcement — which is
how a red test suite and this lint debt both accumulated unnoticed.

These violations predate the previous commit: 94 errors at 31ea42e and 94 at
1476fcd, byte-identical. The fail-closed hardening did not introduce any of
them (_base.py passes ruff cleanly on its own).

All mechanical, against the declared target-version = "py310":
  UP045 (40)  Optional[X]        -> X | None
  UP006 (18)  List/Dict/Tuple    -> list/dict/tuple
  F401  (16)  unused imports removed
  UP035 (12)  deprecated typing imports
  I001   (5)  import blocks sorted
  E501   (2)  two long signatures in composio.py wrapped by hand
  UP007  (1)  Union[X, Y]        -> X | Y

Public API verified unchanged by snapshotting dir() of sidclaw, sidclaw.middleware
and all 11 middleware modules before and after. `sidclaw` and `sidclaw.middleware`
are byte-identical. The only removals are incidental namespace pollution from the
unused imports — typing constructs, stdlib modules, and ApprovalExpiredError /
ApprovalTimeoutError, which remain exported from the canonical top level
(`from sidclaw import ApprovalTimeoutError` still works). The undocumented
`from sidclaw.middleware.composio import ApprovalTimeoutError` no longer resolves;
it was never in an __all__ and nothing imports it.

No behaviour change. 186 tests pass. `ruff check src/` now exits clean.

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

Author: VladUZH

src/sidclaw/middleware/__init__.py

@@ -1,14 +1,21 @@
 """Framework middleware for SidClaw governance."""
 
-from .generic import GovernanceConfig, async_with_governance, with_governance
+from .claude_agent_sdk import (
+    ClaudeAgentGovernanceConfig,
+    govern_claude_agent_tool,
+    govern_claude_agent_tool_async,
+    govern_claude_agent_tools,
+    govern_claude_agent_tools_async,
+)
 from .composio import (
     ComposioGovernanceConfig,
-    govern_composio_execution,
-    govern_composio_execution_async,
     create_composio_governance_modifiers,
     create_composio_governance_modifiers_async,
+    govern_composio_execution,
+    govern_composio_execution_async,
     map_composio_slug,
 )
+from .generic import GovernanceConfig, async_with_governance, with_governance
 from .google_adk import (
     GoogleADKGovernanceConfig,
     govern_google_adk_tool,
@@ -22,13 +29,6 @@
     govern_llamaindex_tools,
     govern_llamaindex_tools_async,
 )
-from .claude_agent_sdk import (
-    ClaudeAgentGovernanceConfig,
-    govern_claude_agent_tool,
-    govern_claude_agent_tool_async,
-    govern_claude_agent_tools,
-    govern_claude_agent_tools_async,
-)
 from .nemoclaw import (
     NemoClawGovernanceConfig,
     create_nemoclaw_proxy,

src/sidclaw/middleware/claude_agent_sdk.py

@@ -21,17 +21,15 @@
 """
 from __future__ import annotations
 
-import copy
-import functools
-from dataclasses import dataclass, field
-from typing import Any, Callable, Dict, List, Optional, Sequence
+from collections.abc import Sequence
+from dataclasses import dataclass
+from typing import Any
 
 from .._client import AsyncSidClaw, SidClaw
-from .._errors import ActionDeniedError, ApprovalExpiredError, ApprovalTimeoutError
+from .._errors import ActionDeniedError
 from .._types import DataClassification, EvaluateParams, EvaluateResponse
 from ._base import record_outcome_async, record_outcome_sync
 
-
 # ---------------------------------------------------------------------------
 # Config
 # ---------------------------------------------------------------------------
@@ -47,7 +45,7 @@ class ClaudeAgentGovernanceConfig:
     resource_scope: str = "claude_agent"
     """Resource scope sent to the policy engine."""
 
-    target_integration: Optional[str] = None
+    target_integration: str | None = None
     """Target integration name override. Defaults to the tool name."""
 
     wait_for_approval: bool = True
@@ -69,7 +67,7 @@ def _evaluate_sync(
     client: SidClaw,
     tool_name: str,
     args: Any,
-    config: Optional[ClaudeAgentGovernanceConfig],
+    config: ClaudeAgentGovernanceConfig | None,
 ) -> EvaluateResponse:
     """Evaluate governance synchronously. Handles allow/deny/approval_required."""
     cfg = config or ClaudeAgentGovernanceConfig()
@@ -126,7 +124,7 @@ async def _evaluate_async(
     client: AsyncSidClaw,
     tool_name: str,
     args: Any,
-    config: Optional[ClaudeAgentGovernanceConfig],
+    config: ClaudeAgentGovernanceConfig | None,
 ) -> EvaluateResponse:
     """Evaluate governance asynchronously. Handles allow/deny/approval_required."""
     cfg = config or ClaudeAgentGovernanceConfig()
@@ -195,14 +193,14 @@ def __init__(
         self,
         client: SidClaw,
         tool: Any,
-        config: Optional[ClaudeAgentGovernanceConfig] = None,
+        config: ClaudeAgentGovernanceConfig | None = None,
     ) -> None:
         self._client = client
         self._tool = tool
         self._config = config
         # Preserve duck-typed attributes
         self.name: str = getattr(tool, "name", "unknown")
-        self.description: Optional[str] = getattr(tool, "description", None)
+        self.description: str | None = getattr(tool, "description", None)
         self.parameters: Any = getattr(tool, "parameters", None)
 
     def execute(self, *args: Any, **kwargs: Any) -> Any:
@@ -232,14 +230,14 @@ def __init__(
         self,
         client: AsyncSidClaw,
         tool: Any,
-        config: Optional[ClaudeAgentGovernanceConfig] = None,
+        config: ClaudeAgentGovernanceConfig | None = None,
     ) -> None:
         self._client = client
         self._tool = tool
         self._config = config
         # Preserve duck-typed attributes
         self.name: str = getattr(tool, "name", "unknown")
-        self.description: Optional[str] = getattr(tool, "description", None)
+        self.description: str | None = getattr(tool, "description", None)
         self.parameters: Any = getattr(tool, "parameters", None)
 
     async def execute(self, *args: Any, **kwargs: Any) -> Any:
@@ -269,7 +267,7 @@ async def execute(self, *args: Any, **kwargs: Any) -> Any:
 def govern_claude_agent_tool(
     client: SidClaw,
     tool: Any,
-    config: Optional[ClaudeAgentGovernanceConfig] = None,
+    config: ClaudeAgentGovernanceConfig | None = None,
 ) -> GovernedClaudeAgentTool:
     """Wrap a Claude Agent SDK tool with SidClaw governance (sync).
 
@@ -301,7 +299,7 @@ def govern_claude_agent_tool(
 def govern_claude_agent_tool_async(
     client: AsyncSidClaw,
     tool: Any,
-    config: Optional[ClaudeAgentGovernanceConfig] = None,
+    config: ClaudeAgentGovernanceConfig | None = None,
 ) -> GovernedClaudeAgentToolAsync:
     """Wrap a Claude Agent SDK tool with SidClaw governance (async).
 
@@ -336,13 +334,13 @@ def govern_claude_agent_tool_async(
 def govern_claude_agent_tools(
     client: SidClaw,
     tools: Sequence[Any],
-    config: Optional[ClaudeAgentGovernanceConfig] = None,
-) -> List[GovernedClaudeAgentTool]:
+    config: ClaudeAgentGovernanceConfig | None = None,
+) -> list[GovernedClaudeAgentTool]:
     """Wrap all tools in a sequence with SidClaw governance (sync).
 
     Uses each tool's name as the target integration unless overridden in config.
     """
-    results: List[GovernedClaudeAgentTool] = []
+    results: list[GovernedClaudeAgentTool] = []
     for tool in tools:
         tool_config = ClaudeAgentGovernanceConfig(
             data_classification=config.data_classification if config else "internal",
@@ -359,13 +357,13 @@ def govern_claude_agent_tools(
 def govern_claude_agent_tools_async(
     client: AsyncSidClaw,
     tools: Sequence[Any],
-    config: Optional[ClaudeAgentGovernanceConfig] = None,
-) -> List[GovernedClaudeAgentToolAsync]:
+    config: ClaudeAgentGovernanceConfig | None = None,
+) -> list[GovernedClaudeAgentToolAsync]:
     """Wrap all tools in a sequence with SidClaw governance (async).
 
     Uses each tool's name as the target integration unless overridden in config.
     """
-    results: List[GovernedClaudeAgentToolAsync] = []
+    results: list[GovernedClaudeAgentToolAsync] = []
     for tool in tools:
         tool_config = ClaudeAgentGovernanceConfig(
             data_classification=config.data_classification if config else "internal",

src/sidclaw/middleware/composio.py

@@ -23,18 +23,15 @@
 """
 from __future__ import annotations
 
-import time
+from collections.abc import Callable
 from dataclasses import dataclass, field
-from typing import Any, Callable, Dict, Optional, Tuple
-
-import anyio
+from typing import Any
 
 from .._client import AsyncSidClaw, SidClaw
-from .._errors import ActionDeniedError, ApprovalExpiredError, ApprovalTimeoutError
+from .._errors import ActionDeniedError
 from .._types import DataClassification, EvaluateParams, EvaluateResponse
 from ._base import record_outcome_async, record_outcome_sync
 
-
 # ---------------------------------------------------------------------------
 # Config
 # ---------------------------------------------------------------------------
@@ -44,7 +41,7 @@
 class ComposioGovernanceConfig:
     """Configuration for Composio governance middleware."""
 
-    data_classification: Dict[str, str] = field(default_factory=dict)
+    data_classification: dict[str, str] = field(default_factory=dict)
     """Override data classification per Composio toolkit slug (e.g. {"SALESFORCE": "confidential"})."""
 
     default_classification: DataClassification = "internal"
@@ -68,7 +65,7 @@ class ComposioGovernanceConfig:
 # ---------------------------------------------------------------------------
 
 
-def map_composio_slug(slug: str) -> Tuple[str, str]:
+def map_composio_slug(slug: str) -> tuple[str, str]:
     """Map a Composio tool slug to ``(operation, target_integration)``.
 
     Convention:
@@ -97,7 +94,7 @@ def map_composio_slug(slug: str) -> Tuple[str, str]:
 
 def _resolve_classification(
     toolkit_slug: str,
-    config: Optional[ComposioGovernanceConfig],
+    config: ComposioGovernanceConfig | None,
 ) -> DataClassification:
     upper = toolkit_slug.upper()
     if config and upper in config.data_classification:
@@ -111,7 +108,7 @@ def _evaluate_sync(
     client: SidClaw,
     slug: str,
     params: Any,
-    config: Optional[ComposioGovernanceConfig],
+    config: ComposioGovernanceConfig | None,
 ) -> EvaluateResponse:
     """Evaluate governance synchronously. Handles allow/deny/approval_required."""
     operation, target_integration = map_composio_slug(slug)
@@ -172,7 +169,7 @@ async def _evaluate_async(
     client: AsyncSidClaw,
     slug: str,
     params: Any,
-    config: Optional[ComposioGovernanceConfig],
+    config: ComposioGovernanceConfig | None,
 ) -> EvaluateResponse:
     """Evaluate governance asynchronously. Handles allow/deny/approval_required."""
     operation, target_integration = map_composio_slug(slug)
@@ -237,7 +234,7 @@ async def _evaluate_async(
 def govern_composio_execution(
     client: SidClaw,
     composio_client: Any,
-    config: Optional[ComposioGovernanceConfig] = None,
+    config: ComposioGovernanceConfig | None = None,
 ) -> Callable[..., Any]:
     """Return a governed wrapper around ``composio.tools.execute()``.
 
@@ -248,7 +245,13 @@ def govern_composio_execution(
     It evaluates governance before execution and records the outcome after.
     """
 
-    def execute(slug: str, *, user_id: str | None = None, arguments: dict[str, Any] | None = None, **kwargs: Any) -> Any:
+    def execute(
+        slug: str,
+        *,
+        user_id: str | None = None,
+        arguments: dict[str, Any] | None = None,
+        **kwargs: Any,
+    ) -> Any:
         params = {"user_id": user_id, "arguments": arguments or {}, **kwargs}
         decision = _evaluate_sync(client, slug, params, config)
 
@@ -271,7 +274,7 @@ def execute(slug: str, *, user_id: str | None = None, arguments: dict[str, Any]
 def govern_composio_execution_async(
     client: AsyncSidClaw,
     composio_client: Any,
-    config: Optional[ComposioGovernanceConfig] = None,
+    config: ComposioGovernanceConfig | None = None,
 ) -> Callable[..., Any]:
     """Return an async governed wrapper around ``composio.tools.execute()``.
 
@@ -280,7 +283,13 @@ def govern_composio_execution_async(
         await execute(slug: str, *, user_id: str, arguments: dict, **kwargs) -> dict
     """
 
-    async def execute(slug: str, *, user_id: str | None = None, arguments: dict[str, Any] | None = None, **kwargs: Any) -> Any:
+    async def execute(
+        slug: str,
+        *,
+        user_id: str | None = None,
+        arguments: dict[str, Any] | None = None,
+        **kwargs: Any,
+    ) -> Any:
         params = {"user_id": user_id, "arguments": arguments or {}, **kwargs}
         decision = await _evaluate_async(client, slug, params, config)
 
@@ -307,16 +316,16 @@ async def execute(slug: str, *, user_id: str | None = None, arguments: dict[str,
 
 def create_composio_governance_modifiers(
     client: SidClaw,
-    config: Optional[ComposioGovernanceConfig] = None,
-) -> Dict[str, Any]:
+    config: ComposioGovernanceConfig | None = None,
+) -> dict[str, Any]:
     """Create ``before_execute`` and ``after_execute`` modifier functions.
 
     These can be used with Composio's modifier/interceptor system::
 
         modifiers = create_composio_governance_modifiers(client)
         result = composio.tools.execute("GITHUB_CREATE_ISSUE", ..., **modifiers)
     """
-    inflight: Dict[str, str] = {}  # toolSlug -> trace_id
+    inflight: dict[str, str] = {}  # toolSlug -> trace_id
 
     def before_execute(tool: str, toolkit: str, params: Any) -> Any:
         decision = _evaluate_sync(client, tool, params, config)
@@ -334,10 +343,10 @@ def after_execute(tool: str, toolkit: str, response: Any) -> Any:
 
 def create_composio_governance_modifiers_async(
     client: AsyncSidClaw,
-    config: Optional[ComposioGovernanceConfig] = None,
-) -> Dict[str, Any]:
+    config: ComposioGovernanceConfig | None = None,
+) -> dict[str, Any]:
     """Create async ``before_execute`` and ``after_execute`` modifier functions."""
-    inflight: Dict[str, str] = {}
+    inflight: dict[str, str] = {}
 
     async def before_execute(tool: str, toolkit: str, params: Any) -> Any:
         decision = await _evaluate_async(client, tool, params, config)