diff --git a/src/applications/differential/field/specification/DifferentialFreeformFieldSpecification.php b/src/applications/differential/field/specification/DifferentialFreeformFieldSpecification.php
index d1a45c51fb..032884fb3c 100644
--- a/src/applications/differential/field/specification/DifferentialFreeformFieldSpecification.php
+++ b/src/applications/differential/field/specification/DifferentialFreeformFieldSpecification.php
@@ -1,270 +1,270 @@
 <?php
 
 abstract class DifferentialFreeformFieldSpecification
   extends DifferentialFieldSpecification {
 
   private function findMentionedTasks($message) {
     $maniphest = 'PhabricatorApplicationManiphest';
     if (!PhabricatorApplication::isClassInstalled($maniphest)) {
       return array();
     }
 
     $prefixes = array(
       'resolve'       => ManiphestTaskStatus::STATUS_CLOSED_RESOLVED,
       'resolves'      => ManiphestTaskStatus::STATUS_CLOSED_RESOLVED,
       'resolved'      => ManiphestTaskStatus::STATUS_CLOSED_RESOLVED,
       'fix'           => ManiphestTaskStatus::STATUS_CLOSED_RESOLVED,
       'fixes'         => ManiphestTaskStatus::STATUS_CLOSED_RESOLVED,
       'fixed'         => ManiphestTaskStatus::STATUS_CLOSED_RESOLVED,
       'wontfix'       => ManiphestTaskStatus::STATUS_CLOSED_WONTFIX,
       'wontfixes'     => ManiphestTaskStatus::STATUS_CLOSED_WONTFIX,
       'wontfixed'     => ManiphestTaskStatus::STATUS_CLOSED_WONTFIX,
       'spite'         => ManiphestTaskStatus::STATUS_CLOSED_SPITE,
       'spites'        => ManiphestTaskStatus::STATUS_CLOSED_SPITE,
       'spited'        => ManiphestTaskStatus::STATUS_CLOSED_SPITE,
       'invalidate'    => ManiphestTaskStatus::STATUS_CLOSED_INVALID,
       'invaldiates'   => ManiphestTaskStatus::STATUS_CLOSED_INVALID,
       'invalidated'   => ManiphestTaskStatus::STATUS_CLOSED_INVALID,
       'close'         => ManiphestTaskStatus::STATUS_CLOSED_RESOLVED,
       'closes'        => ManiphestTaskStatus::STATUS_CLOSED_RESOLVED,
       'closed'        => ManiphestTaskStatus::STATUS_CLOSED_RESOLVED,
       'ref'           => null,
       'refs'          => null,
       'references'    => null,
       'cf.'           => null,
     );
 
     $suffixes = array(
       'as resolved'   => ManiphestTaskStatus::STATUS_CLOSED_RESOLVED,
       'as fixed'      => ManiphestTaskStatus::STATUS_CLOSED_RESOLVED,
       'as wontfix'    => ManiphestTaskStatus::STATUS_CLOSED_WONTFIX,
       'as spite'      => ManiphestTaskStatus::STATUS_CLOSED_SPITE,
       'out of spite'  => ManiphestTaskStatus::STATUS_CLOSED_SPITE,
       'as invalid'    => ManiphestTaskStatus::STATUS_CLOSED_INVALID,
       ''              => null,
     );
 
     $prefix_regex = array();
     foreach ($prefixes as $prefix => $resolution) {
       $prefix_regex[] = preg_quote($prefix, '/');
     }
     $prefix_regex = implode('|', $prefix_regex);
 
     $suffix_regex = array();
     foreach ($suffixes as $suffix => $resolution) {
       $suffix_regex[] = preg_quote($suffix, '/');
     }
     $suffix_regex = implode('|', $suffix_regex);
 
     $matches = null;
     preg_match_all(
       "/({$prefix_regex})\s+T(\d+)\s*({$suffix_regex})/i",
       $message,
       $matches,
       PREG_SET_ORDER);
 
     $tasks_statuses = array();
     foreach ($matches as $set) {
       $prefix = strtolower($set[1]);
       $task_id = (int)$set[2];
       $suffix = strtolower($set[3]);
 
       $status = idx($suffixes, $suffix);
       if (!$status) {
         $status = idx($prefixes, $prefix);
       }
 
       $tasks_statuses[$task_id] = $status;
     }
 
     return $tasks_statuses;
   }
 
   private function findDependentRevisions($message) {
     $dependents = array();
 
     $matches = null;
     preg_match_all(
       '/\b(?i:depends\s+on):?\s+D(\d+(,\s+D\d++)*)\b/',
       $message,
       $matches);
 
     foreach ($matches[1] as $revisions) {
       foreach (preg_split('/,\s+D/', $revisions) as $id) {
         $dependents[$id] = $id;
       }
     }
 
     return $dependents;
   }
 
   public static function findRevertedCommits($message) {
     $reverts = array();
     $matches = null;
 
     // NOTE: Git language is "This reverts commit X."
     // NOTE: Mercurial language is "Backed out changeset Y".
 
     $prefixes = array(
       'revert'        => true,
       'reverts'       => true,
       'back\s*out'    => true,
       'backs\s*out'   => true,
       'backed\s*out'  => true,
       'undo'          => true,
       'undoes'        => true,
     );
 
     $optional = array(
       'commit'        => true,
       'changeset'     => true,
       'rev'           => true,
       'revision'      => true,
       'change'        => true,
       'diff'          => true,
     );
 
     $pre_re = implode('|', array_keys($prefixes));
     $opt_re = implode('|', array_keys($optional));
 
     $matches = null;
     preg_match_all(
       '/\b(?i:'.$pre_re.')(?:\s+(?i:'.$opt_re.'))?([rA-Z0-9a-f,\s]+)\b/',
       $message,
       $matches);
 
     $result = array();
     foreach ($matches[1] as $commits) {
       $commits = preg_split('/[,\s]+/', $commits);
       $commits = array_filter($commits);
       foreach ($commits as $commit) {
         $result[$commit] = $commit;
       }
     }
 
     return $result;
   }
 
   public function didWriteRevision(DifferentialRevisionEditor $editor) {
     $message = $this->renderValueForCommitMessage(false);
 
     $tasks = $this->findMentionedTasks($message);
     if ($tasks) {
       $tasks = id(new ManiphestTask())
         ->loadAllWhere('id IN (%Ld)', array_keys($tasks));
       $this->saveFieldEdges(
         $editor->getRevision(),
         PhabricatorEdgeConfig::TYPE_DREV_HAS_RELATED_TASK,
         mpull($tasks, 'getPHID'));
     }
 
     $dependents = $this->findDependentRevisions($message);
     if ($dependents) {
       $dependents = id(new DifferentialRevision())
         ->loadAllWhere('id IN (%Ld)', $dependents);
       $this->saveFieldEdges(
         $editor->getRevision(),
         PhabricatorEdgeConfig::TYPE_DREV_DEPENDS_ON_DREV,
         mpull($dependents, 'getPHID'));
     }
   }
 
   private function saveFieldEdges(
     DifferentialRevision $revision,
     $edge_type,
     array $add_phids) {
 
     $revision_phid = $revision->getPHID();
 
     $old_phids = PhabricatorEdgeQuery::loadDestinationPHIDs(
       $revision_phid,
       $edge_type);
 
     $add_phids = array_diff($add_phids, $old_phids);
     if (!$add_phids) {
       return;
     }
 
     $edge_editor = id(new PhabricatorEdgeEditor())->setActor($this->getUser());
     foreach ($add_phids as $phid) {
       $edge_editor->addEdge($revision_phid, $edge_type, $phid);
     }
     // NOTE: Deletes only through the fields.
     $edge_editor->save();
   }
 
   public function didParseCommit(
     PhabricatorRepository $repository,
     PhabricatorRepositoryCommit $commit,
     PhabricatorRepositoryCommitData $data) {
 
     $message = $this->renderValueForCommitMessage($is_edit = false);
 
     $user = id(new PhabricatorUser())->loadOneWhere(
       'phid = %s',
       $data->getCommitDetail('authorPHID'));
     if (!$user) {
       // TODO: Maybe after grey users, we should find a way to proceed even
       // if we don't know who the author is.
       return;
     }
 
     $commit_names = self::findRevertedCommits($message);
     if ($commit_names) {
       $reverts = id(new DiffusionCommitQuery())
         ->setViewer($user)
         ->withIdentifiers($commit_names)
         ->withDefaultRepository($repository)
         ->execute();
       foreach ($reverts as $revert) {
         // TODO: Do interesting things here.
       }
     }
 
     $tasks_statuses = $this->findMentionedTasks($message);
     if (!$tasks_statuses) {
       return;
     }
 
     $tasks = id(new ManiphestTaskQuery())
       ->setViewer($user)
-      ->withTaskIDs(array_keys($tasks_statuses))
+      ->withIDs(array_keys($tasks_statuses))
       ->execute();
 
     foreach ($tasks as $task_id => $task) {
       id(new PhabricatorEdgeEditor())
         ->setActor($user)
         ->addEdge(
           $task->getPHID(),
           PhabricatorEdgeConfig::TYPE_TASK_HAS_COMMIT,
           $commit->getPHID())
         ->save();
 
       $status = $tasks_statuses[$task_id];
       if (!$status) {
         // Text like "Ref T123", don't change the task status.
         continue;
       }
 
       if ($task->getStatus() != ManiphestTaskStatus::STATUS_OPEN) {
         // Task is already closed.
         continue;
       }
 
       $commit_name = $repository->formatCommitName(
         $commit->getCommitIdentifier());
 
       $call = new ConduitCall(
         'maniphest.update',
         array(
           'id'        => $task->getID(),
           'status'    => $status,
           'comments'  => "Closed by commit {$commit_name}.",
         ));
 
       $call->setUser($user);
       $call->execute();
     }
   }
 
 }
diff --git a/src/applications/maniphest/ManiphestTaskQuery.php b/src/applications/maniphest/ManiphestTaskQuery.php
index 9f0703a8f2..5c423b3a0b 100644
--- a/src/applications/maniphest/ManiphestTaskQuery.php
+++ b/src/applications/maniphest/ManiphestTaskQuery.php
@@ -1,732 +1,720 @@
 <?php
 
 /**
  * Query tasks by specific criteria. This class uses the higher-performance
  * but less-general Maniphest indexes to satisfy queries.
  *
  * @group maniphest
  */
 final class ManiphestTaskQuery extends PhabricatorQuery {
 
   private $taskIDs             = array();
   private $taskPHIDs           = array();
   private $authorPHIDs         = array();
   private $ownerPHIDs          = array();
   private $includeUnowned      = null;
   private $projectPHIDs        = array();
   private $xprojectPHIDs       = array();
   private $subscriberPHIDs     = array();
   private $anyProjectPHIDs     = array();
   private $anyUserProjectPHIDs = array();
   private $includeNoProject    = null;
 
   private $fullTextSearch   = '';
 
   private $status           = 'status-any';
   const STATUS_ANY          = 'status-any';
   const STATUS_OPEN         = 'status-open';
   const STATUS_CLOSED       = 'status-closed';
   const STATUS_RESOLVED     = 'status-resolved';
   const STATUS_WONTFIX      = 'status-wontfix';
   const STATUS_INVALID      = 'status-invalid';
   const STATUS_SPITE        = 'status-spite';
   const STATUS_DUPLICATE    = 'status-duplicate';
 
   private $priority         = null;
 
   private $minPriority      = null;
   private $maxPriority      = null;
 
   private $groupBy          = 'group-none';
   const GROUP_NONE          = 'group-none';
   const GROUP_PRIORITY      = 'group-priority';
   const GROUP_OWNER         = 'group-owner';
   const GROUP_STATUS        = 'group-status';
   const GROUP_PROJECT       = 'group-project';
 
   private $orderBy          = 'order-modified';
   const ORDER_PRIORITY      = 'order-priority';
   const ORDER_CREATED       = 'order-created';
   const ORDER_MODIFIED      = 'order-modified';
   const ORDER_TITLE         = 'order-title';
 
   private $limit            = null;
   const DEFAULT_PAGE_SIZE   = 1000;
 
   private $offset           = 0;
   private $calculateRows    = false;
 
   private $rowCount         = null;
 
   private $groupByProjectResults = null; // See comment at bottom for details
   private $viewer;
 
   public function setViewer(PhabricatorUser $viewer) {
     $this->viewer = $viewer;
     return $this;
   }
 
   public function getViewer() {
     return $this->viewer;
   }
 
   public function withAuthors(array $authors) {
     $this->authorPHIDs = $authors;
     return $this;
   }
 
   public function withIDs(array $ids) {
     $this->taskIDs = $ids;
     return $this;
   }
 
   public function withPHIDs(array $phids) {
     $this->taskPHIDs = $phids;
     return $this;
   }
 
-  // TODO: Deprecated in favor of `withIDs()`.
-  public function withTaskIDs(array $ids) {
-    $this->taskIDs = $ids;
-    return $this;
-  }
-
-  // TODO: Deprecated in favor of `withPHIDs()`.
-  public function withTaskPHIDs(array $phids) {
-    $this->taskPHIDs = $phids;
-    return $this;
-  }
-
   public function withOwners(array $owners) {
     $this->includeUnowned = false;
     foreach ($owners as $k => $phid) {
       if ($phid == ManiphestTaskOwner::OWNER_UP_FOR_GRABS || $phid === null) {
         $this->includeUnowned = true;
         unset($owners[$k]);
         break;
       }
     }
     $this->ownerPHIDs = $owners;
     return $this;
   }
 
   public function withAllProjects(array $projects) {
     $this->includeNoProject = false;
     foreach ($projects as $k => $phid) {
       if ($phid == ManiphestTaskOwner::PROJECT_NO_PROJECT) {
         $this->includeNoProject = true;
         unset($projects[$k]);
       }
     }
     $this->projectPHIDs = $projects;
     return $this;
   }
 
   public function withoutProjects(array $projects) {
     $this->xprojectPHIDs = $projects;
     return $this;
   }
 
   public function withStatus($status) {
     $this->status = $status;
     return $this;
   }
 
   public function withPriority($priority) {
     $this->priority = $priority;
     return $this;
   }
 
   public function withPrioritiesBetween($min, $max) {
     $this->minPriority = $min;
     $this->maxPriority = $max;
     return $this;
   }
 
   public function withSubscribers(array $subscribers) {
     $this->subscriberPHIDs = $subscribers;
     return $this;
   }
 
   public function withFullTextSearch($fulltext_search) {
     $this->fullTextSearch = $fulltext_search;
     return $this;
   }
 
   public function setGroupBy($group) {
     $this->groupBy = $group;
     return $this;
   }
 
   public function setOrderBy($order) {
     $this->orderBy = $order;
     return $this;
   }
 
   public function setLimit($limit) {
     $this->limit = $limit;
     return $this;
   }
 
   public function setOffset($offset) {
     $this->offset = $offset;
     return $this;
   }
 
   public function setCalculateRows($calculate_rows) {
     $this->calculateRows = $calculate_rows;
     return $this;
   }
 
   public function getRowCount() {
     if ($this->rowCount === null) {
       throw new Exception(
         "You must execute a query with setCalculateRows() before you can ".
         "retrieve a row count.");
     }
     return $this->rowCount;
   }
 
   public function getGroupByProjectResults() {
     return $this->groupByProjectResults;
   }
 
   public function withAnyProjects(array $projects) {
     $this->anyProjectPHIDs = $projects;
     return $this;
   }
 
   public function withAnyUserProjects(array $users) {
     $this->anyUserProjectPHIDs = $users;
     return $this;
   }
 
   /**
    * This is a wrapper until we finish T603. The newer query class this class
    * will inherit from handles catching this exception already.
    */
   public function execute() {
 
     try {
       $result = $this->executeManiphestQuery();
     } catch (PhabricatorEmptyQueryException $ex) {
       $result = array();
       if ($this->calculateRows) {
         $this->rowCount = 0;
       }
     }
 
     return $result;
   }
 
   private function executeManiphestQuery() {
 
     $task_dao = new ManiphestTask();
     $conn = $task_dao->establishConnection('r');
 
     if ($this->calculateRows) {
       $calc = 'SQL_CALC_FOUND_ROWS';
     } else {
       $calc = '';
     }
 
     $where = array();
     $where[] = $this->buildTaskIDsWhereClause($conn);
     $where[] = $this->buildTaskPHIDsWhereClause($conn);
     $where[] = $this->buildStatusWhereClause($conn);
     $where[] = $this->buildPriorityWhereClause($conn);
     $where[] = $this->buildAuthorWhereClause($conn);
     $where[] = $this->buildOwnerWhereClause($conn);
     $where[] = $this->buildSubscriberWhereClause($conn);
     $where[] = $this->buildProjectWhereClause($conn);
     $where[] = $this->buildAnyProjectWhereClause($conn);
     $where[] = $this->buildAnyUserProjectWhereClause($conn);
     $where[] = $this->buildXProjectWhereClause($conn);
     $where[] = $this->buildFullTextWhereClause($conn);
 
     $where = $this->formatWhereClause($where);
 
     $join = array();
     $join[] = $this->buildProjectJoinClause($conn);
     $join[] = $this->buildAnyProjectJoinClause($conn);
     $join[] = $this->buildXProjectJoinClause($conn);
     $join[] = $this->buildSubscriberJoinClause($conn);
 
     $join = array_filter($join);
     if ($join) {
       $join = implode(' ', $join);
     } else {
       $join = '';
     }
 
     $having = '';
     $count = '';
     $group = '';
 
     if (count($this->projectPHIDs) > 1 || count($this->anyProjectPHIDs) > 1) {
       // If we're joining multiple rows, we need to group the results by the
       // task IDs.
       $group = 'GROUP BY task.id';
     } else {
       $group = '';
     }
 
     if (count($this->projectPHIDs) > 1) {
       // We want to treat the query as an intersection query, not a union
       // query. We sum the project count and require it be the same as the
       // number of projects we're searching for.
 
       $count = ', COUNT(project.projectPHID) projectCount';
       $having = qsprintf(
         $conn,
         'HAVING projectCount = %d',
         count($this->projectPHIDs));
     }
 
     $order = $this->buildOrderClause($conn);
 
     $offset = (int)nonempty($this->offset, 0);
     $limit  = (int)nonempty($this->limit, self::DEFAULT_PAGE_SIZE);
 
     if ($this->groupBy == self::GROUP_PROJECT) {
       $limit  = PHP_INT_MAX;
       $offset = 0;
     }
 
     $data = queryfx_all(
       $conn,
       'SELECT %Q * %Q FROM %T task %Q %Q %Q %Q %Q LIMIT %d, %d',
       $calc,
       $count,
       $task_dao->getTableName(),
       $join,
       $where,
       $group,
       $having,
       $order,
       $offset,
       $limit);
 
     if ($this->calculateRows) {
       $count = queryfx_one(
         $conn,
         'SELECT FOUND_ROWS() N');
       $this->rowCount = $count['N'];
     } else {
       $this->rowCount = null;
     }
 
     $tasks = $task_dao->loadAllFromArray($data);
 
     if ($this->groupBy == self::GROUP_PROJECT) {
       $tasks = $this->applyGroupByProject($tasks);
     }
 
     return $tasks;
   }
 
   private function buildTaskIDsWhereClause(AphrontDatabaseConnection $conn) {
     if (!$this->taskIDs) {
       return null;
     }
 
     return qsprintf(
       $conn,
       'id in (%Ld)',
       $this->taskIDs);
   }
 
   private function buildTaskPHIDsWhereClause(AphrontDatabaseConnection $conn) {
     if (!$this->taskPHIDs) {
       return null;
     }
 
     return qsprintf(
       $conn,
       'phid in (%Ls)',
       $this->taskPHIDs);
   }
 
   private function buildStatusWhereClause(AphrontDatabaseConnection $conn) {
 
     static $map = array(
       self::STATUS_RESOLVED   => ManiphestTaskStatus::STATUS_CLOSED_RESOLVED,
       self::STATUS_WONTFIX    => ManiphestTaskStatus::STATUS_CLOSED_WONTFIX,
       self::STATUS_INVALID    => ManiphestTaskStatus::STATUS_CLOSED_INVALID,
       self::STATUS_SPITE      => ManiphestTaskStatus::STATUS_CLOSED_SPITE,
       self::STATUS_DUPLICATE  => ManiphestTaskStatus::STATUS_CLOSED_DUPLICATE,
     );
 
     switch ($this->status) {
       case self::STATUS_ANY:
         return null;
       case self::STATUS_OPEN:
         return 'status = 0';
       case self::STATUS_CLOSED:
         return 'status > 0';
       default:
         $constant = idx($map, $this->status);
         if (!$constant) {
           throw new Exception("Unknown status query '{$this->status}'!");
         }
         return qsprintf(
           $conn,
           'status = %d',
           $constant);
     }
   }
 
   private function buildPriorityWhereClause(AphrontDatabaseConnection $conn) {
     if ($this->priority !== null) {
       return qsprintf(
         $conn,
         'priority = %d',
         $this->priority);
     } elseif ($this->minPriority !== null && $this->maxPriority !== null) {
       return qsprintf(
         $conn,
         'priority >= %d AND priority <= %d',
         $this->minPriority,
         $this->maxPriority);
     }
 
     return null;
   }
 
   private function buildAuthorWhereClause(AphrontDatabaseConnection $conn) {
     if (!$this->authorPHIDs) {
       return null;
     }
 
     return qsprintf(
       $conn,
       'authorPHID in (%Ls)',
       $this->authorPHIDs);
   }
 
   private function buildOwnerWhereClause(AphrontDatabaseConnection $conn) {
     if (!$this->ownerPHIDs) {
       if ($this->includeUnowned === null) {
         return null;
       } else if ($this->includeUnowned) {
         return qsprintf(
           $conn,
           'ownerPHID IS NULL');
       } else {
         return qsprintf(
           $conn,
           'ownerPHID IS NOT NULL');
       }
     }
 
     if ($this->includeUnowned) {
       return qsprintf(
         $conn,
         'ownerPHID IN (%Ls) OR ownerPHID IS NULL',
         $this->ownerPHIDs);
     } else {
       return qsprintf(
         $conn,
         'ownerPHID IN (%Ls)',
         $this->ownerPHIDs);
     }
   }
 
   private function buildFullTextWhereClause(AphrontDatabaseConnection $conn) {
     if (!$this->fullTextSearch) {
       return null;
     }
 
     // In doing a fulltext search, we first find all the PHIDs that match the
     // fulltext search, and then use that to limit the rest of the search
     $fulltext_query = new PhabricatorSearchQuery();
     $fulltext_query->setQuery($this->fullTextSearch);
     $fulltext_query->setParameter('limit', PHP_INT_MAX);
 
     $engine = PhabricatorSearchEngineSelector::newSelector()->newEngine();
     $fulltext_results = $engine->executeSearch($fulltext_query);
 
     if (empty($fulltext_results)) {
       $fulltext_results = array(null);
     }
 
     return qsprintf(
       $conn,
       'phid IN (%Ls)',
       $fulltext_results);
   }
 
   private function buildSubscriberWhereClause(AphrontDatabaseConnection $conn) {
     if (!$this->subscriberPHIDs) {
       return null;
     }
 
     return qsprintf(
       $conn,
       'subscriber.subscriberPHID IN (%Ls)',
       $this->subscriberPHIDs);
   }
 
   private function buildProjectWhereClause(AphrontDatabaseConnection $conn) {
     if (!$this->projectPHIDs && !$this->includeNoProject) {
       return null;
     }
 
     $parts = array();
     if ($this->projectPHIDs) {
       $parts[] = qsprintf(
         $conn,
         'project.projectPHID in (%Ls)',
         $this->projectPHIDs);
     }
     if ($this->includeNoProject) {
       $parts[] = qsprintf(
         $conn,
         'project.projectPHID IS NULL');
     }
 
     return '('.implode(') OR (', $parts).')';
   }
 
   private function buildProjectJoinClause(AphrontDatabaseConnection $conn) {
     if (!$this->projectPHIDs && !$this->includeNoProject) {
       return null;
     }
 
     $project_dao = new ManiphestTaskProject();
     return qsprintf(
       $conn,
       '%Q JOIN %T project ON project.taskPHID = task.phid',
       ($this->includeNoProject ? 'LEFT' : ''),
       $project_dao->getTableName());
   }
 
   private function buildAnyProjectWhereClause(AphrontDatabaseConnection $conn) {
     if (!$this->anyProjectPHIDs) {
       return null;
     }
 
     return qsprintf(
       $conn,
       'anyproject.projectPHID IN (%Ls)',
       $this->anyProjectPHIDs);
   }
 
   private function buildAnyUserProjectWhereClause(
     AphrontDatabaseConnection $conn) {
     if (!$this->anyUserProjectPHIDs) {
       return null;
     }
 
     $projects = id(new PhabricatorProjectQuery())
       ->setViewer($this->viewer)
       ->withMemberPHIDs($this->anyUserProjectPHIDs)
       ->execute();
     $any_user_project_phids = mpull($projects, 'getPHID');
     if (!$any_user_project_phids) {
       throw new PhabricatorEmptyQueryException();
     }
 
     return qsprintf(
       $conn,
       'anyproject.projectPHID IN (%Ls)',
       $any_user_project_phids);
   }
 
   private function buildAnyProjectJoinClause(AphrontDatabaseConnection $conn) {
     if (!$this->anyProjectPHIDs && !$this->anyUserProjectPHIDs) {
       return null;
     }
 
     $project_dao = new ManiphestTaskProject();
     return qsprintf(
       $conn,
       'JOIN %T anyproject ON anyproject.taskPHID = task.phid',
       $project_dao->getTableName());
   }
 
   private function buildXProjectWhereClause(AphrontDatabaseConnection $conn) {
     if (!$this->xprojectPHIDs) {
       return null;
     }
 
     return qsprintf(
       $conn,
       'xproject.projectPHID IS NULL');
   }
 
   private function buildXProjectJoinClause(AphrontDatabaseConnection $conn) {
     if (!$this->xprojectPHIDs) {
       return null;
     }
 
     $project_dao = new ManiphestTaskProject();
     return qsprintf(
       $conn,
       'LEFT JOIN %T xproject ON xproject.taskPHID = task.phid
         AND xproject.projectPHID IN (%Ls)',
       $project_dao->getTableName(),
       $this->xprojectPHIDs);
   }
 
   private function buildSubscriberJoinClause(AphrontDatabaseConnection $conn) {
     if (!$this->subscriberPHIDs) {
       return null;
     }
 
     $subscriber_dao = new ManiphestTaskSubscriber();
     return qsprintf(
       $conn,
       'JOIN %T subscriber ON subscriber.taskPHID = task.phid',
       $subscriber_dao->getTableName());
   }
 
   private function buildOrderClause(AphrontDatabaseConnection $conn) {
     $order = array();
 
     switch ($this->groupBy) {
       case self::GROUP_NONE:
         break;
       case self::GROUP_PRIORITY:
         $order[] = 'priority';
         break;
       case self::GROUP_OWNER:
         $order[] = 'ownerOrdering';
         break;
       case self::GROUP_STATUS:
         $order[] = 'status';
         break;
       case self::GROUP_PROJECT:
         // NOTE: We have to load the entire result set and apply this grouping
         // in the PHP process for now.
         break;
       default:
         throw new Exception("Unknown group query '{$this->groupBy}'!");
     }
 
     switch ($this->orderBy) {
       case self::ORDER_PRIORITY:
         $order[] = 'priority';
         $order[] = 'subpriority';
         $order[] = 'dateModified';
         break;
       case self::ORDER_CREATED:
         $order[] = 'id';
         break;
       case self::ORDER_MODIFIED:
         $order[] = 'dateModified';
         break;
       case self::ORDER_TITLE:
         $order[] = 'title';
         break;
       default:
         throw new Exception("Unknown order query '{$this->orderBy}'!");
     }
 
     $order = array_unique($order);
 
     if (empty($order)) {
       return null;
     }
 
     foreach ($order as $k => $column) {
       switch ($column) {
         case 'subpriority':
         case 'ownerOrdering':
         case 'title':
           $order[$k] = "task.{$column} ASC";
           break;
         default:
           $order[$k] = "task.{$column} DESC";
           break;
       }
     }
 
     return 'ORDER BY '.implode(', ', $order);
   }
 
 
   /**
    * To get paging to work for "group by project", we need to do a bunch of
    * server-side magic since there's currently no way to sort by project name on
    * the database.
    *
    * As a consequence of this, moreover, because the list we return from here
    * may include a single task multiple times (once for each project it's in),
    * sorting gets screwed up in the controller unless we tell it which project
    * to put the task in each time it appears. Hence the magic field
    * groupByProjectResults.
    *
    * TODO: Move this all to the database.
    */
   private function applyGroupByProject(array $tasks) {
     assert_instances_of($tasks, 'ManiphestTask');
 
     $project_phids = array();
     foreach ($tasks as $task) {
       foreach ($task->getProjectPHIDs() as $phid) {
         $project_phids[$phid] = true;
       }
     }
 
     // TODO: This should use the query's viewer once this class extends
     // PhabricatorPolicyQuery (T603).
 
     $handles = id(new PhabricatorObjectHandleData(array_keys($project_phids)))
       ->setViewer(PhabricatorUser::getOmnipotentUser())
       ->loadHandles();
 
     $max = 1;
     foreach ($handles as $handle) {
       $max = max($max, strlen($handle->getName()));
     }
 
     $items = array();
     $ii = 0;
     foreach ($tasks as $key => $task) {
       $phids = $task->getProjectPHIDs();
       if ($this->projectPHIDs) {
         $phids = array_diff($phids, $this->projectPHIDs);
       }
       if ($phids) {
         foreach ($phids as $phid) {
           $items[] = array(
             'key'  => $key,
             'proj' => $phid,
             'seq'  => sprintf(
               '%'.$max.'s%09d',
               $handles[$phid]->getName(),
               $ii),
           );
         }
       } else {
         // Sort "no project" tasks first.
         $items[] = array(
           'key'  => $key,
           'proj' => null,
           'seq'  => sprintf(
             '%'.$max.'s%09d',
             '',
             $ii),
         );
       }
       ++$ii;
     }
 
     $items = isort($items, 'seq');
     $items = array_slice(
       $items,
       nonempty($this->offset),
       nonempty($this->limit, self::DEFAULT_PAGE_SIZE));
 
     $result = array();
     $projects = array();
     foreach ($items as $item) {
       $result[] = $projects[$item['proj']][] = $tasks[$item['key']];
     }
     $this->groupByProjectResults = $projects;
 
     return $result;
   }
 
 }
diff --git a/src/applications/maniphest/conduit/ConduitAPI_maniphest_query_Method.php b/src/applications/maniphest/conduit/ConduitAPI_maniphest_query_Method.php
index fc3397f79e..7ad32d03e9 100644
--- a/src/applications/maniphest/conduit/ConduitAPI_maniphest_query_Method.php
+++ b/src/applications/maniphest/conduit/ConduitAPI_maniphest_query_Method.php
@@ -1,129 +1,129 @@
 <?php
 
 /**
  * @group conduit
  *
  * TODO: Remove maniphest.find, then make this final.
  *
  * @concrete-extensible
  */
 class ConduitAPI_maniphest_query_Method
   extends ConduitAPI_maniphest_Method {
 
 
   public function getMethodDescription() {
     return "Execute complex searches for Maniphest tasks.";
   }
 
   public function defineParamTypes() {
 
     $statuses = array(
       ManiphestTaskQuery::STATUS_ANY,
       ManiphestTaskQuery::STATUS_OPEN,
       ManiphestTaskQuery::STATUS_CLOSED,
       ManiphestTaskQuery::STATUS_RESOLVED,
       ManiphestTaskQuery::STATUS_WONTFIX,
       ManiphestTaskQuery::STATUS_INVALID,
       ManiphestTaskQuery::STATUS_SPITE,
       ManiphestTaskQuery::STATUS_DUPLICATE,
     );
     $statuses = implode(', ', $statuses);
 
     $orders = array(
       ManiphestTaskQuery::ORDER_PRIORITY,
       ManiphestTaskQuery::ORDER_CREATED,
       ManiphestTaskQuery::ORDER_MODIFIED,
     );
     $orders = implode(', ', $orders);
 
     return array(
       'ids'               => 'optional list<uint>',
       'phids'             => 'optional list<phid>',
       'ownerPHIDs'        => 'optional list<phid>',
       'authorPHIDs'       => 'optional list<phid>',
       'projectPHIDs'      => 'optional list<phid>',
       'ccPHIDs'           => 'optional list<phid>',
       'fullText'          => 'optional string',
 
       'status'            => 'optional enum<'.$statuses.'>',
       'order'             => 'optional enum<'.$orders.'>',
 
       'limit'             => 'optional int',
       'offset'            => 'optional int',
     );
   }
 
   public function defineReturnType() {
     return 'list';
   }
 
   public function defineErrorTypes() {
     return array(
     );
   }
 
   protected function execute(ConduitAPIRequest $request) {
     $query = new ManiphestTaskQuery();
 
     $query->setViewer($request->getUser());
 
     $task_ids = $request->getValue('ids');
     if ($task_ids) {
-      $query->withTaskIDs($task_ids);
+      $query->withIDs($task_ids);
     }
 
     $task_phids = $request->getValue('phids');
     if ($task_phids) {
-      $query->withTaskPHIDs($task_phids);
+      $query->withPHIDs($task_phids);
     }
 
     $owners = $request->getValue('ownerPHIDs');
     if ($owners) {
       $query->withOwners($owners);
     }
 
     $authors = $request->getValue('authorPHIDs');
     if ($authors) {
       $query->withAuthors($authors);
     }
 
     $projects = $request->getValue('projectPHIDs');
     if ($projects) {
       $query->withAllProjects($projects);
     }
 
     $ccs = $request->getValue('ccPHIDs');
     if ($ccs) {
       $query->withSubscribers($ccs);
     }
 
     $full_text = $request->getValue('fullText');
     if ($full_text) {
       $query->withFullTextSearch($full_text);
     }
 
     $status = $request->getValue('status');
     if ($status) {
       $query->withStatus($status);
     }
 
     $order = $request->getValue('order');
     if ($order) {
       $query->setOrderBy($order);
     }
 
     $limit = $request->getValue('limit');
     if ($limit) {
       $query->setLimit($limit);
     }
 
     $offset = $request->getValue('offset');
     if ($offset) {
       $query->setOffset($offset);
     }
 
     $results = $query->execute();
     return $this->buildTaskInfoDictionaries($results);
   }
 
 }
diff --git a/src/applications/maniphest/controller/ManiphestTaskListController.php b/src/applications/maniphest/controller/ManiphestTaskListController.php
index 3bb615c7d4..289616b7ec 100644
--- a/src/applications/maniphest/controller/ManiphestTaskListController.php
+++ b/src/applications/maniphest/controller/ManiphestTaskListController.php
@@ -1,977 +1,977 @@
 <?php
 
 /**
  * @group maniphest
  */
 final class ManiphestTaskListController extends ManiphestController {
 
   const DEFAULT_PAGE_SIZE = 1000;
 
   private $view;
 
   public function willProcessRequest(array $data) {
     $this->view = idx($data, 'view');
   }
 
   private function getArrToStrList($key) {
     $arr = $this->getRequest()->getArr($key);
     $arr = implode(',', $arr);
     return nonempty($arr, null);
   }
 
   public function processRequest() {
 
     $request = $this->getRequest();
     $user = $request->getUser();
 
     if ($request->isFormPost()) {
       // Redirect to GET so URIs can be copy/pasted.
 
       $task_ids   = $request->getStr('set_tasks');
       $task_ids   = nonempty($task_ids, null);
 
       $search_text = $request->getStr('set_search');
 
       $min_priority = $request->getInt('set_lpriority');
 
       $max_priority = $request->getInt('set_hpriority');
 
       $uri = $request->getRequestURI()
         ->alter('users',         $this->getArrToStrList('set_users'))
         ->alter('projects',      $this->getArrToStrList('set_projects'))
         ->alter('aprojects',     $this->getArrToStrList('set_aprojects'))
         ->alter('useraprojects', $this->getArrToStrList('set_useraprojects'))
         ->alter('xprojects',     $this->getArrToStrList('set_xprojects'))
         ->alter('owners',        $this->getArrToStrList('set_owners'))
         ->alter('authors',       $this->getArrToStrList('set_authors'))
         ->alter('lpriority',     $min_priority)
         ->alter('hpriority',     $max_priority)
         ->alter('tasks',         $task_ids)
         ->alter('search',        $search_text);
 
       return id(new AphrontRedirectResponse())->setURI($uri);
     }
 
     $nav = $this->buildBaseSideNav();
 
     $has_filter = array(
       'action' => true,
       'created' => true,
       'subscribed' => true,
       'triage' => true,
       'projecttriage' => true,
       'projectall' => true,
     );
 
     $query = null;
     $key = $request->getStr('key');
     if (!$key && !$this->view) {
       if ($this->getDefaultQuery()) {
         $key = $this->getDefaultQuery()->getQueryKey();
       }
     }
 
     if ($key) {
       $query = id(new PhabricatorSearchQuery())->loadOneWhere(
         'queryKey = %s',
         $key);
     }
 
     // If the user is running a saved query, load query parameters from that
     // query. Otherwise, build a new query object from the HTTP request.
 
     if ($query) {
       $nav->selectFilter('Q:'.$query->getQueryKey(), 'custom');
       $this->view = 'custom';
     } else {
       $this->view = $nav->selectFilter($this->view, 'action');
       $query = $this->buildQueryFromRequest();
     }
 
     // Execute the query.
 
     list($tasks, $handles, $total_count) = self::loadTasks(
       $query,
       $user);
 
     // Extract information we need to render the filters from the query.
 
     $search_text    = $query->getParameter('fullTextSearch');
 
     $user_phids     = $query->getParameter('userPHIDs', array());
     $task_ids       = $query->getParameter('taskIDs', array());
     $owner_phids    = $query->getParameter('ownerPHIDs', array());
     $author_phids   = $query->getParameter('authorPHIDs', array());
     $project_phids  = $query->getParameter('projectPHIDs', array());
     $any_project_phids = $query->getParameter(
       'anyProjectPHIDs',
       array());
     $any_user_project_phids = $query->getParameter(
       'anyUserProjectPHIDs',
       array());
     $exclude_project_phids = $query->getParameter(
       'excludeProjectPHIDs',
       array());
     $low_priority   = $query->getParameter('lowPriority');
     $high_priority  = $query->getParameter('highPriority');
 
     $page_size = $query->getParameter('limit');
     $page = $query->getParameter('offset');
 
     $q_status = $query->getParameter('status');
     $q_group  = $query->getParameter('group');
     $q_order  = $query->getParameter('order');
 
     $form = id(new AphrontFormView())
       ->setUser($user)
       ->setAction(
           $request->getRequestURI()
             ->alter('key', null)
             ->alter(
               $this->getStatusRequestKey(),
               $this->getStatusRequestValue($q_status))
             ->alter(
               $this->getOrderRequestKey(),
               $this->getOrderRequestValue($q_order))
             ->alter(
               $this->getGroupRequestKey(),
               $this->getGroupRequestValue($q_group)));
 
     if (isset($has_filter[$this->view])) {
       $tokens = array();
       foreach ($user_phids as $phid) {
         $tokens[$phid] = $handles[$phid]->getFullName();
       }
       $form->appendChild(
         id(new AphrontFormTokenizerControl())
           ->setDatasource('/typeahead/common/searchowner/')
           ->setName('set_users')
           ->setLabel(pht('Users'))
           ->setValue($tokens));
     }
 
     if ($this->view == 'custom') {
       $form->appendChild(
         id(new AphrontFormTextControl())
           ->setName('set_search')
           ->setLabel(pht('Search'))
           ->setValue($search_text));
       $form->appendChild(
         id(new AphrontFormTextControl())
           ->setName('set_tasks')
           ->setLabel(pht('Task IDs'))
           ->setValue(join(',', $task_ids)));
 
       $tokens = array();
       foreach ($owner_phids as $phid) {
         $tokens[$phid] = $handles[$phid]->getFullName();
       }
       $form->appendChild(
         id(new AphrontFormTokenizerControl())
           ->setDatasource('/typeahead/common/searchowner/')
           ->setName('set_owners')
           ->setLabel(pht('Owners'))
           ->setValue($tokens));
 
       $tokens = array();
       foreach ($author_phids as $phid) {
         $tokens[$phid] = $handles[$phid]->getFullName();
       }
       $form->appendChild(
         id(new AphrontFormTokenizerControl())
           ->setDatasource('/typeahead/common/authors/')
           ->setName('set_authors')
           ->setLabel(pht('Authors'))
           ->setValue($tokens));
     }
 
     $tokens = array();
     foreach ($project_phids as $phid) {
       $tokens[$phid] = $handles[$phid]->getFullName();
     }
     if ($this->view != 'projectall' && $this->view != 'projecttriage') {
 
       $caption = null;
       if ($this->view == 'custom') {
         $caption = pht('Find tasks in ALL of these projects ("AND" query).');
       }
 
       $form->appendChild(
         id(new AphrontFormTokenizerControl())
           ->setDatasource('/typeahead/common/searchproject/')
           ->setName('set_projects')
           ->setLabel(pht('Projects'))
           ->setCaption($caption)
           ->setValue($tokens));
     }
 
     if ($this->view == 'custom') {
       $atokens = array();
       foreach ($any_project_phids as $phid) {
         $atokens[$phid] = $handles[$phid]->getFullName();
       }
       $form->appendChild(
         id(new AphrontFormTokenizerControl())
           ->setDatasource('/typeahead/common/projects/')
           ->setName('set_aprojects')
           ->setLabel(pht('Any Projects'))
           ->setCaption(pht('Find tasks in ANY of these projects ("OR" query).'))
           ->setValue($atokens));
 
       $tokens = array();
       foreach ($any_user_project_phids as $phid) {
         $tokens[$phid] = $handles[$phid]->getFullName();
       }
       $form->appendChild(
         id(new AphrontFormTokenizerControl())
         ->setDatasource('/typeahead/common/users/')
         ->setName('set_useraprojects')
         ->setLabel(pht('Any User Projects'))
         ->setCaption(
           pht('Find tasks in ANY of these users\' projects ("OR" query).'))
         ->setValue($tokens));
 
       $tokens = array();
       foreach ($exclude_project_phids as $phid) {
         $tokens[$phid] = $handles[$phid]->getFullName();
       }
       $form->appendChild(
         id(new AphrontFormTokenizerControl())
           ->setDatasource('/typeahead/common/projects/')
           ->setName('set_xprojects')
           ->setLabel(pht('Exclude Projects'))
           ->setCaption(pht('Find tasks NOT in any of these projects.'))
           ->setValue($tokens));
 
       $priority = ManiphestTaskPriority::getLowestPriority();
       if ($low_priority !== null) {
         $priority = $low_priority;
       }
 
       $form->appendChild(
           id(new AphrontFormSelectControl())
             ->setLabel(pht('Min Priority'))
             ->setName('set_lpriority')
             ->setValue($priority)
             ->setOptions(array_reverse(
                 ManiphestTaskPriority::getTaskPriorityMap(), true)));
 
       $priority = ManiphestTaskPriority::getHighestPriority();
       if ($high_priority !== null) {
         $priority = $high_priority;
       }
 
       $form->appendChild(
           id(new AphrontFormSelectControl())
             ->setLabel(pht('Max Priority'))
             ->setName('set_hpriority')
             ->setValue($priority)
             ->setOptions(ManiphestTaskPriority::getTaskPriorityMap()));
 
     }
 
     $form
       ->appendChild($this->renderStatusControl($q_status))
       ->appendChild($this->renderGroupControl($q_group))
       ->appendChild($this->renderOrderControl($q_order));
 
     $submit = id(new AphrontFormSubmitControl())
       ->setValue(pht('Filter Tasks'));
 
     // Only show "Save..." for novel queries which have some kind of query
     // parameters set.
     if ($this->view === 'custom'
         && empty($key)
         && $request->getRequestURI()->getQueryParams()) {
       $submit->addCancelButton(
         '/maniphest/custom/edit/?key='.$query->getQueryKey(),
         pht('Save Custom Query...'));
     }
 
     $form->appendChild($submit);
 
     $create_uri = new PhutilURI('/maniphest/task/create/');
     if ($project_phids) {
       // If we have project filters selected, use them as defaults for task
       // creation.
       $create_uri->setQueryParam('projects', implode(';', $project_phids));
     }
 
     $filter = new AphrontListFilterView();
     if (empty($key)) {
       $filter->appendChild($form);
     }
 
     $have_tasks = false;
     foreach ($tasks as $group => $list) {
       if (count($list)) {
         $have_tasks = true;
         break;
       }
     }
 
     require_celerity_resource('maniphest-task-summary-css');
 
     $list_container = new AphrontNullView();
     $list_container->appendChild(hsprintf(
       '<div class="maniphest-list-container">'));
 
     if (!$have_tasks) {
       $no_tasks = pht('No matching tasks.');
       $list_container->appendChild(hsprintf(
         '<h1 class="maniphest-task-group-header">'.
           '%s'.
         '</h1>',
         $no_tasks));
       $result_count = null;
     } else {
       $pager = new AphrontPagerView();
       $pager->setURI($request->getRequestURI(), 'offset');
       $pager->setPageSize($page_size);
       $pager->setOffset($page);
       $pager->setCount($total_count);
 
       $cur = ($pager->getOffset() + 1);
       $max = min($pager->getOffset() + $page_size, $total_count);
       $tot = $total_count;
 
       $results = pht('Displaying tasks %s - %s of %s.',
         number_format($cur),
         number_format($max),
         number_format($tot));
       $result_count = phutil_tag(
         'div',
         array(
           'class' => 'maniphest-total-result-count'
         ),
         $results);
 
       $selector = new AphrontNullView();
 
       $group = $query->getParameter('group');
       $order = $query->getParameter('order');
       $is_draggable =
         ($order == 'priority') &&
         ($group == 'none' || $group == 'priority');
 
       $lists = array();
       foreach ($tasks as $group => $list) {
         $task_list = new ManiphestTaskListView();
         $task_list->setShowBatchControls(true);
         if ($is_draggable) {
           $task_list->setShowSubpriorityControls(true);
         }
         $task_list->setUser($user);
         $task_list->setTasks($list);
         $task_list->setHandles($handles);
 
         $count = number_format(count($list));
 
         $header =
           javelin_tag(
             'h1',
             array(
               'class' => 'maniphest-task-group-header',
               'sigil' => 'task-group',
               'meta'  => array(
                 'priority' => head($list)->getPriority(),
               ),
             ),
             $group.' ('.$count.')');
 
         $lists[] =
           phutil_tag(
             'div',
             array(
               'class' => 'maniphest-task-group'
             ),
             array(
               $header,
               $task_list,
             ));
       }
 
       $selector->appendChild($lists);
       $selector->appendChild($this->renderBatchEditor($query));
 
       $list_container->appendChild($selector);
       $list_container->appendChild($pager);
 
       Javelin::initBehavior(
         'maniphest-subpriority-editor',
         array(
           'uri'   =>  '/maniphest/subpriority/',
         ));
     }
 
     $nav->appendChild($filter);
     $nav->appendChild($result_count);
     $nav->appendChild($list_container);
 
     $title = pht('Task List');
 
     $crumbs = $this->buildApplicationCrumbs()
       ->addCrumb(
         id(new PhabricatorCrumbView())
           ->setName($title))
       ->addAction(
         id(new PHUIListItemView())
           ->setHref($this->getApplicationURI('/task/create/'))
           ->setName(pht('Create Task'))
           ->setIcon('create'));
 
     $nav->setCrumbs($crumbs);
 
     return $this->buildApplicationPage(
       $nav,
       array(
         'title' => $title,
         'device' => true,
       ));
   }
 
   public static function loadTasks(
     PhabricatorSearchQuery $search_query,
     PhabricatorUser $viewer) {
 
     $any_project = false;
     $search_text = $search_query->getParameter('fullTextSearch');
     $user_phids = $search_query->getParameter('userPHIDs', array());
     $task_ids = $search_query->getParameter('taskIDs', array());
     $project_phids = $search_query->getParameter('projectPHIDs', array());
     $any_project_phids = $search_query->getParameter(
       'anyProjectPHIDs',
       array());
     $any_user_project_phids = $search_query->getParameter(
       'anyUserProjectPHIDs',
       array());
     $xproject_phids = $search_query->getParameter(
       'excludeProjectPHIDs',
       array());
     $owner_phids = $search_query->getParameter('ownerPHIDs', array());
     $author_phids = $search_query->getParameter('authorPHIDs', array());
 
     $low_priority = $search_query->getParameter('lowPriority');
     $low_priority = coalesce($low_priority,
         ManiphestTaskPriority::getLowestPriority());
     $high_priority = $search_query->getParameter('highPriority');
     $high_priority = coalesce($high_priority,
       ManiphestTaskPriority::getHighestPriority());
 
     $query = new ManiphestTaskQuery();
     $query->setViewer($viewer);
-    $query->withTaskIDs($task_ids);
+    $query->withIDs($task_ids);
 
     if ($project_phids) {
       $query->withAllProjects($project_phids);
     }
 
     if ($xproject_phids) {
       $query->withoutProjects($xproject_phids);
     }
 
     if ($any_project_phids) {
       $query->withAnyProjects($any_project_phids);
     }
 
     if ($owner_phids) {
       $query->withOwners($owner_phids);
     }
 
     if ($author_phids) {
       $query->withAuthors($author_phids);
     }
 
     if ($any_user_project_phids) {
       $query->setViewer($viewer);
       $query->withAnyUserProjects($any_user_project_phids);
     }
 
     $status = $search_query->getParameter('status', 'all');
     if (!empty($status['open']) && !empty($status['closed'])) {
       $query->withStatus(ManiphestTaskQuery::STATUS_ANY);
     } else if (!empty($status['open'])) {
       $query->withStatus(ManiphestTaskQuery::STATUS_OPEN);
     } else {
       $query->withStatus(ManiphestTaskQuery::STATUS_CLOSED);
     }
 
     switch ($search_query->getParameter('view')) {
       case 'action':
         $query->withOwners($user_phids);
         break;
       case 'created':
         $query->withAuthors($user_phids);
         break;
       case 'subscribed':
         $query->withSubscribers($user_phids);
         break;
       case 'triage':
         $query->withOwners($user_phids);
         $query->withPriority(ManiphestTaskPriority::PRIORITY_TRIAGE);
         break;
       case 'alltriage':
         $query->withPriority(ManiphestTaskPriority::PRIORITY_TRIAGE);
         break;
       case 'all':
         break;
       case 'projecttriage':
         $query->withPriority(ManiphestTaskPriority::PRIORITY_TRIAGE);
         break;
       case 'projectall':
         break;
       case 'custom':
         $query->withPrioritiesBetween($low_priority, $high_priority);
         break;
     }
 
     $query->withFullTextSearch($search_text);
 
     $order_map = array(
       'priority'  => ManiphestTaskQuery::ORDER_PRIORITY,
       'created'   => ManiphestTaskQuery::ORDER_CREATED,
       'title'     => ManiphestTaskQuery::ORDER_TITLE,
     );
     $query->setOrderBy(
       idx(
         $order_map,
         $search_query->getParameter('order'),
         ManiphestTaskQuery::ORDER_MODIFIED));
 
     $group_map = array(
       'priority'  => ManiphestTaskQuery::GROUP_PRIORITY,
       'owner'     => ManiphestTaskQuery::GROUP_OWNER,
       'status'    => ManiphestTaskQuery::GROUP_STATUS,
       'project'   => ManiphestTaskQuery::GROUP_PROJECT,
     );
     $query->setGroupBy(
       idx(
         $group_map,
         $search_query->getParameter('group'),
         ManiphestTaskQuery::GROUP_NONE));
 
     $query->setCalculateRows(true);
     $query->setLimit($search_query->getParameter('limit'));
     $query->setOffset($search_query->getParameter('offset'));
 
     $data = $query->execute();
     $total_row_count = $query->getRowCount();
 
     $project_group_phids = array();
     if ($search_query->getParameter('group') == 'project') {
       foreach ($data as $task) {
         foreach ($task->getProjectPHIDs() as $phid) {
           $project_group_phids[] = $phid;
         }
       }
     }
 
     $handle_phids = mpull($data, 'getOwnerPHID');
     $handle_phids = array_merge(
       $handle_phids,
       $project_phids,
       $user_phids,
       $xproject_phids,
       $owner_phids,
       $author_phids,
       $project_group_phids,
       $any_project_phids,
       $any_user_project_phids,
       array_mergev(mpull($data, 'getProjectPHIDs')));
     $handles = id(new PhabricatorObjectHandleData($handle_phids))
       ->setViewer($viewer)
       ->loadHandles();
 
     switch ($search_query->getParameter('group')) {
       case 'priority':
         $data = mgroup($data, 'getPriority');
 
         // If we have invalid priorities, they'll all map to "???". Merge
         // arrays to prevent them from overwriting each other.
 
         $out = array();
         foreach ($data as $pri => $tasks) {
           $out[ManiphestTaskPriority::getTaskPriorityName($pri)][] = $tasks;
         }
         foreach ($out as $pri => $tasks) {
           $out[$pri] = array_mergev($tasks);
         }
         $data = $out;
 
         break;
       case 'status':
         $data = mgroup($data, 'getStatus');
 
         $out = array();
         foreach ($data as $status => $tasks) {
           $out[ManiphestTaskStatus::getTaskStatusFullName($status)] = $tasks;
         }
 
         $data = $out;
         break;
       case 'owner':
         $data = mgroup($data, 'getOwnerPHID');
 
         $out = array();
         foreach ($data as $phid => $tasks) {
           if ($phid) {
             $out[$handles[$phid]->getFullName()] = $tasks;
           } else {
             $out['Unassigned'] = $tasks;
           }
         }
 
         $data = $out;
         ksort($data);
 
         // Move "Unassigned" to the top of the list.
         if (isset($data['Unassigned'])) {
           $data = array('Unassigned' => $out['Unassigned']) + $out;
         }
         break;
       case 'project':
         $grouped = array();
         foreach ($query->getGroupByProjectResults() as $project => $tasks) {
           foreach ($tasks as $task) {
             $group = $project ? $handles[$project]->getName() : 'No Project';
             $grouped[$group][$task->getID()] = $task;
           }
         }
         $data = $grouped;
         ksort($data);
 
         // Move "No Project" to the end of the list.
         if (isset($data['No Project'])) {
           $noproject = $data['No Project'];
           unset($data['No Project']);
           $data += array('No Project' => $noproject);
         }
         break;
       default:
         $data = array(
           'Tasks' => $data,
         );
         break;
     }
 
     return array($data, $handles, $total_row_count);
   }
 
   private function renderBatchEditor(PhabricatorSearchQuery $search_query) {
     $user = $this->getRequest()->getUser();
 
     Javelin::initBehavior(
       'maniphest-batch-selector',
       array(
         'selectAll'   => 'batch-select-all',
         'selectNone'  => 'batch-select-none',
         'submit'      => 'batch-select-submit',
         'status'      => 'batch-select-status-cell',
         'idContainer' => 'batch-select-id-container',
         'formID'      => 'batch-select-form',
       ));
 
     $select_all = javelin_tag(
       'a',
       array(
         'href'        => '#',
         'mustcapture' => true,
         'class'       => 'grey button',
         'id'          => 'batch-select-all',
       ),
       pht('Select All'));
 
     $select_none = javelin_tag(
       'a',
       array(
         'href'        => '#',
         'mustcapture' => true,
         'class'       => 'grey button',
         'id'          => 'batch-select-none',
       ),
       pht('Clear Selection'));
 
     $submit = phutil_tag(
       'button',
       array(
         'id'          => 'batch-select-submit',
         'disabled'    => 'disabled',
         'class'       => 'disabled',
       ),
       pht("Batch Edit Selected \xC2\xBB"));
 
     $export = javelin_tag(
       'a',
       array(
         'href' => '/maniphest/export/'.$search_query->getQueryKey().'/',
         'class' => 'grey button',
       ),
       pht('Export to Excel'));
 
     $hidden = phutil_tag(
       'div',
       array(
         'id' => 'batch-select-id-container',
       ),
       '');
 
     $editor = hsprintf(
       '<div class="maniphest-batch-editor">'.
         '<div class="batch-editor-header">%s</div>'.
         '<table class="maniphest-batch-editor-layout">'.
           '<tr>'.
             '<td>%s%s</td>'.
             '<td>%s</td>'.
             '<td id="batch-select-status-cell">%s</td>'.
             '<td class="batch-select-submit-cell">%s%s</td>'.
           '</tr>'.
         '</table>'.
       '</div>',
       pht('Batch Task Editor'),
       $select_all,
       $select_none,
       $export,
       '',
       $submit,
       $hidden);
 
     $editor = phabricator_form(
       $user,
       array(
         'method' => 'POST',
         'action' => '/maniphest/batch/',
         'id'     => 'batch-select-form',
       ),
       $editor);
 
     return $editor;
   }
 
   private function buildQueryFromRequest() {
     $request  = $this->getRequest();
     $user     = $request->getUser();
 
     $status   = $this->getStatusValueFromRequest();
     $group    = $this->getGroupValueFromRequest();
     $order    = $this->getOrderValueFromRequest();
 
     $user_phids = $request->getStrList(
       'users',
       array($user->getPHID()));
 
     if ($this->view == 'projecttriage' || $this->view == 'projectall') {
       $projects = id(new PhabricatorProjectQuery())
         ->setViewer($user)
         ->withMemberPHIDs($user_phids)
         ->execute();
       $any_project_phids = mpull($projects, 'getPHID');
       $any_user_project_phids = array();
     } else {
       $any_project_phids = $request->getStrList('aprojects');
       $any_user_project_phids = $request->getStrList('useraprojects');
     }
 
     $project_phids = $request->getStrList('projects');
     $exclude_project_phids = $request->getStrList('xprojects');
     $task_ids = $request->getStrList('tasks');
 
     if ($task_ids) {
       // We only need the integer portion of each task ID, so get rid of any
       // non-numeric elements
       $numeric_task_ids = array();
 
       foreach ($task_ids as $task_id) {
         $task_id = preg_replace('/\D+/', '', $task_id);
         if (!empty($task_id)) {
           $numeric_task_ids[] = $task_id;
         }
       }
 
       if (empty($numeric_task_ids)) {
         $numeric_task_ids = array(null);
       }
 
       $task_ids = $numeric_task_ids;
     }
 
     $owner_phids    = $request->getStrList('owners');
     $author_phids   = $request->getStrList('authors');
 
     $search_string  = $request->getStr('search');
 
     $low_priority   = $request->getInt('lpriority');
     $high_priority  = $request->getInt('hpriority');
 
     $page = $request->getInt('offset');
     $page_size = self::DEFAULT_PAGE_SIZE;
 
     $query = new PhabricatorSearchQuery();
     $query->setQuery('<<maniphest>>');
     $query->setParameters(
       array(
         'fullTextSearch'      => $search_string,
         'view'                => $this->view,
         'userPHIDs'           => $user_phids,
         'projectPHIDs'        => $project_phids,
         'anyProjectPHIDs'     => $any_project_phids,
         'anyUserProjectPHIDs' => $any_user_project_phids,
         'excludeProjectPHIDs' => $exclude_project_phids,
         'ownerPHIDs'          => $owner_phids,
         'authorPHIDs'         => $author_phids,
         'taskIDs'             => $task_ids,
         'lowPriority'         => $low_priority,
         'highPriority'        => $high_priority,
         'group'               => $group,
         'order'               => $order,
         'offset'              => $page,
         'limit'               => $page_size,
         'status'              => $status,
       ));
 
     $unguarded = AphrontWriteGuard::beginScopedUnguardedWrites();
     $query->save();
     unset($unguarded);
 
     return $query;
   }
 
 /* -(  Toggle Button Controls  )---------------------------------------------
 
   These are a giant mess since we have several different values: the request
   key (GET param used in requests), the request value (short names used in
   requests to keep URIs readable), and the query value (complex value stored in
   the query).
 
 */
 
   private function getStatusValueFromRequest() {
     $map = $this->getStatusMap();
     $val = $this->getRequest()->getStr($this->getStatusRequestKey());
     return idx($map, $val, head($map));
   }
 
   private function getGroupValueFromRequest() {
     $map = $this->getGroupMap();
     $val = $this->getRequest()->getStr($this->getGroupRequestKey());
     return idx($map, $val, head($map));
   }
 
   private function getOrderValueFromRequest() {
     $map = $this->getOrderMap();
     $val = $this->getRequest()->getStr($this->getOrderRequestKey());
     return idx($map, $val, head($map));
   }
 
   private function getStatusRequestKey() {
     return 's';
   }
 
   private function getGroupRequestKey() {
     return 'g';
   }
 
   private function getOrderRequestKey() {
     return 'o';
   }
 
   private function getStatusRequestValue($value) {
     return array_search($value, $this->getStatusMap());
   }
 
   private function getGroupRequestValue($value) {
     return array_search($value, $this->getGroupMap());
   }
 
   private function getOrderRequestValue($value) {
     return array_search($value, $this->getOrderMap());
   }
 
   private function getStatusMap() {
     return array(
       'o'   => array(
         'open' => true,
       ),
       'c'   => array(
         'closed' => true,
       ),
       'oc'  => array(
         'open' => true,
         'closed' => true,
       ),
     );
   }
 
   private function getGroupMap() {
     return array(
       'p' => 'priority',
       'o' => 'owner',
       's' => 'status',
       'j' => 'project',
       'n' => 'none',
     );
   }
 
   private function getOrderMap() {
     return array(
       'p' => 'priority',
       'u' => 'updated',
       'c' => 'created',
       't' => 'title',
     );
   }
 
   private function getStatusButtonMap() {
     return array(
       'o'   => pht('Open'),
       'c'   => pht('Closed'),
       'oc'  => pht('All'),
     );
   }
 
   private function getGroupButtonMap() {
     return array(
       'p' => pht('Priority'),
       'o' => pht('Owner'),
       's' => pht('Status'),
       'j' => pht('Project'),
       'n' => pht('None'),
     );
   }
 
   private function getOrderButtonMap() {
     return array(
       'p' => pht('Priority'),
       'u' => pht('Updated'),
       'c' => pht('Created'),
       't' => pht('Title'),
     );
   }
 
   public function renderStatusControl($value) {
     $request = $this->getRequest();
     return id(new AphrontFormToggleButtonsControl())
       ->setLabel(pht('Status'))
       ->setValue($this->getStatusRequestValue($value))
       ->setBaseURI($request->getRequestURI(), $this->getStatusRequestKey())
       ->setButtons($this->getStatusButtonMap());
   }
 
   public function renderOrderControl($value) {
     $request = $this->getRequest();
     return id(new AphrontFormToggleButtonsControl())
       ->setLabel(pht('Order'))
       ->setValue($this->getOrderRequestValue($value))
       ->setBaseURI($request->getRequestURI(), $this->getOrderRequestKey())
       ->setButtons($this->getOrderButtonMap());
   }
 
   public function renderGroupControl($value) {
     $request = $this->getRequest();
     return id(new AphrontFormToggleButtonsControl())
       ->setLabel(pht('Group'))
       ->setValue($this->getGroupRequestValue($value))
       ->setBaseURI($request->getRequestURI(), $this->getGroupRequestKey())
       ->setButtons($this->getGroupButtonMap());
   }
 
 }
diff --git a/src/applications/maniphest/mail/ManiphestTaskMailReceiver.php b/src/applications/maniphest/mail/ManiphestTaskMailReceiver.php
index 0e1c4ab04d..686b8db907 100644
--- a/src/applications/maniphest/mail/ManiphestTaskMailReceiver.php
+++ b/src/applications/maniphest/mail/ManiphestTaskMailReceiver.php
@@ -1,40 +1,40 @@
 <?php
 
 final class ManiphestTaskMailReceiver extends PhabricatorObjectMailReceiver {
 
   public function isEnabled() {
     $app_class = 'PhabricatorApplicationManiphest';
     return PhabricatorApplication::isClassInstalled($app_class);
   }
 
   protected function getObjectPattern() {
     return 'T[1-9]\d*';
   }
 
   protected function loadObject($pattern, PhabricatorUser $viewer) {
     $id = (int)trim($pattern, 'T');
 
     $results = id(new ManiphestTaskQuery())
       ->setViewer($viewer)
-      ->withTaskIDs(array($id))
+      ->withIDs(array($id))
       ->execute();
 
     return head($results);
   }
 
   protected function processReceivedObjectMail(
     PhabricatorMetaMTAReceivedMail $mail,
     PhabricatorLiskDAO $object,
     PhabricatorUser $sender) {
 
     $editor = new ManiphestTransactionEditor();
     $editor->setActor($sender);
     $handler = $editor->buildReplyHandler($object);
 
     $handler->setActor($sender);
     $handler->setExcludeMailRecipientPHIDs(
       $mail->loadExcludeMailRecipientPHIDs());
     $handler->processEmail($mail);
   }
 
 }
diff --git a/src/applications/maniphest/remarkup/ManiphestRemarkupRule.php b/src/applications/maniphest/remarkup/ManiphestRemarkupRule.php
index 6508252f19..e3bb9200a4 100644
--- a/src/applications/maniphest/remarkup/ManiphestRemarkupRule.php
+++ b/src/applications/maniphest/remarkup/ManiphestRemarkupRule.php
@@ -1,22 +1,22 @@
 <?php
 
 /**
  * @group maniphest
  */
 final class ManiphestRemarkupRule
   extends PhabricatorRemarkupRuleObject {
 
   protected function getObjectNamePrefix() {
     return 'T';
   }
 
   protected function loadObjects(array $ids) {
     $viewer = $this->getEngine()->getConfig('viewer');
 
     return id(new ManiphestTaskQuery())
       ->setViewer($viewer)
-      ->withTaskIDs($ids)
+      ->withIDs($ids)
       ->execute();
   }
 
 }