fix(missing_await): suppress dual sync/async client FPs; fix ruff lint

Dual sync/async client pattern (openai-python, httpx): when a file defines
SyncFoo.close() and AsyncFoo.close() in the same module, pact cannot resolve
which class 'self' refers to and incorrectly flags sync callers. Apply the
same collision-skip logic already used for module-level functions to methods.

Also fix two ruff lint errors that were breaking CI:
- test_checker.py:1835 unused variable 'p' (-> _write_src without assignment)
- test_reduce.py:22 unused import _live_roots

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

Author: Your Name

failure_mode.py

@@ -859,6 +859,15 @@ def _scan_file_missing_await(path: str) -> list[FailureEvidence]:
         for node in _ast.walk(tree)
         if isinstance(node, _ast.FunctionDef)
     }
+    # Sync method names: same-named sync def with self/cls — dual sync/async
+    # client pattern (e.g. SyncClient.close + AsyncClient.close in one file).
+    sync_method_names: set[str] = {
+        node.name
+        for node in _ast.walk(tree)
+        if isinstance(node, _ast.FunctionDef)
+        and node.args.args
+        and node.args.args[0].arg in ("self", "cls")
+    }
     module_async: set[str] = set()
     method_async: set[str] = set()
     for node in _ast.walk(tree):
@@ -870,7 +879,11 @@ def _scan_file_missing_await(path: str) -> list[FailureEvidence]:
             # Heuristic: if the first argument is self/cls, it's a method
             args = node.args.args
             if args and args[0].arg in ("self", "cls"):
-                method_async.add(node.name)
+                # Skip if the same method name also exists as a sync def —
+                # dual sync/async client pattern; pact can't resolve which class
+                # self refers to and would cross-contaminate (e.g. openai-python).
+                if node.name not in sync_method_names:
+                    method_async.add(node.name)
             else:
                 # Skip names that also have a sync def — closure-level name
                 # collision; pact cannot resolve which definition is called.

test_checker.py

@@ -1832,7 +1832,7 @@ def make():
 
 def test_overload_stub_mutable_default_not_flagged(tmp_path):
     """@overload type stubs never execute at runtime — mutable defaults in them are FPs."""
-    p = _write_src(
+    _write_src(
         tmp_path,
         "client.py",
         """
@@ -2015,3 +2015,39 @@ def deploy(env: str, force: bool = False) -> None:
     violations = check_codebase(tmp_path)
     ra = [v for v in violations if v.context == "required_arg_missing" and "typer_tool.py" in v.file]
     assert len(ra) == 0, f"Expected 0 required_arg_missing for @app.command(), got {len(ra)}: {[(v.line, v.call) for v in ra]}"
+
+
+def test_dual_sync_async_client_missing_await_not_flagged(tmp_path):
+    """Dual sync/async client in one file: self.close() in async method of AsyncClient
+    must not be flagged because the same name exists as sync def in SyncClient."""
+    _write_src(
+        tmp_path,
+        "clients.py",
+        """
+        import httpx
+
+        class SyncClient:
+            def close(self) -> None:
+                self._http.close()
+
+            def request(self, method: str, url: str) -> httpx.Response:
+                return self._http.request(method, url)
+
+            def _prepare_request(self, method: str) -> dict:
+                return {"method": method}
+
+        class AsyncClient:
+            async def close(self) -> None:
+                await self._http.aclose()
+
+            async def request(self, method: str, url: str) -> httpx.Response:
+                self._prepare_request(method)
+                return await self._http.request(method, url)
+
+            async def _prepare_request(self, method: str) -> dict:
+                return {"method": method}
+        """,
+    )
+    violations = check_codebase(tmp_path)
+    ma = [v for v in violations if v.context == "missing_await" and "clients.py" in v.file]
+    assert len(ma) == 0, f"Expected 0 missing_await for dual sync/async client, got {len(ma)}: {[(v.line, v.call) for v in ma]}"

test_reduce.py

@@ -19,7 +19,6 @@
     find_passthroughs,
     find_sccs,
     _build_digraph,
-    _live_roots,
 )
 from .extractor import FunctionManifest, CallSite
 from .encoder import Violation