@ngocsangairvds/vsaf 3.2.16 → 4.0.0

package/tools/vds-scripts/memory_orchestrator/tests/service/test_ai_memory_service.py

@@ -1,1661 +0,0 @@
-"""Test suite for VDS Unified Service core functionality."""
-
-import json
-from datetime import UTC, datetime, timedelta
-from types import SimpleNamespace
-from unittest.mock import AsyncMock, patch
-
-import pytest
-
-from vds_memory_orchestrator.service.core.ai_memory_exceptions import (
-    NotFoundError,
-    ServiceUnavailableError,
-    SessionError,
-    ValidationError,
-)
-from vds_memory_orchestrator.service.models.ai_memory_models import (
-    AnalyticsRequest,
-    BusinessDomain,
-    ImportanceLevel,
-    Memory,
-    MemoryBatchDeleteRequest,
-    MemoryBatchUpdateRequest,
-    MemoryCategory,
-    MemoryCreateRequest,
-    MemorySearchRequest,
-    MemoryStatus,
-    MemoryUpdateRequest,
-    Operation,
-    OperationType,
-    Session,
-    SessionBackupRequest,
-    SessionConsolidationRequest,
-    SessionContextRequest,
-    SessionCreateRequest,
-    SessionRestoreRequest,
-    SessionShareAccessLevel,
-    SessionShareRequest,
-    SessionStatus,
-    ToolType,
-)
-from vds_memory_orchestrator.service.services.ai_memory_service import VDSAIMemoryService
-from vds_memory_orchestrator.service.services.storage_strategy import StorageTier
-
-
-class TestVDSAIMemoryService:
-    """Test VDS AI Memory service core functionality"""
-
-    @pytest.mark.asyncio
-    async def test_service_initialization(self, service):
-        """Test service initialization"""
-        assert service._redis_service is not None
-        assert service._mem0_client is not None
-        assert service._background_tasks is not None
-
-    @pytest.mark.asyncio
-    async def test_health_check(self, service, mock_redis_manager):
-        """Test health check functionality"""
-        # Mock Redis health check
-        mock_redis_manager.health_check.return_value = {
-            "status": "healthy",
-            "databases": {
-                "memory_cache": {"status": "connected"},
-                "session_store": {"status": "connected"},
-                "analytics": {"status": "connected"},
-            },
-        }
-
-        health = await service.health_check()
-
-        assert health["status"]["overall"] == "healthy"
-        assert "services" in health
-        assert "checks" in health
-        assert health["services"]["redis"]["status"] == "connected"
-        assert health["services"]["mem0"]["status"] == "connected"
-
-    @pytest.mark.asyncio
-    async def test_create_session(self, service, sample_session_data):
-        """Test session creation"""
-        request = SessionCreateRequest(**sample_session_data)
-
-        with patch.object(service._redis_service, "store_session", return_value=True) as mock_store:
-            response = await service.create_session(request)
-
-            assert response.session_id is not None
-            assert response.user_id == sample_session_data["user_id"]
-            assert response.project_domain == BusinessDomain[sample_session_data["project_domain"]]
-            assert response.status == SessionStatus.ACTIVE
-            assert response.created_at is not None
-
-            mock_store.assert_called_once()
-
-    @pytest.mark.asyncio
-    async def test_create_session_with_validation_error(self, service):
-        """Test session creation with invalid data"""
-        invalid_request = SessionCreateRequest(
-            user_id="",  # Invalid empty user_id
-            project_domain=BusinessDomain.LEP,
-            metadata={},
-        )
-
-        with pytest.raises(ValidationError):
-            await service.create_session(invalid_request)
-
-    @pytest.mark.asyncio
-    async def test_get_session_existing(self, service, sample_session_data):
-        """Test getting existing session"""
-        session_data = {
-            "session_id": "test-session-123",
-            "user_id": sample_session_data["user_id"],
-            "project_domain": sample_session_data["project_domain"],
-            "status": "active",
-            "created_at": datetime.now(UTC).isoformat(),
-            "total_memories": 5,
-            "total_operations": 10,
-            "metadata": sample_session_data["metadata"],
-        }
-
-        with patch.object(service._redis_service, "get_session", return_value=session_data):
-            session = await service.get_session("test-session-123")
-
-            assert session.session_id == "test-session-123"
-            assert session.user_id == sample_session_data["user_id"]
-            assert session.project_domain == BusinessDomain[sample_session_data["project_domain"]]
-            assert session.total_memories == 5
-            assert session.total_operations == 10
-
-    @pytest.mark.asyncio
-    async def test_get_nonexistent_session(self, service):
-        """Test getting non-existent session"""
-        with patch.object(service._redis_service, "get_session", return_value=None):
-            session = await service.get_session("nonexistent-session")
-            assert session is None
-
-    @pytest.mark.asyncio
-    async def test_update_session(self, service, sample_session_data):
-        """Test session update"""
-        update_request = {
-            "session_id": "test-session-123",
-            "metadata": {"updated_field": "updated_value"},
-            "status": "active",
-        }
-
-        existing_session = {
-            "session_id": "test-session-123",
-            "user_id": sample_session_data["user_id"],
-            "project_domain": sample_session_data["project_domain"],
-            "status": "active",
-            "created_at": datetime.now(UTC).isoformat(),
-            "metadata": sample_session_data["metadata"],
-        }
-
-        with (
-            patch.object(service._redis_service, "get_session", return_value=existing_session),
-            patch.object(
-                service._redis_service, "update_session", return_value=True
-            ) as mock_update,
-        ):
-            success = await service.update_session(update_request)
-
-            assert success is True
-            mock_update.assert_called_once()
-
-    @pytest.mark.asyncio
-    async def test_update_nonexistent_session(self, service):
-        """Test updating non-existent session"""
-        update_request = {
-            "session_id": "nonexistent-session",
-            "metadata": {"test": "value"},
-            "status": "active",
-        }
-
-        with patch.object(service._redis_service, "get_session", return_value=None):
-            success = await service.update_session(update_request)
-            assert success is False
-
-    @pytest.mark.asyncio
-    async def test_delete_session(self, service):
-        """Test session deletion"""
-        with (
-            patch.object(
-                service._redis_service, "delete_session", return_value=True
-            ) as mock_delete,
-            patch.object(
-                service._redis_service, "cross_invalidate", return_value=True
-            ) as mock_invalidate,
-        ):
-            success = await service.delete_session("test-session-123")
-
-            assert success is True
-            mock_delete.assert_called_once_with("test-session-123")
-            mock_invalidate.assert_called_once_with("test-session-123")
-
-    @pytest.mark.asyncio
-    async def test_get_user_sessions(self, service):
-        """Test getting user sessions"""
-        session_ids = ["session-1", "session-2", "session-3"]
-
-        with patch.object(service._redis_service, "get_user_sessions", return_value=session_ids):
-            sessions = await service.get_user_sessions("test-user-123")
-
-            assert len(sessions) == 3
-            assert sessions == session_ids
-
-    @pytest.mark.asyncio
-    async def test_session_behavior_metrics_summary(self, service):
-        """Detailed behavior metrics include operation histograms and timeline."""
-        now = datetime.now(UTC)
-        session_model = Session(
-            session_id="session-behavior",
-            user_id="user-42",
-            project_domain=BusinessDomain.PLATFORM,
-            working_directory="/workspace/platform",
-            created_at=now - timedelta(hours=2),
-            last_accessed=now,
-            expires_at=now + timedelta(hours=1),
-        )
-
-        event_success = {
-            "type": OperationType.CREATE.value,
-            "tool_used": ToolType.WRITE.value,
-            "status": "success",
-            "duration_ms": 120,
-            "metadata": {"path": "README.md"},
-        }
-        event_error = {
-            "type": OperationType.UPDATE.value,
-            "tool_used": ToolType.EDIT.value,
-            "status": "error",
-            "duration_ms": 80,
-            "metadata": {"path": "app/main.py"},
-        }
-
-        events = [
-            (json.dumps(event_success), (now - timedelta(minutes=30)).timestamp() * 1000),
-            (json.dumps(event_error), (now - timedelta(minutes=5)).timestamp() * 1000),
-        ]
-
-        service.get_session = AsyncMock(return_value=session_model)
-        service._fetch_operation_events = AsyncMock(return_value=events)
-
-        metrics = await service.get_session_behavior_metrics("session-behavior")
-
-        assert metrics.total_operations == 2
-        assert metrics.operations_by_type[OperationType.CREATE.value] == 1
-        assert metrics.tool_usage[ToolType.WRITE.value] == 1
-        assert metrics.error_count == 1
-        assert metrics.recent_activity[-1].status == "error"
-
-    @pytest.mark.asyncio
-    async def test_session_behavior_metrics_missing_session(self, service):
-        """Missing sessions raise NotFoundError."""
-        service.get_session = AsyncMock(return_value=None)
-
-        with pytest.raises(NotFoundError):
-            await service.get_session_behavior_metrics("unknown-session")
-
-    @pytest.mark.asyncio
-    async def test_backup_session_basic(self, service, sample_session_data):
-        """Backup snapshots capture metadata and store payload in Redis."""
-        session_obj = Session(
-            session_id="session-42",
-            user_id=sample_session_data["user_id"],
-            project_domain=BusinessDomain.INSURANCE,
-            working_directory="/workspace/insurance",
-            created_at=datetime.now(UTC) - timedelta(hours=1),
-            last_accessed=datetime.now(UTC),
-            expires_at=datetime.now(UTC) + timedelta(hours=1),
-        )
-        service.get_session = AsyncMock(return_value=session_obj)
-        service._get_session_memories = AsyncMock(return_value=[])
-        service._fetch_operation_events = AsyncMock(return_value=[])
-
-        response = await service.backup_session(
-            SessionBackupRequest(session_id="session-42", notes="smoke test")
-        )
-
-        assert response.session_id == "session-42"
-        assert response.backup_id.startswith("session-backup-")
-
-    @pytest.mark.asyncio
-    async def test_restore_session_from_backup_create_mode(self, service):
-        """Restoring from backup creates a new session when requested."""
-        backup_payload = {
-            "backup_id": "session-backup-123",
-            "session_id": "session-1",
-            "created_at": datetime.now(UTC).isoformat(),
-            "expires_at": (datetime.now(UTC) + timedelta(days=3)).isoformat(),
-            "notes": None,
-            "include_memories": False,
-            "include_operations": False,
-            "session_data": Session(
-                session_id="session-1",
-                user_id="user-1",
-                project_domain=BusinessDomain.PLATFORM,
-                working_directory="/workspace/platform",
-                created_at=datetime.now(UTC) - timedelta(hours=4),
-                last_accessed=datetime.now(UTC),
-                expires_at=datetime.now(UTC) + timedelta(hours=1),
-            ).model_dump(),
-            "memories": [],
-            "operations": [],
-        }
-
-        service._load_session_backup = AsyncMock(return_value=backup_payload)
-        service._redis_service.store_session = AsyncMock(return_value=True)
-        service._redis_service.set_json = AsyncMock()
-        service._redis_service.set_list = AsyncMock()
-
-        response = await service.restore_session_from_backup(
-            SessionRestoreRequest(backup_id="session-backup-123", restore_mode="create")
-        )
-
-        assert response.success is True
-        assert response.backup_id == "session-backup-123"
-        service._redis_service.store_session.assert_awaited_once()
-
-    def test_apply_session_enrichment_derives_tags(self, service):
-        now = datetime.now(UTC)
-        session = Session(
-            session_id="session-ctx",
-            user_id="user-ctx",
-            project_domain=BusinessDomain.LENDING,
-            working_directory="/workspace/lep/payments",
-            git_branch="feature/risk",
-            git_repository="https://git.vds.vn/lep/payments.git",
-            created_at=now - timedelta(minutes=5),
-            last_accessed=now,
-            expires_at=now + timedelta(hours=1),
-        )
-        memories = [
-            Memory(
-                memory_id="mem-1",
-                content="Investigate loan underwriting bug",
-                category=MemoryCategory.BUSINESS_LOGIC,
-                importance=ImportanceLevel.HIGH,
-                session_id="session-ctx",
-                user_id="user-ctx",
-                status=MemoryStatus.ACTIVE,
-            )
-        ]
-        operations = [
-            Operation(
-                operation_id="op-1",
-                session_id="session-ctx",
-                user_id="user-ctx",
-                operation_type=OperationType.UPDATE,
-                tool_used=ToolType.WRITE,
-                operation_parameters={"task": "Address underwriting bug"},
-            )
-        ]
-
-        enriched = service._apply_session_enrichment(session, memories, operations)
-
-        assert any(tag.startswith("category:") for tag in enriched.context_tags)
-        assert enriched.key_tasks
-
-    @pytest.mark.asyncio
-    async def test_get_session_context_persists_enrichment(self, service, mock_redis_service):
-        now = datetime.now(UTC)
-        session = Session(
-            session_id="session-ctx",
-            user_id="user-ctx",
-            project_domain=BusinessDomain.PLATFORM,
-            working_directory="/workspace/platform",
-            created_at=now - timedelta(minutes=10),
-            last_accessed=now,
-            expires_at=now + timedelta(hours=1),
-        )
-        service.get_session = AsyncMock(return_value=session)
-        memory = Memory(
-            memory_id="mem-1",
-            content="Platform release planning",
-            category=MemoryCategory.BUSINESS_LOGIC,
-            importance=ImportanceLevel.MEDIUM,
-            session_id="session-ctx",
-            user_id="user-ctx",
-            status=MemoryStatus.ACTIVE,
-        )
-        service._get_session_memories = AsyncMock(return_value=[memory])
-        operation = Operation(
-            operation_id="op-1",
-            session_id="session-ctx",
-            user_id="user-ctx",
-            operation_type=OperationType.CREATE,
-            tool_used=ToolType.WRITE,
-            operation_parameters={},
-        )
-        service._get_session_operations = AsyncMock(return_value=[operation])
-        service._redis_service.update_session = AsyncMock(return_value=True)
-
-        request = SessionContextRequest(session_id="session-ctx")
-        response = await service.get_session_context(request)
-
-        assert response.session_data.context_tags
-        service._redis_service.update_session.assert_awaited()
-
-    @pytest.mark.asyncio
-    async def test_share_session_stores_payload(self, service, mock_redis):
-        session_model = Session(
-            session_id="session-share",
-            user_id="owner",
-            project_domain=BusinessDomain.PLATFORM,
-            working_directory="/workspace",
-            created_at=datetime.now(UTC) - timedelta(minutes=30),
-            last_accessed=datetime.now(UTC),
-            expires_at=datetime.now(UTC) + timedelta(hours=1),
-        )
-        service.get_session = AsyncMock(return_value=session_model)
-
-        request = SessionShareRequest(
-            session_id="session-share",
-            target_user_id="user-b",
-            target_team_id=None,
-            access_level=SessionShareAccessLevel.CONTRIBUTE,
-            granted_by="owner",
-        )
-
-        response = await service.share_session("session-share", request)
-
-        assert response.target_user_id == "user-b"
-        assert mock_redis.setex.await_count >= 1
-        mock_redis.zadd.assert_awaited()
-
-    @pytest.mark.asyncio
-    async def test_list_session_shares_uses_payloads(self, service, mock_redis):
-        mock_redis.zrevrange.return_value = [(b"session-share-1", 1.0)]
-        payload = {
-            "share_id": "session-share-1",
-            "session_id": "session-1",
-            "target_user_id": "user-b",
-            "target_team_id": None,
-            "access_level": SessionShareAccessLevel.VIEW.value,
-            "granted_by": "owner",
-            "granted_at": datetime.now(UTC).isoformat(),
-            "expires_at": None,
-            "notes": None,
-        }
-        service._load_session_share_payload = AsyncMock(return_value=payload)
-
-        shares = await service.list_session_shares("session-1")
-
-        assert shares[0].share_id == "session-share-1"
-
-    @pytest.mark.asyncio
-    async def test_list_shared_sessions_combines_sources(self, service, mock_redis):
-        session_obj = Session(
-            session_id="session-1",
-            user_id="owner",
-            project_domain=BusinessDomain.PLATFORM,
-            working_directory="/workspace",
-            created_at=datetime.now(UTC),
-            last_accessed=datetime.now(UTC),
-            expires_at=datetime.now(UTC) + timedelta(hours=1),
-            session_summary="Hotfix context",
-        )
-        service.get_session = AsyncMock(return_value=session_obj)
-        mock_redis.zrevrange.side_effect = [
-            [(b"session-share-1", 1.0)],
-            [],
-        ]
-        payload = {
-            "share_id": "session-share-1",
-            "session_id": "session-1",
-            "target_user_id": "user-b",
-            "target_team_id": None,
-            "access_level": SessionShareAccessLevel.VIEW.value,
-            "granted_by": "owner",
-            "granted_at": datetime.now(UTC).isoformat(),
-            "expires_at": None,
-            "notes": None,
-        }
-        service._load_session_share_payload = AsyncMock(return_value=payload)
-
-        entries = await service.list_shared_sessions("user-b", [])
-
-        assert entries[0].session_summary == "Hotfix context"
-
-    @pytest.mark.asyncio
-    async def test_session_performance_metrics(self, service):
-        now = datetime.now(UTC)
-        event_ok = json.dumps(
-            {
-                "type": OperationType.CREATE.value,
-                "status": "success",
-                "duration_ms": 120,
-                "metadata": {},
-            }
-        )
-        event_fail = json.dumps(
-            {
-                "type": OperationType.UPDATE.value,
-                "status": "error",
-                "duration_ms": 240,
-                "metadata": {},
-            }
-        )
-        service._fetch_operation_events = AsyncMock(
-            return_value=[
-                (event_ok, (now.timestamp() * 1000)),
-                (event_fail, (now.timestamp() * 1000)),
-            ]
-        )
-
-        metrics = await service.get_session_performance_metrics("session-1")
-
-        assert metrics.total_operations == 2
-        assert metrics.failure_count == 1
-
-    @pytest.mark.asyncio
-    async def test_create_memory(self, service, sample_memory_data):
-        """Test memory creation"""
-        request = MemoryCreateRequest(**sample_memory_data)
-
-        with (
-            patch.object(
-                service._mem0_client,
-                "add",
-                return_value={
-                    "id": "test-memory-123",
-                    "memory": sample_memory_data["content"],
-                    "metadata": {
-                        "session_id": sample_memory_data["session_id"],
-                        "user_id": sample_memory_data["user_id"],
-                    },
-                },
-            ) as mock_add,
-            patch.object(
-                service._redis_service, "cross_invalidate", return_value=True
-            ) as mock_invalidate,
-        ):
-            memory_id = await service.create_memory(request)
-
-            assert memory_id.startswith("pg_")
-            mock_add.assert_called_once()
-            mock_invalidate.assert_called_once_with(sample_memory_data["session_id"])
-
-    @pytest.mark.asyncio
-    async def test_create_memory_creates_index_for_long_content(self, service, sample_memory_data):
-        """Long content should trigger index memory creation."""
-        long_content = "A" * 1300
-        data = {**sample_memory_data, "content": long_content}
-        request = MemoryCreateRequest(**data)
-
-        with (
-            patch.object(service._mem0_client, "add", return_value={"id": "mem0-id"}),
-            patch.object(service._redis_service, "cross_invalidate", return_value=True),
-            patch.object(service._crud_service, "_create_index_memory", AsyncMock()) as mock_index,
-        ):
-            memory_id = await service.create_memory(request)
-
-        assert memory_id.startswith("pg_")
-        mock_index.assert_called_once()
-
-    @pytest.mark.asyncio
-    async def test_create_memory_with_error(self, service, sample_memory_data):
-        """Test memory creation with API error"""
-        request = MemoryCreateRequest(**sample_memory_data)
-
-        with (
-            patch.object(service._mem0_client, "add", side_effect=Exception("API Error")),
-            patch.object(service._crud_service, "_enqueue_mem0_push", AsyncMock()) as mock_enqueue,
-        ):
-            memory_id = await service.create_memory(request)
-
-            assert memory_id.startswith("pg_")
-            mock_enqueue.assert_called_once()
-
-    @pytest.mark.asyncio
-    async def test_search_memories(self, service):
-        """Test memory search"""
-        search_request = MemorySearchRequest(
-            query="test query", user_id="test-user-123", limit=10, threshold=0.8
-        )
-
-        mock_search_results = {
-            "results": [
-                {
-                    "id": "memory-1",
-                    "memory": "Test memory content",
-                    "metadata": {
-                        "user_id": "test-user-123",
-                        "session_id": "session-1",
-                        "storage_tier": "mem0_pro",
-                        "tags": ["decision"],
-                        "keywords": ["mem0", "approval"],
-                    },
-                    "score": 0.95,
-                    "created_at": "2025-11-09T05:02:00Z",
-                    "updated_at": "2025-11-09T05:03:00Z",
-                }
-            ],
-            "total": 1,
-        }
-
-        with patch.object(
-            service._mem0_client, "search", return_value=mock_search_results
-        ) as mock_search:
-            response = await service.search_memories(search_request)
-
-            assert len(response.results) == 1
-            assert response.results[0].memory_id == "memory-1"
-            assert response.results[0].metadata["session_id"] == "session-1"
-            assert response.results[0].storage_tier == StorageTier.MEM0_PRO
-            assert response.results[0].tags == ["decision"]
-            assert response.total_count == 1
-            assert response.query == "test query"
-
-            mock_search.assert_called_once()
-
-    @pytest.mark.asyncio
-    async def test_search_memories_rerank_overfetch_filters(self, service):
-        """Overfetch + rerank + typed filters are sent to Mem0."""
-        search_request = MemorySearchRequest(
-            query="policy renewal",
-            user_id="alice",
-            session_id="sess-1",
-            team_id="team-7",
-            category=MemoryCategory.GENERAL,
-            importance=ImportanceLevel.HIGH,
-            project_domain=BusinessDomain.INSURANCE,
-            tags=["renewal", "policy"],
-            limit=10,
-            enable_overfetch=True,
-            enable_reranking=True,
-        )
-
-        async def fake_mem0_call(method_name: str, **kwargs):
-            assert method_name == "search"
-            # Overfetch should multiply limit (default multiplier 5)
-            assert kwargs["limit"] >= 50
-            filters = kwargs.get("filters") or {}
-            and_filters = filters.get("AND")
-            if and_filters is not None:
-                assert any(f.get("user_id") == "alice" for f in and_filters)
-                assert any(f.get("metadata", {}).get("category") == "general" for f in and_filters)
-                assert any(f.get("metadata", {}).get("importance") == "high" for f in and_filters)
-                assert any(
-                    f.get("metadata", {}).get("project_domain") == "INSURANCE" for f in and_filters
-                )
-                assert any(f.get("metadata", {}).get("session_id") == "sess-1" for f in and_filters)
-                assert any(
-                    f.get("keywords", {}).get("in") == ["renewal", "policy"] for f in and_filters
-                )
-            else:
-                # Relaxed search may retry with user-only scope
-                assert filters.get("user_id") == "alice"
-            return {"results": []}
-
-        service._mem0_call = fake_mem0_call  # type: ignore
-
-        response = await service.search_memories(search_request)
-        assert response.total_count == 0
-        assert response.search_mode in ("mem0", "mem0-circuit-open", "mem0-error")
-
-    @pytest.mark.asyncio
-    async def test_search_memories_memory_ids_filter(self, service):
-        """Explicit memory_ids should be forwarded to Mem0 filters."""
-        memory_ids = [
-            "11111111-1111-1111-1111-111111111111",
-            "22222222-2222-2222-2222-222222222222",
-        ]
-        search_request = MemorySearchRequest(
-            query="index memory",
-            user_id="alice",
-            memory_ids=memory_ids,
-            limit=5,
-        )
-
-        async def fake_mem0_call(method_name: str, **kwargs):
-            assert method_name == "search"
-            filters = kwargs["filters"]["AND"]
-            assert any(f.get("memory_ids") == memory_ids for f in filters)
-            return {"results": []}
-
-        service._mem0_call = fake_mem0_call  # type: ignore
-
-        response = await service.search_memories(search_request)
-        assert response.total_count == 0
-
-    @pytest.mark.asyncio
-    async def test_search_memories_infers_user_from_session(self, service):
-        """Session-scope searches should derive user_id for Mem0 filters."""
-        search_request = MemorySearchRequest(
-            query="mem0 knowledge graph",
-            session_id="session-abc",
-            limit=5,
-        )
-
-        mock_session = SimpleNamespace(user_id="agent-cli")
-        with patch.object(service, "get_session", AsyncMock(return_value=mock_session)):
-            with patch.object(
-                service._mem0_client, "search", return_value={"results": []}
-            ) as mock_search:
-                response = await service.search_memories(search_request)
-
-        assert response.total_count == 0
-        # Validate at least one call carried the AND filters
-        and_filters = None
-        for call in mock_search.call_args_list:
-            filters = (call.kwargs or {}).get("filters") or {}
-            if "AND" in filters:
-                and_filters = filters["AND"]
-                break
-        assert and_filters is not None
-        assert any(f.get("user_id") == "agent-cli" for f in and_filters)
-        assert any(f.get("metadata", {}).get("session_id") == "session-abc" for f in and_filters)
-        assert mock_search.call_args_list[0].kwargs["query"] == "mem0 knowledge graph"
-
-    # Sprint 3.1: Temporal Filter Tests
-    @pytest.mark.asyncio
-    async def test_search_memories_temporal_filters_time_range_day(self, service):
-        """Test temporal search with time_range='day' preset."""
-        now = datetime.now(UTC)
-        yesterday = now - timedelta(days=2)
-        tomorrow = now + timedelta(days=1)
-
-        search_request = MemorySearchRequest(
-            query="deployment", user_id="test-user-123", time_range="day", limit=10
-        )
-
-        mock_results = {
-            "results": [
-                {
-                    "id": "old-memory",
-                    "memory": "Old deployment from yesterday",
-                    "metadata": {"user_id": "test-user-123"},
-                    "score": 0.9,
-                    "created_at": yesterday.isoformat(),
-                    "updated_at": yesterday.isoformat(),
-                },
-                {
-                    "id": "new-memory",
-                    "memory": "Recent deployment",
-                    "metadata": {"user_id": "test-user-123"},
-                    "score": 0.95,
-                    "created_at": now.isoformat(),
-                    "updated_at": now.isoformat(),
-                },
-                {
-                    "id": "future-memory",
-                    "memory": "Future deployment",
-                    "metadata": {"user_id": "test-user-123"},
-                    "score": 0.85,
-                    "created_at": tomorrow.isoformat(),
-                    "updated_at": tomorrow.isoformat(),
-                },
-            ]
-        }
-
-        with patch.object(service._mem0_client, "search", return_value=mock_results):
-            response = await service.search_memories(search_request)
-
-            # Should only return memories within last 24 hours
-            assert response.total_count == 1
-            assert response.results[0].memory_id == "new-memory"
-
-    @pytest.mark.asyncio
-    async def test_search_memories_temporal_filters_created_after(self, service):
-        """Test temporal search with created_after filter."""
-        now = datetime.now(UTC)
-        two_days_ago = now - timedelta(days=2)
-        one_day_ago = now - timedelta(days=1)
-        five_hours_ago = now - timedelta(hours=5)
-
-        search_request = MemorySearchRequest(
-            query="architecture", user_id="test-user-123", created_after=one_day_ago, limit=10
-        )
-
-        mock_results = {
-            "results": [
-                {
-                    "id": "mem-1",
-                    "memory": "Architecture from 2 days ago",
-                    "metadata": {"user_id": "test-user-123"},
-                    "score": 0.9,
-                    "created_at": two_days_ago.isoformat(),
-                    "updated_at": now.isoformat(),
-                },
-                {
-                    "id": "mem-2",
-                    "memory": "Recent architecture",
-                    "metadata": {"user_id": "test-user-123"},
-                    "score": 0.95,
-                    "created_at": five_hours_ago.isoformat(),
-                    "updated_at": now.isoformat(),
-                },
-            ]
-        }
-
-        with patch.object(service._mem0_client, "search", return_value=mock_results):
-            response = await service.search_memories(search_request)
-
-            # Should only return memories created after 1 day ago
-            assert response.total_count == 1
-            assert response.results[0].memory_id == "mem-2"
-
-    @pytest.mark.asyncio
-    async def test_search_memories_temporal_filters_created_before(self, service):
-        """Test temporal search with created_before filter."""
-        now = datetime.now(UTC)
-        two_days_ago = now - timedelta(days=2)
-        one_day_ago = now - timedelta(days=1)
-
-        search_request = MemorySearchRequest(
-            query="policies", user_id="test-user-123", created_before=one_day_ago, limit=10
-        )
-
-        mock_results = {
-            "results": [
-                {
-                    "id": "mem-1",
-                    "memory": "Old policy",
-                    "metadata": {"user_id": "test-user-123"},
-                    "score": 0.9,
-                    "created_at": two_days_ago.isoformat(),
-                    "updated_at": now.isoformat(),
-                },
-                {
-                    "id": "mem-2",
-                    "memory": "Recent policy",
-                    "metadata": {"user_id": "test-user-123"},
-                    "score": 0.95,
-                    "created_at": now.isoformat(),
-                    "updated_at": now.isoformat(),
-                },
-            ]
-        }
-
-        with patch.object(service._mem0_client, "search", return_value=mock_results):
-            response = await service.search_memories(search_request)
-
-            # Should only return memories created before 1 day ago
-            assert response.total_count == 1
-            assert response.results[0].memory_id == "mem-1"
-
-    @pytest.mark.asyncio
-    async def test_search_memories_temporal_filters_combined_range(self, service):
-        """Test temporal search with combined created_after and created_before."""
-        now = datetime.now(UTC)
-        three_days_ago = now - timedelta(days=3)
-        two_days_ago = now - timedelta(days=2)
-        one_day_ago = now - timedelta(days=1)
-
-        search_request = MemorySearchRequest(
-            query="releases",
-            user_id="test-user-123",
-            created_after=three_days_ago,
-            created_before=one_day_ago,
-            limit=10,
-        )
-
-        mock_results = {
-            "results": [
-                {
-                    "id": "mem-1",
-                    "memory": "Release from 3 days ago",
-                    "metadata": {"user_id": "test-user-123"},
-                    "score": 0.9,
-                    "created_at": three_days_ago.isoformat(),
-                    "updated_at": now.isoformat(),
-                },
-                {
-                    "id": "mem-2",
-                    "memory": "Release from 2 days ago",
-                    "metadata": {"user_id": "test-user-123"},
-                    "score": 0.95,
-                    "created_at": two_days_ago.isoformat(),
-                    "updated_at": now.isoformat(),
-                },
-                {
-                    "id": "mem-3",
-                    "memory": "Recent release",
-                    "metadata": {"user_id": "test-user-123"},
-                    "score": 0.85,
-                    "created_at": now.isoformat(),
-                    "updated_at": now.isoformat(),
-                },
-            ]
-        }
-
-        with patch.object(service._mem0_client, "search", return_value=mock_results):
-            response = await service.search_memories(search_request)
-
-            # Should return memories between 3 and 1 days ago
-            assert response.total_count == 2
-            memory_ids = {r.memory_id for r in response.results}
-            assert "mem-1" in memory_ids
-            assert "mem-2" in memory_ids
-            assert "mem-3" not in memory_ids
-
-    @pytest.mark.asyncio
-    async def test_search_memories_temporal_filters_updated_after(self, service):
-        """Test temporal search with updated_after filter."""
-        now = datetime.now(UTC)
-        two_days_ago = now - timedelta(days=2)
-        one_day_ago = now - timedelta(days=1)
-        five_hours_ago = now - timedelta(hours=5)
-
-        search_request = MemorySearchRequest(
-            query="configuration", user_id="test-user-123", updated_after=one_day_ago, limit=10
-        )
-
-        mock_results = {
-            "results": [
-                {
-                    "id": "mem-1",
-                    "memory": "Old config, recently updated",
-                    "metadata": {"user_id": "test-user-123"},
-                    "score": 0.9,
-                    "created_at": two_days_ago.isoformat(),
-                    "updated_at": five_hours_ago.isoformat(),
-                },
-                {
-                    "id": "mem-2",
-                    "memory": "Old config, not recently updated",
-                    "metadata": {"user_id": "test-user-123"},
-                    "score": 0.8,
-                    "created_at": two_days_ago.isoformat(),
-                    "updated_at": two_days_ago.isoformat(),
-                },
-            ]
-        }
-
-        with patch.object(service._mem0_client, "search", return_value=mock_results):
-            response = await service.search_memories(search_request)
-
-            # Should only return memories updated after 1 day ago
-            assert response.total_count == 1
-            assert response.results[0].memory_id == "mem-1"
-
-    @pytest.mark.asyncio
-    async def test_get_session_memories_caches_relations(self, service):
-        """Graph results should cache relations/embedding with payloads."""
-        # After MemorySearchService extraction, _get_session_memories is delegated to
-        # the search service which uses its own _mem0_call wrapper. Mock at that level.
-        service._search_service._mem0_call = AsyncMock(
-            return_value={
-                "results": [
-                    {
-                        "id": "mem-1",
-                        "memory": "Session note",
-                        "metadata": {"category": "general", "importance": "medium"},
-                        "relations": [{"to": "mem-2", "type": "follows"}],
-                        "embedding": [0.1, 0.2],
-                    }
-                ]
-            }
-        )
-        service._redis_service.get_json.return_value = None
-        service._redis_service.get_list.return_value = []
-
-        memories = await service._get_session_memories("session-123", limit=5)
-
-        assert len(memories) == 1
-        # Ensure relations/embedding were written to cache payload
-        set_json_calls = service._redis_service.set_json.call_args_list
-        assert any("relations" in call.kwargs["value"] for call in set_json_calls)
-        assert any("embedding" in call.kwargs["value"] for call in set_json_calls)
-
-    @pytest.mark.asyncio
-    async def test_get_session_context(self, service):
-        """Test getting session context"""
-        context_request = SessionContextRequest(
-            session_id="test-session-123",
-            include_memories=True,
-            include_operations=True,
-            include_analytics=True,
-            memory_limit=20,
-            operation_limit=50,
-        )
-
-        mock_session = Session(
-            session_id="test-session-123",
-            user_id="test-user-123",
-            project_domain=BusinessDomain.LEP,
-            status=SessionStatus.ACTIVE,
-            total_memories=5,
-            total_operations=10,
-            created_at=datetime.now(UTC),
-        )
-
-        mock_memories = [
-            Memory(
-                id="memory-1",
-                content="Test memory",
-                user_id="test-user-123",
-                session_id="test-session-123",
-                score=0.95,
-                created_at=datetime.now(UTC),
-            )
-        ]
-
-        with (
-            patch.object(service, "get_session", return_value=mock_session),
-            patch.object(service, "_get_session_memories", return_value=mock_memories),
-            patch.object(service, "_get_session_operations", return_value=[]),
-            patch.object(service, "_get_session_analytics", return_value={}),
-        ):
-            context = await service.get_session_context(context_request)
-
-            assert context.session.session_id == "test-session-123"
-            assert len(context.memories) == 1
-            assert context.summary.total_memories == 5
-            assert context.summary.total_operations == 10
-
-    @pytest.mark.asyncio
-    async def test_consolidate_session(self, service):
-        """Test session consolidation"""
-        consolidation_request = SessionConsolidationRequest(
-            session_id="test-session-123",
-            user_id="test-user-123",
-            consolidation_type="summary",
-            include_insights=True,
-        )
-
-        with (
-            patch.object(service, "_generate_session_summary", return_value="Test summary"),
-            patch.object(
-                service, "_generate_session_insights", return_value=["insight-1", "insight-2"]
-            ),
-            patch.object(
-                service, "_calculate_consolidation_metrics", return_value={"consolidated_items": 5}
-            ),
-        ):
-            response = await service.consolidate_session(consolidation_request)
-
-            assert response.consolidation_id is not None
-            assert response.summary == "Test summary"
-            assert len(response.insights) == 2
-            assert response.metrics["consolidated_items"] == 5
-
-    @pytest.mark.asyncio
-    async def test_get_analytics(self, service):
-        """Test analytics retrieval"""
-        analytics_request = AnalyticsRequest(
-            user_id="test-user-123",
-            timeframe_hours=24,
-            include_sessions=True,
-            include_memories=True,
-            include_operations=True,
-            include_patterns=True,
-        )
-
-        with (
-            patch.object(
-                service._admin_service,
-                "_calculate_user_analytics",
-                return_value={
-                    "total_sessions": 10,
-                    "total_memories": 50,
-                    "avg_session_duration": 1800,
-                },
-            ),
-            patch.object(
-                service._admin_service,
-                "_calculate_system_analytics",
-                return_value={"active_sessions": 25, "cache_hit_rate": 0.85},
-            ),
-            patch.object(
-                service._admin_service,
-                "_analyze_usage_patterns",
-                return_value={
-                    "peak_hours": [9, 10, 14, 15],
-                    "frequent_operations": ["memory_search", "session_create"],
-                },
-            ),
-        ):
-            analytics = await service.get_analytics(analytics_request)
-
-            assert analytics.user_analytics["total_sessions"] == 10
-            assert analytics.user_analytics["total_memories"] == 50
-            assert analytics.system_analytics["active_sessions"] == 25
-            assert analytics.patterns["peak_hours"] == [9, 10, 14, 15]
-
-    @pytest.mark.asyncio
-    async def test_cleanup_expired_sessions(self, service):
-        """Test cleanup of expired sessions"""
-        with patch.object(
-            service._redis_service, "cleanup_expired_sessions", return_value=3
-        ) as mock_cleanup:
-            cleaned_count = await service.cleanup_expired_sessions()
-
-            assert cleaned_count == 3
-            mock_cleanup.assert_called_once()
-
-    @pytest.mark.asyncio
-    async def test_background_task_management(self, service):
-        """Test background task management"""
-        # Start background tasks
-        service.start_background_tasks()
-        assert len(service._background_tasks) > 0
-
-        # Stop background tasks
-        service.stop_background_tasks()
-        assert len(service._background_tasks) == 0
-
-    @pytest.mark.asyncio
-    async def test_analytics_caching(self, service):
-        """Test analytics caching functionality"""
-
-        # Test cache miss
-        with (
-            patch.object(service._redis_service, "get_analytics", return_value=None),
-            patch.object(
-                service._admin_service, "_calculate_user_analytics", return_value={"test": "data"}
-            ) as mock_calc,
-        ):
-            analytics = await service.get_analytics(
-                AnalyticsRequest(user_id="test-user-123", timeframe_hours=24)
-            )
-
-            mock_calc.assert_called_once()
-
-        # Test cache hit
-        cached_data = {"user_analytics": {"cached": True}, "system_analytics": {}, "patterns": {}}
-
-        with (
-            patch.object(service._redis_service, "get_analytics", return_value=cached_data),
-            patch.object(service._admin_service, "_calculate_user_analytics") as mock_calc,
-        ):
-            analytics = await service.get_analytics(
-                AnalyticsRequest(user_id="test-user-123", timeframe_hours=24)
-            )
-
-            mock_calc.assert_not_called()
-            assert analytics.user_analytics.get("cached") is True
-
-    @pytest.mark.asyncio
-    async def test_cache_invalidation_on_memory_create_and_session_delete(self, service):
-        """Creating a memory and deleting a session should purge scoped search cache."""
-        # Prime a fake cache entry
-        await service._redis_service.cache_memory_result(
-            "search:org=vds-internal:user=exec:session=session-xyz", {"results": []}
-        )
-
-        # Set up session info
-        session_data = Session(
-            session_id="session-xyz",
-            user_id="exec",
-            project_domain=BusinessDomain.PLATFORM,
-            created_at=datetime.now(UTC),
-            last_accessed=datetime.now(UTC),
-            expires_at=datetime.now(UTC) + timedelta(hours=1),
-            context_metadata={"org_id": "vds-internal"},
-        )
-        service.get_session = AsyncMock(return_value=session_data)
-
-        # Memory create should invalidate scoped cache
-        mem_request = MemoryCreateRequest(
-            content="Decision: ship feature",
-            category=MemoryCategory.BUSINESS_LOGIC,
-            importance=ImportanceLevel.CRITICAL,
-            session_id="session-xyz",
-            user_id="exec",
-            metadata={"org_id": "vds-internal"},
-        )
-        with patch.object(service._mem0_client, "add", return_value={"id": "mem0-test"}):
-            await service.create_memory(mem_request)
-
-        remaining = await service._redis_service.get_cached_memory_result(
-            "search:org=vds-internal:user=exec:session=session-xyz"
-        )
-        assert remaining is None
-
-        # Re-prime and delete session -> cache cleared
-        await service._redis_service.cache_memory_result(
-            "search:org=vds-internal:user=exec:session=session-xyz", {"results": []}
-        )
-        with patch.object(service._redis_service, "delete_session", return_value=True):
-            await service.delete_session("session-xyz")
-        remaining_after_delete = await service._redis_service.get_cached_memory_result(
-            "search:org=vds-internal:user=exec:session=session-xyz"
-        )
-        assert remaining_after_delete is None
-
-    @pytest.mark.asyncio
-    async def test_analytics_cache_key_determinism(self, service):
-        """Analytics cache keys should be deterministic across normalized inputs."""
-        req1 = AnalyticsRequest(
-            user_id="User-1",
-            timeframe_hours=24,
-            include_sessions=True,
-            include_memories=True,
-            include_operations=True,
-            include_patterns=True,
-        )
-        req2 = AnalyticsRequest(
-            user_id="user-1",
-            timeframe_hours=24,
-            include_sessions=True,
-            include_memories=True,
-            include_operations=True,
-            include_patterns=True,
-        )
-        key1 = service._build_analytics_cache_key(req1)
-        key2 = service._build_analytics_cache_key(req2)
-        assert key1 == key2
-
-        req3 = AnalyticsRequest(
-            user_id="user-1",
-            timeframe_hours=12,
-            include_sessions=True,
-            include_memories=False,
-            include_operations=True,
-            include_patterns=True,
-        )
-        key3 = service._build_analytics_cache_key(req3)
-        assert key1 != key3
-
-    @pytest.mark.asyncio
-    async def test_cache_key_determinism(self, service):
-        """Cache keys should be deterministic for logically identical inputs."""
-        # Arrange two requests differing only by whitespace/case ordering
-        key1 = service._redis_service.generate_cache_key(
-            "search",
-            query="  PgVector  ",
-            user_id="User-1",
-            session_id="SESSION-1",
-            category="Business-Logic",
-            importance="CRITICAL",
-            org_id="VDS-Internal",
-            limit=10,
-            offset=0,
-            facets=["a", "b"],
-        )
-
-        key2 = service._redis_service.generate_cache_key(
-            "search",
-            query="pgvector",
-            user_id="user-1",
-            session_id="session-1",
-            category="business_logic",
-            importance="critical",
-            org_id="vds-internal",
-            limit=10,
-            offset=0,
-            facets=["b", "a"],
-        )
-
-        assert key1 == key2
-
-        # And a differing importance should produce a different key
-        key3 = service._redis_service.generate_cache_key(
-            "search",
-            query="pgvector",
-            user_id="user-1",
-            session_id="session-1",
-            category="business_logic",
-            importance="high",
-            org_id="vds-internal",
-            limit=10,
-            offset=0,
-        )
-
-        assert key1 != key3
-
-
-class TestServiceErrorHandling:
-    """Test service error handling"""
-
-    @pytest.mark.asyncio
-    async def test_redis_connection_error(self, test_config, mock_mem0_client):
-        """Test handling of Redis connection errors"""
-        with (
-            patch(
-                "vds_memory_orchestrator.service.services.ai_memory_service.get_config",
-                return_value=test_config,
-            ),
-            patch("mem0.MemoryClient", return_value=mock_mem0_client),
-            patch(
-                "vds_memory_orchestrator.service.services.ai_memory_service.get_redis_service",
-                AsyncMock(side_effect=ConnectionError("Redis connection failed")),
-            ),
-        ):
-            service = VDSAIMemoryService()
-
-            with pytest.raises(ServiceUnavailableError):
-                await service.initialize()
-
-    @pytest.mark.asyncio
-    async def test_mem0_api_error(self, service, sample_memory_data):
-        """Test handling of Mem0AI API errors"""
-        request = MemoryCreateRequest(**sample_memory_data)
-
-        with (
-            patch.object(service._mem0_client, "add", side_effect=Exception("Mem0AI API Error")),
-            patch.object(service._crud_service, "_enqueue_mem0_push", AsyncMock()) as mock_enqueue,
-        ):
-            memory_id = await service.create_memory(request)
-
-            assert memory_id.startswith("pg_")
-            mock_enqueue.assert_called_once()
-
-    @pytest.mark.asyncio
-    async def test_session_operation_error(self, service, sample_session_data):
-        """Test handling of session operation errors"""
-        request = SessionCreateRequest(**sample_session_data)
-
-        with patch.object(
-            service._redis_service, "store_session", side_effect=Exception("Redis Error")
-        ), pytest.raises(SessionError):
-            await service.create_session(request)
-
-
-class TestDataTransformation:
-    """Test data transformation utilities"""
-
-    @pytest.mark.asyncio
-    async def test_session_to_memory_transformation(self, service):
-        """Test session to memory data transformation"""
-        from vds_memory_orchestrator.service.utils.data_transformer import DataModelTransformer
-
-        session_data = {
-            "session_id": "test-session-123",
-            "user_id": "test-user-456",
-            "project_domain": "LEP",
-            "metadata": {"git_branch": "feature-branch", "environment": "development"},
-        }
-
-        memory_request = DataModelTransformer.session_to_memory(
-            session_data, "Test memory content from session"
-        )
-
-        assert memory_request.content == "Test memory content from session"
-        assert memory_request.user_id == "test-user-456"
-        assert memory_request.session_id == "test-session-123"
-        assert memory_request.project_domain == BusinessDomain.LEP
-        assert "git_branch" in memory_request.metadata
-        assert memory_request.category == MemoryCategory.BUSINESS_LOGIC
-
-    @pytest.mark.asyncio
-    async def test_memory_to_session_transformation(self, service):
-        """Test memory to session data transformation"""
-        from vds_memory_orchestrator.service.utils.data_transformer import DataModelTransformer
-
-        memory_data = {
-            "id": "memory-123",
-            "content": "Test memory content",
-            "user_id": "test-user-456",
-            "session_id": "test-session-123",
-            "metadata": {"project_domain": "LEP", "source": "api"},
-        }
-
-        session_data = DataModelTransformer.memory_to_session(memory_data)
-
-        assert session_data.session_id == "test-session-123"
-        assert session_data.user_id == "test-user-456"
-        assert session_data.project_domain == "LEP"
-        assert len(session_data.operations) == 1
-        assert session_data.operations[0].operation_type == "memory_created"
-
-
-class TestSprint1BatchUpdateMemories:
-    """Test Sprint 1 batch update operations."""
-
-    @pytest.mark.asyncio
-    async def test_batch_update_success(self, service):
-        """Should update multiple memories successfully."""
-        # Create two memories first
-        create1 = MemoryCreateRequest(
-            content="First memory",
-            category=MemoryCategory.GENERAL,
-            importance=ImportanceLevel.MEDIUM,
-            user_id="batch-user-1",
-            session_id="batch-session-1",
-        )
-        create2 = MemoryCreateRequest(
-            content="Second memory",
-            category=MemoryCategory.GENERAL,
-            importance=ImportanceLevel.MEDIUM,
-            user_id="batch-user-1",
-            session_id="batch-session-1",
-        )
-
-        memory_id_1 = await service.create_memory(create1)
-        memory_id_2 = await service.create_memory(create2)
-
-        # Batch update both memories
-        batch_request = MemoryBatchUpdateRequest(
-            updates=[
-                MemoryUpdateRequest(
-                    memory_id=memory_id_1,
-                    content="Updated first memory",
-                ),
-                MemoryUpdateRequest(
-                    memory_id=memory_id_2,
-                    content="Updated second memory",
-                ),
-            ]
-        )
-
-        result = await service.batch_update_memories(batch_request)
-
-        assert "results" in result
-        assert len(result["results"]) == 2
-        assert all(r["status"] == "updated" for r in result["results"])
-
-    @pytest.mark.asyncio
-    async def test_batch_update_with_errors(self, service):
-        """Should handle errors gracefully in batch operations."""
-        # Create one valid memory
-        create = MemoryCreateRequest(
-            content="Valid memory",
-            category=MemoryCategory.GENERAL,
-            importance=ImportanceLevel.MEDIUM,
-            user_id="batch-user-2",
-            session_id="batch-session-2",
-        )
-        result = await service.create_memory(create)
-        valid_id = result
-
-        # Batch update with one invalid ID
-        batch_request = MemoryBatchUpdateRequest(
-            updates=[
-                MemoryUpdateRequest(
-                    memory_id=valid_id,
-                    content="Updated valid memory",
-                ),
-                MemoryUpdateRequest(
-                    memory_id="non-existent-id",
-                    content="This should fail",
-                ),
-            ]
-        )
-
-        result = await service.batch_update_memories(batch_request)
-
-        assert "results" in result
-        assert len(result["results"]) == 2
-        # One should succeed, one should have error
-        statuses = [r["status"] for r in result["results"]]
-        assert "updated" in statuses
-        assert "error" in statuses
-
-    @pytest.mark.asyncio
-    async def test_batch_update_empty_list(self, service):
-        """Should validate min_items constraint (pydantic Field min_length=1)."""
-        import pydantic
-
-        with pytest.raises(pydantic.ValidationError):
-            MemoryBatchUpdateRequest(updates=[])
-
-
-class TestSprint1BatchDeleteMemories:
-    """Test Sprint 1 batch delete operations."""
-
-    @pytest.mark.asyncio
-    async def test_batch_delete_by_ids(self, service):
-        """Should delete multiple memories by IDs."""
-        # Create three memories
-        memory_ids = []
-        for i in range(3):
-            create = MemoryCreateRequest(
-                content=f"Memory {i}",
-                category=MemoryCategory.GENERAL,
-                importance=ImportanceLevel.LOW,
-                user_id="batch-delete-user",
-                session_id="batch-delete-session",
-            )
-            result = await service.create_memory(create)
-            memory_ids.append(result)
-
-        # Delete all three
-        batch_request = MemoryBatchDeleteRequest(memory_ids=memory_ids)
-
-        deleted = await service.batch_delete_memories(batch_request)
-
-        assert deleted == 3
-
-    @pytest.mark.asyncio
-    async def test_batch_delete_by_filters(self, service):
-        """Should delete memories matching filter criteria."""
-        # Create memories with same session
-        for i in range(3):
-            create = MemoryCreateRequest(
-                content=f"Filtered memory {i}",
-                category=MemoryCategory.GENERAL,
-                importance=ImportanceLevel.LOW,
-                user_id="filter-delete-user",
-                session_id="filter-delete-session",
-            )
-            await service.create_memory(create)
-
-        # Delete by filter
-        batch_request = MemoryBatchDeleteRequest(
-            session_id="filter-delete-session",
-            user_id="filter-delete-user",
-        )
-
-        deleted = await service.batch_delete_memories(batch_request)
-
-        assert deleted >= 3
-
-    @pytest.mark.asyncio
-    async def test_batch_delete_mixed(self, service):
-        """Should handle both IDs and filters in same request."""
-        # Create memories
-        create1 = MemoryCreateRequest(
-            content="ID delete target",
-            category=MemoryCategory.GENERAL,
-            importance=ImportanceLevel.LOW,
-            user_id="mixed-delete-user",
-            session_id="mixed-session",
-        )
-        result1 = await service.create_memory(create1)
-        memory_id = result1
-
-        create2 = MemoryCreateRequest(
-            content="Filter delete target",
-            category=MemoryCategory.GENERAL,
-            importance=ImportanceLevel.LOW,
-            user_id="mixed-delete-user",
-            session_id="mixed-session",
-        )
-        await service.create_memory(create2)
-
-        # Delete by both ID and filter
-        batch_request = MemoryBatchDeleteRequest(
-            memory_ids=[memory_id],
-            session_id="mixed-session",
-        )
-
-        deleted = await service.batch_delete_memories(batch_request)
-
-        assert deleted >= 2
-
-    @pytest.mark.asyncio
-    async def test_batch_delete_no_filters(self, service):
-        """Should skip delete when no filters provided."""
-        batch_request = MemoryBatchDeleteRequest()
-
-        deleted = await service.batch_delete_memories(batch_request)
-
-        # Should return 0 without filters (safety guard)
-        assert deleted == 0
-
-
-class TestSprint1DeleteByFilters:
-    """Test Sprint 1 delete by filter operations."""
-
-    @pytest.mark.asyncio
-    async def test_delete_by_user_id(self, service):
-        """Should delete memories for specific user."""
-        # Create test memories
-        for i in range(2):
-            create = MemoryCreateRequest(
-                content=f"User filter test {i}",
-                category=MemoryCategory.GENERAL,
-                importance=ImportanceLevel.LOW,
-                user_id="user-filter-test",
-                session_id="user-filter-session",
-            )
-            await service.create_memory(create)
-
-        # Delete by user filter
-        batch_request = MemoryBatchDeleteRequest(user_id="user-filter-test")
-
-        deleted = await service.delete_memories_by_filter(batch_request)
-
-        assert deleted >= 2
-
-    @pytest.mark.asyncio
-    async def test_delete_by_category(self, service):
-        """Should delete memories by category."""
-        # Create test memories
-        for i in range(2):
-            create = MemoryCreateRequest(
-                content=f"Category test {i}",
-                category=MemoryCategory.PERSONAL,
-                importance=ImportanceLevel.LOW,
-                user_id="category-filter-user",
-                session_id="category-filter-session",
-            )
-            await service.create_memory(create)
-
-        # Delete by category filter
-        batch_request = MemoryBatchDeleteRequest(
-            user_id="category-filter-user",
-            category=MemoryCategory.PERSONAL,
-        )
-
-        deleted = await service.delete_memories_by_filter(batch_request)
-
-        assert deleted >= 2
-
-    @pytest.mark.asyncio
-    async def test_delete_by_importance(self, service):
-        """Should delete memories by importance level."""
-        # Create test memories
-        for i in range(2):
-            create = MemoryCreateRequest(
-                content=f"Importance test {i}",
-                category=MemoryCategory.GENERAL,
-                importance=ImportanceLevel.LOW,
-                user_id="importance-filter-user",
-                session_id="importance-filter-session",
-            )
-            await service.create_memory(create)
-
-        # Delete by importance filter
-        batch_request = MemoryBatchDeleteRequest(
-            user_id="importance-filter-user",
-            importance=ImportanceLevel.LOW,
-        )
-
-        deleted = await service.delete_memories_by_filter(batch_request)
-
-        assert deleted >= 2
-
-    @pytest.mark.asyncio
-    async def test_delete_by_project_domain(self, service):
-        """Should delete memories by project domain."""
-        # Create test memories
-        for i in range(2):
-            create = MemoryCreateRequest(
-                content=f"Domain test {i}",
-                category=MemoryCategory.PROJECT,
-                importance=ImportanceLevel.LOW,
-                user_id="domain-filter-user",
-                session_id="domain-filter-session",
-                project_domain=BusinessDomain.LEP,
-            )
-            await service.create_memory(create)
-
-        # Delete by project domain filter
-        batch_request = MemoryBatchDeleteRequest(
-            user_id="domain-filter-user",
-            project_domain=BusinessDomain.LEP,
-        )
-
-        deleted = await service.delete_memories_by_filter(batch_request)
-
-        assert deleted >= 2
-
-    @pytest.mark.asyncio
-    async def test_delete_combined_filters(self, service):
-        """Should delete memories matching all filter criteria."""
-        # Create memories with specific attributes
-        for i in range(2):
-            create = MemoryCreateRequest(
-                content=f"Combined filter test {i}",
-                category=MemoryCategory.TASK,
-                importance=ImportanceLevel.MEDIUM,
-                user_id="combined-filter-user",
-                session_id="combined-filter-session",
-                project_domain=BusinessDomain.INSURANCE,
-            )
-            await service.create_memory(create)
-
-        # Delete with combined filters
-        batch_request = MemoryBatchDeleteRequest(
-            user_id="combined-filter-user",
-            session_id="combined-filter-session",
-            category=MemoryCategory.TASK,
-            importance=ImportanceLevel.MEDIUM,
-            project_domain=BusinessDomain.INSURANCE,
-        )
-
-        deleted = await service.delete_memories_by_filter(batch_request)
-
-        assert deleted >= 2