anchor.diff:      {noreply, RMgr#rmgr{curr = Replicators2}}.
   
   create_replicator(Id, Request, NotifyPid, NotifyData,
  -                  SentOk, Monitors, SuccessMin) ->
  -    #replicator{id = Id,
  -                request = Request,
  -                notify_pid = NotifyPid,
  -                notify_data = NotifyData,
  -                sent_ok = SentOk,
  -                monitors = Monitors,
  -                success_min = SuccessMin}.
  -
  -update_replicator(#replicator{sent_ok = SentOk,
  -                              success_min = SuccessMin,
  -                              received_err = ReceivedErr,
  -                              received_ok = ReceivedOk
  +                  SentOk, Monitors, ReceivedOkMin) ->
  +    #replicator{id              = Id,
  +                request         = Request,
  +                notify_pid      = NotifyPid,
  +                notify_data     = NotifyData,
  +                sent_ok         = SentOk,
  +                monitors        = Monitors,
  +                received_ok_min = ReceivedOkMin,
  +                received_ok     = 0,
  +                received_err    = 0}.
  +
  +update_replicator(#replicator{sent_ok         = SentOk,
  +                              monitors        = Monitors,
  +                              received_ok_min = ReceivedOkMin,
  +                              received_ok     = ReceivedOk,
  +                              received_err    = ReceivedErr
                                } = Replicator) ->
  -    case ReceivedOk + ReceivedErr >= SentOk of
  -        true  -> notify_replicator(Replicator);
  -        false -> case SentOk >= SuccessMin of
  -                     true ->
  -                         case ReceivedOk =:= SuccessMin of
  -                             true  ->
  -                                 true;
  -                             false ->
  -                                 {ok, Replicator}
  -                         end;
  -                     false ->
  -                         {error, not_enough_active_replicas}
  -                 end
  +    case SentOk >= ReceivedOkMin of
  +        true ->
  +            case ReceivedOk + ReceivedErr >= SentOk of
  +                true ->
  +                    mc_downstream:demonitor(Monitors),
  +                    notify_replicator(Replicator),
  +                    {done, all_responses_received};
  +                false ->
  +                    case ReceivedOk == ReceivedOkMin of
  +                        true  -> notify_replicator(Replicator);
  +                        false -> {ok, Replicator}
  +                    end
  +            end;
  +        false ->
  +            mc_downstream:demonitor(Monitors),
  +            notify_replicator(Replicator),
  +            {error, not_enough_active_replicas}
       end.
   
  -notify_replicator(#replicator{notify_pid = NotifyPid,
  +notify_replicator(#replicator{notify_pid  = NotifyPid,
                                 notify_data = NotifyData} = Replicator) ->
       notify_replicator(NotifyPid, NotifyData, Replicator).
   
  
positive.code:             #rmgr{curr = Replicators} = RMgr) ->
      % Invoked when a downstream provides a final notification result.
      case dict:find(Id, Replicators) of
          {ok, Rep} ->
              Responses2 = [{Addr, RV} | Rep#replicator.responses],
              Replicators2 =
                  case update_replicator(
                         Rep#replicator{responses = Responses2}) of
                      {ok, R} -> dict:store(Id, R, Replicators);
                      _       -> dict:erase(Id, Replicators)
                  end,
              {noreply, RMgr#rmgr{curr = Replicators2}};
          error ->
  
negative.code:             {NotifyPid, _} = _From,
              #rmgr{curr = Replicators} = RMgr) ->
      % TODO: Use Policy for N instead of just pinning N to # of Addrs.
      ReceivedOkMin = length(Addrs),
      Id = make_ref(),
      {SentOk, Monitors} =
          lists:foldl(
  