fix(chroma): release SQLite lock on cache invalidation, not just close_palace

`close_palace` already routed through `_close_client` to release chromadb's
rust-side SQLite WAL/journal lock before next open. The `_client` cache-
rebuild path (inode/mtime change OR DB-appeared-after-open) was the second
lifecycle point but did not match: it overwrote the dict slot directly,
leaving the stale handle alive until GC.

Under that branch, a concurrent reader could hit "database is locked"
mid-rebuild because the OS-level lock was still held by the previous
PersistentClient instance, even though MemPalace had stopped using it.

Now matches close_palace: `_close_client(cached)` runs before the slot
is overwritten on every invalidation path. Pinned with a test that seeds
a sentinel into `_clients`, materializes `chroma.sqlite3` to trip
`mtime_appeared`, and asserts the sentinel was passed to `_close_client`.

Author: mvalentsev

mempalace/backends/chroma.py

@@ -1007,6 +1007,15 @@ def _client(self, palace_path: str):
         )
 
         if cached is None or inode_changed or mtime_changed or mtime_appeared:
+            # When invalidating an existing cached client (inode/mtime change
+            # or DB-file-appeared), close it before overwriting the slot so
+            # the SQLite WAL/journal lock is released up front. Otherwise the
+            # stale handle lingers until GC and a concurrent reader can hit
+            # "database is locked" mid-rebuild — the same lifecycle hazard
+            # close_palace() guards via _close_client().
+            if cached is not None:
+                _close_client(cached)
+                self._clients.pop(palace_path, None)
             ChromaBackend._prepare_palace_for_open(palace_path)
             cached = chromadb.PersistentClient(path=palace_path)
             self._clients[palace_path] = cached

tests/test_backends.py

@@ -315,6 +315,50 @@ def test_chroma_cache_picks_up_db_created_after_first_open(tmp_path):
     assert backend._freshness[str(palace_path)] != (0, 0.0)
 
 
+def test_chroma_cache_invalidation_closes_old_client(tmp_path, monkeypatch):
+    """Cache invalidation (DB inode/mtime change OR DB-appeared-after-open)
+    must release the old client's SQLite WAL/journal lock before replacing
+    the cache slot. Otherwise the stale handle lingers until GC and a
+    concurrent reader can hit "database is locked" mid-rebuild — the same
+    lifecycle hazard `close_palace()` already guards via `_close_client()`."""
+    from mempalace.backends import chroma as chroma_mod
+
+    backend = chroma_mod.ChromaBackend()
+    palace_path = tmp_path / "palace"
+    palace_path.mkdir()
+
+    closed = []
+    real_close = chroma_mod._close_client
+
+    def _spy(client):
+        closed.append(client)
+        real_close(client)
+
+    monkeypatch.setattr(chroma_mod, "_close_client", _spy)
+
+    # Seed the cache as if a prior _client() call had opened the palace
+    # before chroma.sqlite3 existed (freshness (0, 0.0) is the absent-DB
+    # signal). _close_client swallows AttributeError on non-Client objects,
+    # so a sentinel is fine here — we just need an identity to spot.
+    sentinel = object()
+    backend._clients[str(palace_path)] = sentinel
+    backend._freshness[str(palace_path)] = (0, 0.0)
+
+    # Materialize chroma.sqlite3 so the next _client() trips mtime_appeared
+    # and rebuilds the cache.
+    import chromadb as _chromadb
+
+    _chromadb.PersistentClient(path=str(palace_path)).get_or_create_collection("seed")
+
+    refreshed = backend._client(str(palace_path))
+
+    assert refreshed is not sentinel
+    assert sentinel in closed, (
+        "old cached client must be _close_client'd on cache invalidation, "
+        "not silently overwritten"
+    )
+
+
 def test_base_collection_update_default_rejects_mismatched_lengths():
     """The ABC default update() raises ValueError rather than silently misaligning."""
     from mempalace.backends.base import BaseCollection