diff --git a/src/applications/audit/constants/PhabricatorAuditCommitStatusConstants.php b/src/applications/audit/constants/PhabricatorAuditCommitStatusConstants.php
index 877fd0b4ba..e559862c83 100644
--- a/src/applications/audit/constants/PhabricatorAuditCommitStatusConstants.php
+++ b/src/applications/audit/constants/PhabricatorAuditCommitStatusConstants.php
@@ -1,96 +1,140 @@
 <?php
 
 final class PhabricatorAuditCommitStatusConstants extends Phobject {
 
+  private $key;
+  private $spec = array();
+
   const NONE                = 0;
   const NEEDS_AUDIT         = 1;
   const CONCERN_RAISED      = 2;
   const PARTIALLY_AUDITED   = 3;
   const FULLY_AUDITED       = 4;
   const NEEDS_VERIFICATION = 5;
 
   const MODERN_NONE = 'none';
   const MODERN_NEEDS_AUDIT = 'needs-audit';
   const MODERN_CONCERN_RAISED = 'concern-raised';
   const MODERN_PARTIALLY_AUDITED = 'partially-audited';
   const MODERN_AUDITED = 'audited';
   const MODERN_NEEDS_VERIFICATION = 'needs-verification';
 
+  public static function newForLegacyStatus($status) {
+    $map = self::getMap();
+
+    foreach ($map as $key => $spec) {
+      if (idx($spec, 'legacy') == $status) {
+        return self::newForStatus($key);
+      }
+    }
+
+    return self::newForStatus($status);
+  }
+
+  public static function newForStatus($status) {
+    $result = new self();
+
+    $result->key = $status;
+
+    $map = self::getMap();
+    if (isset($map[$status])) {
+      $result->spec = $map[$status];
+    }
+
+    return $result;
+  }
+
+  public function getKey() {
+    return $this->key;
+  }
+
+  public function getIcon() {
+    return idx($this->spec, 'icon');
+  }
+
+  public function getColor() {
+    return idx($this->spec, 'color');
+  }
+
+  public function getName() {
+    return idx($this->spec, 'name', pht('Unknown ("%s")', $this->key));
+  }
+
   public static function getStatusNameMap() {
     $map = self::getMap();
     return ipull($map, 'name', 'legacy');
   }
 
   public static function getStatusName($code) {
     return idx(self::getStatusNameMap(), $code, pht('Unknown'));
   }
 
   public static function getOpenStatusConstants() {
     $constants = array();
     foreach (self::getMap() as $map) {
       if (!$map['closed']) {
         $constants[] = $map['legacy'];
       }
     }
     return $constants;
   }
 
   public static function getStatusColor($code) {
     $map = self::getMap();
     $map = ipull($map, 'color', 'legacy');
     return idx($map, $code);
   }
 
   public static function getStatusIcon($code) {
     $map = self::getMap();
     $map = ipull($map, 'icon', 'legacy');
     return idx($map, $code);
   }
 
   private static function getMap() {
     return array(
       self::MODERN_NONE => array(
         'name' => pht('No Audits'),
         'legacy' => self::NONE,
         'icon' => 'fa-check',
         'color' => 'bluegrey',
         'closed' => true,
       ),
       self::MODERN_NEEDS_AUDIT => array(
         'name' => pht('Audit Required'),
         'legacy' => self::NEEDS_AUDIT,
         'icon' => 'fa-exclamation-circle',
         'color' => 'orange',
         'closed' => false,
       ),
       self::MODERN_CONCERN_RAISED => array(
         'name' => pht('Concern Raised'),
         'legacy' => self::CONCERN_RAISED,
         'icon' => 'fa-times-circle',
         'color' => 'red',
         'closed' => false,
       ),
       self::MODERN_PARTIALLY_AUDITED => array(
         'name' => pht('Partially Audited'),
         'legacy' => self::PARTIALLY_AUDITED,
         'icon' => 'fa-check-circle-o',
         'color' => 'yellow',
         'closed' => false,
       ),
       self::MODERN_AUDITED => array(
         'name' => pht('Audited'),
         'legacy' => self::FULLY_AUDITED,
         'icon' => 'fa-check-circle',
         'color' => 'green',
         'closed' => true,
       ),
       self::MODERN_NEEDS_VERIFICATION => array(
         'name' => pht('Needs Verification'),
         'legacy' => self::NEEDS_VERIFICATION,
         'icon' => 'fa-refresh',
         'color' => 'indigo',
         'closed' => false,
       ),
     );
   }
 }
diff --git a/src/applications/audit/management/PhabricatorAuditSynchronizeManagementWorkflow.php b/src/applications/audit/management/PhabricatorAuditSynchronizeManagementWorkflow.php
index db6ce096c4..96d06e65c2 100644
--- a/src/applications/audit/management/PhabricatorAuditSynchronizeManagementWorkflow.php
+++ b/src/applications/audit/management/PhabricatorAuditSynchronizeManagementWorkflow.php
@@ -1,60 +1,58 @@
 <?php
 
 final class PhabricatorAuditSynchronizeManagementWorkflow
   extends PhabricatorAuditManagementWorkflow {
 
   protected function didConstruct() {
     $this
       ->setName('synchronize')
       ->setExamples('**synchronize** ...')
       ->setSynopsis(pht('Update audit status for commits.'))
       ->setArguments(
         array_merge(
           $this->getCommitConstraintArguments(),
           array()));
   }
 
   public function execute(PhutilArgumentParser $args) {
     $viewer = $this->getViewer();
     $objects = $this->loadCommitsWithConstraints($args);
 
     foreach ($objects as $object) {
       $commits = $this->loadCommitsForConstraintObject($object);
       foreach ($commits as $commit) {
         $commit = id(new DiffusionCommitQuery())
           ->setViewer($viewer)
           ->withPHIDs(array($commit->getPHID()))
           ->needAuditRequests(true)
           ->executeOne();
         if (!$commit) {
           continue;
         }
 
-        $old_status = $commit->getAuditStatus();
+        $old_status = $commit->getAuditStatusObject();
         $commit->updateAuditStatus($commit->getAudits());
-        $new_status = $commit->getAuditStatus();
+        $new_status = $commit->getAuditStatusObject();
 
-        if ($old_status == $new_status) {
+        if ($old_status->getKey() == $new_status->getKey()) {
           echo tsprintf(
             "%s\n",
             pht(
               'No changes for "%s".',
               $commit->getDisplayName()));
         } else {
           echo tsprintf(
             "%s\n",
             pht(
               'Updating "%s": "%s" -> "%s".',
               $commit->getDisplayName(),
-              PhabricatorAuditCommitStatusConstants::getStatusName(
-                $old_status),
-              PhabricatorAuditCommitStatusConstants::getStatusName(
-                $new_status)));
+              $old_status->getName(),
+              $new_status->getName()));
 
           $commit->save();
         }
       }
     }
   }
 
 }
diff --git a/src/applications/audit/view/PhabricatorAuditListView.php b/src/applications/audit/view/PhabricatorAuditListView.php
index cb9fecac3a..fb56e7cd55 100644
--- a/src/applications/audit/view/PhabricatorAuditListView.php
+++ b/src/applications/audit/view/PhabricatorAuditListView.php
@@ -1,182 +1,179 @@
 <?php
 
 final class PhabricatorAuditListView extends AphrontView {
 
   private $commits = array();
   private $header;
   private $showDrafts;
   private $noDataString;
   private $highlightedAudits;
 
   public function setNoDataString($no_data_string) {
     $this->noDataString = $no_data_string;
     return $this;
   }
 
   public function getNoDataString() {
     return $this->noDataString;
   }
 
   public function setHeader($header) {
     $this->header = $header;
     return $this;
   }
 
   public function getHeader() {
     return $this->header;
   }
 
   public function setShowDrafts($show_drafts) {
     $this->showDrafts = $show_drafts;
     return $this;
   }
 
   public function getShowDrafts() {
     return $this->showDrafts;
   }
 
   /**
    * These commits should have both commit data and audit requests attached.
    */
   public function setCommits(array $commits) {
     assert_instances_of($commits, 'PhabricatorRepositoryCommit');
     $this->commits = mpull($commits, null, 'getPHID');
     return $this;
   }
 
   public function getCommits() {
     return $this->commits;
   }
 
   private function getCommitDescription($phid) {
     if ($this->commits === null) {
       return pht('(Unknown Commit)');
     }
 
     $commit = idx($this->commits, $phid);
     if (!$commit) {
       return pht('(Unknown Commit)');
     }
 
     $summary = $commit->getCommitData()->getSummary();
     if (strlen($summary)) {
       return $summary;
     }
 
     // No summary, so either this is still importing or just has an empty
     // commit message.
 
     if (!$commit->isImported()) {
       return pht('(Importing Commit...)');
     } else {
       return pht('(Untitled Commit)');
     }
   }
 
   public function render() {
     $list = $this->buildList();
     $list->setFlush(true);
     return $list->render();
   }
 
   public function buildList() {
     $viewer = $this->getViewer();
     $rowc = array();
 
     $phids = array();
     foreach ($this->getCommits() as $commit) {
       $phids[] = $commit->getPHID();
 
       foreach ($commit->getAudits() as $audit) {
         $phids[] = $audit->getAuditorPHID();
       }
 
       $author_phid = $commit->getAuthorPHID();
       if ($author_phid) {
         $phids[] = $author_phid;
       }
     }
 
     $handles = $viewer->loadHandles($phids);
 
     $show_drafts = $this->getShowDrafts();
 
     $draft_icon = id(new PHUIIconView())
       ->setIcon('fa-comment yellow')
       ->addSigil('has-tooltip')
       ->setMetadata(
         array(
           'tip' => pht('Unsubmitted Comments'),
         ));
 
     $list = new PHUIObjectItemListView();
     foreach ($this->commits as $commit) {
       $commit_phid = $commit->getPHID();
       $commit_handle = $handles[$commit_phid];
       $committed = null;
 
       $commit_name = $commit_handle->getName();
       $commit_link = $commit_handle->getURI();
       $commit_desc = $this->getCommitDescription($commit_phid);
       $committed = phabricator_datetime($commit->getEpoch(), $viewer);
 
-      $status = $commit->getAuditStatus();
-
-      $status_text =
-        PhabricatorAuditCommitStatusConstants::getStatusName($status);
-      $status_color =
-        PhabricatorAuditCommitStatusConstants::getStatusColor($status);
-      $status_icon =
-        PhabricatorAuditCommitStatusConstants::getStatusIcon($status);
+      $status = $commit->getAuditStatusObject();
+
+      $status_text = $status->getName();
+      $status_color = $status->getColor();
+      $status_icon = $status->getIcon();
 
       $author_phid = $commit->getAuthorPHID();
       if ($author_phid) {
         $author_name = $handles[$author_phid]->renderLink();
       } else {
         $author_name = $commit->getCommitData()->getAuthorName();
       }
 
       $item = id(new PHUIObjectItemView())
         ->setObjectName($commit_name)
         ->setHeader($commit_desc)
         ->setHref($commit_link)
         ->setDisabled($commit->isUnreachable())
         ->addByline(pht('Author: %s', $author_name))
         ->addIcon('none', $committed);
 
       if ($show_drafts) {
         if ($commit->getHasDraft($viewer)) {
           $item->addAttribute($draft_icon);
         }
       }
 
       $audits = $commit->getAudits();
       $auditor_phids = mpull($audits, 'getAuditorPHID');
       if ($auditor_phids) {
         $auditor_list = $handles->newSublist($auditor_phids)
           ->renderList()
           ->setAsInline(true);
       } else {
         $auditor_list = phutil_tag('em', array(), pht('None'));
       }
       $item->addAttribute(pht('Auditors: %s', $auditor_list));
 
       if ($status_color) {
         $item->setStatusIcon($status_icon.' '.$status_color, $status_text);
       }
 
       $list->addItem($item);
     }
 
     if ($this->noDataString) {
       $list->setNoDataString($this->noDataString);
     }
 
     if ($this->header) {
       $list->setHeader($this->header);
     }
 
     return $list;
   }
 
 }
diff --git a/src/applications/diffusion/view/DiffusionHistoryTableView.php b/src/applications/diffusion/view/DiffusionHistoryTableView.php
index 3885bbf47c..cfd7019679 100644
--- a/src/applications/diffusion/view/DiffusionHistoryTableView.php
+++ b/src/applications/diffusion/view/DiffusionHistoryTableView.php
@@ -1,196 +1,196 @@
 <?php
 
 final class DiffusionHistoryTableView extends DiffusionHistoryView {
 
   public function render() {
     $drequest = $this->getDiffusionRequest();
 
     $viewer = $this->getUser();
 
     $buildables = $this->loadBuildables(
       mpull($this->getHistory(), 'getCommit'));
     $has_any_build = false;
 
     $show_revisions = PhabricatorApplication::isClassInstalledForViewer(
       'PhabricatorDifferentialApplication',
       $viewer);
 
     $handles = $viewer->loadHandles($this->getRequiredHandlePHIDs());
 
     $graph = null;
     if ($this->getParents()) {
       $parents = $this->getParents();
 
       // If we're filtering parents, remove relationships which point to
       // commits that are not part of the visible graph. Otherwise, we get
       // a big tree of nonsense when viewing release branches like "stable"
       // versus "master".
       if ($this->getFilterParents()) {
         foreach ($parents as $key => $nodes) {
           foreach ($nodes as $nkey => $node) {
             if (empty($parents[$node])) {
               unset($parents[$key][$nkey]);
             }
           }
         }
       }
 
       $graph = id(new PHUIDiffGraphView())
         ->setIsHead($this->getIsHead())
         ->setIsTail($this->getIsTail())
         ->renderGraph($parents);
     }
 
     $show_builds = PhabricatorApplication::isClassInstalledForViewer(
       'PhabricatorHarbormasterApplication',
       $this->getUser());
 
     $rows = array();
     $ii = 0;
     foreach ($this->getHistory() as $history) {
       $epoch = $history->getEpoch();
 
       if ($epoch) {
         $committed = $viewer->formatShortDateTime($epoch);
       } else {
         $committed = null;
       }
 
       $data = $history->getCommitData();
       $author_phid = $committer = $committer_phid = null;
       if ($data) {
         $author_phid = $data->getCommitDetail('authorPHID');
         $committer_phid = $data->getCommitDetail('committerPHID');
         $committer = $data->getCommitDetail('committer');
       }
 
       if ($author_phid && isset($handles[$author_phid])) {
         $author = $handles[$author_phid]->renderLink();
       } else {
         $author = self::renderName($history->getAuthorName());
       }
 
       $different_committer = false;
       if ($committer_phid) {
         $different_committer = ($committer_phid != $author_phid);
       } else if ($committer != '') {
         $different_committer = ($committer != $history->getAuthorName());
       }
       if ($different_committer) {
         if ($committer_phid && isset($handles[$committer_phid])) {
           $committer = $handles[$committer_phid]->renderLink();
         } else {
           $committer = self::renderName($committer);
         }
         $author = hsprintf('%s/%s', $author, $committer);
       }
 
       // We can show details once the message and change have been imported.
       $partial_import = PhabricatorRepositoryCommit::IMPORTED_MESSAGE |
                         PhabricatorRepositoryCommit::IMPORTED_CHANGE;
 
       $commit = $history->getCommit();
       if ($commit && $commit->isPartiallyImported($partial_import) && $data) {
         $summary = AphrontTableView::renderSingleDisplayLine(
           $history->getSummary());
       } else {
         $summary = phutil_tag('em', array(), pht("Importing\xE2\x80\xA6"));
       }
 
       $build = null;
       if ($show_builds) {
         $buildable = idx($buildables, $commit->getPHID());
         if ($buildable !== null) {
           $build = $this->renderBuildable($buildable);
           $has_any_build = true;
         }
       }
 
       $browse = $this->linkBrowse(
         $history->getPath(),
         array(
           'commit' => $history->getCommitIdentifier(),
           'branch' => $drequest->getBranch(),
           'type' => $history->getFileType(),
         ));
 
-      $status = $commit->getAuditStatus();
-      $icon = PhabricatorAuditCommitStatusConstants::getStatusIcon($status);
-      $color = PhabricatorAuditCommitStatusConstants::getStatusColor($status);
-      $name = PhabricatorAuditCommitStatusConstants::getStatusName($status);
+      $status = $commit->getAuditStatusObject();
+      $icon = $status->getIcon();
+      $color = $status->getColor();
+      $name = $status->getName();
 
       $audit_view = id(new PHUIIconView())
         ->setIcon($icon, $color)
         ->addSigil('has-tooltip')
         ->setMetadata(
           array(
             'tip' => $name,
           ));
 
       $rows[] = array(
         $graph ? $graph[$ii++] : null,
         $browse,
         self::linkCommit(
           $drequest->getRepository(),
           $history->getCommitIdentifier()),
         $build,
         $audit_view,
         ($commit ?
           self::linkRevision(idx($this->getRevisions(), $commit->getPHID())) :
           null),
         $author,
         $summary,
         $committed,
       );
     }
 
     $view = new AphrontTableView($rows);
     $view->setHeaders(
       array(
         null,
         null,
         pht('Commit'),
         null,
         null,
         null,
         pht('Author'),
         pht('Details'),
         pht('Committed'),
       ));
     $view->setColumnClasses(
       array(
         'threads',
         'nudgeright',
         '',
         'icon',
         'icon',
         '',
         '',
         'wide',
         'right',
       ));
     $view->setColumnVisibility(
       array(
         $graph ? true : false,
         true,
         true,
         $has_any_build,
         true,
         $show_revisions,
       ));
     $view->setDeviceVisibility(
       array(
         $graph ? true : false,
         true,
         true,
         true,
         true,
         true,
         false,
         true,
         false,
       ));
     return $view->render();
   }
 
 }
diff --git a/src/applications/repository/phid/PhabricatorRepositoryCommitPHIDType.php b/src/applications/repository/phid/PhabricatorRepositoryCommitPHIDType.php
index b5abd40032..c37bdc04f9 100644
--- a/src/applications/repository/phid/PhabricatorRepositoryCommitPHIDType.php
+++ b/src/applications/repository/phid/PhabricatorRepositoryCommitPHIDType.php
@@ -1,127 +1,127 @@
 <?php
 
 final class PhabricatorRepositoryCommitPHIDType extends PhabricatorPHIDType {
 
   const TYPECONST = 'CMIT';
 
   public function getTypeName() {
     return pht('Diffusion Commit');
   }
 
   public function newObject() {
     return new PhabricatorRepositoryCommit();
   }
 
   public function getPHIDTypeApplicationClass() {
     return 'PhabricatorDiffusionApplication';
   }
 
   protected function buildQueryForObjects(
     PhabricatorObjectQuery $query,
     array $phids) {
 
     return id(new DiffusionCommitQuery())
       ->withPHIDs($phids);
   }
 
   public function loadHandles(
     PhabricatorHandleQuery $query,
     array $handles,
     array $objects) {
 
     $unreachable = array();
     foreach ($handles as $phid => $handle) {
       $commit = $objects[$phid];
       if ($commit->isUnreachable()) {
         $unreachable[$phid] = $commit;
       }
     }
 
     if ($unreachable) {
       $query = id(new DiffusionCommitHintQuery())
         ->setViewer($query->getViewer())
         ->withCommits($unreachable);
 
       $query->execute();
 
       $hints = $query->getCommitMap();
     } else {
       $hints = array();
     }
 
     foreach ($handles as $phid => $handle) {
       $commit = $objects[$phid];
       $repository = $commit->getRepository();
       $commit_identifier = $commit->getCommitIdentifier();
 
       $name = $repository->formatCommitName($commit_identifier);
 
       if ($commit->isUnreachable()) {
         $handle->setStatus(PhabricatorObjectHandle::STATUS_CLOSED);
 
         // If we have a hint about this commit being rewritten, add the
         // rewrite target to the handle name. This reduces the chance users
         // will be caught offguard by the rewrite.
         $hint = idx($hints, $phid);
         if ($hint && $hint->isRewritten()) {
           $new_name = $hint->getNewCommitIdentifier();
           $new_name = $repository->formatCommitName($new_name);
           $name = pht("%s \xE2\x99\xBB %s",  $name, $new_name);
         }
       }
 
       $summary = $commit->getSummary();
       if (strlen($summary)) {
         $full_name = $name.': '.$summary;
       } else {
         $full_name = $name;
       }
 
       $handle->setName($name);
       $handle->setFullName($full_name);
       $handle->setURI($commit->getURI());
       $handle->setTimestamp($commit->getEpoch());
 
-      $status = $commit->getAuditStatus();
-      $icon = PhabricatorAuditCommitStatusConstants::getStatusIcon($status);
-      $color = PhabricatorAuditCommitStatusConstants::getStatusColor($status);
-      $name = PhabricatorAuditCommitStatusConstants::getStatusName($status);
+      $status = $commit->getAuditStatusObject();
+      $icon = $status->getIcon();
+      $color = $status->getColor();
+      $name = $status->getName();
 
       $handle
         ->setStateIcon($icon)
         ->setStateColor($color)
         ->setStateName($name);
     }
   }
 
   public static function getCommitObjectNamePattern() {
     $min_unqualified = PhabricatorRepository::MINIMUM_UNQUALIFIED_HASH;
     $min_qualified   = PhabricatorRepository::MINIMUM_QUALIFIED_HASH;
 
     return
       '(?:r[A-Z]+:?|R[0-9]+:)[1-9]\d*'.
       '|'.
       '(?:r[A-Z]+:?|R[0-9]+:)[a-f0-9]{'.$min_qualified.',40}'.
       '|'.
       '[a-f0-9]{'.$min_unqualified.',40}';
   }
 
   public function canLoadNamedObject($name) {
     $pattern = self::getCommitObjectNamePattern();
     return preg_match('(^'.$pattern.'$)', $name);
   }
 
   public function loadNamedObjects(
     PhabricatorObjectQuery $query,
     array $names) {
 
     $query = id(new DiffusionCommitQuery())
       ->setViewer($query->getViewer())
       ->withIdentifiers($names);
 
     $query->execute();
 
     return $query->getIdentifierMap();
   }
 
 }
diff --git a/src/applications/repository/storage/PhabricatorRepositoryCommit.php b/src/applications/repository/storage/PhabricatorRepositoryCommit.php
index f36869686f..447db08e6c 100644
--- a/src/applications/repository/storage/PhabricatorRepositoryCommit.php
+++ b/src/applications/repository/storage/PhabricatorRepositoryCommit.php
@@ -1,861 +1,866 @@
 <?php
 
 final class PhabricatorRepositoryCommit
   extends PhabricatorRepositoryDAO
   implements
     PhabricatorPolicyInterface,
     PhabricatorFlaggableInterface,
     PhabricatorProjectInterface,
     PhabricatorTokenReceiverInterface,
     PhabricatorSubscribableInterface,
     PhabricatorMentionableInterface,
     HarbormasterBuildableInterface,
     HarbormasterCircleCIBuildableInterface,
     HarbormasterBuildkiteBuildableInterface,
     PhabricatorCustomFieldInterface,
     PhabricatorApplicationTransactionInterface,
     PhabricatorFulltextInterface,
     PhabricatorFerretInterface,
     PhabricatorConduitResultInterface,
     PhabricatorDraftInterface {
 
   protected $repositoryID;
   protected $phid;
   protected $authorIdentityPHID;
   protected $committerIdentityPHID;
   protected $commitIdentifier;
   protected $epoch;
   protected $mailKey;
   protected $authorPHID;
   protected $auditStatus = PhabricatorAuditCommitStatusConstants::NONE;
   protected $summary = '';
   protected $importStatus = 0;
 
   const IMPORTED_MESSAGE = 1;
   const IMPORTED_CHANGE = 2;
   const IMPORTED_OWNERS = 4;
   const IMPORTED_HERALD = 8;
   const IMPORTED_ALL = 15;
 
   const IMPORTED_CLOSEABLE = 1024;
   const IMPORTED_UNREACHABLE = 2048;
 
   private $commitData = self::ATTACHABLE;
   private $audits = self::ATTACHABLE;
   private $repository = self::ATTACHABLE;
   private $customFields = self::ATTACHABLE;
   private $authorIdentity = self::ATTACHABLE;
   private $committerIdentity = self::ATTACHABLE;
 
   private $drafts = array();
   private $auditAuthorityPHIDs = array();
 
   public function attachRepository(PhabricatorRepository $repository) {
     $this->repository = $repository;
     return $this;
   }
 
   public function getRepository($assert_attached = true) {
     if ($assert_attached) {
       return $this->assertAttached($this->repository);
     }
     return $this->repository;
   }
 
   public function isPartiallyImported($mask) {
     return (($mask & $this->getImportStatus()) == $mask);
   }
 
   public function isImported() {
     return $this->isPartiallyImported(self::IMPORTED_ALL);
   }
 
   public function isUnreachable() {
     return $this->isPartiallyImported(self::IMPORTED_UNREACHABLE);
   }
 
   public function writeImportStatusFlag($flag) {
     return $this->adjustImportStatusFlag($flag, true);
   }
 
   public function clearImportStatusFlag($flag) {
     return $this->adjustImportStatusFlag($flag, false);
   }
 
   private function adjustImportStatusFlag($flag, $set) {
     $conn_w = $this->establishConnection('w');
     $table_name = $this->getTableName();
     $id = $this->getID();
 
     if ($set) {
       queryfx(
         $conn_w,
         'UPDATE %T SET importStatus = (importStatus | %d) WHERE id = %d',
         $table_name,
         $flag,
         $id);
 
       $this->setImportStatus($this->getImportStatus() | $flag);
     } else {
       queryfx(
         $conn_w,
         'UPDATE %T SET importStatus = (importStatus & ~%d) WHERE id = %d',
         $table_name,
         $flag,
         $id);
 
       $this->setImportStatus($this->getImportStatus() & ~$flag);
     }
 
     return $this;
   }
 
   protected function getConfiguration() {
     return array(
       self::CONFIG_AUX_PHID   => true,
       self::CONFIG_TIMESTAMPS => false,
       self::CONFIG_COLUMN_SCHEMA => array(
         'commitIdentifier' => 'text40',
         'mailKey' => 'bytes20',
         'authorPHID' => 'phid?',
         'authorIdentityPHID' => 'phid?',
         'committerIdentityPHID' => 'phid?',
         'auditStatus' => 'uint32',
         'summary' => 'text255',
         'importStatus' => 'uint32',
       ),
       self::CONFIG_KEY_SCHEMA => array(
         'key_phid' => null,
         'phid' => array(
           'columns' => array('phid'),
           'unique' => true,
         ),
         'repositoryID' => array(
           'columns' => array('repositoryID', 'importStatus'),
         ),
         'authorPHID' => array(
           'columns' => array('authorPHID', 'auditStatus', 'epoch'),
         ),
         'repositoryID_2' => array(
           'columns' => array('repositoryID', 'epoch'),
         ),
         'key_commit_identity' => array(
           'columns' => array('commitIdentifier', 'repositoryID'),
           'unique' => true,
         ),
         'key_epoch' => array(
           'columns' => array('epoch'),
         ),
         'key_author' => array(
           'columns' => array('authorPHID', 'epoch'),
         ),
       ),
       self::CONFIG_NO_MUTATE => array(
         'importStatus',
       ),
     ) + parent::getConfiguration();
   }
 
   public function generatePHID() {
     return PhabricatorPHID::generateNewPHID(
       PhabricatorRepositoryCommitPHIDType::TYPECONST);
   }
 
   public function loadCommitData() {
     if (!$this->getID()) {
       return null;
     }
     return id(new PhabricatorRepositoryCommitData())->loadOneWhere(
       'commitID = %d',
       $this->getID());
   }
 
   public function attachCommitData(
     PhabricatorRepositoryCommitData $data = null) {
     $this->commitData = $data;
     return $this;
   }
 
   public function getCommitData() {
     return $this->assertAttached($this->commitData);
   }
 
   public function attachAudits(array $audits) {
     assert_instances_of($audits, 'PhabricatorRepositoryAuditRequest');
     $this->audits = $audits;
     return $this;
   }
 
   public function getAudits() {
     return $this->assertAttached($this->audits);
   }
 
   public function hasAttachedAudits() {
     return ($this->audits !== self::ATTACHABLE);
   }
 
   public function attachIdentities(
     PhabricatorRepositoryIdentity $author = null,
     PhabricatorRepositoryIdentity $committer = null) {
 
     $this->authorIdentity = $author;
     $this->committerIdentity = $committer;
 
     return $this;
   }
 
   public function getAuthorIdentity() {
     return $this->assertAttached($this->authorIdentity);
   }
 
   public function getCommitterIdentity() {
     return $this->assertAttached($this->committerIdentity);
   }
 
   public function loadAndAttachAuditAuthority(
     PhabricatorUser $viewer,
     $actor_phid = null) {
 
     if ($actor_phid === null) {
       $actor_phid = $viewer->getPHID();
     }
 
     // TODO: This method is a little weird and sketchy, but worlds better than
     // what came before it. Eventually, this should probably live in a Query
     // class.
 
     // Figure out which requests the actor has authority over: these are user
     // requests where they are the auditor, and packages and projects they are
     // a member of.
 
     if (!$actor_phid) {
       $attach_key = $viewer->getCacheFragment();
       $phids = array();
     } else {
       $attach_key = $actor_phid;
       // At least currently, when modifying your own commits, you act only on
       // behalf of yourself, not your packages/projects -- the idea being that
       // you can't accept your own commits. This may change or depend on
       // config.
       $actor_is_author = ($actor_phid == $this->getAuthorPHID());
       if ($actor_is_author) {
         $phids = array($actor_phid);
       } else {
         $phids = array();
         $phids[$actor_phid] = true;
 
         $owned_packages = id(new PhabricatorOwnersPackageQuery())
           ->setViewer($viewer)
           ->withAuthorityPHIDs(array($actor_phid))
           ->execute();
         foreach ($owned_packages as $package) {
           $phids[$package->getPHID()] = true;
         }
 
         $projects = id(new PhabricatorProjectQuery())
           ->setViewer($viewer)
           ->withMemberPHIDs(array($actor_phid))
           ->execute();
         foreach ($projects as $project) {
           $phids[$project->getPHID()] = true;
         }
 
         $phids = array_keys($phids);
       }
     }
 
     $this->auditAuthorityPHIDs[$attach_key] = array_fuse($phids);
 
     return $this;
   }
 
   public function hasAuditAuthority(
     PhabricatorUser $viewer,
     PhabricatorRepositoryAuditRequest $audit,
     $actor_phid = null) {
 
     if ($actor_phid === null) {
       $actor_phid = $viewer->getPHID();
     }
 
     if (!$actor_phid) {
       $attach_key = $viewer->getCacheFragment();
     } else {
       $attach_key = $actor_phid;
     }
 
     $map = $this->assertAttachedKey($this->auditAuthorityPHIDs, $attach_key);
 
     if (!$actor_phid) {
       return false;
     }
 
     return isset($map[$audit->getAuditorPHID()]);
   }
 
   public function writeOwnersEdges(array $package_phids) {
     $src_phid = $this->getPHID();
     $edge_type = DiffusionCommitHasPackageEdgeType::EDGECONST;
 
     $editor = new PhabricatorEdgeEditor();
 
     $dst_phids = PhabricatorEdgeQuery::loadDestinationPHIDs(
       $src_phid,
       $edge_type);
 
     foreach ($dst_phids as $dst_phid) {
       $editor->removeEdge($src_phid, $edge_type, $dst_phid);
     }
 
     foreach ($package_phids as $package_phid) {
       $editor->addEdge($src_phid, $edge_type, $package_phid);
     }
 
     $editor->save();
 
     return $this;
   }
 
   public function getAuditorPHIDsForEdit() {
     $audits = $this->getAudits();
     return mpull($audits, 'getAuditorPHID');
   }
 
   public function save() {
     if (!$this->mailKey) {
       $this->mailKey = Filesystem::readRandomCharacters(20);
     }
     return parent::save();
   }
 
   public function delete() {
     $data = $this->loadCommitData();
     $audits = id(new PhabricatorRepositoryAuditRequest())
       ->loadAllWhere('commitPHID = %s', $this->getPHID());
     $this->openTransaction();
 
       if ($data) {
         $data->delete();
       }
       foreach ($audits as $audit) {
         $audit->delete();
       }
       $result = parent::delete();
 
     $this->saveTransaction();
     return $result;
   }
 
   public function getDateCreated() {
     // This is primarily to make analysis of commits with the Fact engine work.
     return $this->getEpoch();
   }
 
   public function getURI() {
     return '/'.$this->getMonogram();
   }
 
   /**
    * Synchronize a commit's overall audit status with the individual audit
    * triggers.
    */
   public function updateAuditStatus(array $requests) {
     assert_instances_of($requests, 'PhabricatorRepositoryAuditRequest');
 
     $any_concern = false;
     $any_accept = false;
     $any_need = false;
 
     foreach ($requests as $request) {
       switch ($request->getAuditStatus()) {
         case PhabricatorAuditStatusConstants::AUDIT_REQUIRED:
         case PhabricatorAuditStatusConstants::AUDIT_REQUESTED:
           $any_need = true;
           break;
         case PhabricatorAuditStatusConstants::ACCEPTED:
           $any_accept = true;
           break;
         case PhabricatorAuditStatusConstants::CONCERNED:
           $any_concern = true;
           break;
       }
     }
 
     $current_status = $this->getAuditStatus();
     $status_verify = PhabricatorAuditCommitStatusConstants::NEEDS_VERIFICATION;
 
     if ($any_concern) {
       if ($current_status == $status_verify) {
         // If the change is in "Needs Verification", we keep it there as
         // long as any auditors still have concerns.
         $status = $status_verify;
       } else {
         $status = PhabricatorAuditCommitStatusConstants::CONCERN_RAISED;
       }
     } else if ($any_accept) {
       if ($any_need) {
         $status = PhabricatorAuditCommitStatusConstants::PARTIALLY_AUDITED;
       } else {
         $status = PhabricatorAuditCommitStatusConstants::FULLY_AUDITED;
       }
     } else if ($any_need) {
       $status = PhabricatorAuditCommitStatusConstants::NEEDS_AUDIT;
     } else {
       $status = PhabricatorAuditCommitStatusConstants::NONE;
     }
 
     return $this->setAuditStatus($status);
   }
 
   public function getMonogram() {
     $repository = $this->getRepository();
     $callsign = $repository->getCallsign();
     $identifier = $this->getCommitIdentifier();
     if ($callsign !== null) {
       return "r{$callsign}{$identifier}";
     } else {
       $id = $repository->getID();
       return "R{$id}:{$identifier}";
     }
   }
 
   public function getDisplayName() {
     $repository = $this->getRepository();
     $identifier = $this->getCommitIdentifier();
     return $repository->formatCommitName($identifier);
   }
 
   /**
    * Return a local display name for use in the context of the containing
    * repository.
    *
    * In Git and Mercurial, this returns only a short hash, like "abcdef012345".
    * See @{method:getDisplayName} for a short name that always includes
    * repository context.
    *
    * @return string Short human-readable name for use inside a repository.
    */
   public function getLocalName() {
     $repository = $this->getRepository();
     $identifier = $this->getCommitIdentifier();
     return $repository->formatCommitName($identifier, $local = true);
   }
 
   /**
    * Make a strong effort to find a way to render this commit's committer.
    * This currently attempts to use @{PhabricatorRepositoryIdentity}, and
    * falls back to examining the commit detail information. After we force
    * the migration to using identities, update this method to remove the
    * fallback. See T12164 for details.
    */
   public function renderAnyCommitter(PhabricatorUser $viewer, $handles) {
     $committer = $this->renderCommitter($viewer, $handles);
     if ($committer) {
       return $committer;
     }
 
     return $this->renderAuthor($viewer, $handles);
   }
 
   public function renderCommitter(PhabricatorUser $viewer, $handles) {
     $committer_phid = $this->getCommitterDisplayPHID();
     if ($committer_phid) {
       return $handles[$committer_phid]->renderLink();
     }
 
     $data = $this->getCommitData();
     $committer_name = $data->getCommitDetail('committer');
     if (strlen($committer_name)) {
       return DiffusionView::renderName($committer_name);
     }
 
     return null;
   }
 
   public function renderAuthor(PhabricatorUser $viewer, $handles) {
     $author_phid = $this->getAuthorDisplayPHID();
     if ($author_phid) {
       return $handles[$author_phid]->renderLink();
     }
 
     $data = $this->getCommitData();
     $author_name = $data->getAuthorName();
     if (strlen($author_name)) {
       return DiffusionView::renderName($author_name);
     }
 
     return null;
   }
 
   public function loadIdentities(PhabricatorUser $viewer) {
     if ($this->authorIdentity !== self::ATTACHABLE) {
       return $this;
     }
 
     $commit = id(new DiffusionCommitQuery())
       ->setViewer($viewer)
       ->withIDs(array($this->getID()))
       ->needIdentities(true)
       ->executeOne();
 
     $author_identity = $commit->getAuthorIdentity();
     $committer_identity = $commit->getCommitterIdentity();
 
     return $this->attachIdentities($author_identity, $committer_identity);
   }
 
   public function hasCommitterIdentity() {
     return ($this->getCommitterIdentity() !== null);
   }
 
   public function hasAuthorIdentity() {
     return ($this->getAuthorIdentity() !== null);
   }
 
   public function getCommitterDisplayPHID() {
     if ($this->hasCommitterIdentity()) {
       return $this->getCommitterIdentity()->getIdentityDisplayPHID();
     }
 
     $data = $this->getCommitData();
     return $data->getCommitDetail('committerPHID');
   }
 
   public function getAuthorDisplayPHID() {
     if ($this->hasAuthorIdentity()) {
       return $this->getAuthorIdentity()->getIdentityDisplayPHID();
     }
 
     $data = $this->getCommitData();
     return $data->getCommitDetail('authorPHID');
   }
 
+  public function getAuditStatusObject() {
+    $status = $this->getAuditStatus();
+    return PhabricatorAuditCommitStatusConstants::newForLegacyStatus($status);
+  }
+
 /* -(  PhabricatorPolicyInterface  )----------------------------------------- */
 
   public function getCapabilities() {
     return array(
       PhabricatorPolicyCapability::CAN_VIEW,
       PhabricatorPolicyCapability::CAN_EDIT,
     );
   }
 
   public function getPolicy($capability) {
     switch ($capability) {
       case PhabricatorPolicyCapability::CAN_VIEW:
         return $this->getRepository()->getPolicy($capability);
       case PhabricatorPolicyCapability::CAN_EDIT:
         return PhabricatorPolicies::POLICY_USER;
     }
   }
 
   public function hasAutomaticCapability($capability, PhabricatorUser $viewer) {
     return $this->getRepository()->hasAutomaticCapability($capability, $viewer);
   }
 
   public function describeAutomaticCapability($capability) {
     return pht(
       'Commits inherit the policies of the repository they belong to.');
   }
 
 
 /* -(  PhabricatorTokenReceiverInterface  )---------------------------------- */
 
   public function getUsersToNotifyOfTokenGiven() {
     return array(
       $this->getAuthorPHID(),
     );
   }
 
 /* -( Stuff for serialization )---------------------------------------------- */
 
   /**
    * NOTE: this is not a complete serialization; only the 'protected' fields are
    * involved. This is due to ease of (ab)using the Lisk abstraction to get this
    * done, as well as complexity of the other fields.
    */
   public function toDictionary() {
     return array(
       'repositoryID' => $this->getRepositoryID(),
       'phid' =>  $this->getPHID(),
       'commitIdentifier' =>  $this->getCommitIdentifier(),
       'epoch' => $this->getEpoch(),
       'mailKey' => $this->getMailKey(),
       'authorPHID' => $this->getAuthorPHID(),
       'auditStatus' => $this->getAuditStatus(),
       'summary' => $this->getSummary(),
       'importStatus' => $this->getImportStatus(),
     );
   }
 
   public static function newFromDictionary(array $dict) {
     return id(new PhabricatorRepositoryCommit())
       ->loadFromArray($dict);
   }
 
 
 /* -(  HarbormasterBuildableInterface  )------------------------------------- */
 
 
   public function getHarbormasterBuildableDisplayPHID() {
     return $this->getHarbormasterBuildablePHID();
   }
 
   public function getHarbormasterBuildablePHID() {
     return $this->getPHID();
   }
 
   public function getHarbormasterContainerPHID() {
     return $this->getRepository()->getPHID();
   }
 
   public function getBuildVariables() {
     $results = array();
 
     $results['buildable.commit'] = $this->getCommitIdentifier();
     $repo = $this->getRepository();
 
     $results['repository.callsign'] = $repo->getCallsign();
     $results['repository.phid'] = $repo->getPHID();
     $results['repository.vcs'] = $repo->getVersionControlSystem();
     $results['repository.uri'] = $repo->getPublicCloneURI();
 
     return $results;
   }
 
   public function getAvailableBuildVariables() {
     return array(
       'buildable.commit' => pht('The commit identifier, if applicable.'),
       'repository.callsign' =>
         pht('The callsign of the repository in Phabricator.'),
       'repository.phid' =>
         pht('The PHID of the repository in Phabricator.'),
       'repository.vcs' =>
         pht('The version control system, either "svn", "hg" or "git".'),
       'repository.uri' =>
         pht('The URI to clone or checkout the repository from.'),
     );
   }
 
   public function newBuildableEngine() {
     return new DiffusionBuildableEngine();
   }
 
 
 /* -(  HarbormasterCircleCIBuildableInterface  )----------------------------- */
 
 
   public function getCircleCIGitHubRepositoryURI() {
     $repository = $this->getRepository();
 
     $commit_phid = $this->getPHID();
     $repository_phid = $repository->getPHID();
 
     if ($repository->isHosted()) {
       throw new Exception(
         pht(
           'This commit ("%s") is associated with a hosted repository '.
           '("%s"). Repositories must be imported from GitHub to be built '.
           'with CircleCI.',
           $commit_phid,
           $repository_phid));
     }
 
     $remote_uri = $repository->getRemoteURI();
     $path = HarbormasterCircleCIBuildStepImplementation::getGitHubPath(
       $remote_uri);
     if (!$path) {
       throw new Exception(
         pht(
           'This commit ("%s") is associated with a repository ("%s") that '.
           'with a remote URI ("%s") that does not appear to be hosted on '.
           'GitHub. Repositories must be hosted on GitHub to be built with '.
           'CircleCI.',
           $commit_phid,
           $repository_phid,
           $remote_uri));
     }
 
     return $remote_uri;
   }
 
   public function getCircleCIBuildIdentifierType() {
     return 'revision';
   }
 
   public function getCircleCIBuildIdentifier() {
     return $this->getCommitIdentifier();
   }
 
 
 /* -(  HarbormasterBuildkiteBuildableInterface  )---------------------------- */
 
 
   public function getBuildkiteBranch() {
     $viewer = PhabricatorUser::getOmnipotentUser();
     $repository = $this->getRepository();
 
     $branches = DiffusionQuery::callConduitWithDiffusionRequest(
       $viewer,
       DiffusionRequest::newFromDictionary(
         array(
           'repository' => $repository,
           'user' => $viewer,
         )),
       'diffusion.branchquery',
       array(
         'contains' => $this->getCommitIdentifier(),
         'repository' => $repository->getPHID(),
       ));
 
     if (!$branches) {
       throw new Exception(
         pht(
           'Commit "%s" is not an ancestor of any branch head, so it can not '.
           'be built with Buildkite.',
           $this->getCommitIdentifier()));
     }
 
     $branch = head($branches);
 
     return 'refs/heads/'.$branch['shortName'];
   }
 
   public function getBuildkiteCommit() {
     return $this->getCommitIdentifier();
   }
 
 
 /* -(  PhabricatorCustomFieldInterface  )------------------------------------ */
 
 
   public function getCustomFieldSpecificationForRole($role) {
     return PhabricatorEnv::getEnvConfig('diffusion.fields');
   }
 
   public function getCustomFieldBaseClass() {
     return 'PhabricatorCommitCustomField';
   }
 
   public function getCustomFields() {
     return $this->assertAttached($this->customFields);
   }
 
   public function attachCustomFields(PhabricatorCustomFieldAttachment $fields) {
     $this->customFields = $fields;
     return $this;
   }
 
 
 /* -(  PhabricatorSubscribableInterface  )----------------------------------- */
 
 
   public function isAutomaticallySubscribed($phid) {
 
     // TODO: This should also list auditors, but handling that is a bit messy
     // right now because we are not guaranteed to have the data. (It should not
     // include resigned auditors.)
 
     return ($phid == $this->getAuthorPHID());
   }
 
 
 /* -(  PhabricatorApplicationTransactionInterface  )------------------------- */
 
 
   public function getApplicationTransactionEditor() {
     return new PhabricatorAuditEditor();
   }
 
   public function getApplicationTransactionObject() {
     return $this;
   }
 
   public function getApplicationTransactionTemplate() {
     return new PhabricatorAuditTransaction();
   }
 
   public function willRenderTimeline(
     PhabricatorApplicationTransactionView $timeline,
     AphrontRequest $request) {
 
     $xactions = $timeline->getTransactions();
 
     $path_ids = array();
     foreach ($xactions as $xaction) {
       if ($xaction->hasComment()) {
         $path_id = $xaction->getComment()->getPathID();
         if ($path_id) {
           $path_ids[] = $path_id;
         }
       }
     }
 
     $path_map = array();
     if ($path_ids) {
       $path_map = id(new DiffusionPathQuery())
         ->withPathIDs($path_ids)
         ->execute();
       $path_map = ipull($path_map, 'path', 'id');
     }
 
     return $timeline->setPathMap($path_map);
   }
 
 /* -(  PhabricatorFulltextInterface  )--------------------------------------- */
 
 
   public function newFulltextEngine() {
     return new DiffusionCommitFulltextEngine();
   }
 
 
 /* -(  PhabricatorFerretInterface  )----------------------------------------- */
 
 
   public function newFerretEngine() {
     return new DiffusionCommitFerretEngine();
   }
 
 
 /* -(  PhabricatorConduitResultInterface  )---------------------------------- */
 
   public function getFieldSpecificationsForConduit() {
     return array(
       id(new PhabricatorConduitSearchFieldSpecification())
         ->setKey('identifier')
         ->setType('string')
         ->setDescription(pht('The commit identifier.')),
     );
   }
 
   public function getFieldValuesForConduit() {
 
     // NOTE: This data should be similar to the information returned about
     // commmits by "differential.diff.search" with the "commits" attachment.
 
     return array(
       'identifier' => $this->getCommitIdentifier(),
     );
   }
 
   public function getConduitSearchAttachments() {
     return array();
   }
 
 
 /* -(  PhabricatorDraftInterface  )------------------------------------------ */
 
   public function newDraftEngine() {
     return new DiffusionCommitDraftEngine();
   }
 
   public function getHasDraft(PhabricatorUser $viewer) {
     return $this->assertAttachedKey($this->drafts, $viewer->getCacheFragment());
   }
 
   public function attachHasDraft(PhabricatorUser $viewer, $has_draft) {
     $this->drafts[$viewer->getCacheFragment()] = $has_draft;
     return $this;
   }
 
 }