get-claudia 1.28.2 → 1.28.3

package/memory-daemon/claudia_memory/mcp/server.py

@@ -66,9 +66,33 @@ from ..services.remember import (
     remember_fact,
     remember_message,
 )
+from ..embeddings import get_embedding_service
 
 logger = logging.getLogger(__name__)
 
+
+def _coerce_arg(arguments: Dict[str, Any], key: str, expected_type: type = list) -> None:
+    """Coerce a tool argument from JSON string to expected type in-place.
+
+    LLMs sometimes serialize array parameters as JSON strings instead of
+    native arrays. This transparently parses them back so handler code
+    can assume native types.
+    """
+    value = arguments.get(key)
+    if isinstance(value, str):
+        try:
+            parsed = json.loads(value)
+            if isinstance(parsed, expected_type):
+                arguments[key] = parsed
+            else:
+                logger.warning(
+                    f"Coercion: '{key}' parsed to {type(parsed).__name__}, "
+                    f"expected {expected_type.__name__}"
+                )
+        except (json.JSONDecodeError, TypeError):
+            logger.warning(f"Could not parse '{key}' as JSON: {value[:100]}")
+
+
 # Initialize the MCP server
 server = Server("claudia-memory")
 
@@ -94,7 +118,7 @@ async def list_tools() -> ListToolsResult:
                         "default": "fact",
                     },
                     "about": {
-                        "type": "array",
+                        "type": ["array", "string"],
                         "items": {"type": "string"},
                         "description": "Entity names this memory relates to (people, projects, etc.)",
                     },
@@ -139,7 +163,7 @@ async def list_tools() -> ListToolsResult:
                         "default": 10,
                     },
                     "types": {
-                        "type": "array",
+                        "type": ["array", "string"],
                         "items": {"type": "string"},
                         "description": "Filter by memory types (fact, preference, observation, learning, commitment)",
                     },
@@ -153,7 +177,7 @@ async def list_tools() -> ListToolsResult:
                         "default": False,
                     },
                     "ids": {
-                        "type": "array",
+                        "type": ["array", "string"],
                         "items": {"type": "integer"},
                         "description": "Fetch specific memories by ID (skips search). Use after a compact search to get full content.",
                     },
@@ -232,7 +256,7 @@ async def list_tools() -> ListToolsResult:
                         "default": 5,
                     },
                     "types": {
-                        "type": "array",
+                        "type": ["array", "string"],
                         "items": {"type": "string"},
                         "description": "Filter by type (reminder, suggestion, warning, insight)",
                     },
@@ -268,7 +292,7 @@ async def list_tools() -> ListToolsResult:
                         "description": "Description of the entity",
                     },
                     "aliases": {
-                        "type": "array",
+                        "type": ["array", "string"],
                         "items": {"type": "string"},
                         "description": "Alternative names or spellings",
                     },
@@ -287,7 +311,7 @@ async def list_tools() -> ListToolsResult:
                         "description": "Search query",
                     },
                     "types": {
-                        "type": "array",
+                        "type": ["array", "string"],
                         "items": {"type": "string"},
                         "description": "Filter by entity types",
                     },
@@ -354,7 +378,7 @@ async def list_tools() -> ListToolsResult:
                         ),
                     },
                     "facts": {
-                        "type": "array",
+                        "type": ["array", "string"],
                         "items": {
                             "type": "object",
                             "properties": {
@@ -388,7 +412,7 @@ async def list_tools() -> ListToolsResult:
                         "description": "Structured facts, preferences, observations, learnings extracted from the session",
                     },
                     "commitments": {
-                        "type": "array",
+                        "type": ["array", "string"],
                         "items": {
                             "type": "object",
                             "properties": {
@@ -416,7 +440,7 @@ async def list_tools() -> ListToolsResult:
                         "description": "Commitments or promises made during the session",
                     },
                     "entities": {
-                        "type": "array",
+                        "type": ["array", "string"],
                         "items": {
                             "type": "object",
                             "properties": {
@@ -437,7 +461,7 @@ async def list_tools() -> ListToolsResult:
                         "description": "New or updated entities mentioned during the session",
                     },
                     "relationships": {
-                        "type": "array",
+                        "type": ["array", "string"],
                         "items": {
                             "type": "object",
                             "properties": {
@@ -451,12 +475,12 @@ async def list_tools() -> ListToolsResult:
                         "description": "Relationships between entities observed during the session",
                     },
                     "key_topics": {
-                        "type": "array",
+                        "type": ["array", "string"],
                         "items": {"type": "string"},
                         "description": "Main topics discussed in the session",
                     },
                     "reflections": {
-                        "type": "array",
+                        "type": ["array", "string"],
                         "items": {
                             "type": "object",
                             "properties": {
@@ -492,7 +516,7 @@ async def list_tools() -> ListToolsResult:
                         ),
                     },
                 },
-                "required": ["episode_id", "narrative"],
+                "required": ["narrative"],
             },
         ),
         Tool(
@@ -524,7 +548,7 @@ async def list_tools() -> ListToolsResult:
                         "description": "Semantic search query (optional). If omitted, returns recent high-importance reflections.",
                     },
                     "types": {
-                        "type": "array",
+                        "type": ["array", "string"],
                         "items": {
                             "type": "string",
                             "enum": ["observation", "pattern", "learning", "question"],
@@ -570,7 +594,7 @@ async def list_tools() -> ListToolsResult:
                 "type": "object",
                 "properties": {
                     "operations": {
-                        "type": "array",
+                        "type": ["array", "string"],
                         "description": "Array of operations to execute in order",
                         "items": {
                             "type": "object",
@@ -775,12 +799,12 @@ async def list_tools() -> ListToolsResult:
                         "description": "Brief summary of the document",
                     },
                     "about": {
-                        "type": "array",
+                        "type": ["array", "string"],
                         "items": {"type": "string"},
                         "description": "Entity names this document relates to",
                     },
                     "memory_ids": {
-                        "type": "array",
+                        "type": ["array", "string"],
                         "items": {"type": "integer"},
                         "description": "Memory IDs to link as sourced from this document",
                     },
@@ -1158,6 +1182,7 @@ async def call_tool(name: str, arguments: Dict[str, Any]) -> CallToolResult:
     """Handle tool calls"""
     try:
         if name == "memory.remember":
+            _coerce_arg(arguments, "about")
             memory_id = remember_fact(
                 content=arguments["content"],
                 memory_type=arguments.get("type", "fact"),
@@ -1187,6 +1212,8 @@ async def call_tool(name: str, arguments: Dict[str, Any]) -> CallToolResult:
             )
 
         elif name == "memory.recall":
+            _coerce_arg(arguments, "types")
+            _coerce_arg(arguments, "ids")
             # Direct fetch by IDs (skip search)
             if "ids" in arguments and arguments["ids"]:
                 results = fetch_by_ids(arguments["ids"])
@@ -1339,6 +1366,7 @@ async def call_tool(name: str, arguments: Dict[str, Any]) -> CallToolResult:
             )
 
         elif name == "memory.predictions":
+            _coerce_arg(arguments, "types")
             predictions = get_predictions(
                 limit=arguments.get("limit", 5),
                 prediction_types=arguments.get("types"),
@@ -1364,6 +1392,7 @@ async def call_tool(name: str, arguments: Dict[str, Any]) -> CallToolResult:
             )
 
         elif name == "memory.entity":
+            _coerce_arg(arguments, "aliases")
             entity_id = remember_entity(
                 name=arguments["name"],
                 entity_type=arguments.get("type", "person"),
@@ -1380,6 +1409,7 @@ async def call_tool(name: str, arguments: Dict[str, Any]) -> CallToolResult:
             )
 
         elif name == "memory.search_entities":
+            _coerce_arg(arguments, "types")
             results = search_entities(
                 query=arguments["query"],
                 entity_types=arguments.get("types"),
@@ -1426,19 +1456,30 @@ async def call_tool(name: str, arguments: Dict[str, Any]) -> CallToolResult:
             )
 
         elif name == "memory.end_session":
-            episode_id = arguments["episode_id"]
+            # Coerce all array fields (LLMs may send JSON strings)
+            for field in ("facts", "commitments", "entities", "relationships", "key_topics", "reflections"):
+                _coerce_arg(arguments, field)
 
-            # Auto-create episode if it doesn't exist (handles skipped buffer_turn)
+            # Handle missing or invalid episode_id: auto-create
+            episode_id = arguments.get("episode_id")
             svc = get_remember_service()
-            episode = svc.db.get_one("episodes", where="id = ?", where_params=(episode_id,))
-            if not episode:
+            if episode_id is None:
                 from datetime import datetime
-                new_id = svc.db.insert("episodes", {
+                episode_id = svc.db.insert("episodes", {
                     "started_at": datetime.utcnow().isoformat(),
-                    "source": arguments.get("source", "claude_code"),
+                    "source": "claude_code",
                 })
-                logger.info(f"Auto-created episode {new_id} (requested {episode_id} did not exist)")
-                episode_id = new_id
+                logger.info(f"Auto-created episode {episode_id} (no episode_id provided)")
+            else:
+                episode = svc.db.get_one("episodes", where="id = ?", where_params=(episode_id,))
+                if not episode:
+                    from datetime import datetime
+                    new_id = svc.db.insert("episodes", {
+                        "started_at": datetime.utcnow().isoformat(),
+                        "source": arguments.get("source", "claude_code"),
+                    })
+                    logger.info(f"Auto-created episode {new_id} (requested {episode_id} did not exist)")
+                    episode_id = new_id
 
             result = end_session(
                 episode_id=episode_id,
@@ -1489,6 +1530,7 @@ async def call_tool(name: str, arguments: Dict[str, Any]) -> CallToolResult:
             )
 
         elif name == "memory.reflections":
+            _coerce_arg(arguments, "types")
             action = arguments.get("action", "get")
             limit = arguments.get("limit", 10)
             types = arguments.get("types")
@@ -1578,7 +1620,35 @@ async def call_tool(name: str, arguments: Dict[str, Any]) -> CallToolResult:
                 )
 
         elif name == "memory.batch":
+            _coerce_arg(arguments, "operations")
             operations = arguments.get("operations", [])
+
+            # --- Pass 1: Collect all texts that need embeddings ---
+            embed_tasks = []  # list of (index, text) for parallel embedding
+            for i, op in enumerate(operations):
+                op_type = op.get("op")
+                if op_type == "remember":
+                    embed_tasks.append((i, op["content"]))
+                elif op_type == "entity":
+                    # Only new entities need embeddings; collect optimistically
+                    embed_text = f"{op['name']}. {op.get('description') or ''}"
+                    embed_tasks.append((i, embed_text))
+
+            # --- Parallel embedding pass ---
+            embeddings_map = {}  # index -> embedding
+            if embed_tasks:
+                try:
+                    emb_svc = get_embedding_service()
+                    texts = [text for _, text in embed_tasks]
+                    all_embeddings = await emb_svc.embed_batch(texts)
+                    for (idx, _), emb in zip(embed_tasks, all_embeddings):
+                        if emb is not None:
+                            embeddings_map[idx] = emb
+                except Exception as e:
+                    logger.warning(f"Batch parallel embedding failed, falling back to per-op: {e}")
+                    # embeddings_map stays empty; remember_fact/entity will embed individually
+
+            # --- Pass 2: Execute operations with pre-computed embeddings ---
             results = []
             for i, op in enumerate(operations):
                 op_type = op.get("op")
@@ -1590,6 +1660,7 @@ async def call_tool(name: str, arguments: Dict[str, Any]) -> CallToolResult:
                             entity_type=op.get("type", "person"),
                             description=op.get("description"),
                             aliases=op.get("aliases"),
+                            _precomputed_embedding=embeddings_map.get(i),
                         )
                         op_result["success"] = True
                         op_result["entity_id"] = entity_id
@@ -1601,6 +1672,7 @@ async def call_tool(name: str, arguments: Dict[str, Any]) -> CallToolResult:
                             importance=op.get("importance", 1.0),
                             source=op.get("source"),
                             source_context=op.get("source_context"),
+                            _precomputed_embedding=embeddings_map.get(i),
                         )
                         op_result["success"] = True
                         op_result["memory_id"] = memory_id
@@ -1716,6 +1788,8 @@ async def call_tool(name: str, arguments: Dict[str, Any]) -> CallToolResult:
             )
 
         elif name == "memory.file":
+            _coerce_arg(arguments, "about")
+            _coerce_arg(arguments, "memory_ids")
             doc_svc = get_document_service()
             result = doc_svc.file_document_from_text(
                 content=arguments["content"],

package/memory-daemon/claudia_memory/services/remember.py

@@ -141,6 +141,7 @@ class RememberService:
         source_context: Optional[str] = None,
         metadata: Optional[Dict] = None,
         origin_type: Optional[str] = None,
+        _precomputed_embedding: Optional[List[float]] = None,
     ) -> Optional[int]:
         """
         Store a discrete fact/memory.
@@ -217,8 +218,8 @@ class RememberService:
 
         memory_id = self.db.insert("memories", insert_data)
 
-        # Generate and store embedding
-        embedding = embed_sync(content)
+        # Store embedding (use precomputed if available, otherwise generate)
+        embedding = _precomputed_embedding or embed_sync(content)
         if embedding:
             try:
                 self.db.execute(
@@ -263,6 +264,7 @@ class RememberService:
         description: Optional[str] = None,
         aliases: Optional[List[str]] = None,
         metadata: Optional[Dict] = None,
+        _precomputed_embedding: Optional[List[float]] = None,
     ) -> int:
         """
         Create or update an entity.
@@ -326,9 +328,9 @@ class RememberService:
                 },
             )
 
-            # Generate and store embedding
+            # Store embedding (use precomputed if available, otherwise generate)
             embed_text = f"{name}. {description or ''}"
-            embedding = embed_sync(embed_text)
+            embedding = _precomputed_embedding or embed_sync(embed_text)
             if embedding:
                 try:
                     self.db.execute(
@@ -1512,12 +1514,12 @@ def remember_message(content: str, role: str = "user", **kwargs) -> Dict[str, An
 
 
 def remember_fact(content: str, **kwargs) -> Optional[int]:
-    """Store a discrete fact"""
+    """Store a discrete fact. Pass _precomputed_embedding to skip Ollama call."""
     return get_remember_service().remember_fact(content, **kwargs)
 
 
 def remember_entity(name: str, **kwargs) -> int:
-    """Create or update an entity"""
+    """Create or update an entity. Pass _precomputed_embedding to skip Ollama call."""
     return get_remember_service().remember_entity(name, **kwargs)
 
 

package/memory-daemon/tests/test_batch_parallel.py

@@ -0,0 +1,348 @@
+"""Tests for parallel batch embedding optimization.
+
+Verifies that the batch handler's parallel embedding pass correctly:
+- Skips embed_sync when precomputed embeddings are provided
+- Falls back to embed_sync when no precomputed embedding is given
+- Stores memories and entities correctly in both cases
+
+Note: Vector tables (memory_embeddings, entity_embeddings) require sqlite-vec
+which may not be available in test environments. Tests verify behavior through
+mock assertions rather than querying vector tables directly.
+"""
+
+import json
+import tempfile
+from datetime import datetime
+from pathlib import Path
+from unittest.mock import MagicMock, patch
+
+import pytest
+
+from claudia_memory.database import Database, content_hash
+
+
+@pytest.fixture
+def db():
+    """Create a temporary test database"""
+    with tempfile.TemporaryDirectory() as tmpdir:
+        db_path = Path(tmpdir) / "test.db"
+        database = Database(db_path)
+        database.initialize()
+        yield database
+        database.close()
+
+
+def _get_remember_service(db):
+    """Create a RememberService with test database and mocked embeddings"""
+    from claudia_memory.services.remember import RememberService
+    from claudia_memory.extraction.entity_extractor import get_extractor
+
+    svc = RememberService.__new__(RememberService)
+    svc.db = db
+    svc.embedding_service = MagicMock()
+    svc.extractor = get_extractor()
+    return svc
+
+
+def _fake_embedding(text):
+    """Generate a deterministic fake 384-dim embedding from text"""
+    import hashlib
+    h = hashlib.sha256(text.encode()).digest()
+    return [float(b) / 255.0 for b in (h * 12)][:384]
+
+
+class TestPrecomputedEmbedding:
+    """Tests that precomputed embeddings skip the embed_sync call"""
+
+    def test_remember_fact_with_precomputed_skips_embed(self, db):
+        """When precomputed embedding is provided, embed_sync is not called"""
+        svc = _get_remember_service(db)
+        fake_emb = _fake_embedding("test content")
+
+        with patch("claudia_memory.services.remember.embed_sync") as mock_embed:
+            memory_id = svc.remember_fact(
+                content="Ford prefers async communication",
+                memory_type="preference",
+                importance=0.7,
+                _precomputed_embedding=fake_emb,
+            )
+
+            mock_embed.assert_not_called()
+
+        assert memory_id is not None
+        # Memory itself is stored in the regular memories table
+        memory = db.get_one("memories", where="id = ?", where_params=(memory_id,))
+        assert memory is not None
+        assert memory["content"] == "Ford prefers async communication"
+        assert memory["type"] == "preference"
+
+    def test_remember_fact_without_precomputed_calls_embed(self, db):
+        """Without precomputed embedding, embed_sync is called normally"""
+        svc = _get_remember_service(db)
+        fallback_emb = _fake_embedding("fallback")
+
+        with patch("claudia_memory.services.remember.embed_sync", return_value=fallback_emb) as mock_embed:
+            memory_id = svc.remember_fact(
+                content="Some fact to remember",
+                memory_type="fact",
+                importance=0.8,
+            )
+
+            mock_embed.assert_called_once_with("Some fact to remember")
+
+        assert memory_id is not None
+
+    def test_remember_entity_with_precomputed_skips_embed(self, db):
+        """New entity uses precomputed embedding instead of calling embed_sync"""
+        svc = _get_remember_service(db)
+        fake_emb = _fake_embedding("Ford Perry. CEO of Perry Ventures")
+
+        with patch("claudia_memory.services.remember.embed_sync") as mock_embed:
+            entity_id = svc.remember_entity(
+                name="Ford Perry",
+                entity_type="person",
+                description="CEO of Perry Ventures",
+                _precomputed_embedding=fake_emb,
+            )
+
+            mock_embed.assert_not_called()
+
+        assert entity_id is not None
+        entity = db.get_one("entities", where="id = ?", where_params=(entity_id,))
+        assert entity["name"] == "Ford Perry"
+        assert entity["description"] == "CEO of Perry Ventures"
+
+    def test_remember_entity_existing_skips_embedding(self, db):
+        """Updating an existing entity doesn't try to embed again"""
+        svc = _get_remember_service(db)
+
+        with patch("claudia_memory.services.remember.embed_sync") as mock_embed:
+            # Create entity first time
+            entity_id1 = svc.remember_entity(
+                name="Ford Perry",
+                entity_type="person",
+                _precomputed_embedding=_fake_embedding("first"),
+            )
+
+            # Update same entity (existing path doesn't embed)
+            entity_id2 = svc.remember_entity(
+                name="Ford Perry",
+                entity_type="person",
+                description="Updated description",
+                _precomputed_embedding=_fake_embedding("second"),
+            )
+
+            mock_embed.assert_not_called()
+
+        assert entity_id1 == entity_id2
+
+    def test_remember_fact_dedup_with_precomputed(self, db):
+        """Duplicate content deduplicates even with precomputed embeddings"""
+        svc = _get_remember_service(db)
+
+        with patch("claudia_memory.services.remember.embed_sync") as mock_embed:
+            id1 = svc.remember_fact(
+                content="Ford prefers email",
+                _precomputed_embedding=_fake_embedding("v1"),
+            )
+            id2 = svc.remember_fact(
+                content="Ford prefers email",
+                _precomputed_embedding=_fake_embedding("v2"),
+            )
+
+            mock_embed.assert_not_called()
+
+        assert id1 == id2
+
+    def test_precomputed_none_falls_back_to_embed_sync(self, db):
+        """Explicitly passing None for precomputed embedding falls back"""
+        svc = _get_remember_service(db)
+        fallback_emb = _fake_embedding("fallback")
+
+        with patch("claudia_memory.services.remember.embed_sync", return_value=fallback_emb) as mock_embed:
+            memory_id = svc.remember_fact(
+                content="Content needing fallback",
+                _precomputed_embedding=None,
+            )
+
+            mock_embed.assert_called_once()
+
+        assert memory_id is not None
+
+
+class TestBatchWithParallelEmbeddings:
+    """Integration-style tests simulating the batch handler's two-pass flow"""
+
+    def test_batch_seven_memories_no_sequential_embeds(self, db):
+        """Realistic scenario: 7 memories from a transcript, all pre-embedded"""
+        svc = _get_remember_service(db)
+
+        memories = [
+            {"content": f"Memory {i}: fact about the call", "type": "fact", "importance": 0.6 + i * 0.05}
+            for i in range(7)
+        ]
+        embeddings = [_fake_embedding(m["content"]) for m in memories]
+
+        with patch("claudia_memory.services.remember.embed_sync") as mock_embed:
+            ids = []
+            for m, emb in zip(memories, embeddings):
+                mid = svc.remember_fact(
+                    content=m["content"],
+                    memory_type=m["type"],
+                    importance=m["importance"],
+                    _precomputed_embedding=emb,
+                )
+                ids.append(mid)
+
+            mock_embed.assert_not_called()
+
+        assert len(ids) == 7
+        assert all(mid is not None for mid in ids)
+        assert len(set(ids)) == 7  # All unique
+
+        # Verify all memories stored in regular table
+        for mid, m in zip(ids, memories):
+            row = db.get_one("memories", where="id = ?", where_params=(mid,))
+            assert row is not None
+            assert row["content"] == m["content"]
+
+    def test_batch_mixed_operations(self, db):
+        """Batch with entity + remember + relate, only primary ops pre-embedded"""
+        svc = _get_remember_service(db)
+
+        with patch("claudia_memory.services.remember.embed_sync") as mock_embed:
+            # Entity op with precomputed
+            entity_id = svc.remember_entity(
+                name="Ford Perry",
+                entity_type="person",
+                description="CEO of Perry Ventures",
+                _precomputed_embedding=_fake_embedding("Ford Perry. CEO"),
+            )
+
+            # Remember op with precomputed
+            memory_id = svc.remember_fact(
+                content="Ford prefers async communication",
+                memory_type="preference",
+                about_entities=["Ford Perry"],
+                _precomputed_embedding=_fake_embedding("Ford prefers async"),
+            )
+
+            # Relate op (no embedding needed)
+            rel_id = svc.relate_entities(
+                source_name="Ford Perry",
+                target_name="Test User",
+                relationship_type="potential_partner",
+            )
+
+        assert entity_id is not None
+        assert memory_id is not None
+        assert rel_id is not None
+
+        # Verify entity linked to memory
+        link = db.get_one(
+            "memory_entities",
+            where="memory_id = ? AND entity_id = ?",
+            where_params=(memory_id, entity_id),
+        )
+        assert link is not None
+
+    def test_batch_partial_embedding_failure_fallback(self, db):
+        """When some embeddings fail (None), those ops fall back to embed_sync"""
+        svc = _get_remember_service(db)
+        fallback_emb = _fake_embedding("fallback")
+
+        with patch("claudia_memory.services.remember.embed_sync", return_value=fallback_emb) as mock_embed:
+            # Op with precomputed embedding
+            id1 = svc.remember_fact(
+                content="Good content with embedding",
+                _precomputed_embedding=_fake_embedding("good"),
+            )
+            # Op without precomputed (simulating embedding failure)
+            id2 = svc.remember_fact(
+                content="Content that failed embedding",
+                _precomputed_embedding=None,
+            )
+
+            # embed_sync called only for the second (failed) one
+            mock_embed.assert_called_once_with("Content that failed embedding")
+
+        assert id1 is not None
+        assert id2 is not None
+        assert id1 != id2
+
+    def test_two_pass_flow_simulation(self, db):
+        """Full simulation of the batch handler's two-pass architecture"""
+        svc = _get_remember_service(db)
+
+        # These are the operations that would come from memory.batch
+        operations = [
+            {"op": "entity", "name": "Ford Perry", "type": "person", "description": "CEO"},
+            {"op": "remember", "content": "Ford prefers email", "type": "preference", "importance": 0.7, "about": ["Ford Perry"]},
+            {"op": "remember", "content": "Meeting scheduled for Friday", "type": "fact", "importance": 0.8},
+            {"op": "relate", "source": "Ford Perry", "target": "Kamil", "relationship": "business_contact"},
+        ]
+
+        # --- Pass 1: Collect texts and generate embeddings ---
+        embed_texts = []
+        embed_indices = []
+        for i, op in enumerate(operations):
+            if op["op"] == "remember":
+                embed_texts.append(op["content"])
+                embed_indices.append(i)
+            elif op["op"] == "entity":
+                embed_texts.append(f"{op['name']}. {op.get('description', '')}")
+                embed_indices.append(i)
+
+        # Simulate parallel embedding
+        all_embeddings = [_fake_embedding(t) for t in embed_texts]
+        embeddings_map = {idx: emb for idx, emb in zip(embed_indices, all_embeddings)}
+
+        # --- Pass 2: Execute with precomputed embeddings ---
+        results = []
+        with patch("claudia_memory.services.remember.embed_sync") as mock_embed:
+            for i, op in enumerate(operations):
+                if op["op"] == "entity":
+                    eid = svc.remember_entity(
+                        name=op["name"],
+                        entity_type=op.get("type", "person"),
+                        description=op.get("description"),
+                        _precomputed_embedding=embeddings_map.get(i),
+                    )
+                    results.append({"op": "entity", "id": eid})
+                elif op["op"] == "remember":
+                    mid = svc.remember_fact(
+                        content=op["content"],
+                        memory_type=op.get("type", "fact"),
+                        about_entities=op.get("about"),
+                        importance=op.get("importance", 1.0),
+                        _precomputed_embedding=embeddings_map.get(i),
+                    )
+                    results.append({"op": "remember", "id": mid})
+                elif op["op"] == "relate":
+                    rid = svc.relate_entities(
+                        source_name=op["source"],
+                        target_name=op["target"],
+                        relationship_type=op["relationship"],
+                    )
+                    results.append({"op": "relate", "id": rid})
+
+            # embed_sync may be called for entities created during linking
+            # (e.g., "Kamil" created by relate), but NOT for the primary ops
+            # For the 2 remember ops and 1 entity op, embed_sync was NOT used
+            # It might be called for auto-created entities in about_entities linking
+            pass
+
+        assert len(results) == 4
+        assert all(r["id"] is not None for r in results)
+
+        # Verify data integrity
+        entity = db.get_one("entities", where="name = ?", where_params=("Ford Perry",))
+        assert entity is not None
+        assert entity["description"] == "CEO"
+
+        mem1 = db.get_one("memories", where="content = ?", where_params=("Ford prefers email",))
+        assert mem1 is not None
+        assert mem1["type"] == "preference"
+
+        mem2 = db.get_one("memories", where="content = ?", where_params=("Meeting scheduled for Friday",))
+        assert mem2 is not None

package/memory-daemon/tests/test_llm_coercion.py

@@ -0,0 +1,258 @@
+"""Tests for LLM serialization error defense.
+
+Validates that the MCP layer gracefully handles two classes of LLM tool-calling
+errors: (1) string-serialized arrays and (2) missing optional fields like
+episode_id in end_session.
+"""
+
+import json
+import tempfile
+from pathlib import Path
+
+import pytest
+import jsonschema
+
+from claudia_memory.database import Database
+from claudia_memory.mcp.server import _coerce_arg
+from claudia_memory.services.remember import RememberService
+
+
+# ---------------------------------------------------------------------------
+# Helpers
+# ---------------------------------------------------------------------------
+
+def _make_db():
+    """Create a fresh test database."""
+    tmpdir = tempfile.mkdtemp()
+    db_path = Path(tmpdir) / "test.db"
+    db = Database(db_path)
+    db.initialize()
+    return db, tmpdir
+
+
+def _make_service(db):
+    """Create a RememberService without embedding service."""
+    svc = RememberService.__new__(RememberService)
+    svc.db = db
+    svc.embeddings = None
+    return svc
+
+
+# ---------------------------------------------------------------------------
+# TestCoerceArg -- unit tests for the _coerce_arg utility
+# ---------------------------------------------------------------------------
+
+class TestCoerceArg:
+    """Tests for _coerce_arg string-to-native coercion."""
+
+    def test_string_to_list(self):
+        """JSON string containing an array should be parsed to a list."""
+        args = {"about": '["Alice", "Bob"]'}
+        _coerce_arg(args, "about")
+        assert args["about"] == ["Alice", "Bob"]
+
+    def test_string_to_list_of_objects(self):
+        """JSON string containing array of objects should parse correctly."""
+        reflections = [{"type": "learning", "content": "User prefers concise responses"}]
+        args = {"reflections": json.dumps(reflections)}
+        _coerce_arg(args, "reflections")
+        assert args["reflections"] == reflections
+
+    def test_noop_on_native_list(self):
+        """Already-native list should be left unchanged."""
+        original = ["Alice", "Bob"]
+        args = {"about": original}
+        _coerce_arg(args, "about")
+        assert args["about"] is original
+
+    def test_noop_on_none(self):
+        """None value should be left unchanged."""
+        args = {"about": None}
+        _coerce_arg(args, "about")
+        assert args["about"] is None
+
+    def test_noop_on_missing_key(self):
+        """Missing key should not raise or create the key."""
+        args = {}
+        _coerce_arg(args, "about")
+        assert "about" not in args
+
+    def test_invalid_json_leaves_value(self):
+        """Unparseable string should be left as-is (with warning logged)."""
+        args = {"about": "not valid json ["}
+        _coerce_arg(args, "about")
+        assert args["about"] == "not valid json ["
+
+    def test_wrong_type_after_parse_leaves_value(self):
+        """String that parses to wrong type (e.g. dict instead of list) stays as-is."""
+        args = {"about": '{"key": "value"}'}
+        _coerce_arg(args, "about")
+        # Should remain the original string since parsed result is dict, not list
+        assert args["about"] == '{"key": "value"}'
+
+    def test_empty_array_string(self):
+        """Empty array string should parse to empty list."""
+        args = {"types": "[]"}
+        _coerce_arg(args, "types")
+        assert args["types"] == []
+
+
+# ---------------------------------------------------------------------------
+# TestEndSessionMissingEpisodeId -- handler auto-creates episodes
+# ---------------------------------------------------------------------------
+
+class TestEndSessionMissingEpisodeId:
+    """Tests for end_session handler when episode_id is missing or invalid."""
+
+    def test_auto_creates_episode_when_none(self):
+        """end_session should auto-create an episode when episode_id is not provided."""
+        db, tmpdir = _make_db()
+        try:
+            svc = _make_service(db)
+
+            # Simulate calling end_session without episode_id
+            # (We test at the service level with a freshly-created episode)
+            from datetime import datetime
+            episode_id = svc.db.insert("episodes", {
+                "started_at": datetime.utcnow().isoformat(),
+                "source": "claude_code",
+            })
+
+            result = svc.end_session(
+                episode_id=episode_id,
+                narrative="Session without prior buffer_turn calls.",
+            )
+
+            assert result["narrative_stored"] is True
+            episode = db.get_one("episodes", where="id = ?", where_params=(episode_id,))
+            assert episode is not None
+            assert episode["narrative"] == "Session without prior buffer_turn calls."
+        finally:
+            db.close()
+
+    def test_auto_creates_episode_for_nonexistent_id(self):
+        """end_session should create a new episode if requested ID doesn't exist."""
+        db, tmpdir = _make_db()
+        try:
+            svc = _make_service(db)
+
+            # Use an ID that doesn't exist
+            fake_id = 99999
+            episode = db.get_one("episodes", where="id = ?", where_params=(fake_id,))
+            assert episode is None  # Confirm it doesn't exist
+
+            # The handler logic (tested here at DB level) should create a new one
+            from datetime import datetime
+            new_id = svc.db.insert("episodes", {
+                "started_at": datetime.utcnow().isoformat(),
+                "source": "claude_code",
+            })
+
+            result = svc.end_session(
+                episode_id=new_id,
+                narrative="Fallback episode for missing ID.",
+            )
+
+            assert result["narrative_stored"] is True
+        finally:
+            db.close()
+
+    def test_end_session_with_facts_as_string(self):
+        """end_session should work when facts arrive as a JSON string after coercion."""
+        db, tmpdir = _make_db()
+        try:
+            svc = _make_service(db)
+
+            # Create episode
+            from datetime import datetime
+            episode_id = svc.db.insert("episodes", {
+                "started_at": datetime.utcnow().isoformat(),
+                "source": "claude_code",
+            })
+
+            # Simulate coerced facts (string -> list already done by _coerce_arg)
+            facts = [{"content": "User likes dark mode", "type": "preference"}]
+
+            result = svc.end_session(
+                episode_id=episode_id,
+                narrative="Testing string-serialized facts.",
+                facts=facts,
+            )
+
+            assert result["narrative_stored"] is True
+            assert result["facts_stored"] >= 1
+        finally:
+            db.close()
+
+
+# ---------------------------------------------------------------------------
+# TestSchemaValidation -- verify updated schemas accept both types
+# ---------------------------------------------------------------------------
+
+class TestSchemaValidation:
+    """Tests that updated schemas pass jsonschema validation for both array and string."""
+
+    def _make_schema(self, prop_name, prop_schema, required=None):
+        """Build a minimal object schema with one property."""
+        schema = {
+            "type": "object",
+            "properties": {
+                prop_name: prop_schema,
+            },
+        }
+        if required:
+            schema["required"] = required
+        return schema
+
+    def test_array_type_union_accepts_native_array(self):
+        """Schema with type: [array, string] should accept a native array."""
+        schema = self._make_schema("about", {
+            "type": ["array", "string"],
+            "items": {"type": "string"},
+        })
+        # Should not raise
+        jsonschema.validate({"about": ["Alice", "Bob"]}, schema)
+
+    def test_array_type_union_accepts_string(self):
+        """Schema with type: [array, string] should accept a JSON string."""
+        schema = self._make_schema("about", {
+            "type": ["array", "string"],
+            "items": {"type": "string"},
+        })
+        # Should not raise
+        jsonschema.validate({"about": '["Alice", "Bob"]'}, schema)
+
+    def test_original_array_only_rejects_string(self):
+        """Original schema with type: array should reject a string (proving the fix is needed)."""
+        schema = self._make_schema("about", {
+            "type": "array",
+            "items": {"type": "string"},
+        })
+        with pytest.raises(jsonschema.ValidationError):
+            jsonschema.validate({"about": '["Alice", "Bob"]'}, schema)
+
+    def test_end_session_narrative_only_required(self):
+        """end_session schema should only require narrative, not episode_id."""
+        schema = {
+            "type": "object",
+            "properties": {
+                "episode_id": {"type": "integer"},
+                "narrative": {"type": "string"},
+            },
+            "required": ["narrative"],
+        }
+        # Should not raise -- episode_id is omitted
+        jsonschema.validate({"narrative": "Session summary"}, schema)
+
+    def test_end_session_rejects_missing_narrative(self):
+        """end_session schema should still require narrative."""
+        schema = {
+            "type": "object",
+            "properties": {
+                "episode_id": {"type": "integer"},
+                "narrative": {"type": "string"},
+            },
+            "required": ["narrative"],
+        }
+        with pytest.raises(jsonschema.ValidationError):
+            jsonschema.validate({"episode_id": 1}, schema)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "get-claudia",
-  "version": "1.28.2",
+  "version": "1.28.3",
   "description": "An AI assistant who learns how you work.",
   "keywords": [
     "claudia",

package/template-v2/.claude/agents/document-processor.md

@@ -131,6 +131,73 @@ Return this exact JSON structure:
 }
 ```
 
+### Memory Operations (for batch storage pipeline)
+
+When Claudia dispatches you with `extraction_type: "memory_operations"`, return ready-to-store operations matching the `memory.batch` input format. This lets Claudia pipe your output directly into `memory.batch` after review, skipping manual composition.
+
+```json
+{
+  "extraction_type": "memory_operations",
+  "source_summary": "Extracted 7 memories from call with Ford Perry",
+  "memory_operations": [
+    {
+      "op": "remember",
+      "content": "Ford Perry prefers async communication over calls",
+      "type": "preference",
+      "importance": 0.7,
+      "about": ["Ford Perry"],
+      "source_context": "2026-02-04 call with Ford Perry re: partnership"
+    },
+    {
+      "op": "remember",
+      "content": "Ford committed to sending the revised proposal by Friday Feb 7",
+      "type": "commitment",
+      "importance": 0.9,
+      "about": ["Ford Perry"],
+      "source_context": "2026-02-04 call with Ford Perry re: partnership"
+    },
+    {
+      "op": "entity",
+      "name": "Ford Perry",
+      "type": "person",
+      "description": "Potential partner, CEO of Perry Ventures"
+    },
+    {
+      "op": "relate",
+      "source": "Kamil Banc",
+      "target": "Ford Perry",
+      "relationship": "potential_partner",
+      "strength": 0.6
+    }
+  ],
+  "confidence": 0.85,
+  "ambiguities": [],
+  "needs_claudia_judgment": true,
+  "judgment_reason": "Review extracted memories for accuracy before batch storage"
+}
+```
+
+**Memory operation field reference:**
+
+| Field | Required | Description |
+|-------|----------|-------------|
+| `op` | Yes | `"remember"`, `"entity"`, or `"relate"` |
+| `content` | For remember | The memory text (preserve exact wording for commitments) |
+| `type` | For remember | `"fact"`, `"preference"`, `"observation"`, `"commitment"`, `"decision"` |
+| `importance` | For remember | 0.0-1.0 (commitments default 0.9, facts 0.7, observations 0.6) |
+| `about` | For remember | Entity names this memory relates to |
+| `source_context` | For remember | One-line breadcrumb: "YYYY-MM-DD [source] re: [topic]" |
+| `name` | For entity | Entity name |
+| `source`/`target` | For relate | Entity names for relationship |
+| `relationship` | For relate | Relationship type (works_with, client_of, etc.) |
+
+**When to use memory_operations extraction:**
+- Processing transcripts where Claudia needs structured memories
+- Processing emails where facts, commitments, and relationships need capturing
+- Any document where multiple memory operations are expected
+
+**Always set `needs_claudia_judgment: true`** for memory_operations. Claudia must review before storing.
+
 ## Deadline Confidence
 
 | Level | Meaning |

package/template-v2/.claude/skills/capture-meeting/SKILL.md

@@ -50,7 +50,33 @@ The file is automatically routed to the right folder:
 - Which person files to update?
 - Any new people to track?
 
-### 3. Extract Key Information
+### 3. Extract Key Information (Agent-Accelerated)
+
+**Preferred: Dispatch Document Processor for extraction.** Instead of composing memory operations manually (which takes 2+ minutes of thinking time), dispatch the Document Processor agent (Haiku) with the transcript content and `extraction_type: "memory_operations"`. The agent returns ready-to-store operations in ~10-20 seconds.
+
+**Agent pipeline workflow:**
+```
+1. Dispatch Document Processor (Haiku) with:
+   - The full transcript text
+   - extraction_type: "memory_operations"
+   - Context: participant names, meeting topic, date
+
+2. Agent returns memory_operations[] array with:
+   - Facts, preferences, observations
+   - Commitments with deadlines
+   - Entity definitions
+   - Relationship links
+
+3. Review agent output (judgment layer):
+   - Verify commitment wording is accurate
+   - Check importance scores are reasonable
+   - Confirm entity names match existing entities
+   - Adjust or remove any questionable extractions
+
+4. Call memory.batch with the reviewed operations
+```
+
+**Fallback: Manual extraction** (use when agent is unavailable or for very short notes)
 
 **Decisions Made:**
 - What was decided?

package/template-v2/.claude/skills/memory-manager.md

@@ -68,11 +68,37 @@ User shares transcript/email/document
          ↓
     If user says "extract now":
          ↓
-    Extract and present for verification
+    Use agent-accelerated extraction (see below)
          ↓
-    Store verified memories/entities
+    Review agent output, then store verified memories/entities
 ```
 
+**Agent-Accelerated Extraction (Preferred for transcripts and emails)**
+
+For transcripts, emails, and longer documents, use the Document Processor agent (Haiku) instead of composing `memory.batch` operations manually. Manual composition takes 2+ minutes of thinking time; the agent returns structured operations in ~10-20 seconds.
+
+```
+Dispatch Document Processor (Haiku) with:
+├── The filed document content
+├── extraction_type: "memory_operations"
+└── Context: participant names, topic, date
+         ↓
+Agent returns memory_operations[] array
+(facts, commitments, entities, relationships)
+         ↓
+Review agent output (Claudia's judgment layer):
+├── Verify commitment wording is accurate
+├── Check importance scores
+├── Confirm entity names match existing entities
+└── Remove or adjust questionable extractions
+         ↓
+Call memory.batch with reviewed operations
+```
+
+**When to use agent extraction:** Transcripts (3+ paragraphs), emails with multiple topics, documents with commitments or relationship context.
+
+**When to extract manually:** Very short notes (1-2 sentences), single-fact corrections, quick entity creation.
+
 **If you find yourself reading multiple source documents** without calling `memory.file` for each one, **STOP and fix it**. Go back and file each source before continuing.
 
 **If you find yourself auto-extracting without asking**, **STOP**. File first, then ask if the user wants extraction now or later. This keeps you responsive during long documents.