fix: handle Windows subprocess incompatibility and Postgres test isolation

Two root cause fixes for CI failures:

1. Windows subprocess incompatibility:
   - SelectorEventLoop (used on Windows for aiosqlite stability) doesn't
     support asyncio.create_subprocess_shell()
   - Added Windows detection to _quick_count_files() and
     _scan_directory_modified_since() to use Python fallbacks
   - Updated db.py comment to document this limitation

2. Postgres integration test isolation:
   - Test fixtures created their own engine but MCP lifespan created
     a separate global engine via get_or_create_db()
   - This caused DuplicateTableError when MCP tried to run migrations
   - Fixed by setting db._engine and db._session_maker in test fixture
     so get_or_create_db() skips re-initialization

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>
Signed-off-by: phernandez <paul@basicmachines.co>

Author: phernandez

src/basic_memory/api/app.py

@@ -62,6 +62,7 @@ async def lifespan(app: FastAPI):  # pragma: no cover
     )
     if app_config.sync_changes and not is_test_env:
         logger.info(f"Sync changes enabled: {app_config.sync_changes}")
+
         # start file sync task in background
         async def _file_sync_runner() -> None:
             await initialize_file_sync(app_config)

src/basic_memory/db.py

@@ -33,8 +33,9 @@
 # - "RuntimeError: Event loop is closed"
 # - "IndexError: pop from an empty deque"
 #
-# We don't rely on Proactor-only features (like subprocess pipes), so use the
-# more stable SelectorEventLoopPolicy everywhere on Windows.
+# The SelectorEventLoop doesn't support subprocess operations, so code that uses
+# asyncio.create_subprocess_shell() (like sync_service._quick_count_files) must
+# detect Windows and use fallback implementations.
 if sys.platform == "win32":  # pragma: no cover
     asyncio.set_event_loop_policy(asyncio.WindowsSelectorEventLoopPolicy())
 

src/basic_memory/mcp/server.py

@@ -26,6 +26,11 @@ async def lifespan(app: FastMCP):
     app_config = ConfigManager().config
     logger.info("Starting Basic Memory MCP server")
 
+    # Track if we created the engine (vs test fixtures providing it)
+    # This prevents disposing an engine provided by test fixtures when
+    # multiple Client connections are made in the same test
+    engine_was_none = db._engine is None
+
     # Initialize app (runs migrations, reconciles projects)
     await initialize_app(app_config)
 
@@ -40,6 +45,7 @@ async def lifespan(app: FastMCP):
         logger.info("Test environment detected - skipping local file sync")
     elif app_config.sync_changes and not app_config.cloud_mode_enabled:
         logger.info("Starting file sync in background")
+
         async def _file_sync_runner() -> None:
             await initialize_file_sync(app_config)
 
@@ -61,8 +67,12 @@ async def _file_sync_runner() -> None:
             except asyncio.CancelledError:
                 logger.info("File sync task cancelled")
 
-        await db.shutdown_db()
-        logger.info("Database connections closed")
+        # Only shutdown DB if we created it (not if test fixture provided it)
+        if engine_was_none:
+            await db.shutdown_db()
+            logger.info("Database connections closed")
+        else:
+            logger.debug("Skipping DB shutdown - engine provided externally")
 
 
 mcp = FastMCP(

src/basic_memory/sync/sync_service.py

@@ -2,6 +2,7 @@
 
 import asyncio
 import os
+import sys
 import time
 from collections import OrderedDict
 from dataclasses import dataclass, field
@@ -1027,12 +1028,22 @@ async def _quick_count_files(self, directory: Path) -> int:
         Uses subprocess to leverage OS-level file counting which is much faster
         than Python iteration, especially on network filesystems like TigrisFS.
 
+        On Windows, subprocess is not supported with SelectorEventLoop (which we use
+        to avoid aiosqlite cleanup issues), so we fall back to Python-based counting.
+
         Args:
             directory: Directory to count files in
 
         Returns:
             Number of files in directory (recursive)
         """
+        # Windows with SelectorEventLoop doesn't support subprocess
+        if sys.platform == "win32":
+            count = 0
+            async for _ in self.scan_directory(directory):
+                count += 1
+            return count
+
         process = await asyncio.create_subprocess_shell(
             f'find "{directory}" -type f | wc -l',
             stdout=asyncio.subprocess.PIPE,
@@ -1063,13 +1074,20 @@ async def _scan_directory_modified_since(
         This is dramatically faster than scanning all files and comparing mtimes,
         especially on network filesystems like TigrisFS where stat operations are expensive.
 
+        On Windows, subprocess is not supported with SelectorEventLoop (which we use
+        to avoid aiosqlite cleanup issues), so we fall back to a full directory scan.
+
         Args:
             directory: Directory to scan
             since_timestamp: Unix timestamp to find files newer than
 
         Returns:
             List of relative file paths modified since the timestamp (respects .bmignore)
         """
+        # Windows with SelectorEventLoop doesn't support subprocess
+        if sys.platform == "win32":
+            return await self._scan_directory_full(directory)
+
         # Convert timestamp to find-compatible format
         since_date = datetime.fromtimestamp(since_timestamp).strftime("%Y-%m-%d %H:%M:%S")
 

test-int/conftest.py

@@ -146,6 +146,11 @@ async def engine_factory(
             autoflush=False,
         )
 
+        # Set module-level state to prevent MCP lifespan from re-initializing
+        # This ensures get_or_create_db() sees an existing engine and skips initialization
+        db._engine = engine
+        db._session_maker = session_maker
+
         # Drop and recreate all tables for test isolation
         async with engine.begin() as conn:
             await conn.execute(text("DROP TABLE IF EXISTS search_index CASCADE"))
@@ -158,7 +163,10 @@ async def engine_factory(
 
         yield engine, session_maker
 
+        # Clean up module-level state
         await engine.dispose()
+        db._engine = None
+        db._session_maker = None
 
     else:
         # SQLite: Create fresh database (fast with tmp files)

tests/services/test_initialization.py

@@ -8,7 +8,6 @@
     ensure_initialization,
     initialize_database,
     reconcile_projects_with_config,
-    initialize_file_sync,
 )