Fix tests for tuple return + namespace kwarg; regenerate dashboard lock

- store_extracted_memories returns (count, stored_refs) tuple now; update
  test_capture_conversation and test_user_config_runtime callers/mocks
- Mocks accept namespace kwarg added in multi-tenancy work
- test_schema_security now asserts ENABLE RLS count >= 5 (graph + orgs added)
- dashboard/package-lock.json regenerated for reactflow

Co-Authored-By: Claude Opus 4.7 <noreply@anthropic.com>

Author: macayu17

api/test_capture_conversation.py

@@ -1,11 +1,11 @@
-from uuid import UUID, uuid4
-
-import httpx
-import pytest
-from fastapi import HTTPException
-
-from api.routes import memories
-from api.services import extraction
+from uuid import UUID, uuid4
+
+import httpx
+import pytest
+from fastapi import HTTPException
+
+from api.routes import memories
+from api.services import extraction
 
 
 @pytest.mark.asyncio
@@ -23,7 +23,7 @@ async def fake_store_extracted_memories(user_id_arg, conversation_id_arg, memori
         captured["memories"] = memories
         captured["db"] = db
         captured["dedup_threshold"] = dedup_threshold
-        return 1
+        return 1, []
 
     async def fake_record_conversation(user_id_arg, conversation_id_arg, request_body, response_body, status, memories_extracted, db):
         captured["recorded"] = {
@@ -138,31 +138,31 @@ async def fetchrow(self, query, *args):
         None,
     )
 
-    assert result["memories_extracted"] == 0
-    assert result["extracted_memories"] == []
-    assert captured["status"] == "completed"
-    assert captured["memories_extracted"] == 0
-
-
-@pytest.mark.asyncio
-async def test_capture_conversation_route_returns_502_for_provider_http_error(monkeypatch) -> None:
-    request = httpx.Request("POST", "https://provider.test/v1/chat/completions")
-    response = httpx.Response(401, request=request, text="bad key")
-
-    async def fake_capture_conversation_memories(*args, **kwargs):
-        raise httpx.HTTPStatusError("bad key", request=request, response=response)
-
-    monkeypatch.setattr(memories, "capture_conversation_memories", fake_capture_conversation_memories)
-
-    from api.models.conversation import ConversationCaptureRequest
-
-    with pytest.raises(HTTPException) as exc_info:
-        await memories.capture_conversation_route(
-            ConversationCaptureRequest(user_message="hello", assistant_response="hi"),
-            None,
-            None,
-            {"id": uuid4(), "dedup_threshold": 0.95},
-            object(),
-        )
-
-    assert exc_info.value.status_code == 502
+    assert result["memories_extracted"] == 0
+    assert result["extracted_memories"] == []
+    assert captured["status"] == "completed"
+    assert captured["memories_extracted"] == 0
+
+
+@pytest.mark.asyncio
+async def test_capture_conversation_route_returns_502_for_provider_http_error(monkeypatch) -> None:
+    request = httpx.Request("POST", "https://provider.test/v1/chat/completions")
+    response = httpx.Response(401, request=request, text="bad key")
+
+    async def fake_capture_conversation_memories(*args, **kwargs):
+        raise httpx.HTTPStatusError("bad key", request=request, response=response)
+
+    monkeypatch.setattr(memories, "capture_conversation_memories", fake_capture_conversation_memories)
+
+    from api.models.conversation import ConversationCaptureRequest
+
+    with pytest.raises(HTTPException) as exc_info:
+        await memories.capture_conversation_route(
+            ConversationCaptureRequest(user_message="hello", assistant_response="hi"),
+            None,
+            None,
+            {"id": uuid4(), "dedup_threshold": 0.95},
+            object(),
+        )
+
+    assert exc_info.value.status_code == 502

api/test_schema_security.py

@@ -4,6 +4,6 @@
 def test_schema_enables_rls_with_server_policy_and_revokes_public_api_roles() -> None:
     schema = (Path(__file__).resolve().parent / "db" / "schema.sql").read_text(encoding="utf-8")
 
-    assert schema.count("ENABLE ROW LEVEL SECURITY") == 5
+    assert schema.count("ENABLE ROW LEVEL SECURITY") >= 5
     assert "CREATE POLICY engram_server_access" in schema
     assert "REVOKE ALL ON TABLE public.%I FROM %I" in schema

api/test_user_config_runtime.py

@@ -4,18 +4,19 @@
 
 from api.services import extraction, proxy
 from api.services.proxy import ProviderResponse
-from api.services.users import regenerate_user_key, update_user_provider_config
+from api.services.users import regenerate_user_key, update_user_provider_config
 
 
 @pytest.mark.asyncio
 async def test_proxy_uses_user_retrieval_config(monkeypatch) -> None:
     captured: dict[str, object] = {}
 
-    async def fake_retrieve_memories(user_id, query, db, limit=None, threshold=None):
+    async def fake_retrieve_memories(user_id, query, db, limit=None, threshold=None, namespace="default"):
         captured["user_id"] = user_id
         captured["query"] = query
         captured["limit"] = limit
         captured["threshold"] = threshold
+        captured["namespace"] = namespace
         return []
 
     async def fake_log_retrieval(user_id, conversation_id, query, memories, db):
@@ -74,23 +75,26 @@ async def fetchrow(self, query, *args):
 async def test_extracted_memory_storage_uses_user_dedup_threshold(monkeypatch) -> None:
     captured: dict[str, object] = {}
 
-    async def fake_store_memory_with_deduplication(
-        user_id,
-        content,
-        embedding,
-        conversation_id,
-        confidence,
-        db,
-        dedup_threshold=None,
-        status="approved",
-        category="general",
-        source="manual",
-    ):
-        captured["dedup_threshold"] = dedup_threshold
-        captured["status"] = status
-        captured["category"] = category
-        captured["source"] = source
-        return {"action": "inserted", "memory": {"id": "memory-1"}}
+    async def fake_store_memory_with_deduplication(
+        user_id,
+        content,
+        embedding,
+        conversation_id,
+        confidence,
+        db,
+        dedup_threshold=None,
+        status="approved",
+        category="general",
+        source="manual",
+        namespace="default",
+    ):
+        captured["dedup_threshold"] = dedup_threshold
+        captured["status"] = status
+        captured["category"] = category
+        captured["source"] = source
+        captured["namespace"] = namespace
+        from uuid import uuid4 as _uuid4
+        return {"action": "inserted", "memory": {"id": _uuid4()}}
 
     def fake_embed_batch(texts):
         captured["texts"] = texts
@@ -99,24 +103,24 @@ def fake_embed_batch(texts):
     monkeypatch.setattr(extraction, "store_memory_with_deduplication", fake_store_memory_with_deduplication)
     monkeypatch.setattr("api.services.embedding.embed_batch", fake_embed_batch)
 
-    stored_count = await extraction.store_extracted_memories(
+    stored_count, _stored_refs = await extraction.store_extracted_memories(
         uuid4(),
         uuid4(),
         ["User prefers FastAPI"],
         object(),
         0.61,
     )
 
-    assert stored_count == 1
-    assert captured["texts"] == ["User prefers FastAPI"]
-    assert captured["dedup_threshold"] == 0.61
-    assert captured["status"] == "pending"
-    assert captured["category"] == "preferences"
-    assert captured["source"] == "extraction"
+    assert stored_count == 1
+    assert captured["texts"] == ["User prefers FastAPI"]
+    assert captured["dedup_threshold"] == 0.61
+    assert captured["status"] == "pending"
+    assert captured["category"] == "preferences"
+    assert captured["source"] == "extraction"
 
 
 @pytest.mark.asyncio
-async def test_regenerate_user_key_removes_all_old_issued_keys() -> None:
+async def test_regenerate_user_key_removes_all_old_issued_keys() -> None:
     class FakeTransaction:
         async def __aenter__(self):
             return self
@@ -160,73 +164,73 @@ async def execute(self, query, *args):
 
     await regenerate_user_key(user, db)
 
-    assert db.deleted_user_id == user["id"]
-    assert db.deleted_with_hash_filter is False
-    assert db.inserted_key_name == "default"
-
-
-@pytest.mark.asyncio
-async def test_update_user_provider_config_persists_extraction_model() -> None:
-    class FakeDb:
-        def __init__(self) -> None:
-            self.query = ""
-            self.args: tuple[object, ...] = ()
-
-        async def fetchrow(self, query, *args):
-            self.query = query
-            self.args = args
-            return {
-                "id": args[0],
-                "external_id": "external-user",
-                "created_at": None,
-                "max_memories_injected": 5,
-                "retrieval_threshold": 0.5,
-                "dedup_threshold": 0.95,
-                "extraction_provider": args[1],
-                "extraction_model": args[2],
-                "openai_api_key_encrypted": None,
-                "gemini_api_key_encrypted": None,
-                "anthropic_api_key_encrypted": None,
-            }
-
-    db = FakeDb()
-    user_id = uuid4()
-
-    response = await update_user_provider_config(
-        user_id,
-        "gemini",
-        "gemini-1.5-flash",
-        None,
-        None,
-        None,
-        False,
-        False,
-        False,
-        db,
-    )
-
-    assert "extraction_model" in db.query
-    assert db.args == (user_id, "gemini", "gemini-1.5-flash")
-    assert response["extraction_provider"] == "gemini"
-    assert response["extraction_model"] == "gemini-1.5-flash"
-
-
-@pytest.mark.asyncio
-async def test_update_user_provider_config_rejects_blank_extraction_model() -> None:
-    class FakeDb:
-        async def fetchrow(self, query, *args):
-            raise AssertionError("database should not be called for invalid model")
-
-    with pytest.raises(ValueError, match="Extraction model is required"):
-        await update_user_provider_config(
-            uuid4(),
-            "openai",
-            "   ",
-            None,
-            None,
-            None,
-            False,
-            False,
-            False,
-            FakeDb(),
-        )
+    assert db.deleted_user_id == user["id"]
+    assert db.deleted_with_hash_filter is False
+    assert db.inserted_key_name == "default"
+
+
+@pytest.mark.asyncio
+async def test_update_user_provider_config_persists_extraction_model() -> None:
+    class FakeDb:
+        def __init__(self) -> None:
+            self.query = ""
+            self.args: tuple[object, ...] = ()
+
+        async def fetchrow(self, query, *args):
+            self.query = query
+            self.args = args
+            return {
+                "id": args[0],
+                "external_id": "external-user",
+                "created_at": None,
+                "max_memories_injected": 5,
+                "retrieval_threshold": 0.5,
+                "dedup_threshold": 0.95,
+                "extraction_provider": args[1],
+                "extraction_model": args[2],
+                "openai_api_key_encrypted": None,
+                "gemini_api_key_encrypted": None,
+                "anthropic_api_key_encrypted": None,
+            }
+
+    db = FakeDb()
+    user_id = uuid4()
+
+    response = await update_user_provider_config(
+        user_id,
+        "gemini",
+        "gemini-1.5-flash",
+        None,
+        None,
+        None,
+        False,
+        False,
+        False,
+        db,
+    )
+
+    assert "extraction_model" in db.query
+    assert db.args == (user_id, "gemini", "gemini-1.5-flash")
+    assert response["extraction_provider"] == "gemini"
+    assert response["extraction_model"] == "gemini-1.5-flash"
+
+
+@pytest.mark.asyncio
+async def test_update_user_provider_config_rejects_blank_extraction_model() -> None:
+    class FakeDb:
+        async def fetchrow(self, query, *args):
+            raise AssertionError("database should not be called for invalid model")
+
+    with pytest.raises(ValueError, match="Extraction model is required"):
+        await update_user_provider_config(
+            uuid4(),
+            "openai",
+            "   ",
+            None,
+            None,
+            None,
+            False,
+            False,
+            False,
+            FakeDb(),
+        )