anchor.diff:    case AddRoleResult of
       {ok, NewStateData} ->
         error_logger:info_msg("INFO: Actor ~w with PID ~p registered for role
  -                             ~w.", [NewStateData#conv_state.actor_type_name,
  -                                    NewStateData#conv_state.actor_pid,
  -                                    RoleName]),
  -      {reply, ok, setup, NewStateData};
  +                             ~w in protocol ~w.~n",
  +                            [NewStateData#conv_state.actor_type_name,
  +                             NewStateData#conv_state.actor_pid,
  +                             RoleName, ProtocolName]),
  +      {reply, ok, NewStateData};
       {error, Err} ->
  -      error_logger:warning_msg("WARN: Actor ~w could not fulfil role ~w: ~p",
  +      error_logger:warning_msg("WARN: Actor ~w with PID ~p could not fulfil role " ++
  +                               "~w in protocol ~w; error: ~p.~n",
                                  [StateData#conv_state.actor_type_name,
  +                                StateData#conv_state.actor_pid,
                                   RoleName,
  +                                ProtocolName,
                                   Err]),
  -      {reply, {error, Err}, CurrentState, StateData}
  +      {reply, {error, Err}, StateData}
     end.
   
  -handle_terminate_conversation(ConversationID, CurrentState, StateData) ->
  -  ActorName = StateData#conv_state.actor_type_name,
  -  ActorPID = StateData#conv_state.actor_pid,
  -  CurrentCID = StateData#conv_state.conversation_id,
  -  if ConversationID == CurrentCID ->
  -       error_logger:info_msg("INFO: Actor ~w with PID ~p exiting conversation ~p.~n",
  -                             [ActorName, ActorPID, ConversationID]),
  -       {next_state, idle, freshen_state(StateData)};
  -     ConversationID =/= CurrentCID ->
  -       error_logger:warning_msg("WARN: Terminate conversation (ID ~p) called for monitor in " ++
  -                                " different conversation (ID ~p) in actor type ~w with PID ~p.~n",
  -                               [ConversationID, CurrentCID, ActorName, ActorPID]),
  -       {next_state, CurrentState, StateData}
  -  end.
  -
  -% Idle / setup have identical (boring) behaviours for async messages,
  -% as most setup messages are synchronous.
  -handle_setup_async(Inv = {invitation, _, _}, CurrentState, StateData) ->
  -  error_logger:error_msg("ERROR: Monitor got asynchronous invitation message ~p~n", [Inv]),
  -  {stop, error_invitation_async, StateData};
  -handle_setup_async({terminate_conversation, ConvID}, CurrentState, StateData) ->
  -  handle_terminate_conversation(ConvID, CurrentState, StateData);
  -handle_setup_async(Msg = {message, _MsgData}, CurrentState, StateData) ->
  -  error_logger:warning_msg("WARN: Got message (~p) in idle state: ignoring.~n ", [Msg, StateData]),
  -  {next_state, CurrentState, StateData};
  -handle_setup_async(Other, CurrentState, StateData) ->
  -  error_logger:warning_msg("WARN: Got unhandled asynchronous message (~p) in ~p state: ignoring.",
  -                           [Other, CurrentState]),
  -  {next_state, CurrentState, StateData}.
  +handle_terminate_conversation(ConversationID, State) ->
  +  ActorName = State#conv_state.actor_type_name,
  +  ActorPID = State#conv_state.actor_pid,
  +  ActiveProtocols = State#conv_state.active_protocols,
  +  NewActiveProtocols = bidirectional_map:remove_right(ConversationID),
  +  NewState = State#conv_state{active_protocols=NewActiveProtocols},
  +  error_logger:info_msg("INFO: Actor ~w with PID ~p exiting conversation ~p.~n",
  +                       [ActorName, ActorPID, ConversationID]),
  +  {noreply, NewState}.
   
   
   % Here, we deliver the message to the attached actor (which is a gen_server).
  
positive.code: %  - Figure out what needs to be changed in session_actor, and do those
  %  - Get monitor loading / storage / resets going. What stores what?
  
  fresh_state(ActorPid, ActorTypeName, AvailableRoles) ->
    #conv_state{actor_pid=ActorPid,
                actor_type_name=ActorTypeName,
                conversation_id=no_conversation,
                available_roles=[],
                conversation_roles=[],
                monitors=orddict:new(),
                active_role=no_active_role}.
  
  freshen_state(OldState) ->
    ActorPid = OldState#conv_state.actor_pid,
    ActorTypeName = OldState#conv_state.actor_type_name,
    AvailableRoles = OldState#conv_state.available_roles,
    fresh_state(ActorPid, ActorTypeName, AvailableRoles).
  
  % Initialises the basic monitor state with some default values.
  init([ActorPid, ActorTypeName, AvailableRoles]) ->
    {ok, fresh_state(ActorPid, ActorTypeName, AvailableRoles)}.
  
  
  % Called when we've been invited to fufil a role.
  
negative.code: % New state:
  % Actor PID (as before)
  % Actor type name (as before)
  % Protocol <-|-> Conversation ID mapping (as we can be involved in mult protocols)
  % Protocol |-> Role mapping (where Role is the role we can play in a protocol)
  % Monitors (Protocol |-> Monitor Instance)
  % Active protocol
  