diff --git a/apps/l10nstats/management/commands/deactivate.py b/apps/l10nstats/management/commands/deactivate.py
new file mode 100644
index 00000000..708885b3
--- /dev/null
+++ b/apps/l10nstats/management/commands/deactivate.py
@@ -0,0 +1,74 @@
+# This Source Code Form is subject to the terms of the Mozilla Public
+# License, v. 2.0. If a copy of the MPL was not distributed with this file,
+# You can obtain one at http://mozilla.org/MPL/2.0/.
+
+import json
+from urllib2 import urlopen
+from urlparse import urljoin
+from ConfigParser import ConfigParser
+
+from django.core.management.base import BaseCommand
+
+from l10nstats.models import Active
+
+
+class Command(BaseCommand):
+    option_list = BaseCommand.option_list
+
+    def handle(self, *args, **kwargs):
+        self.handleApps(*args, **kwargs)
+        self.handleDirs(*args, **kwargs)
+
+    def handleApps(self, *args, **kwargs):
+        l10nbuilds = urlopen(
+            'https://raw.githubusercontent.com/Pike/master-ball/'
+            'master/l10n-master/l10nbuilds.ini')
+        cp = ConfigParser()
+        cp.readfp(l10nbuilds)
+        for section in cp.sections():
+            self.stdout.write(section + '\n')
+            self.handleSection(section, dict(cp.items(section)))
+
+    def handleSection(self, section, items):
+        locales = items['locales']
+        if locales == 'all':
+            inipath = '/'.join((
+                items['repo'], items['mozilla'],
+                'raw-file', 'default',
+                items['l10n.ini']
+            ))
+            ini = ConfigParser()
+            ini.readfp(urlopen(inipath))
+            allpath = urljoin(
+                urljoin(inipath, ini.get('general', 'depth')),
+                ini.get('general', 'all'))
+            locales = urlopen(allpath).read()
+        locales = locales.split()
+        obs = (Active.objects
+               .filter(run__tree__code=section)
+               .exclude(run__locale__code__in=locales)
+               .order_by('run__locale__code'))
+        obslocs = ' '.join(obs.values_list('run__locale__code', flat=True))
+        if not obslocs:
+            self.stdout.write(' OK\n')
+            return
+        s = raw_input('Remove %s? [Y/n] ' % obslocs)
+        if s.lower() == 'y' or s == '':
+            obs.delete()
+
+    def handleDirs(self, *args, **kwargs):
+        dirbuilds = json.load(urlopen(
+            'https://raw.githubusercontent.com/Pike/master-ball/'
+            'master/l10n-master/dir-builds.json'))
+        for treedata in dirbuilds:
+            obs = (Active.objects
+                   .filter(run__tree__code=treedata['name'])
+                   .exclude(run__locale__code__in=treedata['locales'])
+                   .order_by('run__locale__code'))
+            obslocs = ' '.join(obs.values_list('run__locale__code', flat=True))
+            if not obslocs:
+                self.stdout.write(' OK\n')
+                continue
+            s = raw_input('Remove %s? [Y/n] ' % obslocs)
+            if s.lower() == 'y' or s == '':
+                obs.delete()
diff --git a/apps/shipping/static/shipping/css/dashboard.css b/apps/shipping/static/shipping/css/dashboard.css
index d6552df9..d42a0d7f 100644
--- a/apps/shipping/static/shipping/css/dashboard.css
+++ b/apps/shipping/static/shipping/css/dashboard.css
@@ -72,6 +72,53 @@ table.stats td.status {
 }
 
 
+.actions .pending.oi {
+    color: #0096DD;
+}
+
+.actions .rejected.oi {
+    color: red;
+}
+.actions .no_update.oi {
+    color: black;
+}
+
+.signoffs.actions .suggest-error {
+    color: red;
+}
+.signoffs.actions .suggest-failure {
+    color: #ff6c00;
+}
+.signoffs.actions .suggest-warnings {
+    color: green;
+}
+.signoffs.actions .suggest-success {
+    color: green;
+}
+
+.signoffs.status, .signoffs.actions {
+    text-align: center;
+    white-space: nowrap;
+}
+.signoffs.status .status-ok {
+    color: green;
+}
+
+.signoffs .status-fallback {
+    color: #ff6c00;
+}
+
+.signoffs a {
+    color: #000000;
+}
+
+.signoffs a:hover {
+    color: #000000;
+    border-color: #484848;
+}
+
+
+
 /* override of exhibit CSS effect
   (done here rather than editing exhibit-bundle.css)
 */
diff --git a/apps/shipping/static/shipping/js/dashboard.js b/apps/shipping/static/shipping/js/dashboard.js
index dff821e6..906e1117 100644
--- a/apps/shipping/static/shipping/js/dashboard.js
+++ b/apps/shipping/static/shipping/js/dashboard.js
@@ -4,7 +4,7 @@
 /* global Exhibit */
 
 jQuery(document).one("scriptsLoaded.exhibit", function(evt) {
-    var EX_OPTIONS = ["result", "shipping", "signoff"];
+    var EX_OPTIONS = ["result", "action", "signoff"];
     var params = Exhibit.parseURLParameters();
     for (var i in EX_OPTIONS) {
         var option = EX_OPTIONS[i];
diff --git a/apps/shipping/templates/shipping/dashboard.html b/apps/shipping/templates/shipping/dashboard.html
index f26a6cfe..d1dc1423 100644
--- a/apps/shipping/templates/shipping/dashboard.html
+++ b/apps/shipping/templates/shipping/dashboard.html
@@ -10,6 +10,7 @@
 
 {% block head_matter %}
 <link rel="stylesheet" href="{% static "shipping/css/dashboard.css" %}" type="text/css">
+<link rel="stylesheet" href="{% static "css/open-iconic.css" %}" type="text/css">
 <link href="{% url 'shipping.views.status.status_json' %}?{{ query }}" type="application/json" rel="exhibit-data"/>
 <style>
 .progress {
@@ -55,10 +56,10 @@ <h1 class="large">Sign-offs {% if subtitles %}({{ subtitles|join:", " }}){% endi
       data-ex-show-toolbox="false"
       data-ex-collectionID="buids"
       data-ex-column-labels="Locale, Tree, %, Errors, Missing, Warnings,
-       Reported, Obsolete, Unchanged, Status, History, Sign-off"
+       Reported, Obsolete, Unchanged, Status, History, Status, Action"
       data-ex-columns=".locale, .tree, .completion, .errors, .missing,
        .warnings, .report, .obsolete,  .unchanged, .changed,
-       .completion, .signoff"
+       .completion, .state, .new_run"
       data-ex-cellSpacing="0">
       <table style="display:none;">
     <tr>
@@ -89,18 +90,34 @@ <h1 class="large">Sign-offs {% if subtitles %}({{ subtitles|join:", " }}){% endi
              data-ex-style-subcontent="background-position:{&#123; .background_offset_x }}px {&#123; .background_offset_y }}px"></div>
          </a>
        </td>
-<td>
-  <span data-ex-if="exists(.tree.appversion)">
-  <span>
-  <a data-ex-href-subcontent="{% url 'shipping.views.signoff.signoff' "&#123;&#123;.locale&#125;&#125;" "&#123;&#123;.tree.appversion&#125;&#125;" %}">
-    <span data-ex-if="exists(.signoff )">
-      <span data-ex-content=".signoff"></span>
-      <span>none</span>
-    </span>
-  </a>
-  </span>
-  </span>
-</td>
+       <td class="signoffs status">
+         <span data-ex-if="exists(.tree.appversion)">
+         <a data-ex-href-subcontent="{% url 'shipping.views.signoff.signoff' "&#123;&#123;.locale&#125;&#125;" "&#123;&#123;.tree.appversion&#125;&#125;" %}">
+         <span data-ex-if='.state = "OK"'>
+           <span class="oi status-ok" data-ex-data-glyph-subcontent="{&#123;.state_glyph}}"></span>
+           <span><span class="oi status-fallback" data-ex-data-glyph-subcontent="{&#123;.state_glyph}}"></span> <span data-ex-content=".state"></span></span>
+         </span>
+         </a>
+         </span>
+       </td>
+       <td class="signoffs actions">
+         <span data-ex-if="exists(.tree.appversion)">
+           <a data-ex-href-subcontent="{% url 'shipping.views.signoff.signoff' "&#123;&#123;.locale&#125;&#125;" "&#123;&#123;.tree.appversion&#125;&#125;" %}">
+             <span data-ex-if="exists(.action)">
+               <span>
+                 <span data-ex-if='.action = "rejected"'><span class="oi rejected" data-glyph='x'></span></span>
+                 <span data-ex-if='contains(.action, "review")'><span class="oi pending" data-glyph="magnifying-glass"></span></span>
+               </span>
+             </span>
+             <span data-ex-if="exists(.new_run)">
+               <span data-ex-class-subcontent='oi suggest-{&#123;.result}}' data-glyph="graph"></span>
+             </span>
+             <span data-ex-if="exists(.needs_update)">
+               <span title="Needs Update" class="oi no_update" data-glyph="ban"></span>
+             </span>
+           </a>
+         </span>
+       </td>
     </tr>
       </table>
     </div>
@@ -128,9 +145,13 @@ <h1 class="large">Sign-offs {% if subtitles %}({{ subtitles|join:", " }}){% endi
        <div data-ex-role="facet" data-ex-expression=".locale" data-ex-facet-label="Locale"
          data-ex-height="5em"
          id="locale-facet"></div>
-       <div data-ex-role="facet" data-ex-expression=".signoff"
+       <div data-ex-role="facet" data-ex-expression=".state"
          data-ex-missing-label="none"
+         data-ex-sort-direction="reverse"
          data-ex-height="5em" data-ex-facet-label="Sign-off" id="signoff-facet"></div>
+       <div data-ex-role="facet" data-ex-expression="union(.action, .new_run)"
+         data-ex-missing-label="none"
+         data-ex-height="5em" data-ex-facet-label="Action" id="action-facet"></div>
        <div><a href="{% url 'shipping.views.index' %}?{{ request.GET.urlencode }}">Edit</a> this dashboard.</div>
      </td>
    </tr>
diff --git a/apps/shipping/tests/test_suggestions.py b/apps/shipping/tests/test_suggestions.py
index 8be58f1a..7198b83f 100644
--- a/apps/shipping/tests/test_suggestions.py
+++ b/apps/shipping/tests/test_suggestions.py
@@ -2,6 +2,7 @@
 # License, v. 2.0. If a copy of the MPL was not distributed with this
 # file, You can obtain one at http://mozilla.org/MPL/2.0/.
 
+from collections import defaultdict
 import datetime
 import itertools
 from nose.tools import eq_, ok_
@@ -31,6 +32,7 @@
 from l10nstats.models import Run, Active
 from shipping.views.signoff import SignoffView
 from shipping.views import teamsnippet
+from shipping.views.status import StatusJSON
 
 
 class DataMixin(object):
@@ -135,7 +137,7 @@ def add_run(self, push, tree=None, **rundata):
             srctime=push.push_date,
             **rundata
         )
-        run.revisions = push.changesets.all()
+        run.revisions.add(push.tip)
         run.activate()
         self.latest_run = run
         return run
@@ -166,7 +168,42 @@ def add_signoff(self, push, flag, av=None):
         return signoff
 
 
-class TeamSnippetTest(TestCase, DataMixin):
+class TeamSnippetProcessMixin(object):
+    def process(self, flags):
+        context = teamsnippet(self.locale, [])['context']
+        ok_('applications' in context)
+        eq_(len(context['applications']), 1)
+        application, runs = context['applications'][0]
+        eq_(application, self.app)
+        run = self.check_runs_and_get(runs)
+        eq_(run['appversion'], self.av)
+        eq_(bool(run['is_active']), not(flags & self.NEEDS_UPDATE))
+        eq_(bool(run['accepted']),
+            bool(flags & self.HAS_SIGNOFF) or bool(self.fallback))
+        eq_(bool(run['under_review']), bool(flags & self.PENDING))
+        if flags & self.SUGGESTED:
+            eq_(run['is_active'], True)
+            eq_(run['suggested_shortrev'],
+                self.latest_run.revisions.all()[0].shortrev)
+            eq_(run['suggest_class'],
+                'error' if self.latest_run.errors else
+                'warning' if self.latest_run.allmissing else 'success')
+            eq_(run['suggest_glyph'],
+                'bolt' if self.latest_run.errors else
+                'graph' if self.latest_run.allmissing else 'badge')
+        else:
+            eq_(run['suggested_shortrev'], None)
+            eq_(run['suggest_class'], None)
+            eq_(run['suggest_glyph'], None)
+        signed = [a for a in (run.actions or []) if a.flag_name == 'accepted']
+        eq_(len(signed), 0)
+        if flags & self.REJECTED:
+            pass
+        # TODO: Test more actions
+        # TODO: Fallback
+
+
+class TeamSnippetTest(TestCase, DataMixin, TeamSnippetProcessMixin):
     """Test the team page snippet data without fallbacks or migrations.
     """
 
@@ -219,42 +256,9 @@ def setUp(self):
     def check_runs_and_get(self, runs):
         """Subclass this if you run these tests on more than one run."""
         eq_(len(runs), 1)
+        eq_(runs[0]['tree'], self.tree)
         return runs[0]
 
-    def process(self, flags):
-        context = teamsnippet(self.locale, [])['context']
-        ok_('applications' in context)
-        eq_(len(context['applications']), 1)
-        application, runs = context['applications'][0]
-        eq_(application, self.app)
-        run = self.check_runs_and_get(runs)
-        eq_(run['appversion'], self.av)
-        eq_(run['tree'], self.tree)
-        eq_(bool(run['is_active']), not(flags & self.NEEDS_UPDATE))
-        eq_(bool(run['accepted']),
-            bool(flags & self.HAS_SIGNOFF) or bool(self.fallback))
-        eq_(bool(run['under_review']), bool(flags & self.PENDING))
-        if flags & self.SUGGESTED:
-            eq_(run['is_active'], True)
-            eq_(run['suggested_shortrev'],
-                self.latest_run.revisions.all()[0].shortrev)
-            eq_(run['suggest_class'],
-                'error' if self.latest_run.errors else
-                'warning' if self.latest_run.allmissing else 'success')
-            eq_(run['suggest_glyph'],
-                'bolt' if self.latest_run.errors else
-                'graph' if self.latest_run.allmissing else 'badge')
-        else:
-            eq_(run['suggested_shortrev'], None)
-            eq_(run['suggest_class'], None)
-            eq_(run['suggest_glyph'], None)
-        signed = [a for a in (run.actions or []) if a.flag_name == 'accepted']
-        eq_(len(signed), 0)
-        if flags & self.REJECTED:
-            pass
-        # TODO: Test more actions
-        # TODO: Fallback
-
     def test_no_progress(self):
         self.process(self.NEEDS_UPDATE)
 
@@ -409,7 +413,76 @@ def test_2nd_rejected_3rd_pending(self):
         self.process(self.REJECTED | self.PENDING)
 
 
-class TeamSnippetMigrationTest(TestCase, DataMixin):
+class StatusProcessMixin(object):
+    def process(self, flags):
+        view = StatusJSON(locales=[self.locale], trees=[], avs=[])
+        items = defaultdict(dict)
+        for item in view.get_data()[0]:
+            items[item['type']][item.get('id', item['label'])] = item
+        # de-defaultdict
+        items = dict(items.iteritems())
+        eq_(items['AppVer4Tree'], {self.tree.code: {
+            'type': 'AppVer4Tree',
+            'appversion': self.av.code,
+            'label': self.tree.code}})
+        self.check_runs(items['Build'])
+        if flags & (self.PENDING | self.HAS_SIGNOFF | self.REJECTED):
+            eq_(len(items['SignOff']), 1)
+            item = items['SignOff'][
+                '%s/%s' % (self.tree.code, self.locale.code)
+            ]
+            eq_(item['tree'], self.tree.code)
+            if flags & self.HAS_SIGNOFF:
+                eq_(item['state'], 'OK')
+                if flags & self.SUGGESTED:
+                    eq_(item['state_glyph'], 'graph')
+                else:
+                    eq_(item['state_glyph'], 'check')
+            else:
+                eq_(item['state'], None)
+                eq_(item['state_glyph'], '')
+            eq_('pending' in item['signoff'], bool(flags & self.PENDING))
+            eq_('accepted' in item['signoff'], bool(flags & self.HAS_SIGNOFF))
+            eq_('rejected' in item['signoff'], bool(flags & self.REJECTED))
+            signoffs = set(item['signoff'])
+            eq_(len(signoffs), len(item['signoff']))
+            eq_(signoffs - set(('pending', 'accepted', 'rejected')),
+                set([]))
+            if flags & (self.PENDING | self.REJECTED):
+                eq_('review' in item['action'], bool(flags & self.PENDING))
+                eq_('rejected' in item['action'], bool(flags & self.REJECTED))
+            else:
+                ok_('actions' not in item)
+        else:
+            ok_('SignOff' not in items)
+        if flags & (self.NEEDS_UPDATE | self.SUGGESTED):
+            eq_(len(items['NewPush']), 1)
+            item = items['NewPush'][
+                '%s/%s' % (self.tree.code, self.locale.code)
+            ]
+            if flags & self.SUGGESTED:
+                eq_(item['new_run'], 'sign off')
+            else:
+                ok_('new_run' not in item)
+            if flags & self.NEEDS_UPDATE:
+                eq_(item['needs_update'], True)
+            else:
+                ok_('needs_update' not in item)
+        else:
+            ok_('NewPush' not in items)
+
+
+
+class StatusTest(StatusProcessMixin, TeamSnippetTest, DataMixin):
+    """Test the dashboard status data without fallbacks or migrations.
+    """
+    def check_runs(self, runs):
+        eq_(len(runs), 1)
+        eq_(runs["%s/%s" % (self.tree.code, self.locale.code)]['tree'],
+            self.tree.code)
+
+
+class TeamSnippetMigrationTestcases(DataMixin):
     '''Test for appversion with a migration
 
     Changes:          *   *   *    *   *
@@ -419,8 +492,8 @@ class TeamSnippetMigrationTest(TestCase, DataMixin):
 
     def setUp(self):
         self.base()
-        self.repo, self.tree = self.create_repo()
-        self.beta_repo, self.beta_tree = self.create_repo('beta')
+        self.aurora_repo, self.aurora_tree = self.create_repo()
+        self.repo, self.tree = self.create_repo('beta')
         self.av = AppVersion.objects.create(
             app=self.app,
             version='1.0',
@@ -434,83 +507,77 @@ def setUp(self):
             accepts_signoffs=False,
             fallback=self.av
         )
-        changesets = self.add_changesets(self.repo, 5)
+        changesets = self.add_changesets(self.aurora_repo, 5)
         # set up both base and beta to have active runs
         # before we do appversions, just so that they're active
         current_push_date = self.now()
         push_id = itertools.count(1)
         beta_push_id = itertools.count(1)
         push = self.add_push(push_id, changesets[0],
+            repository=self.aurora_repo,
             push_date=current_push_date)
         self.add_run(
             push,
+            tree=self.aurora_tree,
             total=100,
             changed=80,
             completion=80
         )
         self.pushes = [push]
         betapush = self.add_push(beta_push_id, changesets[0],
-            repository=self.beta_repo,
+            repository=self.repo,
             push_date=current_push_date)
         self.add_run(
             betapush,
-            tree=self.beta_tree,
+            tree=self.tree,
             total=100,
             changed=80,
             completion=80
         )
         self.beta_pushes = [betapush]
-        self.pushes.append(self.add_push(push_id, changesets[1]))
-        self.pushes.append(self.add_push(push_id, changesets[2]))
+        self.pushes.append(self.add_push(push_id, changesets[1],
+            repository=self.aurora_repo))
+        self.pushes.append(self.add_push(push_id, changesets[2],
+            repository=self.aurora_repo))
         # MERGE DAY!
         avt1 = AppVersionTreeThrough.objects.create(
             start=self.now(),
-            tree=self.tree,
+            tree=self.aurora_tree,
             appversion=self.av,
             end=None,
         )
         avt2 = AppVersionTreeThrough.objects.create(
             start=self.now(),
-            tree=self.beta_tree,
+            tree=self.tree,
             appversion=self.av,
             end=None)
         AppVersionTreeThrough.objects.create(
             start=avt2.start,
-            tree=self.tree,
+            tree=self.aurora_tree,
             appversion=self.next_av,
             end=None)
         avt1.end = avt2.start
         avt1.save()
         self.beta_pushes.append(self.add_push(beta_push_id,
             changesets[1:3],
-            repository=self.beta_repo))
+            repository=self.repo))
         # post-merge work on beta, maybe
         self.beta_pushes.append(self.add_push(beta_push_id,
             changesets[3],
-            repository=self.beta_repo))
+            repository=self.repo))
         self.beta_pushes.append(self.add_push(beta_push_id,
             changesets[4],
-            repository=self.beta_repo))
+            repository=self.repo))
 
     def check_runs_and_get(self, runs):
         eq_(len(runs), 2)
         for run in runs:
             if run['appversion'] == self.av:
+                eq_(runs[0]['tree'], self.tree)
                 return run
 
-    def process(self, **run_details):
-        context = teamsnippet(self.locale, [])['context']
-        ok_('applications' in context)
-        eq_(len(context['applications']), 1)
-        application, runs = context['applications'][0]
-        eq_(application, self.app)
-        run = self.check_runs_and_get(runs)
-        for key, value in run_details.iteritems():
-            ok_(key in run)
-            eq_(run[key], value)
-
     def test_nothing(self):
-        self.process(is_active=None, suggest_class=None)
+        self.process(self.NEEDS_UPDATE)
 
     def test_good_on_merge(self):
         '''got a good run on the last changeset of base,
@@ -518,6 +585,7 @@ def test_good_on_merge(self):
         push = self.pushes[2]
         self.add_run(
             push,
+            tree=self.aurora_tree,
             total=100,
             changed=80,
             completion=80
@@ -526,16 +594,12 @@ def test_good_on_merge(self):
         beta_push = self.beta_pushes[1]
         self.add_run(
             beta_push,
-            tree=self.beta_tree,
+            tree=self.tree,
             total=100,
             changed=80,
             completion=80
         )
-        self.process(
-            is_active=True,
-            suggest_class=None,
-            suggest_glyph=None
-        )
+        self.process(self.HAS_SIGNOFF)
 
     def test_missing_on_merge(self):
         '''got a good run prior to the last changeset of base,
@@ -543,6 +607,7 @@ def test_missing_on_merge(self):
         push = self.pushes[1]
         self.add_run(
             push,
+            tree=self.aurora_tree,
             total=100,
             changed=80,
             completion=80
@@ -551,17 +616,12 @@ def test_missing_on_merge(self):
         beta_push = self.beta_pushes[1]
         self.add_run(
             beta_push,
-            tree=self.beta_tree,
+            tree=self.tree,
             total=100,
             changed=80,
             completion=80
         )
-        self.process(
-            is_active=True,
-            suggested_shortrev=beta_push.tip.shortrev,
-            suggest_class='success',
-            suggest_glyph='badge'
-        )
+        self.process(self.HAS_SIGNOFF | self.SUGGESTED)
 
     def test_good_on_merge_and_more(self):
         '''got a good run on the last changeset of base,
@@ -569,6 +629,7 @@ def test_good_on_merge_and_more(self):
         push = self.pushes[2]
         self.add_run(
             push,
+            tree=self.aurora_tree,
             total=100,
             changed=80,
             completion=80
@@ -577,7 +638,7 @@ def test_good_on_merge_and_more(self):
         beta_push = self.beta_pushes[1]
         self.add_run(
             beta_push,
-            tree=self.beta_tree,
+            tree=self.tree,
             total=100,
             changed=80,
             completion=80
@@ -585,17 +646,12 @@ def test_good_on_merge_and_more(self):
         beta_push = self.beta_pushes[2]
         self.add_run(
             beta_push,
-            tree=self.beta_tree,
+            tree=self.tree,
             total=100,
             changed=80,
             completion=80
         )
-        self.process(
-            is_active=True,
-            suggested_shortrev=beta_push.tip.shortrev,
-            suggest_class='success',
-            suggest_glyph='badge'
-        )
+        self.process(self.HAS_SIGNOFF | self.SUGGESTED)
 
     def test_missing_on_merge_and_more(self):
         '''got a good run prior to the last changeset of base,
@@ -603,6 +659,7 @@ def test_missing_on_merge_and_more(self):
         push = self.pushes[1]
         self.add_run(
             push,
+            tree=self.aurora_tree,
             total=100,
             changed=80,
             completion=80
@@ -611,7 +668,7 @@ def test_missing_on_merge_and_more(self):
         beta_push = self.beta_pushes[1]
         self.add_run(
             beta_push,
-            tree=self.beta_tree,
+            tree=self.tree,
             total=100,
             changed=80,
             completion=80
@@ -619,14 +676,27 @@ def test_missing_on_merge_and_more(self):
         beta_push = self.beta_pushes[2]
         self.add_run(
             beta_push,
-            tree=self.beta_tree,
+            tree=self.tree,
             total=100,
             changed=80,
             completion=80
         )
-        self.process(
-            is_active=True,
-            suggested_shortrev=beta_push.tip.shortrev,
-            suggest_class='success',
-            suggest_glyph='badge'
-        )
+        self.process(self.HAS_SIGNOFF | self.SUGGESTED)
+
+
+class TeamSnippetMigrationTest(
+        TeamSnippetMigrationTestcases,
+        TeamSnippetProcessMixin,
+        TestCase):
+    pass
+
+
+class StatusMigrationTest(StatusProcessMixin, TeamSnippetMigrationTestcases, DataMixin, TestCase):
+    """Test the dashboard status data without fallbacks or migrations.
+    """
+    def check_runs(self, runs):
+        eq_(len(runs), 2)
+        eq_(runs["%s/%s" % (self.aurora_tree.code, self.locale.code)]['tree'],
+            self.aurora_tree.code)
+        eq_(runs["%s/%s" % (self.tree.code, self.locale.code)]['tree'],
+            self.tree.code)
diff --git a/apps/shipping/views/status.py b/apps/shipping/views/status.py
index f7b4b284..d96de21f 100644
--- a/apps/shipping/views/status.py
+++ b/apps/shipping/views/status.py
@@ -8,10 +8,10 @@
 
 from django.http import HttpResponse, HttpResponseBadRequest
 from django.views.generic import View
-from life.models import Changeset, Locale
+from life.models import Changeset, Locale, Push
 from l10nstats.models import Run, ProgressPosition
 from shipping.api import accepted_signoffs, flags4appversions
-from shipping.models import (Milestone, Action,
+from shipping.models import (Milestone, Action, Signoff,
                              Application, AppVersion)
 from django.views.decorators.cache import cache_control
 from django.utils import simplejson
@@ -222,7 +222,9 @@ def toExhibit(d):
             result = 'success'
             tree = d['tree__code']
             locale = d['locale__code']
-            if missing or ('errors' in d and d['errors']):
+            if ('errors' in d and d['errors']):
+                result = 'error'
+            elif missing:
                 result = 'failure'
             elif d['obsolete']:
                 result = 'warnings'
@@ -247,33 +249,25 @@ def toExhibit(d):
             if 'obsolete' in d and d['obsolete']:
                 rd['obsolete'] = d['obsolete']
             return rd
-        return prog_pos_items + map(toExhibit, q.values(*leafs))
+        run_items = map(toExhibit, q.values(*leafs))
+        self.runids2tree = dict((d['runid'], d['tree']) for d in run_items)
+        return prog_pos_items + run_items
 
     def get_signoffs(self):
-        avq = defaultdict(set)
+        appversions_with_pushes = []
+        _treeid_to_avt = {}
+        tree_ids = {}
+        avts = (AppVersion.trees.through.objects
+            .current()
+            .filter(appversion__accepts_signoffs=True)
+        )
         if self.avs:
-            for appver in (AppVersion.objects
-                           .filter(code__in=self.avs).values('id')):
-                avq['id__in'].add(appver['id'])
+            avts = avts.filter(appversion__code__in=self.avs)
+        for avt in avts.select_related('appversion__app', 'tree__l10n'):
+            _treeid_to_avt[avt.tree.id] = avt
+            tree_ids[avt.tree.code] = avt.tree.id
 
-        if self.trees:
-            av_ids = (AppVersion.trees.through.objects
-                      .current()
-                .filter(tree__code__in=self.trees)
-                .values_list('appversion_id', flat=True))
-            avq['id__in'].update(av_ids)
-
-        # restrict avq to building appversions open to signoffs
-        currently_building = set(AppVersion.trees.through.objects
-                                 .current()
-                                 .filter(appversion__accepts_signoffs=True)
-                                 .values_list('appversion_id', flat=True))
-        if avq:
-            avq['id__in'] &= currently_building
-        else:
-            avq['id__in'] = currently_building
-
-        appvers = AppVersion.objects.filter(**avq)
+        appvers = [avt.appversion for avt in _treeid_to_avt.values()]
         locales = None
         if self.locales:
             locales = list(Locale.objects
@@ -281,31 +275,130 @@ def get_signoffs(self):
                 .values_list('id', flat=True))
 
         locflags4av = flags4appversions(appvers, locales=locales)
-        tree_avs = (AppVersion.trees.through.objects
-                    .current()
-                    .filter(appversion__in=appvers))
-        av2tree = dict(tree_avs.values_list("appversion__code", "tree__code"))
+        av2tree = dict((avt.appversion.code, avt.tree.code)
+            for avt in _treeid_to_avt.itervalues())
         values = dict(Action._meta.get_field('flag').flatchoices)
         so_items = {}
+        actions = {}
         for av in appvers:
             for loc, (real_av, flags) in locflags4av[av].iteritems():
                 flag_values = [
                     (real_av == av.code or f != Action.ACCEPTED) and values[f]
                     or real_av
                     for f in flags]
-                so_items[(av2tree[av.code], loc)] = flag_values
+                item = {
+                    'flags': flag_values,
+                    'state': None,
+                    'action': []
+                }
+                if Action.ACCEPTED in flags:
+                    item['state'] = (real_av == av.code) and 'OK' or real_av
+                if Action.REJECTED in flags:
+                    item['action'].append('rejected')
+                if Action.PENDING in flags:
+                    item['action'].append('review')
+                so_items[(av2tree[av.code], loc)] = item
+                for flag, action in flags.items():
+                    if real_av == av.code or flag == Action.PENDING:
+                        actions[action] = [av, loc]
+        for action, signoff, push_date in (Action.objects
+            .filter(id__in = actions.keys())
+            .values_list('id', 'signoff', 'signoff__push__push_date')):
+                actions[action] += [signoff, push_date]
+        last_action = {}
+        last_signoff = {}
+        for action, (av, loc, signoff, push_date) in sorted(
+                actions.iteritems(),
+                key=lambda t: t[1][3],
+                reverse=True):
+            if (av, loc) in last_action:
+                continue
+            last_action[(av, loc)] = push_date
+            last_signoff[(av, loc)] = signoff
+
+        runs_with_open_av = [run for run, tree in self.runids2tree.items()
+            if tree in tree_ids and _treeid_to_avt[tree_ids[tree]].appversion.accepts_signoffs]
+        changesets = dict((tuple(t[:2]), t[2])
+            for t in Run.revisions.through.objects
+            .filter(run__in=runs_with_open_av,
+                    changeset__repositories__locale__isnull=False)
+            .values_list('run__tree', 'run__locale__code', 'changeset'))
+        pushdates = dict((tuple(t[:2]), t[2])
+            for t in Push.changesets.through.objects
+            .filter(changeset__in=set(changesets.values()))
+            .values_list('changeset', 'push__repository__forest', 'push__push_date'))
+        avl_has_new_run = set()
+        maybe_new_run = []
+        for (treeid, locale_code), changeset in changesets.iteritems():
+            avt = _treeid_to_avt[treeid]
+            push_date = pushdates[(changeset, avt.tree.l10n.id)]
+            if avt.start and push_date < avt.start:
+                # need update
+                appversions_with_pushes.append({
+                    "needs_update": True,
+                    "type": "NewPush",
+                    "label": avt.tree.code  + '/' + locale_code
+                })
+                continue
+            if avt.end and push_date > avt.end:
+                continue
+            if ((avt.appversion, locale_code) in last_action and
+                last_action[(avt.appversion, locale_code)] >= push_date):
+                    continue
+            maybe_new_run.append((avt.appversion, changeset, avt.tree.code,
+                locale_code, last_signoff.get((avt.appversion, locale_code))
+            ))
+
+        # find out if the sign-off is on the same revision as the last push
+        old_signoffs = filter(None, (t[4] for t in maybe_new_run))
+        signoffs_to_skip = set()
+        if old_signoffs:
+            so_tips = dict(Signoff.objects
+                .filter(id__in=old_signoffs)
+                .annotate(cs=Max("push__changesets"))
+                .values_list('id', 'cs'))
+            latest_changeset = dict((t[4], t[1]) for t in maybe_new_run)
+            for so_id, tip in so_tips.iteritems():
+                if latest_changeset[so_id] == tip:
+                    signoffs_to_skip.add(so_id)
+        for av, changeset, tree_code, locale_code, last_so in maybe_new_run:
+            if last_so in signoffs_to_skip:
+                continue
+            avl_has_new_run.add((tree_code, locale_code))
+            appversions_with_pushes.append({
+                "new_run": "sign off",
+                "type": "NewPush",
+                "label": tree_code + '/' + locale_code
+            })
 
         # make a list now
-        items = [{"type": "SignOff",
-                  "label": "%s/%s" % (tree, locale),
-                  "tree": tree,
-                  "signoff": sorted(values)}
-                 for (tree, locale), values in sorted(so_items.iteritems(),
-                                                      key=lambda t:t[0])]
+        items = []
+        for (tree, locale), values in sorted(so_items.iteritems(),
+                                             key=lambda t:t[0]):
+            glyph = ''
+            if values['state'] == 'OK':
+                glyph = 'check'
+                if (tree, locale) in avl_has_new_run:
+                    glyph = 'graph'
+            elif values['state']:
+                glyph = 'warning'
+            item = {
+                "type": "SignOff",
+                "label": "%s/%s" % (tree, locale),
+                "tree": tree,
+                "state": values['state'],
+                "state_glyph": glyph,
+                "signoff": sorted(values['flags'])
+            }
+            if values['action']:
+                item['action'] = values['action']
+            items.append(item)
+
         items += [{"type": "AppVer4Tree",
                    "label": tree,
                    "appversion": av}
                   for av, tree in av2tree.iteritems()]
+        items += appversions_with_pushes
         return items
 
     def content(self, request, items):