anchor.diff:                                          MessagePayload ->
                                               lager:info("~p: dropping packet from ~p to ~p due to preload interposition.", [node(), TracingNode, OriginNode]),
   
  -                                            case partisan_config:get(faulted) of 
  +                                            case partisan_config:get(fauled_for_background) of 
                                                   true ->
                                                       ok;
                                                   _ ->
                                                       lager:info("~p: setting node ~p to faulted due to preload interposition hit on message: ~p", [node(), TracingNode, Message]),
  -                                                    partisan_config:set(faulted, true)
  +                                                    partisan_config:set(fauled_for_background, true)
                                               end,
   
                                               undefined;
  
positive.code:                         replay_debug("unknown preload: ~p", [Other]),
                          OmissionNodes0
                  end
              end, [], Omissions),
  
              replay_debug("Nodes involved in omissions (possibly faulted): ~p", [OmissionNodes]),
  
              %% Load background annotations.
              BackgroundAnnotations = background_annotations(),
              lager:info("Background annotations are: ~p", [BackgroundAnnotations]),
  
              %% Install faulted tracing interposition function.
              %% TODO: ONLY BACKGROUND.
              lists:foreach(fun(Node) ->
                  InterpositionFun = fun({forward_message, _N, M}) ->
                      lager:info("~p: interposition called for message: ~p", [node(), M]),
  
                      case partisan_config:get(faulted) of 
                          true ->
                              case M of 
                                  undefined ->
                                      undefined;
                                  _ ->
                                      MessageType = message_type(forward_message, M),
  
                                      case lists:member(element(2, MessageType), BackgroundAnnotations) of 
                                          true ->
                                              lager:info("~p: faulted during forward_message of background message, message ~p should be dropped.", [node(), M]),
                                              undefined;
                                          false ->
                                              lager:info("~p: faulted, but forward_message payload is not background message: ~p, message_type: ~p", [node(), M, MessageType]),
                                              M
                                      end
                              end;
                          _ ->
                              M
                      end;
                      ({receive_message, _N, M}) -> 
                          case partisan_config:get(faulted) of 
                              true ->
                                  case M of 
                                      undefined ->
                                          undefined;
                                      _ ->
                                          MessageType = message_type(receive_message, M),
  
                                          case lists:member(element(2, MessageType), BackgroundAnnotations) of 
                                              true ->
                                                  lager:info("~p: faulted during receive_message of background message, message ~p should be dropped.", [node(), M]),
                                                  undefined;
                                              false ->
                                                  lager:info("~p: faulted, but receive_message payload is not background message: ~p, message_type: ~p", [node(), M, MessageType]),
                                                  M
                                          end
                                  end;
                              _ ->
                                  M
                          end
                  end,
  
                  %% Install function.
                  ok = rpc:call(Node, ?MANAGER, add_interposition_fun, [{faulted, Node}, InterpositionFun])
              end, OmissionNodes)
      end,
  
      ok.
  
  
negative.code:             {ok, [Omissions]} = file:consult(PreloadOmissionFile),
  
              %% Preload each omission at the correct node.
              lists:foldl(fun({T, Message}, OmissionNodes0) ->
                  case T of
                      pre_interposition_fun ->
                          {TracingNode, forward_message, OriginNode, MessagePayload} = Message,
  