anchor.diff:    when is_list(Quorums) ->
       lists:all(have_quorum(_, State), Quorums).
   
  +check_quorum(Activity, State) ->
  +    case have_local_lease(State) of
  +        true ->
  +            Unsafe = proplists:get_bool(unsafe, get_options(Activity)),
  +            Unsafe orelse have_quorum(Activity#activity.quorum, State);
  +        false ->
  +            false
  +    end.
  +
   check_quorums(#state{activities = Activities} = State) ->
  -    {Quorum, NoQuorum} =
  -        lists:partition(?cut(have_quorum(_#activity.quorum, State)),
  -                        Activities),
  +    {Quorum, NoQuorum} = lists:partition(check_quorum(_, State), Activities),
   
       case NoQuorum of
           [] ->
  
positive.code: 
  -type activity_option() :: {quorum_timeout, non_neg_integer()}
                           | {timeout, non_neg_integer()}
                           | quiet.
  -type activity_options() :: [activity_option()].
  
  -record(activity, { pid          :: pid(),
  
negative.code: 
      State#state{activities = Quorum}.
  
  handle_wait_for_quorum(Lease,
                         Quorum, Unsafe, SubCall, Timeout, From, State) ->
      gen_server2:conditional(
        wait_for_quorum_pred(Lease, Quorum, _),
        ?cut(handle_wait_for_quorum_success(SubCall, From, _2)),
        Timeout,
        handle_wait_for_quorum_timeout(Unsafe, SubCall, Timeout,
                                       From, Lease, Quorum, _)),
  
      State.
  
  wait_for_quorum_pred(Lease, Quorum, State) ->
      have_lease(Lease, State) andalso have_quorum(Quorum, State).
  
  handle_wait_for_quorum_success(SubCall, From, State) ->
      {noreply, handle_activity_subcall(SubCall, From, State)}.
  
  handle_wait_for_quorum_timeout(false, _, _, From,
                                 RequiredLease, RequiredQuorum, State) ->
      reply_no_quorum(From, RequiredLease, RequiredQuorum, State);
  handle_wait_for_quorum_timeout(true, SubCall, Timeout, From,
                                 RequiredLease, RequiredQuorum,
                                 #state{leases = RemoteLeases} = State) ->
      case have_lease(RequiredLease, State) of
          true ->
              ?log_debug("Failed to acquire quorum for call ~p after ~bms. "
                         "Continuing since 'unsafe' option is set.~n"
                         "Required quorum: ~p~n"
                         "Leases: ~p",
                         [SubCall, Timeout, RequiredQuorum, RemoteLeases]),
              handle_wait_for_quorum_success(SubCall, From, State);
          false ->
              %% don't continue if we somehow don't even have the local lease
              reply_no_quorum(From, RequiredLease, RequiredQuorum, State)
      end.
  
  reply_no_quorum(From, RequiredLease, RequiredQuorum,
                  #state{local_lease_holder = LocalLease,
  