diff --git a/src/applications/releeph/conduit/ConduitAPI_releeph_queryrequests_Method.php b/src/applications/releeph/conduit/ConduitAPI_releeph_queryrequests_Method.php
index 3eccb6a214..7180166efb 100644
--- a/src/applications/releeph/conduit/ConduitAPI_releeph_queryrequests_Method.php
+++ b/src/applications/releeph/conduit/ConduitAPI_releeph_queryrequests_Method.php
@@ -1,70 +1,73 @@
 <?php
 
 final class ConduitAPI_releeph_queryrequests_Method
   extends ConduitAPI_releeph_Method {
 
   public function getMethodDescription() {
     return
       "Return information about all Releeph requests linked to the given ids.";
   }
 
   public function defineParamTypes() {
     return array(
       'revisionPHIDs'         => 'optional list<phid>',
       'requestedCommitPHIDs'  => 'optional list<phid>'
     );
   }
 
   public function defineReturnType() {
     return 'dict<string, wild>';
   }
 
   public function defineErrorTypes() {
     return array();
   }
 
   protected function execute(ConduitAPIRequest $conduit_request) {
     $revision_phids = $conduit_request->getValue('revisionPHIDs');
     $requested_commit_phids =
       $conduit_request->getValue('requestedCommitPHIDs');
     $result = array();
 
     if (!$revision_phids && !$requested_commit_phids) {
       return $result;
     }
 
     $query = new ReleephRequestQuery();
     $query->setViewer($conduit_request->getUser());
 
     if ($revision_phids) {
       $query->withRevisionPHIDs($revision_phids);
     } else if ($requested_commit_phids) {
       $query->withRequestedCommitPHIDs($requested_commit_phids);
     }
 
     $releephRequests = $query->execute();
 
     foreach ($releephRequests as $releephRequest) {
       $branch = $releephRequest->loadReleephBranch();
+      if (!$branch) {
+        continue;
+      }
       $request_commit_phid = $releephRequest->getRequestCommitPHID();
       $revisionPHID =
         $query->getRevisionPHID($request_commit_phid);
       $status = $releephRequest->getStatus();
       $statusName = ReleephRequestStatus::getStatusDescriptionFor($status);
       $url = PhabricatorEnv::getProductionURI('/RQ'.$releephRequest->getID());
 
       $result[] = array(
         'branchBasename' => $branch->getBasename(),
         'branchSymbolic' => $branch->getSymbolicName(),
         'requestID'      => $releephRequest->getID(),
         'revisionPHID'   => $revisionPHID,
         'status'         => $status,
         'statusName'     => $statusName,
         'url'            => $url,
       );
     }
 
     return $result;
   }
 
 }
diff --git a/src/applications/releeph/query/ReleephRequestQuery.php b/src/applications/releeph/query/ReleephRequestQuery.php
index b57bc7a79b..560f7898fc 100644
--- a/src/applications/releeph/query/ReleephRequestQuery.php
+++ b/src/applications/releeph/query/ReleephRequestQuery.php
@@ -1,223 +1,235 @@
 <?php
 
 final class ReleephRequestQuery
   extends PhabricatorCursorPagedPolicyAwareQuery {
 
   private $requestedCommitPHIDs;
   private $commitToRevMap;
   private $ids;
   private $phids;
   private $severities;
   private $requestorPHIDs;
   private $branchIDs;
+  private $revisionPHIDs;
 
   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);
+    $this->revisionPHIDs = $revision_phids;
+    return $this;
   }
 
   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) {
 
         // 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);
     }
 
+    if ($this->revisionPHIDs) {
+      $type = PhabricatorEdgeConfig::TYPE_DREV_HAS_COMMIT;
+
+      $edges = id(new PhabricatorEdgeQuery())
+        ->withSourcePHIDs($this->revisionPHIDs)
+        ->withEdgeTypes(array($type))
+        ->execute();
+
+      $this->commitToRevMap = array();
+      foreach ($edges as $revision_phid => $edge) {
+        foreach ($edge[$type] as $commitPHID => $item) {
+          $this->commitToRevMap[$commitPHID] = $revision_phid;
+        }
+      }
+
+      if (!$this->commitToRevMap) {
+        throw new PhabricatorEmptyQueryException("Malformed Revision Phids");
+      }
+
+      $where[] = qsprintf(
+        $conn_r,
+        'requestCommitPHID IN (%Ls)',
+        array_keys($this->commitToRevMap));
+    }
+
     $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/storage/ReleephRequest.php b/src/applications/releeph/storage/ReleephRequest.php
index a46e365aa2..932b2b64ea 100644
--- a/src/applications/releeph/storage/ReleephRequest.php
+++ b/src/applications/releeph/storage/ReleephRequest.php
@@ -1,335 +1,342 @@
 <?php
 
 final class ReleephRequest extends ReleephDAO
   implements
     PhabricatorPolicyInterface,
     PhabricatorCustomFieldInterface {
 
   protected $branchID;
   protected $requestUserPHID;
   protected $details = array();
   protected $userIntents = array();
   protected $inBranch;
   protected $pickStatus;
   protected $mailKey;
 
   // Information about the thing being requested
   protected $requestCommitPHID;
 
   // Information about the last commit to the releeph branch
   protected $commitIdentifier;
   protected $commitPHID;
 
   // Pre-populated handles that we'll bulk load in ReleephBranch
   private $handles = self::ATTACHABLE;
   private $customFields = self::ATTACHABLE;
 
 
 
 /* -(  Constants and helper methods  )--------------------------------------- */
 
   const INTENT_WANT = 'want';
   const INTENT_PASS = 'pass';
 
   const PICK_PENDING  = 1; // old
   const PICK_FAILED   = 2;
   const PICK_OK       = 3;
   const PICK_MANUAL   = 4; // old
   const REVERT_OK     = 5;
   const REVERT_FAILED = 6;
 
   public function shouldBeInBranch() {
     return
       $this->getPusherIntent() == self::INTENT_WANT &&
       /**
        * We use "!= pass" instead of "== want" in case the requestor intent is
        * not present.  In other words, only revert if the requestor explicitly
        * passed.
        */
       $this->getRequestorIntent() != self::INTENT_PASS;
   }
 
   /**
    * Will return INTENT_WANT if any pusher wants this request, and no pusher
    * passes on this request.
    */
   public function getPusherIntent() {
     $project = $this->loadReleephProject();
+    if (!$project) {
+      return null;
+    }
+
     if (!$project->getPushers()) {
       return self::INTENT_WANT;
     }
 
     $found_pusher_want = false;
     foreach ($this->userIntents as $phid => $intent) {
       if ($project->isAuthoritativePHID($phid)) {
         if ($intent == self::INTENT_PASS) {
           return self::INTENT_PASS;
         }
 
         $found_pusher_want = true;
       }
     }
 
     if ($found_pusher_want) {
       return self::INTENT_WANT;
     } else {
       return null;
     }
   }
 
   public function getRequestorIntent() {
     return idx($this->userIntents, $this->requestUserPHID);
   }
 
   public function getStatus() {
     return $this->calculateStatus();
   }
 
   private function calculateStatus() {
     if ($this->shouldBeInBranch()) {
       if ($this->getInBranch()) {
         return ReleephRequestStatus::STATUS_PICKED;
       } else {
         return ReleephRequestStatus::STATUS_NEEDS_PICK;
       }
     } else {
       if ($this->getInBranch()) {
         return ReleephRequestStatus::STATUS_NEEDS_REVERT;
       } else {
         $has_been_in_branch = $this->getCommitIdentifier();
         // Regardless of why we reverted something, always say reverted if it
         // was once in the branch.
         if ($has_been_in_branch) {
           return ReleephRequestStatus::STATUS_REVERTED;
         } elseif ($this->getPusherIntent() === ReleephRequest::INTENT_PASS) {
           // Otherwise, if it has never been in the branch, explicitly say why:
           return ReleephRequestStatus::STATUS_REJECTED;
         } elseif ($this->getRequestorIntent() === ReleephRequest::INTENT_WANT) {
           return ReleephRequestStatus::STATUS_REQUESTED;
         } else {
           return ReleephRequestStatus::STATUS_ABANDONED;
         }
       }
     }
   }
 
 
 /* -(  Lisk mechanics  )----------------------------------------------------- */
 
   public function getConfiguration() {
     return array(
       self::CONFIG_AUX_PHID => true,
       self::CONFIG_SERIALIZATION => array(
         'details' => self::SERIALIZATION_JSON,
         'userIntents' => self::SERIALIZATION_JSON,
       ),
     ) + parent::getConfiguration();
   }
 
   public function generatePHID() {
     return PhabricatorPHID::generateNewPHID(
       ReleephPHIDTypeRequest::TYPECONST);
   }
 
   public function save() {
     if (!$this->getMailKey()) {
       $this->setMailKey(Filesystem::readRandomCharacters(20));
     }
     return parent::save();
   }
 
 
 /* -(  Helpful accessors )--------------------------------------------------- */
 
   public function setHandles($handles) {
     $this->handles = $handles;
     return $this;
   }
 
   public function getHandles() {
     return $this->assertAttached($this->handles);
   }
 
   public function getDetail($key, $default = null) {
     return idx($this->getDetails(), $key, $default);
   }
 
   public function setDetail($key, $value) {
     $this->details[$key] = $value;
     return $this;
   }
 
   public function getReason() {
     // Backward compatibility: reason used to be called comments
     $reason = $this->getDetail('reason');
     if (!$reason) {
       return $this->getDetail('comments');
     }
     return $reason;
   }
 
   public function getSummary() {
     /**
      * Instead, you can use:
      *  - getDetail('summary')    // the actual user-chosen summary
      *  - getSummaryForDisplay()  // falls back to the original commit title
      *
      * Or for the fastidious:
      *  - id(new ReleephSummaryFieldSpecification())
      *      ->setReleephRequest($rr)
      *      ->getValue()          // programmatic equivalent to getDetail()
      */
     throw new Exception(
       "getSummary() has been deprecated!");
   }
 
   /**
    * Allow a null summary, and fall back to the title of the commit.
    */
   public function getSummaryForDisplay() {
     $summary = $this->getDetail('summary');
 
     if (!$summary) {
       $pr_commit_data = $this->loadPhabricatorRepositoryCommitData();
       if ($pr_commit_data) {
         $message_lines = explode("\n", $pr_commit_data->getCommitMessage());
         $message_lines = array_filter($message_lines);
         $summary = head($message_lines);
       }
     }
 
     if (!$summary) {
       $summary = '(no summary given and commit message empty or unparsed)';
     }
 
     return $summary;
   }
 
   public function loadRequestCommitDiffPHID() {
     $phids = array();
     $commit = $this->loadPhabricatorRepositoryCommit();
     if ($commit) {
       $phids = PhabricatorEdgeQuery::loadDestinationPHIDs(
         $commit->getPHID(),
         PhabricatorEdgeConfig::TYPE_COMMIT_HAS_DREV);
     }
 
     return head($phids);
   }
 
 
 /* -(  Loading external objects  )------------------------------------------- */
 
   public function loadReleephBranch() {
     return $this->loadOneRelative(
       new ReleephBranch(),
       'id',
       'getBranchID');
   }
 
   public function loadReleephProject() {
-    return $this->loadReleephBranch()->loadReleephProject();
+    $branch = $this->loadReleephBranch();
+    if ($branch) {
+      return $branch->loadReleephProject();
+    }
   }
 
   public function loadPhabricatorRepositoryCommit() {
     return $this->loadOneRelative(
       new PhabricatorRepositoryCommit(),
       'phid',
       'getRequestCommitPHID');
   }
 
   public function loadPhabricatorRepositoryCommitData() {
     $commit = $this->loadPhabricatorRepositoryCommit();
     if ($commit) {
       return $commit->loadOneRelative(
         new PhabricatorRepositoryCommitData(),
         'commitID');
     }
   }
 
   // TODO: (T603) Get rid of all this one-off ad-hoc loading.
   public function loadDifferentialRevision() {
     $diff_phid = $this->loadRequestCommitDiffPHID();
     if (!$diff_phid) {
       return null;
     }
     return $this->loadOneRelative(
         new DifferentialRevision(),
         'phid',
         'loadRequestCommitDiffPHID');
   }
 
 
 /* -(  State change helpers  )----------------------------------------------- */
 
   public function setUserIntent(PhabricatorUser $user, $intent) {
     $this->userIntents[$user->getPHID()] = $intent;
     return $this;
   }
 
 
 /* -(  Migrating to status-less ReleephRequests  )--------------------------- */
 
   protected function didReadData() {
     if ($this->userIntents === null) {
       $this->userIntents = array();
     }
   }
 
   public function setStatus($value) {
     throw new Exception('`status` is now deprecated!');
   }
 
 /* -(  Make magic Lisk methods private  )------------------------------------ */
 
   private function setUserIntents(array $ar) {
     return parent::setUserIntents($ar);
   }
 
 
 /* -(  PhabricatorPolicyInterface  )----------------------------------------- */
 
 
   public function getCapabilities() {
     return array(
       PhabricatorPolicyCapability::CAN_VIEW,
       PhabricatorPolicyCapability::CAN_EDIT,
     );
   }
 
   public function getPolicy($capability) {
     return PhabricatorPolicies::POLICY_USER;
   }
 
   public function hasAutomaticCapability($capability, PhabricatorUser $viewer) {
     return false;
   }
 
   public function describeAutomaticCapability($capability) {
     return null;
   }
 
 
 
 /* -(  PhabricatorCustomFieldInterface  )------------------------------------ */
 
 
   public function getCustomFieldSpecificationForRole($role) {
     return PhabricatorEnv::getEnvConfig('releeph.fields');
   }
 
   public function getCustomFieldBaseClass() {
     return 'ReleephFieldSpecification';
   }
 
   public function getCustomFields() {
     return $this->assertAttached($this->customFields);
   }
 
   public function attachCustomFields(PhabricatorCustomFieldAttachment $fields) {
     $this->customFields = $fields;
     return $this;
   }
 
 
 }