diff --git a/src/applications/drydock/query/DrydockRepositoryOperationQuery.php b/src/applications/drydock/query/DrydockRepositoryOperationQuery.php
index 570e68e825..fb1f6583a8 100644
--- a/src/applications/drydock/query/DrydockRepositoryOperationQuery.php
+++ b/src/applications/drydock/query/DrydockRepositoryOperationQuery.php
@@ -1,171 +1,184 @@
 <?php
 
 final class DrydockRepositoryOperationQuery extends DrydockQuery {
 
   private $ids;
   private $phids;
   private $objectPHIDs;
   private $repositoryPHIDs;
   private $operationStates;
   private $operationTypes;
   private $isDismissed;
+  private $authorPHIDs;
 
   public function withIDs(array $ids) {
     $this->ids = $ids;
     return $this;
   }
 
   public function withPHIDs(array $phids) {
     $this->phids = $phids;
     return $this;
   }
 
   public function withObjectPHIDs(array $object_phids) {
     $this->objectPHIDs = $object_phids;
     return $this;
   }
 
   public function withRepositoryPHIDs(array $repository_phids) {
     $this->repositoryPHIDs = $repository_phids;
     return $this;
   }
 
   public function withOperationStates(array $states) {
     $this->operationStates = $states;
     return $this;
   }
 
   public function withOperationTypes(array $types) {
     $this->operationTypes = $types;
     return $this;
   }
 
   public function withIsDismissed($dismissed) {
     $this->isDismissed = $dismissed;
     return $this;
   }
 
+  public function withAuthorPHIDs(array $phids) {
+    $this->authorPHIDs = $phids;
+    return $this;
+  }
+
   public function newResultObject() {
     return new DrydockRepositoryOperation();
   }
 
   protected function loadPage() {
     return $this->loadStandardPage($this->newResultObject());
   }
 
   protected function willFilterPage(array $operations) {
     $implementations = DrydockRepositoryOperationType::getAllOperationTypes();
 
     foreach ($operations as $key => $operation) {
       $impl = idx($implementations, $operation->getOperationType());
       if (!$impl) {
         $this->didRejectResult($operation);
         unset($operations[$key]);
         continue;
       }
       $impl = clone $impl;
       $operation->attachImplementation($impl);
     }
 
     $repository_phids = mpull($operations, 'getRepositoryPHID');
     if ($repository_phids) {
       $repositories = id(new PhabricatorRepositoryQuery())
         ->setViewer($this->getViewer())
         ->setParentQuery($this)
         ->withPHIDs($repository_phids)
         ->execute();
       $repositories = mpull($repositories, null, 'getPHID');
     } else {
       $repositories = array();
     }
 
     foreach ($operations as $key => $operation) {
       $repository = idx($repositories, $operation->getRepositoryPHID());
       if (!$repository) {
         $this->didRejectResult($operation);
         unset($operations[$key]);
         continue;
       }
       $operation->attachRepository($repository);
     }
 
     return $operations;
   }
 
   protected function didFilterPage(array $operations) {
     $object_phids = mpull($operations, 'getObjectPHID');
     if ($object_phids) {
       $objects = id(new PhabricatorObjectQuery())
         ->setViewer($this->getViewer())
         ->setParentQuery($this)
         ->withPHIDs($object_phids)
         ->execute();
       $objects = mpull($objects, null, 'getPHID');
     } else {
       $objects = array();
     }
 
     foreach ($operations as $key => $operation) {
       $object = idx($objects, $operation->getObjectPHID());
       $operation->attachObject($object);
     }
 
     return $operations;
   }
 
   protected function buildWhereClauseParts(AphrontDatabaseConnection $conn) {
     $where = parent::buildWhereClauseParts($conn);
 
     if ($this->ids !== null) {
       $where[] = qsprintf(
         $conn,
         'id IN (%Ld)',
         $this->ids);
     }
 
     if ($this->phids !== null) {
       $where[] = qsprintf(
         $conn,
         'phid IN (%Ls)',
         $this->phids);
     }
 
     if ($this->objectPHIDs !== null) {
       $where[] = qsprintf(
         $conn,
         'objectPHID IN (%Ls)',
         $this->objectPHIDs);
     }
 
     if ($this->repositoryPHIDs !== null) {
       $where[] = qsprintf(
         $conn,
         'repositoryPHID IN (%Ls)',
         $this->repositoryPHIDs);
     }
 
     if ($this->operationStates !== null) {
       $where[] = qsprintf(
         $conn,
         'operationState IN (%Ls)',
         $this->operationStates);
     }
 
     if ($this->operationTypes !== null) {
       $where[] = qsprintf(
         $conn,
         'operationType IN (%Ls)',
         $this->operationTypes);
     }
 
     if ($this->isDismissed !== null) {
       $where[] = qsprintf(
         $conn,
         'isDismissed = %d',
         (int)$this->isDismissed);
     }
 
+    if ($this->authorPHIDs !== null) {
+      $where[] = qsprintf(
+        $conn,
+        'authorPHID IN (%Ls)',
+        $this->authorPHIDs);
+    }
+
     return $where;
   }
 
 }
diff --git a/src/applications/drydock/query/DrydockRepositoryOperationSearchEngine.php b/src/applications/drydock/query/DrydockRepositoryOperationSearchEngine.php
index 1de32be28f..eeb85329bf 100644
--- a/src/applications/drydock/query/DrydockRepositoryOperationSearchEngine.php
+++ b/src/applications/drydock/query/DrydockRepositoryOperationSearchEngine.php
@@ -1,101 +1,135 @@
 <?php
 
 final class DrydockRepositoryOperationSearchEngine
   extends PhabricatorApplicationSearchEngine {
 
   public function getResultTypeDescription() {
     return pht('Drydock Repository Operations');
   }
 
   public function getApplicationClassName() {
     return 'PhabricatorDrydockApplication';
   }
 
   public function newQuery() {
     return id(new DrydockRepositoryOperationQuery());
   }
 
   protected function buildQueryFromParameters(array $map) {
     $query = $this->newQuery();
 
+    if ($map['repositoryPHIDs']) {
+      $query->withRepositoryPHIDs($map['repositoryPHIDs']);
+    }
+
+    if ($map['authorPHIDs']) {
+      $query->withAuthorPHIDs($map['authorPHIDs']);
+    }
+
+    if ($map['states']) {
+      $query->withOperationStates($map['states']);
+    }
+
     return $query;
   }
 
   protected function buildCustomSearchFields() {
     return array(
+      id(new PhabricatorSearchDatasourceField())
+        ->setLabel(pht('Repositories'))
+        ->setKey('repositoryPHIDs')
+        ->setAliases(array('repository', 'repositories', 'repositoryPHID'))
+        ->setDatasource(new DiffusionRepositoryFunctionDatasource()),
+
+      // NOTE: Repository operations aren't necessarily created by a real
+      // user, but for now they normally are. Just use a user typeahead until
+      // more use cases arise.
+      id(new PhabricatorUsersSearchField())
+        ->setLabel(pht('Authors'))
+        ->setKey('authorPHIDs')
+        ->setAliases(array('author', 'authors', 'authorPHID')),
+      id(new PhabricatorSearchCheckboxesField())
+        ->setLabel(pht('States'))
+        ->setKey('states')
+        ->setAliases(array('state'))
+        ->setOptions(DrydockRepositoryOperation::getOperationStateNameMap()),
     );
   }
 
   protected function getURI($path) {
     return '/drydock/operation/'.$path;
   }
 
   protected function getBuiltinQueryNames() {
     return array(
       'all' => pht('All Operations'),
     );
   }
 
   public function buildSavedQueryFromBuiltin($query_key) {
     $query = $this->newSavedQuery();
     $query->setQueryKey($query_key);
 
     switch ($query_key) {
       case 'all':
         return $query;
     }
 
     return parent::buildSavedQueryFromBuiltin($query_key);
   }
 
   protected function renderResultList(
     array $operations,
     PhabricatorSavedQuery $query,
     array $handles) {
     assert_instances_of($operations, 'DrydockRepositoryOperation');
 
     $viewer = $this->requireViewer();
 
     $view = new PHUIObjectItemListView();
     foreach ($operations as $operation) {
       $id = $operation->getID();
 
       $item = id(new PHUIObjectItemView())
         ->setHeader($operation->getOperationDescription($viewer))
         ->setHref($this->getApplicationURI("operation/{$id}/"))
         ->setObjectName(pht('Repository Operation %d', $id));
 
       $state = $operation->getOperationState();
 
       $icon = DrydockRepositoryOperation::getOperationStateIcon($state);
       $name = DrydockRepositoryOperation::getOperationStateName($state);
 
       $item->setStatusIcon($icon, $name);
 
+
+      $created = phabricator_datetime($operation->getDateCreated(), $viewer);
+      $item->addIcon(null, $created);
+
       $item->addByline(
         array(
           pht('Via:'),
           ' ',
           $viewer->renderHandle($operation->getAuthorPHID()),
         ));
 
       $object_phid = $operation->getObjectPHID();
       $repository_phid = $operation->getRepositoryPHID();
 
       $item->addAttribute($viewer->renderHandle($object_phid));
 
       if ($repository_phid !== $object_phid) {
         $item->addAttribute($viewer->renderHandle($repository_phid));
       }
 
       $view->addItem($item);
     }
 
     $result = id(new PhabricatorApplicationSearchResultView())
       ->setObjectList($view)
       ->setNoDataString(pht('No matching operations.'));
 
     return $result;
   }
 
 }
diff --git a/src/applications/drydock/storage/DrydockRepositoryOperation.php b/src/applications/drydock/storage/DrydockRepositoryOperation.php
index 190b5b1310..4e25280c3f 100644
--- a/src/applications/drydock/storage/DrydockRepositoryOperation.php
+++ b/src/applications/drydock/storage/DrydockRepositoryOperation.php
@@ -1,234 +1,237 @@
 <?php
 
 /**
  * Represents a request to perform a repository operation like a merge or
  * cherry-pick.
  */
 final class DrydockRepositoryOperation extends DrydockDAO
   implements
     PhabricatorPolicyInterface {
 
   const STATE_WAIT = 'wait';
   const STATE_WORK = 'work';
   const STATE_DONE = 'done';
   const STATE_FAIL = 'fail';
 
   protected $authorPHID;
   protected $objectPHID;
   protected $repositoryPHID;
   protected $repositoryTarget;
   protected $operationType;
   protected $operationState;
   protected $properties = array();
   protected $isDismissed;
 
   private $repository = self::ATTACHABLE;
   private $object = self::ATTACHABLE;
   private $implementation = self::ATTACHABLE;
 
   public static function initializeNewOperation(
     DrydockRepositoryOperationType $op) {
 
     return id(new DrydockRepositoryOperation())
       ->setOperationState(self::STATE_WAIT)
       ->setOperationType($op->getOperationConstant())
       ->setIsDismissed(0);
   }
 
   protected function getConfiguration() {
     return array(
       self::CONFIG_AUX_PHID => true,
       self::CONFIG_SERIALIZATION => array(
         'properties' => self::SERIALIZATION_JSON,
       ),
       self::CONFIG_COLUMN_SCHEMA => array(
         'repositoryTarget' => 'bytes',
         'operationType' => 'text32',
         'operationState' => 'text32',
         'isDismissed' => 'bool',
       ),
       self::CONFIG_KEY_SCHEMA => array(
         'key_object' => array(
           'columns' => array('objectPHID'),
         ),
         'key_repository' => array(
           'columns' => array('repositoryPHID', 'operationState'),
         ),
       ),
     ) + parent::getConfiguration();
   }
 
   public function generatePHID() {
     return PhabricatorPHID::generateNewPHID(
       DrydockRepositoryOperationPHIDType::TYPECONST);
   }
 
   public function attachRepository(PhabricatorRepository $repository) {
     $this->repository = $repository;
     return $this;
   }
 
   public function getRepository() {
     return $this->assertAttached($this->repository);
   }
 
   public function attachObject($object) {
     $this->object = $object;
     return $this;
   }
 
   public function getObject() {
     return $this->assertAttached($this->object);
   }
 
   public function attachImplementation(DrydockRepositoryOperationType $impl) {
     $this->implementation = $impl;
     return $this;
   }
 
   public function getImplementation() {
     return $this->implementation;
   }
 
   public function getProperty($key, $default = null) {
     return idx($this->properties, $key, $default);
   }
 
   public function setProperty($key, $value) {
     $this->properties[$key] = $value;
     return $this;
   }
 
+  public static function getOperationStateNameMap() {
+    return array(
+      self::STATE_WAIT => pht('Waiting'),
+      self::STATE_WORK => pht('Working'),
+      self::STATE_DONE => pht('Done'),
+      self::STATE_FAIL => pht('Failed'),
+    );
+  }
+
   public static function getOperationStateIcon($state) {
     $map = array(
       self::STATE_WAIT => 'fa-clock-o',
       self::STATE_WORK => 'fa-plane ph-spin blue',
       self::STATE_DONE => 'fa-check green',
       self::STATE_FAIL => 'fa-times red',
     );
 
     return idx($map, $state, null);
   }
 
   public static function getOperationStateName($state) {
-    $map = array(
-      self::STATE_WAIT => pht('Waiting'),
-      self::STATE_WORK => pht('Working'),
-      self::STATE_DONE => pht('Done'),
-      self::STATE_FAIL => pht('Failed'),
-    );
-
+    $map = self::getOperationStateNameMap();
     return idx($map, $state, pht('<Unknown: %s>', $state));
   }
 
   public function scheduleUpdate() {
     PhabricatorWorker::scheduleTask(
       'DrydockRepositoryOperationUpdateWorker',
       array(
         'operationPHID' => $this->getPHID(),
       ),
       array(
         'objectPHID' => $this->getPHID(),
         'priority' => PhabricatorWorker::PRIORITY_ALERTS,
       ));
   }
 
   public function applyOperation(DrydockInterface $interface) {
     return $this->getImplementation()->applyOperation(
       $this,
       $interface);
   }
 
   public function getOperationDescription(PhabricatorUser $viewer) {
     return $this->getImplementation()->getOperationDescription(
       $this,
       $viewer);
   }
 
   public function getOperationCurrentStatus(PhabricatorUser $viewer) {
     return $this->getImplementation()->getOperationCurrentStatus(
       $this,
       $viewer);
   }
 
   public function isUnderway() {
     switch ($this->getOperationState()) {
       case self::STATE_WAIT:
       case self::STATE_WORK:
         return true;
     }
 
     return false;
   }
 
   public function isDone() {
     return ($this->getOperationState() === self::STATE_DONE);
   }
 
   public function getWorkingCopyMerges() {
     return $this->getImplementation()->getWorkingCopyMerges(
       $this);
   }
 
   public function setWorkingCopyLeasePHID($lease_phid) {
     return $this->setProperty('exec.leasePHID', $lease_phid);
   }
 
   public function getWorkingCopyLeasePHID() {
     return $this->getProperty('exec.leasePHID');
   }
 
   public function setCommandError(array $error) {
     return $this->setProperty('exec.workingcopy.error', $error);
   }
 
   public function getCommandError() {
     return $this->getProperty('exec.workingcopy.error');
   }
 
 
 
 /* -(  PhabricatorPolicyInterface  )----------------------------------------- */
 
 
   public function getCapabilities() {
     return array(
       PhabricatorPolicyCapability::CAN_VIEW,
       PhabricatorPolicyCapability::CAN_EDIT,
     );
   }
 
   public function getPolicy($capability) {
     $need_capability = $this->getRequiredRepositoryCapability($capability);
 
     return $this->getRepository()
       ->getPolicy($need_capability);
   }
 
   public function hasAutomaticCapability($capability, PhabricatorUser $viewer) {
     $need_capability = $this->getRequiredRepositoryCapability($capability);
 
     return $this->getRepository()
       ->hasAutomaticCapability($need_capability, $viewer);
   }
 
   public function describeAutomaticCapability($capability) {
     return pht(
       'A repository operation inherits the policies of the repository it '.
       'affects.');
   }
 
   private function getRequiredRepositoryCapability($capability) {
     // To edit a RepositoryOperation, require that the user be able to push
     // to the repository.
 
     $map = array(
       PhabricatorPolicyCapability::CAN_EDIT =>
         DiffusionPushCapability::CAPABILITY,
     );
 
     return idx($map, $capability, $capability);
   }
 
 
 }