fix(tests,identity): order-independent event loop + Windows key permissions

conftest autouse fixture provisions a fresh current event loop per test (Python 3.13 asyncio.run resets the current loop to None, causing order-dependent failures). Four test_coverage_boost concurrency tests now build gather() inside an async wrapper. keys.py POSIX 0o600 check is gated behind os.name==posix; stat.S_IMODE returns 0o666 on NTFS (not an error), so the guard wrongly rejected valid keys on Windows. POSIX enforcement unchanged.

hearthnet/identity/keys.py

@@ -262,16 +262,17 @@ def load(keys_dir: Path) -> KeyPair:
     pub_path = keys_dir / "device.pub"
     if not priv_path.exists() or not pub_path.exists():
         raise IdentityError("keys_missing", reason=f"Key files not found in {keys_dir}")
-    # Check permissions on POSIX
-    try:
+    # Check permissions on POSIX only. POSIX mode bits are not meaningful on
+    # Windows (NTFS files commonly report 0o666 regardless of ACLs), so the
+    # check would raise false positives there. stat.S_IMODE does not raise on
+    # Windows, so an explicit os.name guard is required.
+    if os.name == "posix":
         mode = oct(stat.S_IMODE(priv_path.stat().st_mode))
         if not mode.endswith("600") and not mode.endswith("400"):
             raise IdentityError(
                 "keys_permissions",
                 reason=f"Private key {priv_path} has unsafe permissions {mode}",
             )
-    except AttributeError:
-        pass  # Windows
     try:
         sk_b64 = priv_path.read_text().strip()
         padding = 4 - len(sk_b64) % 4

tests/conftest.py

@@ -1,8 +1,11 @@
 from __future__ import annotations
 
+import asyncio
 import sys
 from pathlib import Path
 
+import pytest
+
 ROOT = Path(__file__).resolve().parents[1]
 if str(ROOT) not in sys.path:
     sys.path.insert(0, str(ROOT))
@@ -15,3 +18,28 @@ try:
     nest_asyncio.apply()
 except ImportError:
     pass
+
+
+@pytest.fixture(autouse=True)
+def _ensure_current_event_loop():
+    """Guarantee every test starts with an open current event loop.
+
+    Python 3.13 no longer auto-creates an event loop on demand, and
+    ``asyncio.run()`` resets the current loop to ``None`` when it exits. Many
+    sync tests in this suite call ``asyncio.get_event_loop().run_until_complete``
+    or build coroutines via ``asyncio.gather(...)`` outside a running loop, both
+    of which require a current loop to exist. Without this fixture those tests
+    fail or pass purely depending on the order in which test files happen to
+    run. Setting a fresh loop per test makes the suite order-independent.
+    """
+    loop = asyncio.new_event_loop()
+    asyncio.set_event_loop(loop)
+    try:
+        yield
+    finally:
+        try:
+            loop.close()
+        finally:
+            # Leave an open loop set as current for any teardown/collection
+            # work that runs between this test and the next one's setup.
+            asyncio.set_event_loop(asyncio.new_event_loop())

tests/test_coverage_boost.py

@@ -206,8 +206,11 @@ class TestConcurrentOperations:
                 (1, 0),
                 {"input": {"recipient": f"user-{idx}", "body": f"message {idx}"}, "params": {}}
             )
-        
-        results = _run(asyncio.gather(*[task(i) for i in range(5)]))
+
+        async def _all():
+            return await asyncio.gather(*[task(i) for i in range(5)])
+
+        results = _run(_all())
         assert len(results) == 5
 
     def test_concurrent_embeddings(self, node):
@@ -221,8 +224,11 @@ class TestConcurrentOperations:
                 )
             except Exception:
                 return {"skipped": True}
-        
-        results = _run(asyncio.gather(*[task(i) for i in range(3)]))
+
+        async def _all():
+            return await asyncio.gather(*[task(i) for i in range(3)])
+
+        results = _run(_all())
         assert len(results) == 3
 
     def test_concurrent_rag_operations(self, node):
@@ -237,8 +243,11 @@ class TestConcurrentOperations:
                     "text": f"Content {idx}"
                 }}
             )
-        
-        results = _run(asyncio.gather(*[task(i) for i in range(5)]))
+
+        async def _all():
+            return await asyncio.gather(*[task(i) for i in range(5)])
+
+        results = _run(_all())
         assert len(results) == 5
 
 
@@ -311,8 +320,11 @@ class TestErrorRecovery:
                 )
             except BusError:
                 return {"error": f"expected {idx}"}
-        
-        results = _run(asyncio.gather(*[task(i) for i in range(5)]))
+
+        async def _all():
+            return await asyncio.gather(*[task(i) for i in range(5)])
+
+        results = _run(_all())
         assert len(results) == 5