Logger.make_buf
 
   bm.draw_screen
-  imode.load_more_threads ibuf.content_height
+  imode.load_more_threads :num => ibuf.content_height, :when_done => lambda {   reporting_thread { sleep 1; PollManager.poll } }
 
-  reporting_thread { sleep 5; PollManager.poll }
   PollManager.start_thread
 
   until $exception
             log "built query from #{text.inspect}: #{qobj}"
             mode = SearchResultsMode.new qobj
             bm.spawn "search: \"#{short_text}\"", mode
-            mode.load_more_threads mode.buffer.content_height
+            mode.load_more_threads :num => mode.buffer.content_height
           rescue Ferret::QueryParser::QueryParseException => e
             bm.flash "Couldn't parse query."
           end
             b = BufferManager.spawn_unless_exists(:draft) do
               mode = LabelSearchResultsMode.new [:draft]
             end
-            b.mode.load_more_threads b.content_height
+            b.mode.load_more_threads :num => b.content_height
           end
         when :nothing
         when :redraw
 
   def multi_search people
     mode = PersonSearchResultsMode.new people
     BufferManager.spawn "personal search results", mode
-    mode.load_more_threads mode.buffer.content_height
+    mode.load_more_threads :num => mode.buffer.content_height
   end
 
   def search
 
 
   def is_relevant? m; m.has_label? :inbox; end
 
-  def load_more_threads n=ThreadIndexMode::LOAD_MORE_THREAD_NUM
+  def load_more_threads opts={}
+    n = opts[:num] || ThreadIndexMode::LOAD_MORE_THREAD_NUM
     load_n_threads_background n, :label => :inbox,
                                  :load_killed => false,
                                  :load_spam => false,
-                                 :when_done => lambda { |num|
+                                 :when_done => (lambda do |num|
+      opts[:when_done].call if opts[:when_done]
       BufferManager.flash "Added #{num} threads."
-    }
+    end)
   end
 
   def reload
     drop_all_threads
     BufferManager.draw_screen
-    load_more_threads buffer.content_height
+    load_more_threads :num => buffer.content_height
   end
 end
 
 
       b = BufferManager.spawn_unless_exists(label) do
         mode = LabelSearchResultsMode.new [label]
       end
-      b.mode.load_more_threads b.content_height
+      b.mode.load_more_threads :num => b.content_height
     end
   end
 end
 
 
   def is_relevant? m; @labels.all? { |l| m.has_label? l }; end
 
-  def load_more_threads n=ThreadIndexMode::LOAD_MORE_THREAD_NUM
+  def load_more_threads opts={}
+    n = opts[:num] || ThreadIndexMode::LOAD_MORE_THREAD_NUM
     load_n_threads_background n, :labels => @labels,
                                  :load_killed => true,
                                  :load_spam => false,
                                  :when_done =>(lambda do |num|
+      opts[:when_done].call if opts[:when_done]
       if num > 0
         BufferManager.flash "Found #{num} threads"
       else
 
 
   def is_relevant? m; @people.any? { |p| m.from == p }; end
 
-  def load_more_threads n=ThreadIndexMode::LOAD_MORE_THREAD_NUM
+  def load_more_threads opts={}
+    n = opts[:num] || ThreadIndexMode::LOAD_MORE_THREAD_NUM
     load_n_threads_background n, :participants => @people,
                                  :load_killed => true,
                                  :load_spam => false,
                                  :when_done =>(lambda do |num|
+      opts[:when_done].call if opts[:when_done]
       if num > 0
         BufferManager.flash "Found #{num} threads"
       else
 
   ## TODO: think about this
   def is_relevant? m; super; end
 
-  def load_more_threads n=ThreadIndexMode::LOAD_MORE_THREAD_NUM
+  def load_more_threads opts={}
+    n = opts[:num] || ThreadIndexMode::LOAD_MORE_THREAD_NUM
     load_n_threads_background n, :qobj => @qobj,
                                  :load_killed => true,
                                  :load_spam => false,
                                  :when_done =>(lambda do |num|
+      opts[:when_done].call if opts[:when_done]
       if num > 0
         BufferManager.flash "Found #{num} threads"
       else
 
   def handle_add_update m
     if is_relevant?(m) || @ts.is_relevant?(m)
       @ts.load_thread_for_message m
+      @new_cache.delete @ts.thread_for(m) # force recalculation of newness
       update
     end
   end