But actually do it tho.

src/git-repository-async.js

@@ -783,12 +783,17 @@ export default class GitRepositoryAsync {
 
   // Get the current branch and update this.branch.
   //
-  // Returns a {Promise} which resolves to the {String} branch name.
+  // Returns a {Promise} which resolves to a {boolean} indicating whether the
+  // branch name changed.
   _refreshBranch () {
     return this.getRepo()
       .then(repo => repo.getCurrentBranch())
       .then(ref => ref.name())
-      .then(branchName => this.branch = branchName)
+      .then(branchName => {
+        const changed = branchName !== this.branch
+        this.branch = branchName
+        return changed
+      })
   }
 
   // Refresh the cached ahead/behind count with the given branch.
@@ -796,10 +801,15 @@ export default class GitRepositoryAsync {
   // * `branchName` The {String} name of the branch whose ahead/behind should be
   //                used for the refresh.
   //
-  // Returns a {Promise} which will resolve to {null}.
+  // Returns a {Promise} which will resolve to a {boolean} indicating whether
+  // the ahead/behind count changed.
   _refreshAheadBehindCount (branchName) {
     return this.getAheadBehindCount(branchName)
-      .then(counts => this.upstream = counts)
+      .then(counts => {
+        const changed = !_.isEqual(counts, this.upstream)
+        this.upstream = counts
+        return changed
+      })
   }
 
   // Get the status for this repository.
@@ -905,15 +915,15 @@ export default class GitRepositoryAsync {
 
   // Refresh the cached status.
   //
-  // Returns a {Promise} which will resolve to {null}.
+  // Returns a {Promise} which will resolve to a {boolean} indicating whether
+  // any statuses changed.
   _refreshStatus () {
     return Promise.all([this._getRepositoryStatus(), this._getSubmoduleStatuses()])
       .then(([repositoryStatus, submoduleStatus]) => {
         const statusesByPath = _.extend({}, repositoryStatus, submoduleStatus)
-        if (!_.isEqual(this.pathStatusCache, statusesByPath) && this.emitter != null) {
-          this.emitter.emit('did-change-statuses')
-        }
+        const changed = !_.isEqual(this.pathStatusCache, statusesByPath)
         this.pathStatusCache = statusesByPath
+        return changed
       })
   }
 
@@ -927,7 +937,13 @@ export default class GitRepositoryAsync {
 
     this._refreshingPromise = this._refreshingPromise.then(_ => {
       return Promise.all([status, branch, aheadBehind])
-        .then(_ => null)
+        .then(([statusChanged, branchChanged, aheadBehindChanged]) => {
+          if (this.emitter && (statusChanged || branchChanged || aheadBehindChanged)) {
+            this.emitter.emit('did-change-statuses')
+          }
+
+          return null
+        })
         // Because all these refresh steps happen asynchronously, it's entirely
         // possible the repository was destroyed while we were working. In which
         // case we should just swallow the error.