anchor.diff:             SubSyncI = find_intersection(DestI, RestI),
              case intervals:is_empty(SubSyncI) of
                  false ->
  +                   MySubSyncI = find_intersection(RestI, DestI), % mapped to my range
  +                   Reconcile = Initiator andalso (Stage =:= reconciliation),
                      if RMethod =:= bloom -> 
                             ForkState = State#rr_recon_state{dest_interval = SubSyncI,
                                                              struct = Params},
                             {ok, Pid} = fork_recon(ForkState),
  -                          ok;
  -                      true -> Pid = self()
  -                   end,
  -                   send_chunk_req(DhtNodePid, Pid, find_intersection(RestI, DestI), SubSyncI,
  -                                  get_max_items(RMethod));
  +                          send_chunk_req(DhtNodePid, Pid, MySubSyncI, SubSyncI,
  +                                         get_max_items(RMethod), Reconcile);
  +                      true ->
  +                          send_chunk_req(DhtNodePid, self(), MySubSyncI, SubSyncI,
  +                                         get_max_items(RMethod), Reconcile)
  +                   end;
                  true -> ok
              end;
           true -> ok
       end,
       if EmptyRest orelse RMethod =:= bloom ->
              begin_sync(SyncStruct, Params, NewState#rr_recon_state{stage = reconciliation});
  -       not EmptyRest andalso RMethod =:= merkle_tree ->
  -           NewState#rr_recon_state{stage = build_struct};
          true ->
  -           NewState#rr_recon_state{stage = reconciliation}
  +           NewState % keep stage (at initiator: reconciliation, at other: build_struct)
       end.
   
   -spec begin_sync(MySyncStruct::sync_struct(), OtherSyncStruct::parameters(),
  
positive.code:     % keys mapped to our interval
      DBList = [encodeBlob(KeyX, VersionX) || {KeyX, VersionX} <- DBList0],
      MySyncI = case RMethod of
                    merkle_tree -> SyncStruct#merkle_params.interval;
                    art         -> art:get_interval(SyncStruct)
                end,
      build_struct(DBList, MySyncI, RestI, State);
  
negative.code:     SID = rr_recon_stats:get(session_id, Stats),
      SyncFinished = intervals:is_empty(RestI),
      if not SyncFinished ->
             send_chunk_req(DhtNodePid, self(), RestI, RestI, get_max_items(bloom), true);
         true -> ok
      end,
      ?TRACE("Reconcile Bloom Session=~p ; Diff=~p", [SID, length(Diff)]),
  