anchor.diff:  %% Determine capabilities of legacy nodes based on app.config settings and
   %% the provided app-var -> mode mapping associated with capabilities when
   %% registered.
  -query_capabilities(Node, #state{registered=Registered}) ->
  +query_capabilities(Node, State=#state{registered=Registered}) ->
  +    %% Only query results we do not already have local knowledge of
  +    Known = dict:from_list(get_supported(Node, State)),
       lists:mapfoldl(fun({Capability, Info}, ResolvedAcc) ->
                              {Resv, Cap} = query_capability(Node,
  +                                                          Known,
                                                             Capability,
                                                             Info#capability.default,
                                                             Info#capability.legacy),
                              {Cap, ResolvedAcc and Resv}
                      end, true, Registered).
  +
  +query_capability(Node, Known, Capability, DefaultSup, LegacyVar) ->
  +    case dict:find(Capability, Known) of
  +        {ok, Supported} ->
  +            {true, {Capability, Supported}};
  +        error ->
  +            query_capability(Node, Capability, DefaultSup, LegacyVar)
  +    end.
   
   query_capability(_, Capability, DefaultSup, undefined) ->
       Default = {Capability, [DefaultSup]},
  
positive.code: 
  handle_call({register, Capability, Info}, _From, State) ->
      State2 = register_capability(node(), Capability, Info, State),
      State3 = renegotiate_capabilities(State2),
      publish_supported(State3),
      update_local_cache(State3),
      save_registered(State3#state.registered),
      {reply, ok, State3};
  
  handle_call({ring_changed, Ring}, _From, State) ->
      State2 = update_supported(Ring, State),
  
negative.code:                             {[], []} ->
                                  add_node(Node, Supported, StateAcc);
                              {[], _} ->
                                  add_node(Node, Supported, StateAcc);
                              {Same, Same} ->
                                  StateAcc;
                              {_, _} ->
  