anchor.diff:  
   handle_activity_subcall({start_activity,
                            Domain,
  -                         DomainToken, ParentName, Quorum, Async, Name, Body},
  +                         DomainToken,
  +                         ParentName, Quorum, Opts, Async, Name, Body},
                           From, State) ->
       FullName = ParentName ++ [Name],
       handle_start_activity(Async,
                             Domain,
  -                          DomainToken, FullName, Quorum, Body, From, State);
  +                          DomainToken,
  +                          FullName, Quorum, Opts, Body, From, State);
   handle_activity_subcall({register_process,
  -                         Domain, DomainToken, ParentName, Quorum, Name, Pid},
  +                         Domain,
  +                         DomainToken, ParentName, Quorum, Opts, Name, Pid},
                           From, State) ->
       FullName = ParentName ++ [Name],
       handle_register_process(Domain,
  -                            DomainToken, FullName, Quorum, Pid, From, State);
  +                            DomainToken,
  +                            FullName, Quorum, Opts, Pid, From, State);
   handle_activity_subcall({switch_quorum,
                            Domain,
  -                         _DomainToken, Name, Quorum, Activity}, From, State) ->
  +                         _DomainToken,
  +                         Name, Quorum, _Opts, Activity}, From, State) ->
       handle_switch_quorum(Domain, Name, Quorum, Activity, From, State);
   handle_activity_subcall(Request, From, State) ->
       ?log_error("Received unexpected activity call ~p from ~p when state is~n~p",
  
positive.code:                      | {majority, Nodes}
                       | [quorum(Nodes)].
  
  -record(activity, { pid          :: pid(),
                      mref         :: reference(),
                      domain       :: term(),
                      domain_token :: binary() | any(),
                      name         :: [term()],
                      quorum       :: quorum() }).
  
  -record(activity_token, { lease        :: {node(), binary()},
                            domain_token :: binary(),
  
negative.code: 
      Quorum  = convert_quorum(UserQuorum),
      SubCall = list_to_tuple([Call,
                               Domain,
                               DomainToken, TokenName, Quorum, Opts | Args]),
  
      call(Node, {wait_for_quorum,
                  Lease, Quorum, SubCall, QuorumTimeout}, OuterTimeout).
  