fix: remove pytest.mark.asyncio and use llm-as-judge for memory integration tests

CLAUDE.md

···
 - 3.10+ and complete typing (T | None preferred over Optional[T] and list[T] over typing.List[T])
 - use prefer functional over OOP
 - keep implementation details private and functions pure
+- never use `pytest.mark.asyncio`, its unnecessary
 
 ## Project Structure
 

evals/test_basic_responses.py

···
 """Test phi's basic response behavior."""
 
-import pytest
-
 from bot.agent import Response
 
 
[e-mail]
 async def test_phi_responds_to_philosophical_question(phi_agent, evaluate_response):
     """Test that phi engages meaningfully with philosophical questions."""
     agent = phi_agent
···
         )
 
 
[e-mail]
 async def test_phi_ignores_spam(phi_agent):
     """Test that phi appropriately ignores spam-like content."""
     agent = phi_agent
···
     assert response.reason is not None
 
 
[e-mail]
 async def test_phi_maintains_thread_context(phi_agent, evaluate_response):
     """Test that phi uses thread context appropriately."""
     agent = phi_agent
···
         )
 
 
[e-mail]
 async def test_phi_respects_character_limit(phi_agent):
     """Test that phi's responses fit Bluesky's 300 character limit."""
     agent = phi_agent
···
         )
 
 
[e-mail]
 async def test_phi_handles_casual_greeting(phi_agent, evaluate_response):
     """Test that phi responds appropriately to casual greetings."""
     agent = phi_agent

evals/test_memory_integration.py

···
 
 import pytest
 
-from bot.agent import PhiAgent
 from bot.config import Settings
 from bot.memory import MemoryType, NamespaceMemory
 
 
[e-mail]
-async def test_phi_retrieves_episodic_memory(settings):
-    """Test that phi can retrieve and use episodic memories."""
[e-mail]
+def memory_settings():
+    """Check if memory keys are available."""
+    settings = Settings()
     if not all([settings.turbopuffer_api_key, settings.openai_api_key, settings.anthropic_api_key]):
-        pytest.skip("Requires TurboPuffer, OpenAI, and Anthropic API keys in .env")
+        pytest.skip("Requires TURBOPUFFER_API_KEY, OPENAI_API_KEY, and ANTHROPIC_API_KEY")
+    return settings
 
-    # Create memory system
-    memory = NamespaceMemory(api_key=settings.turbopuffer_api_key)
 
-    # Store a memory about a user
-    await memory.store_user_memory(
-        "alice.bsky",
-        "Alice mentioned she's working on a PhD in neuroscience",
-        MemoryType.USER_FACT,
+async def test_core_memory_integration(memory_settings, phi_agent, evaluate_response):
+    """Test that phi uses core memories in responses."""
+    memory = NamespaceMemory(api_key=memory_settings.turbopuffer_api_key)
+
+    # Store a core memory
+    await memory.store_core_memory(
+        label="test_interaction_rule",
+        content="When users mention birds, always acknowledge the beauty of murmuration patterns",
+        memory_type=MemoryType.GUIDELINE,
     )
 
-    # Create agent
-    agent = PhiAgent()
-    agent.memory = memory
+    # Override agent's memory with our test memory
+    phi_agent.memory = memory
 
-    # Process a mention that should trigger memory retrieval
-    response = await agent.process_mention(
-        mention_text="what do you remember about me?",
-        author_handle="alice.bsky",
+    # Ask about birds
+    response = await phi_agent.process_mention(
+        mention_text="I saw a huge flock of starlings today",
+        author_handle="test.user",
         thread_context="No previous messages in this thread.",
-        thread_uri="at://test/thread/memory1",
+        thread_uri="at://test/thread/1",
     )
 
     if response.action == "reply":
-        assert response.text is not None
-        # Should reference the neuroscience PhD in the response
-        assert (
-            "neuroscience" in response.text.lower()
-            or "phd" in response.text.lower()
-            or "working on" in response.text.lower()
-        ), "Response should reference stored memory about Alice"
+        await evaluate_response(
+            "Does the response acknowledge or reference murmuration patterns?",
+            response.text,
+        )
 
 
[e-mail]
-async def test_phi_stores_conversation_in_memory(settings):
-    """Test that phi stores interactions in episodic memory."""
-    if not all([settings.turbopuffer_api_key, settings.openai_api_key, settings.anthropic_api_key]):
-        pytest.skip("Requires TurboPuffer, OpenAI, and Anthropic API keys in .env")
+async def test_user_memory_integration(memory_settings, phi_agent, evaluate_response):
+    """Test that phi uses user-specific memories in responses."""
+    memory = NamespaceMemory(api_key=memory_settings.turbopuffer_api_key)
 
-    memory = NamespaceMemory(api_key=settings.turbopuffer_api_key)
+    # Store a memory about a user
+    await memory.store_user_memory(
+        handle="alice.test",
+        content="Alice is researching swarm intelligence in biological systems",
+        memory_type=MemoryType.USER_FACT,
+    )
 
-    agent = PhiAgent()
-    agent.memory = memory
+    # Override agent's memory
+    phi_agent.memory = memory
 
-    # Have a conversation
-    response = await agent.process_mention(
-        mention_text="I'm really interested in phenomenology",
-        author_handle="bob.bsky",
+    # User asks a question
+    response = await phi_agent.process_mention(
+        mention_text="what do you remember about my research?",
+        author_handle="alice.test",
         thread_context="No previous messages in this thread.",
-        thread_uri="at://test/thread/memory2",
+        thread_uri="at://test/thread/2",
     )
 
     if response.action == "reply":
-        # Verify memories were stored
-        memories = await memory.get_user_memories("bob.bsky", limit=10)
-
-        assert len(memories) > 0, "Should have stored conversation in memory"
-
-        # Check that both user's message and bot's response were stored
-        memory_texts = [m.content for m in memories]
-        assert any(
-            "phenomenology" in text.lower() for text in memory_texts
-        ), "Should store user's message about phenomenology"
+        await evaluate_response(
+            "Does the response reference Alice's research on swarm intelligence or biological systems?",
+            response.text,
+        )