diff --git a/akonadi/entitycache_p.h b/akonadi/entitycache_p.h
index eda286102..61772bd79 100644
--- a/akonadi/entitycache_p.h
+++ b/akonadi/entitycache_p.h
@@ -1,231 +1,232 @@
 /*
     Copyright (c) 2009 Volker Krause <vkrause@kde.org>
 
     This library is free software; you can redistribute it and/or modify it
     under the terms of the GNU Library General Public License as published by
     the Free Software Foundation; either version 2 of the License, or (at your
     option) any later version.
 
     This library is distributed in the hope that it will be useful, but WITHOUT
     ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
     FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Library General Public
     License for more details.
 
     You should have received a copy of the GNU Library General Public License
     along with this library; see the file COPYING.LIB.  If not, write to the
     Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
     02110-1301, USA.
 */
 
 #ifndef AKONADI_ENTITYCACHE_P_H
 #define AKONADI_ENTITYCACHE_P_H
 
 #include <akonadi/item.h>
 #include <akonadi/itemfetchjob.h>
 #include <akonadi/itemfetchscope.h>
 #include <akonadi/collection.h>
 #include <akonadi/collectionfetchjob.h>
 #include <akonadi/collectionfetchscope.h>
 
 #include <qobject.h>
 #include <QQueue>
 #include <QVariant>
 #include <QtCore/QQueue>
 
 class KJob;
 
 namespace Akonadi {
 
 /**
   @internal
   QObject part of EntityCache.
 */
 class EntityCacheBase : public QObject
 {
   Q_OBJECT
   public:
     explicit EntityCacheBase (QObject * parent = 0);
 
   signals:
     void dataAvailable();
 
   private slots:
     virtual void fetchResult( KJob* job ) = 0;
 };
 
 template <typename T>
 struct EntityCacheNode
 {
   EntityCacheNode() : pending( false ), invalid( false ) {}
   EntityCacheNode( typename T::Id id ) : entity( T( id ) ), pending( true ), invalid( false ) {}
   T entity;
   bool pending;
   bool invalid;
 };
 
 /**
  * @internal
  * A in-memory FIFO cache for a small amount of Entity objects.
  */
 template<typename T, typename FetchJob, typename FetchScope>
 class EntityCache : public EntityCacheBase
 {
   public:
     explicit EntityCache( int maxCapacity, QObject *parent = 0 ) :
       EntityCacheBase( parent ),
       mCapacity( maxCapacity )
     {}
 
     ~EntityCache()
     {
       qDeleteAll( mCache );
     }
 
     /** Object is available in the cache and can be retrieved. */
     bool isCached( typename T::Id id ) const
     {
       EntityCacheNode<T>* node = cacheNodeForId( id );
       return node && !node->pending;
     }
 
     /** Object has been requested but is not yet loaded into the cache or is already available. */
     bool isRequested( typename T::Id id ) const
     {
       return cacheNodeForId( id );
     }
 
     /** Returns the cached object if available, an empty instance otherwise. */
     T retrieve( typename T::Id id ) const
     {
       EntityCacheNode<T>* node = cacheNodeForId( id );
       if ( node && !node->pending && !node->invalid )
         return node->entity;
       return T();
     }
 
     /** Marks the cache entry as invalid, use in case the object has been deleted on the server. */
     void invalidate( typename T::Id id )
     {
       EntityCacheNode<T>* node = cacheNodeForId( id );
       if ( node )
         node->invalid = true;
     }
 
     /** Triggers a re-fetching of a cache entry, use if it has changed on the server. */
     void update( typename T::Id id, const FetchScope &scope )
     {
       EntityCacheNode<T>* node = cacheNodeForId( id );
-      if ( node )
+      if ( node ) {
         mCache.removeAll( node );
-      if ( !node || node->pending )
-        request( id, scope );
-      delete node;
+        if ( node->pending )
+          request( id, scope );
+        delete node;
+      }
     }
 
     /** Requests the object to be cached if it is not yet in the cache. @returns @c true if it was in the cache already. */
     bool ensureCached( typename T::Id id, const FetchScope &scope )
     {
       EntityCacheNode<T>* node = cacheNodeForId( id );
       if ( !node ) {
         request( id, scope );
         return false;
       }
       return !node->pending;
     }
 
     /**
       Asks the cache to retrieve @p id. @p request is used as
       a token to indicate which request has been finished in the
       dataAvailable() signal.
     */
     void request( typename T::Id id, const FetchScope &scope )
     {
       Q_ASSERT( !isRequested( id ) );
       shrinkCache();
       EntityCacheNode<T> *node = new EntityCacheNode<T>( id );
       FetchJob* job = createFetchJob( id );
       job->setFetchScope( scope );
       job->setProperty( "EntityCacheNode", QVariant::fromValue<typename T::Id>( id ) );
       connect( job, SIGNAL(result(KJob*)), SLOT(fetchResult(KJob*)) );
       mCache.enqueue( node );
     }
 
   private:
     EntityCacheNode<T>* cacheNodeForId( typename T::Id id ) const
     {
       for ( typename QQueue<EntityCacheNode<T>*>::const_iterator it = mCache.constBegin(), endIt = mCache.constEnd();
             it != endIt; ++it )
       {
         if ( (*it)->entity.id() == id )
           return *it;
       }
       return 0;
     }
 
     void fetchResult( KJob* job )
     {
       typename T::Id id = job->property( "EntityCacheNode" ).template value<typename T::Id>();
       EntityCacheNode<T> *node = cacheNodeForId( id );
       if ( !node )
         return; // got replaced in the meantime
 
       node->pending = false;
       extractResult( node, job );
       if ( node->entity.id() != id ) { // make sure we find this node again if something went wrong here...
         kWarning() << "Something went very wrong...";
         node->entity.setId( id );
         node->invalid = true;
       }
       emit dataAvailable();
     }
 
     void extractResult( EntityCacheNode<T>* node, KJob* job ) const;
 
     inline FetchJob* createFetchJob( typename T::Id id )
     {
       return new FetchJob( T( id ), this );
     }
 
     /** Tries to reduce the cache size until at least one more object fits in. */
     void shrinkCache()
     {
       while ( mCache.size() >= mCapacity && !mCache.first()->pending )
         delete mCache.dequeue();
     }
 
   private:
     QQueue<EntityCacheNode<T>*> mCache;
     int mCapacity;
 };
 
 template<> inline void EntityCache<Collection, CollectionFetchJob, CollectionFetchScope>::extractResult( EntityCacheNode<Collection>* node, KJob *job ) const
 {
   CollectionFetchJob* fetch = qobject_cast<CollectionFetchJob*>( job );
   Q_ASSERT( fetch );
   if ( fetch->collections().isEmpty() )
     node->entity = Collection();
   else
     node->entity = fetch->collections().first();
 }
 
 template<> inline void EntityCache<Item, ItemFetchJob, ItemFetchScope>::extractResult( EntityCacheNode<Item>* node, KJob *job ) const
 {
   ItemFetchJob* fetch = qobject_cast<ItemFetchJob*>( job );
   Q_ASSERT( fetch );
   if ( fetch->items().isEmpty() )
     node->entity = Item();
   else
     node->entity = fetch->items().first();
 }
 
 template<> inline CollectionFetchJob* EntityCache<Collection, CollectionFetchJob, CollectionFetchScope>::createFetchJob( Collection::Id id )
 {
   return new CollectionFetchJob( Collection( id ), CollectionFetchJob::Base, this );
 }
 
 typedef EntityCache<Collection, CollectionFetchJob, CollectionFetchScope> CollectionCache;
 typedef EntityCache<Item, ItemFetchJob, ItemFetchScope> ItemCache;
 
 }
 
 #endif
diff --git a/akonadi/monitor_p.cpp b/akonadi/monitor_p.cpp
index 78845055c..df267fc48 100644
--- a/akonadi/monitor_p.cpp
+++ b/akonadi/monitor_p.cpp
@@ -1,332 +1,332 @@
 /*
     Copyright (c) 2007 Tobias Koenig <tokoe@kde.org>
 
     This library is free software; you can redistribute it and/or modify it
     under the terms of the GNU Library General Public License as published by
     the Free Software Foundation; either version 2 of the License, or (at your
     option) any later version.
 
     This library is distributed in the hope that it will be useful, but WITHOUT
     ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
     FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Library General Public
     License for more details.
 
     You should have received a copy of the GNU Library General Public License
     along with this library; see the file COPYING.LIB.  If not, write to the
     Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
     02110-1301, USA.
 */
 
 // @cond PRIVATE
 
 #include "monitor_p.h"
 
 #include "collectionfetchjob.h"
 #include "collectionstatistics.h"
 #include "itemfetchjob.h"
 #include "notificationmessage_p.h"
 #include "session.h"
 
 #include <kdebug.h>
 
 using namespace Akonadi;
 
 static const int PipelineSize = 5;
 
 MonitorPrivate::MonitorPrivate(Monitor * parent) :
   q_ptr( parent ),
   nm( 0 ),
   monitorAll( false ),
   collectionCache( 3*PipelineSize ), // needs to be at least 3x pipeline size for the collection move case
   itemCache( PipelineSize ), // needs to be at least 1x pipeline size
   fetchCollection( false ),
   fetchCollectionStatistics( false )
 {
 }
 
 void MonitorPrivate::init()
 {
   QObject::connect( &collectionCache, SIGNAL(dataAvailable()), q_ptr, SLOT(dataAvailable()) );
   QObject::connect( &itemCache, SIGNAL(dataAvailable()), q_ptr, SLOT(dataAvailable()) );
 }
 
 bool MonitorPrivate::connectToNotificationManager()
 {
   NotificationMessage::registerDBusTypes();
 
   if ( !nm )
     nm = new org::freedesktop::Akonadi::NotificationManager( QLatin1String( "org.freedesktop.Akonadi" ),
                                                      QLatin1String( "/notifications" ),
                                                      QDBusConnection::sessionBus(), q_ptr );
   else
     return true;
 
   if ( !nm ) {
     kWarning() << "Unable to connect to notification manager";
   } else {
     QObject::connect( nm, SIGNAL(notify(Akonadi::NotificationMessage::List)),
              q_ptr, SLOT(slotNotify(Akonadi::NotificationMessage::List)) );
     return true;
   }
   return false;
 }
 
 int MonitorPrivate::pipelineSize() const
 {
   return PipelineSize;
 }
 
 bool MonitorPrivate::acceptNotification(const NotificationMessage & msg)
 {
   if ( isSessionIgnored( msg.sessionId() ) )
     return false;
   switch ( msg.type() ) {
     case NotificationMessage::InvalidType:
       kWarning() << "Received invalid change notification!";
       return false;
     case NotificationMessage::Item:
       return isItemMonitored( msg.uid(), msg.parentCollection(), msg.parentDestCollection(), msg.mimeType(), msg.resource() )
           || isCollectionMonitored( msg.parentCollection(), msg.resource() )
           || isCollectionMonitored( msg.parentDestCollection(), msg.resource() );
     case NotificationMessage::Collection:
       return isCollectionMonitored( msg.uid(), msg.resource() )
           || isCollectionMonitored( msg.parentCollection(), msg.resource() )
           || isCollectionMonitored( msg.parentDestCollection(), msg.resource() );
   }
   Q_ASSERT( false );
   return false;
 }
 
 void MonitorPrivate::dispatchNotifications()
 {
   while ( pipeline.size() < pipelineSize() && !pendingNotifications.isEmpty() ) {
     const NotificationMessage msg = pendingNotifications.dequeue();
     if ( ensureDataAvailable( msg ) && pipeline.isEmpty() )
       emitNotification( msg );
     else
       pipeline.enqueue( msg );
   }
 }
 
 bool MonitorPrivate::ensureDataAvailable( const NotificationMessage &msg )
 {
   bool allCached = true;
   if ( fetchCollection ) {
     if ( !collectionCache.ensureCached( msg.parentCollection(), mCollectionFetchScope ) )
       allCached = false;
     if ( msg.operation() == NotificationMessage::Move && !collectionCache.ensureCached( msg.parentDestCollection(), mCollectionFetchScope ) )
       allCached = false;
   }
   if ( msg.operation() == NotificationMessage::Remove )
     return allCached; // the actual object is gone already, nothing to fetch there
 
   if ( msg.type() == NotificationMessage::Item && !mItemFetchScope.isEmpty() ) {
     if ( !itemCache.ensureCached( msg.uid(), mItemFetchScope ) )
       allCached = false;
   } else if ( msg.type() == NotificationMessage::Collection && fetchCollection ) {
     if ( !collectionCache.ensureCached( msg.uid(), mCollectionFetchScope ) )
       allCached = false;
   }
   return allCached;
 }
 
 void MonitorPrivate::emitNotification( const NotificationMessage &msg )
 {
   const Collection parent = collectionCache.retrieve( msg.parentCollection() );
   Collection destParent;
   if ( msg.operation() == NotificationMessage::Move )
     destParent = collectionCache.retrieve( msg.parentDestCollection() );
 
   if ( msg.type() == NotificationMessage::Collection ) {
     const Collection col = collectionCache.retrieve( msg.uid() );
     emitCollectionNotification( msg, col, parent, destParent );
   } else if ( msg.type() == NotificationMessage::Item ) {
     const Item item = itemCache.retrieve( msg.uid() );
     emitItemNotification( msg, item, parent, destParent );
   }
 }
 
 void MonitorPrivate::dataAvailable()
 {
   while ( !pipeline.isEmpty() ) {
     const NotificationMessage msg = pipeline.head();
     if ( ensureDataAvailable( msg ) ) {
       emitNotification( msg );
       pipeline.dequeue();
     } else {
       break;
     }
   }
   dispatchNotifications();
 }
 
 void MonitorPrivate::updatePendingStatistics( const NotificationMessage &msg )
 {
   if ( msg.type() == NotificationMessage::Item ) {
     notifyCollectionStatisticsWatchers( msg.parentCollection(), msg.resource() );
   } else if ( msg.type() == NotificationMessage::Collection && msg.operation() == NotificationMessage::Remove ) {
     // no need for statistics updates anymore
     recentlyChangedCollections.remove( msg.uid() );
   }
 }
 
 void MonitorPrivate::slotSessionDestroyed( QObject * object )
 {
   Session* session = qobject_cast<Session*>( object );
   if ( session )
     sessions.removeAll( session->sessionId() );
 }
 
 void MonitorPrivate::slotStatisticsChangedFinished( KJob* job )
 {
   if ( job->error() ) {
     kWarning() << "Error on fetching collection statistics: " << job->errorText();
   } else {
     CollectionStatisticsJob *statisticsJob = static_cast<CollectionStatisticsJob*>( job );
     emit q_ptr->collectionStatisticsChanged( statisticsJob->collection().id(),
                                              statisticsJob->statistics() );
   }
 }
 
 void MonitorPrivate::slotFlushRecentlyChangedCollections()
 {
   foreach( Collection::Id collection, recentlyChangedCollections ) {
     if ( fetchCollectionStatistics ) {
       fetchStatistics( collection );
     } else {
       static const CollectionStatistics dummyStatistics;
       emit q_ptr->collectionStatisticsChanged( collection, dummyStatistics );
     }
   }
   recentlyChangedCollections.clear();
 }
 
 void MonitorPrivate::slotNotify( const NotificationMessage::List &msgs )
 {
   foreach ( const NotificationMessage &msg, msgs ) {
     invalidateCaches( msg );
     if ( acceptNotification( msg ) ) {
       updatePendingStatistics( msg );
       NotificationMessage::appendAndCompress( pendingNotifications, msg );
     }
   }
 
   dispatchNotifications();
 }
 
 void MonitorPrivate::emitItemNotification( const NotificationMessage &msg, const Item &item,
                                              const Collection &collection, const Collection &collectionDest  )
 {
   Q_ASSERT( msg.type() == NotificationMessage::Item );
   Collection col = collection;
   Collection colDest = collectionDest;
   if ( !col.isValid() ) {
     col = Collection( msg.parentCollection() );
     col.setResource( QString::fromUtf8( msg.resource() ) );
   }
   if ( !colDest.isValid() ) {
     colDest = Collection( msg.parentDestCollection() );
     // FIXME setResource here required ?
   }
   Item it = item;
-  if ( !it.isValid() ) {
+  if ( !it.isValid() || msg.operation() == NotificationMessage::Remove ) {
     it = Item( msg.uid() );
     it.setRemoteId( msg.remoteId() );
     it.setMimeType( msg.mimeType() );
   }
   if ( !it.parentCollection().isValid() ) {
     if ( msg.operation() == NotificationMessage::Move )
       it.setParentCollection( colDest );
     else
       it.setParentCollection( col );
   }
   switch ( msg.operation() ) {
     case NotificationMessage::Add:
       emit q_ptr->itemAdded( it, col );
       break;
     case NotificationMessage::Modify:
       emit q_ptr->itemChanged( it, msg.itemParts() );
       break;
     case NotificationMessage::Move:
       emit q_ptr->itemMoved( it, col, colDest );
       break;
     case NotificationMessage::Remove:
       emit q_ptr->itemRemoved( it );
       break;
     case NotificationMessage::Link:
       emit q_ptr->itemLinked( it, col );
       break;
     case NotificationMessage::Unlink:
       emit q_ptr->itemUnlinked( it, col );
       break;
     default:
       kDebug() << "Unknown operation type" << msg.operation() << "in item change notification";
       break;
   }
 }
 
 void MonitorPrivate::emitCollectionNotification( const NotificationMessage &msg, const Collection &col,
                                                    const Collection &par, const Collection &dest )
 {
   Q_ASSERT( msg.type() == NotificationMessage::Collection );
   Collection collection = col;
-  if ( !collection.isValid() ) {
+  if ( !collection.isValid() || msg.operation() == NotificationMessage::Remove ) {
     collection = Collection( msg.uid() );
     collection.setResource( QString::fromUtf8( msg.resource() ) );
     collection.setRemoteId( msg.remoteId() );
   }
 
   Collection parent = par;
   if ( !parent.isValid() )
     parent = Collection( msg.parentCollection() );
   Collection destination = dest;
   if ( !destination.isValid() )
     destination = Collection( msg.parentDestCollection() );
 
   if ( !collection.parentCollection().isValid() ) {
     if ( msg.operation() == NotificationMessage::Move )
       collection.setParentCollection( destination );
     else
       collection.setParentCollection( parent );
   }
 
   switch ( msg.operation() ) {
     case NotificationMessage::Add:
       emit q_ptr->collectionAdded( collection, parent );
       break;
     case NotificationMessage::Modify:
       emit q_ptr->collectionChanged( collection );
       break;
     case NotificationMessage::Move:
       emit q_ptr->collectionMoved( collection, parent, destination );
       break;
     case NotificationMessage::Remove:
       emit q_ptr->collectionRemoved( collection );
       break;
     default:
       kDebug() << "Unknown operation type" << msg.operation() << "in collection change notification";
   }
 }
 
 void MonitorPrivate::invalidateCaches( const NotificationMessage &msg )
 {
   // remove invalidates
   if ( msg.operation() == NotificationMessage::Remove ) {
     if ( msg.type() == NotificationMessage::Collection ) {
       collectionCache.invalidate( msg.uid() );
     } else if ( msg.type() == NotificationMessage::Item ) {
       itemCache.invalidate( msg.uid() );
     }
   }
 
   // modify removes the cache entry, as we need to re-fetch
   if ( msg.operation() == NotificationMessage::Modify ) {
     if ( msg.type() == NotificationMessage::Collection ) {
       collectionCache.update( msg.uid(), mCollectionFetchScope );
     } else if ( msg.type() == NotificationMessage::Item ) {
       itemCache.update( msg.uid(), mItemFetchScope );
     }
   }
 }
 
 // @endcond