anchor.diff:  
   build_org_dict() ->
       OrgDict = dict:new(),
  -    dets:foldl(fun(#node{status = deleted}, Dict) ->
  -                       %% skip deleted nodes
  +    dets:foldl(fun(#node{status = Skip}, Dict) when Skip =:= deleted; Skip =:= not_found ->
  +                       %% skip deleted or not found nodes
                          Dict;
                     (#node{org_id = OrgId}=Node, Dict) ->
                          dict:append(OrgId, Node, Dict)
                  end, OrgDict, all_nodes).
   
   make_delete_fun(CouchUrl) ->
  -    fun(#node{status = deleted}, _PrevTime) ->
  -            %% already deleted, skip
  +    fun(#node{status = Skip}, _PrevTime) when Skip =:= deleted; Skip =:= not_found ->
  +            %% already deleted or not found, skip
               now();
          (#node{id = NodeId, org_id = OrgId}, PrevTime) ->
               case delete_node_delay(OrgId, NodeId, CouchUrl, PrevTime) of
                   {ok, NewTime} ->
                       mark_node(deleted, NodeId),
                       NewTime;
  +                {not_found, NewTime} ->
  +                    mark_node(not_found, NodeId),
  +                    NewTime;
                   {Error, NewTime} ->
                       mark_node(delete_error, NodeId, Error),
                       NewTime
  
positive.code: summarize_nodes() ->
      Counts = ?fix_table(all_nodes,
                          dets:foldl(
                            fun(Node, {NTotal, NDeleted, NToDelete, NDeleteError}) ->
                                    {NTotal + 1,
                                     NDeleted + deleted_count(Node),
                                     NToDelete + to_delete_count(Node),
                                     NDeleteError + delete_error_count(Node)}
                            end, {0, 0, 0, 0}, all_nodes)),
      Labels = [total, deleted, to_delete, delete_error],
      lists:zip(Labels, tuple_to_list(Counts)).
  
  deleted_count(#node{status = deleted}) -> 1;
  
negative.code:             Headers = [{"Content-Type", "application/json"},
                         {"Accept", "application/json"}],
              case ibrowse:send_req(Url, Headers, delete, [], ?IBROWSE_OPTS) of
                  {ok, "404", _H, _Body} ->
                      not_found;
                  {ok, "200", _H, Body} ->
                      Rev = binary_to_list(ej:get({<<"_rev">>}, ejson:decode(Body))),
                      log(info, "Got rev ~s ~s", [Rev, Url]),
  