diff --git a/src/applications/releeph/field/selector/ReleephDefaultFieldSelector.php b/src/applications/releeph/field/selector/ReleephDefaultFieldSelector.php
index 9863db71db..0801203b89 100644
--- a/src/applications/releeph/field/selector/ReleephDefaultFieldSelector.php
+++ b/src/applications/releeph/field/selector/ReleephDefaultFieldSelector.php
@@ -1,73 +1,161 @@
 <?php
 
 final class ReleephDefaultFieldSelector extends ReleephFieldSelector {
 
+  /**
+   * Determine if this install is Facebook.
+   *
+   * TODO: This is a giant hacky mess because I am dumb and moved forward on
+   * Releeph changes with partial information. Recover from this as gracefully
+   * as possible. This obivously is an abomination. -epriestley
+   */
+  public static function isFacebook() {
+    try {
+      class_exists('ReleephFacebookKarmaFieldSpecification');
+      return true;
+    } catch (Exception $ex) {
+      return false;
+    }
+  }
+
+  /**
+   * @phutil-external-symbol class ReleephFacebookKarmaFieldSpecification
+   * @phutil-external-symbol class ReleephFacebookSeverityFieldSpecification
+   * @phutil-external-symbol class ReleephFacebookTagFieldSpecification
+   * @phutil-external-symbol class ReleephFacebookTasksFieldSpecification
+   */
   public function getFieldSpecifications() {
-    return array(
-      new ReleephCommitMessageFieldSpecification(),
-      new ReleephSummaryFieldSpecification(),
-      new ReleephReasonFieldSpecification(),
-      new ReleephAuthorFieldSpecification(),
-      new ReleephRevisionFieldSpecification(),
-      new ReleephRequestorFieldSpecification(),
-      new ReleephSeverityFieldSpecification(),
-      new ReleephOriginalCommitFieldSpecification(),
-      new ReleephDiffMessageFieldSpecification(),
-      new ReleephStatusFieldSpecification(),
-      new ReleephIntentFieldSpecification(),
-      new ReleephBranchCommitFieldSpecification(),
-      new ReleephDiffSizeFieldSpecification(),
-      new ReleephDiffChurnFieldSpecification(),
-    );
+    if (self::isFacebook()) {
+      return array(
+        new ReleephCommitMessageFieldSpecification(),
+        new ReleephSummaryFieldSpecification(),
+        new ReleephReasonFieldSpecification(),
+        new ReleephAuthorFieldSpecification(),
+        new ReleephRevisionFieldSpecification(),
+        new ReleephRequestorFieldSpecification(),
+        new ReleephFacebookKarmaFieldSpecification(),
+        new ReleephFacebookSeverityFieldSpecification(),
+        new ReleephOriginalCommitFieldSpecification(),
+        new ReleephDiffMessageFieldSpecification(),
+        new ReleephStatusFieldSpecification(),
+        new ReleephIntentFieldSpecification(),
+        new ReleephBranchCommitFieldSpecification(),
+        new ReleephDiffSizeFieldSpecification(),
+        new ReleephDiffChurnFieldSpecification(),
+        new ReleephFacebookTagFieldSpecification(),
+        new ReleephFacebookTasksFieldSpecification(),
+      );
+    } else {
+      return array(
+        new ReleephCommitMessageFieldSpecification(),
+        new ReleephSummaryFieldSpecification(),
+        new ReleephReasonFieldSpecification(),
+        new ReleephAuthorFieldSpecification(),
+        new ReleephRevisionFieldSpecification(),
+        new ReleephRequestorFieldSpecification(),
+        new ReleephSeverityFieldSpecification(),
+        new ReleephOriginalCommitFieldSpecification(),
+        new ReleephDiffMessageFieldSpecification(),
+        new ReleephStatusFieldSpecification(),
+        new ReleephIntentFieldSpecification(),
+        new ReleephBranchCommitFieldSpecification(),
+        new ReleephDiffSizeFieldSpecification(),
+        new ReleephDiffChurnFieldSpecification(),
+      );
+    }
   }
 
   public function arrangeFieldsForHeaderView(array $fields) {
-    return array(
-      // Top group
-      array(
-        'left' => self::selectFields($fields, array(
-          'ReleephAuthorFieldSpecification',
-          'ReleephRevisionFieldSpecification',
-          'ReleephOriginalCommitFieldSpecification',
-          'ReleephDiffSizeFieldSpecification',
-          'ReleephDiffChurnFieldSpecification',
-        )),
-        'right' => self::selectFields($fields, array(
-          'ReleephRequestorFieldSpecification',
-          'ReleephSeverityFieldSpecification',
-          'ReleephStatusFieldSpecification',
-          'ReleephIntentFieldSpecification',
-          'ReleephBranchCommitFieldSpecification',
-        ))
-      ),
+    if (self::isFacebook()) {
+      return array(
+        // Top group
+        array(
+          'left' => self::selectFields($fields, array(
+            'ReleephAuthorFieldSpecification',
+            'ReleephRevisionFieldSpecification',
+            'ReleephOriginalCommitFieldSpecification',
+            'ReleephDiffSizeFieldSpecification',
+            'ReleephDiffChurnFieldSpecification',
+            'ReleephFacebookTasksFieldSpecification',
+          )),
+          'right' => self::selectFields($fields, array(
+            'ReleephRequestorFieldSpecification',
+            'ReleephFacebookKarmaFieldSpecification',
+            'ReleephFacebookSeverityFieldSpecification',
+            'ReleephFacebookTagFieldSpecification',
+            'ReleephStatusFieldSpecification',
+            'ReleephIntentFieldSpecification',
+            'ReleephBranchCommitFieldSpecification',
+          ))
+        ),
+
+        // Bottom group
+        array(
+          'left' => self::selectFields($fields, array(
+            'ReleephDiffMessageFieldSpecification',
+          )),
+          'right' => self::selectFields($fields, array(
+            'ReleephReasonFieldSpecification',
+          ))
+        )
+      );
+    } else {
+      return array(
+        // Top group
+        array(
+          'left' => self::selectFields($fields, array(
+            'ReleephAuthorFieldSpecification',
+            'ReleephRevisionFieldSpecification',
+            'ReleephOriginalCommitFieldSpecification',
+            'ReleephDiffSizeFieldSpecification',
+            'ReleephDiffChurnFieldSpecification',
+          )),
+          'right' => self::selectFields($fields, array(
+            'ReleephRequestorFieldSpecification',
+            'ReleephSeverityFieldSpecification',
+            'ReleephStatusFieldSpecification',
+            'ReleephIntentFieldSpecification',
+            'ReleephBranchCommitFieldSpecification',
+          ))
+        ),
 
-      // Bottom group
-      array(
-        'left' => self::selectFields($fields, array(
-          'ReleephDiffMessageFieldSpecification',
-        )),
-        'right' => self::selectFields($fields, array(
-          'ReleephReasonFieldSpecification',
-        ))
-      )
-    );
+        // Bottom group
+        array(
+          'left' => self::selectFields($fields, array(
+            'ReleephDiffMessageFieldSpecification',
+          )),
+          'right' => self::selectFields($fields, array(
+            'ReleephReasonFieldSpecification',
+          ))
+        )
+      );
+    }
   }
 
   public function arrangeFieldsForSelectForm(array $fields) {
-    return self::selectFields($fields, array(
-      'ReleephStatusFieldSpecification',
-      'ReleephSeverityFieldSpecification',
-      'ReleephRequestorFieldSpecification',
-    ));
+    if (self::isFacebook()) {
+      return self::selectFields($fields, array(
+        'ReleephStatusFieldSpecification',
+        'ReleephFacebookSeverityFieldSpecification',
+        'ReleephRequestorFieldSpecification',
+        'ReleephFacebookTagFieldSpecification',
+      ));
+    } else {
+      return self::selectFields($fields, array(
+        'ReleephStatusFieldSpecification',
+        'ReleephSeverityFieldSpecification',
+        'ReleephRequestorFieldSpecification',
+      ));
+    }
   }
 
   public function sortFieldsForCommitMessage(array $fields) {
     return self::selectFields($fields, array(
       'ReleephCommitMessageFieldSpecification',
       'ReleephRequestorFieldSpecification',
       'ReleephIntentFieldSpecification',
       'ReleephReasonFieldSpecification',
     ));
   }
 
 }
diff --git a/src/applications/releeph/query/ReleephRequestQuery.php b/src/applications/releeph/query/ReleephRequestQuery.php
index 02ca00b676..b57bc7a79b 100644
--- a/src/applications/releeph/query/ReleephRequestQuery.php
+++ b/src/applications/releeph/query/ReleephRequestQuery.php
@@ -1,215 +1,223 @@
 <?php
 
 final class ReleephRequestQuery
   extends PhabricatorCursorPagedPolicyAwareQuery {
 
   private $requestedCommitPHIDs;
   private $commitToRevMap;
   private $ids;
   private $phids;
   private $severities;
   private $requestorPHIDs;
   private $branchIDs;
 
   const STATUS_ALL          = 'status-all';
   const STATUS_OPEN         = 'status-open';
   const STATUS_REQUESTED    = 'status-requested';
   const STATUS_NEEDS_PULL   = 'status-needs-pull';
   const STATUS_REJECTED     = 'status-rejected';
   const STATUS_ABANDONED    = 'status-abandoned';
   const STATUS_PULLED       = 'status-pulled';
   const STATUS_NEEDS_REVERT = 'status-needs-revert';
   const STATUS_REVERTED     = 'status-reverted';
 
   private $status = self::STATUS_ALL;
 
   public function withIDs(array $ids) {
     $this->ids = $ids;
     return $this;
   }
 
   public function withPHIDs(array $phids) {
     $this->phids = $phids;
     return $this;
   }
 
   public function withBranchIDs(array $branch_ids) {
     $this->branchIDs = $branch_ids;
     return $this;
   }
 
   public function getRevisionPHID($commit_phid) {
     if ($this->commitToRevMap) {
       return idx($this->commitToRevMap, $commit_phid, null);
     }
 
     return null;
   }
 
   public function withStatus($status) {
     $this->status = $status;
     return $this;
   }
 
   public function withRequestedCommitPHIDs(array $requested_commit_phids) {
     $this->requestedCommitPHIDs = $requested_commit_phids;
     return $this;
   }
 
   public function withRequestorPHIDs(array $phids) {
     $this->requestorPHIDs = $phids;
     return $this;
   }
 
   public function withSeverities(array $severities) {
     $this->severities = $severities;
     return $this;
   }
 
   public function withRevisionPHIDs(array $revision_phids) {
     $type = PhabricatorEdgeConfig::TYPE_DREV_HAS_COMMIT;
 
     $edges = id(new PhabricatorEdgeQuery())
       ->withSourcePHIDs($revision_phids)
       ->withEdgeTypes(array($type))
       ->execute();
 
     $this->commitToRevMap = array();
 
     foreach ($edges as $revision_phid => $edge) {
       foreach ($edge[$type] as $commitPHID => $item) {
         $this->commitToRevMap[$commitPHID] = $revision_phid;
       }
     }
 
     $this->requestedCommitPHIDs = array_keys($this->commitToRevMap);
   }
 
   public function loadPage() {
     $table = new ReleephRequest();
     $conn_r = $table->establishConnection('r');
 
     $data = queryfx_all(
       $conn_r,
       'SELECT * FROM %T %Q %Q %Q',
       $table->getTableName(),
       $this->buildWhereClause($conn_r),
       $this->buildOrderClause($conn_r),
       $this->buildLimitClause($conn_r));
 
     return $table->loadAllFromArray($data);
   }
 
   public function willFilterPage(array $requests) {
 
     // TODO: These should be serviced by the query, but are not currently
     // denormalized anywhere. For now, filter them here instead.
 
     $keep_status = array_fuse($this->getKeepStatusConstants());
     if ($keep_status) {
       foreach ($requests as $key => $request) {
         if (empty($keep_status[$request->getStatus()])) {
           unset($requests[$key]);
         }
       }
     }
 
     if ($this->severities) {
       $severities = array_fuse($this->severities);
       foreach ($requests as $key => $request) {
-        if (empty($severities[$request->getDetail('releeph:severity')])) {
+
+        // NOTE: Facebook uses a custom field here.
+        if (ReleephDefaultFieldSelector::isFacebook()) {
+          $severity = $request->getDetail('severity');
+        } else {
+          $severity = $request->getDetail('releeph:severity');
+        }
+
+        if (empty($severities[$severity])) {
           unset($requests[$key]);
         }
       }
     }
 
     return $requests;
   }
 
   private function buildWhereClause(AphrontDatabaseConnection $conn_r) {
     $where = array();
 
     if ($this->ids) {
       $where[] = qsprintf(
         $conn_r,
         'id IN (%Ld)',
         $this->ids);
     }
 
     if ($this->phids) {
       $where[] = qsprintf(
         $conn_r,
         'phid IN (%Ls)',
         $this->phids);
     }
 
     if ($this->branchIDs) {
       $where[] = qsprintf(
         $conn_r,
         'branchID IN (%Ld)',
         $this->branchIDs);
     }
 
     if ($this->requestedCommitPHIDs) {
       $where[] = qsprintf(
         $conn_r,
         'requestCommitPHID IN (%Ls)',
         $this->requestedCommitPHIDs);
     }
 
     if ($this->requestorPHIDs) {
       $where[] = qsprintf(
         $conn_r,
         'requestUserPHID IN (%Ls)',
         $this->requestorPHIDs);
     }
 
     $where[] = $this->buildPagingClause($conn_r);
 
     return $this->formatWhereClause($where);
   }
 
   private function getKeepStatusConstants() {
     switch ($this->status) {
       case self::STATUS_ALL:
         return array();
       case self::STATUS_OPEN:
         return array(
           ReleephRequestStatus::STATUS_REQUESTED,
           ReleephRequestStatus::STATUS_NEEDS_PICK,
           ReleephRequestStatus::STATUS_NEEDS_REVERT,
         );
       case self::STATUS_REQUESTED:
         return array(
           ReleephRequestStatus::STATUS_REQUESTED,
         );
       case self::STATUS_NEEDS_PULL:
         return array(
           ReleephRequestStatus::STATUS_NEEDS_PICK,
         );
       case self::STATUS_REJECTED:
         return array(
           ReleephRequestStatus::STATUS_REJECTED,
         );
       case self::STATUS_ABANDONED:
         return array(
           ReleephRequestStatus::STATUS_ABANDONED,
         );
       case self::STATUS_PULLED:
         return array(
           ReleephRequestStatus::STATUS_PICKED,
         );
       case self::STATUS_NEEDS_REVERT:
         return array(
           ReleephRequestStatus::NEEDS_REVERT,
         );
       case self::STATUS_REVERTED:
         return array(
           ReleephRequestStatus::REVERTED,
         );
       default:
         throw new Exception("Unknown status '{$this->status}'!");
     }
   }
 
 }
diff --git a/src/applications/releeph/query/ReleephRequestSearchEngine.php b/src/applications/releeph/query/ReleephRequestSearchEngine.php
index 9f30734838..0042fec9d6 100644
--- a/src/applications/releeph/query/ReleephRequestSearchEngine.php
+++ b/src/applications/releeph/query/ReleephRequestSearchEngine.php
@@ -1,158 +1,169 @@
 <?php
 
 final class ReleephRequestSearchEngine
   extends PhabricatorApplicationSearchEngine {
 
   private $branch;
   private $baseURI;
 
   public function setBranch(ReleephBranch $branch) {
     $this->branch = $branch;
     return $this;
   }
 
   public function getBranch() {
     return $this->branch;
   }
 
   public function setBaseURI($base_uri) {
     $this->baseURI = $base_uri;
     return $this;
   }
 
   public function buildSavedQueryFromRequest(AphrontRequest $request) {
     $saved = new PhabricatorSavedQuery();
 
     $saved->setParameter('status', $request->getStr('status'));
     $saved->setParameter('severity', $request->getStr('severity'));
     $saved->setParameter('requestorPHIDs', $request->getArr('requestorPHIDs'));
 
     return $saved;
   }
 
   public function buildQueryFromSavedQuery(PhabricatorSavedQuery $saved) {
     $query = id(new ReleephRequestQuery())
       ->withBranchIDs(array($this->getBranch()->getID()));
 
     $status = $saved->getParameter('status');
     $status = idx($this->getStatusValues(), $status);
     if ($status) {
       $query->withStatus($status);
     }
 
     $severity = $saved->getParameter('severity');
     if ($severity) {
       $query->withSeverities(array($severity));
     }
 
     $requestor_phids = $saved->getParameter('requestorPHIDs');
     if ($requestor_phids) {
       $query->withRequestorPHIDs($requestor_phids);
     }
 
     return $query;
   }
 
   public function buildSearchForm(
     AphrontFormView $form,
     PhabricatorSavedQuery $saved_query) {
 
     $phids = $saved_query->getParameter('requestorPHIDs', array());
     $handles = id(new PhabricatorObjectHandleData($phids))
       ->setViewer($this->requireViewer())
       ->loadHandles();
     $requestor_tokens = mpull($handles, 'getFullName', 'getPHID');
 
     $form
       ->appendChild(
         id(new AphrontFormSelectControl())
           ->setName('status')
           ->setLabel(pht('Status'))
           ->setValue($saved_query->getParameter('status'))
           ->setOptions($this->getStatusOptions()))
       ->appendChild(
         id(new AphrontFormSelectControl())
           ->setName('severity')
           ->setLabel(pht('Severity'))
           ->setValue($saved_query->getParameter('severity'))
           ->setOptions($this->getSeverityOptions()))
       ->appendChild(
         id(new AphrontFormTokenizerControl())
           ->setDatasource('/typeahead/common/users/')
           ->setName('requestorPHIDs')
           ->setLabel(pht('Requestors'))
           ->setValue($requestor_tokens));
   }
 
   protected function getURI($path) {
     return $this->baseURI.$path;
   }
 
   public function getBuiltinQueryNames() {
     $names = array(
       'open' => pht('Open Requests'),
       'all' => pht('All Requests'),
     );
 
     if ($this->requireViewer()->isLoggedIn()) {
       $names['requested'] = pht('Requested');
     }
 
     return $names;
   }
 
   public function buildSavedQueryFromBuiltin($query_key) {
 
     $query = $this->newSavedQuery();
     $query->setQueryKey($query_key);
 
     switch ($query_key) {
       case 'open':
         return $query->setParameter('status', 'open');
       case 'all':
         return $query;
       case 'requested':
         return $query->setParameter(
           'requestorPHIDs',
           array($this->requireViewer()->getPHID()));
     }
 
     return parent::buildSavedQueryFromBuiltin($query_key);
   }
 
   private function getStatusOptions() {
     return array(
       ''              => pht('(All Requests)'),
       'open'          => pht('Open Requests'),
       'requested'     => pht('Pull Requested'),
       'needs-pull'    => pht('Needs Pull'),
       'rejected'      => pht('Rejected'),
       'abandoned'     => pht('Abandoned'),
       'pulled'        => pht('Pulled'),
       'needs-revert'  => pht('Needs Revert'),
       'reverted'      => pht('Reverted'),
     );
   }
 
   private function getStatusValues() {
     return array(
       'open'          => ReleephRequestQuery::STATUS_OPEN,
       'requested'     => ReleephRequestQuery::STATUS_REQUESTED,
       'needs-pull'    => ReleephRequestQuery::STATUS_NEEDS_PULL,
       'rejected'      => ReleephRequestQuery::STATUS_REJECTED,
       'abandoned'     => ReleephRequestQuery::STATUS_ABANDONED,
       'pulled'        => ReleephRequestQuery::STATUS_PULLED,
       'needs-revert'  => ReleephRequestQuery::STATUS_NEEDS_REVERT,
       'reverted'      => ReleephRequestQuery::STATUS_REVERTED,
     );
   }
 
   private function getSeverityOptions() {
-    return array(
-      '' => pht('(All Severities)'),
-      ReleephSeverityFieldSpecification::HOTFIX => pht('Hotfix'),
-      ReleephSeverityFieldSpecification::RELEASE => pht('Release'),
-    );
+    if (ReleephDefaultFieldSelector::isFacebook()) {
+      return array(
+        '' => pht('(All Severities)'),
+        11 => 'HOTFIX',
+        12 => 'PIGGYBACK',
+        13 => 'RELEASE',
+        14 => 'DAILY',
+        15 => 'PARKING',
+      );
+    } else {
+      return array(
+        '' => pht('(All Severities)'),
+        ReleephSeverityFieldSpecification::HOTFIX => pht('Hotfix'),
+        ReleephSeverityFieldSpecification::RELEASE => pht('Release'),
+      );
+    }
   }
 
 }