Hi all, What is the 'right' behavior of a SAGA implementation when a user adds multiple contexts of the same type to a session? Example: in an file browsing application on top of SAGA, a user creates two contexts of type "ftp": one with username "anonymous" and an empty password (for anonymous FTP access), and one with username "john" and password "1234" (to access a private FTP server). Should a SAGA implementation try all contexts of type "ftp" in this case, or just one of them? And what if both contexts actually work for a certain URL, but result in different access rights? In that case, a directory.cwd() call may succeed with one context but fail with another one due to insuffient permissions. Should an implementation then also retry the other available contexts in the cwd() method, or fail with an AuthorizationFailed exception? Currently, the SAGA spec leaves the 'right' behavior entirely up to the application. Should a multi-adaptor SAGA implementation leave the behavior to the adaptors? In that case, different adaptors may do different things. One adaptor may try all contexts with the right type, while another one may only try just one. Some adaptors may only try multiple contexts in the constructor, while others may also do this in the individual methods. Is each implementation supposed to prescribe 'the right way' to adaptor writers? Should each adaptor document its use of contexts? Should each adaptor mimic the behavior of the underlying middleware? (e.g. an SSH adaptor tries multiple keys automatically, but an FTP adaptor only tries one username/password combination). Or would it be desirable if the spec prescribes something here? best, -Mathijs