diff --git a/src/applications/people/query/PhabricatorPeopleQuery.php b/src/applications/people/query/PhabricatorPeopleQuery.php
index 88e2437dbd..32ae31859b 100644
--- a/src/applications/people/query/PhabricatorPeopleQuery.php
+++ b/src/applications/people/query/PhabricatorPeopleQuery.php
@@ -1,611 +1,628 @@
 <?php
 
 final class PhabricatorPeopleQuery
   extends PhabricatorCursorPagedPolicyAwareQuery {
 
   private $usernames;
   private $realnames;
   private $emails;
   private $phids;
   private $ids;
   private $dateCreatedAfter;
   private $dateCreatedBefore;
   private $isAdmin;
   private $isSystemAgent;
   private $isMailingList;
   private $isDisabled;
   private $isApproved;
   private $nameLike;
   private $nameTokens;
+  private $namePrefixes;
 
   private $needPrimaryEmail;
   private $needProfile;
   private $needProfileImage;
   private $needAvailability;
   private $needBadges;
   private $cacheKeys = array();
 
   public function withIDs(array $ids) {
     $this->ids = $ids;
     return $this;
   }
 
   public function withPHIDs(array $phids) {
     $this->phids = $phids;
     return $this;
   }
 
   public function withEmails(array $emails) {
     $this->emails = $emails;
     return $this;
   }
 
   public function withRealnames(array $realnames) {
     $this->realnames = $realnames;
     return $this;
   }
 
   public function withUsernames(array $usernames) {
     $this->usernames = $usernames;
     return $this;
   }
 
   public function withDateCreatedBefore($date_created_before) {
     $this->dateCreatedBefore = $date_created_before;
     return $this;
   }
 
   public function withDateCreatedAfter($date_created_after) {
     $this->dateCreatedAfter = $date_created_after;
     return $this;
   }
 
   public function withIsAdmin($admin) {
     $this->isAdmin = $admin;
     return $this;
   }
 
   public function withIsSystemAgent($system_agent) {
     $this->isSystemAgent = $system_agent;
     return $this;
   }
 
   public function withIsMailingList($mailing_list) {
     $this->isMailingList = $mailing_list;
     return $this;
   }
 
   public function withIsDisabled($disabled) {
     $this->isDisabled = $disabled;
     return $this;
   }
 
   public function withIsApproved($approved) {
     $this->isApproved = $approved;
     return $this;
   }
 
   public function withNameLike($like) {
     $this->nameLike = $like;
     return $this;
   }
 
   public function withNameTokens(array $tokens) {
     $this->nameTokens = array_values($tokens);
     return $this;
   }
 
+  public function withNamePrefixes(array $prefixes) {
+    $this->namePrefixes = $prefixes;
+    return $this;
+  }
+
   public function needPrimaryEmail($need) {
     $this->needPrimaryEmail = $need;
     return $this;
   }
 
   public function needProfile($need) {
     $this->needProfile = $need;
     return $this;
   }
 
   public function needProfileImage($need) {
     $cache_key = PhabricatorUserProfileImageCacheType::KEY_URI;
 
     if ($need) {
       $this->cacheKeys[$cache_key] = true;
     } else {
       unset($this->cacheKeys[$cache_key]);
     }
 
     return $this;
   }
 
   public function needAvailability($need) {
     $this->needAvailability = $need;
     return $this;
   }
 
   public function needBadges($need) {
     $this->needBadges = $need;
     return $this;
   }
 
   public function needUserSettings($need) {
     $cache_key = PhabricatorUserPreferencesCacheType::KEY_PREFERENCES;
 
     if ($need) {
       $this->cacheKeys[$cache_key] = true;
     } else {
       unset($this->cacheKeys[$cache_key]);
     }
 
     return $this;
   }
 
   public function newResultObject() {
     return new PhabricatorUser();
   }
 
   protected function loadPage() {
     $table = new PhabricatorUser();
     $data = $this->loadStandardPageRows($table);
 
     if ($this->needPrimaryEmail) {
       $table->putInSet(new LiskDAOSet());
     }
 
     return $table->loadAllFromArray($data);
   }
 
   protected function didFilterPage(array $users) {
     if ($this->needProfile) {
       $user_list = mpull($users, null, 'getPHID');
       $profiles = new PhabricatorUserProfile();
       $profiles = $profiles->loadAllWhere(
         'userPHID IN (%Ls)',
         array_keys($user_list));
 
       $profiles = mpull($profiles, null, 'getUserPHID');
       foreach ($user_list as $user_phid => $user) {
         $profile = idx($profiles, $user_phid);
 
         if (!$profile) {
           $profile = PhabricatorUserProfile::initializeNewProfile($user);
         }
 
         $user->attachUserProfile($profile);
       }
     }
 
     if ($this->needBadges) {
       $awards = id(new PhabricatorBadgesAwardQuery())
         ->setViewer($this->getViewer())
         ->withRecipientPHIDs(mpull($users, 'getPHID'))
         ->execute();
 
       $awards = mgroup($awards, 'getRecipientPHID');
 
       foreach ($users as $user) {
         $user_awards = idx($awards, $user->getPHID(), array());
         $badge_phids = mpull($user_awards, 'getBadgePHID');
         $user->attachBadgePHIDs($badge_phids);
       }
     }
 
     if ($this->needAvailability) {
       $rebuild = array();
       foreach ($users as $user) {
         $cache = $user->getAvailabilityCache();
         if ($cache !== null) {
           $user->attachAvailability($cache);
         } else {
           $rebuild[] = $user;
         }
       }
 
       if ($rebuild) {
         $this->rebuildAvailabilityCache($rebuild);
       }
     }
 
     $this->fillUserCaches($users);
 
     return $users;
   }
 
   protected function shouldGroupQueryResultRows() {
     if ($this->nameTokens) {
       return true;
     }
 
     return parent::shouldGroupQueryResultRows();
   }
 
   protected function buildJoinClauseParts(AphrontDatabaseConnection $conn) {
     $joins = parent::buildJoinClauseParts($conn);
 
     if ($this->emails) {
       $email_table = new PhabricatorUserEmail();
       $joins[] = qsprintf(
         $conn,
         'JOIN %T email ON email.userPHID = user.PHID',
         $email_table->getTableName());
     }
 
     if ($this->nameTokens) {
       foreach ($this->nameTokens as $key => $token) {
         $token_table = 'token_'.$key;
         $joins[] = qsprintf(
           $conn,
           'JOIN %T %T ON %T.userID = user.id AND %T.token LIKE %>',
           PhabricatorUser::NAMETOKEN_TABLE,
           $token_table,
           $token_table,
           $token_table,
           $token);
       }
     }
 
     return  $joins;
   }
 
   protected function buildWhereClauseParts(AphrontDatabaseConnection $conn) {
     $where = parent::buildWhereClauseParts($conn);
 
     if ($this->usernames !== null) {
       $where[] = qsprintf(
         $conn,
         'user.userName IN (%Ls)',
         $this->usernames);
     }
 
+    if ($this->namePrefixes) {
+      $parts = array();
+      foreach ($this->namePrefixes as $name_prefix) {
+        $parts[] = qsprintf(
+          $conn,
+          'user.username LIKE %>',
+          $name_prefix);
+      }
+      $where[] = '('.implode(' OR ', $parts).')';
+    }
+
     if ($this->emails !== null) {
       $where[] = qsprintf(
         $conn,
         'email.address IN (%Ls)',
         $this->emails);
     }
 
     if ($this->realnames !== null) {
       $where[] = qsprintf(
         $conn,
         'user.realName IN (%Ls)',
         $this->realnames);
     }
 
     if ($this->phids !== null) {
       $where[] = qsprintf(
         $conn,
         'user.phid IN (%Ls)',
         $this->phids);
     }
 
     if ($this->ids !== null) {
       $where[] = qsprintf(
         $conn,
         'user.id IN (%Ld)',
         $this->ids);
     }
 
     if ($this->dateCreatedAfter) {
       $where[] = qsprintf(
         $conn,
         'user.dateCreated >= %d',
         $this->dateCreatedAfter);
     }
 
     if ($this->dateCreatedBefore) {
       $where[] = qsprintf(
         $conn,
         'user.dateCreated <= %d',
         $this->dateCreatedBefore);
     }
 
     if ($this->isAdmin !== null) {
       $where[] = qsprintf(
         $conn,
         'user.isAdmin = %d',
         (int)$this->isAdmin);
     }
 
     if ($this->isDisabled !== null) {
       $where[] = qsprintf(
         $conn,
         'user.isDisabled = %d',
         (int)$this->isDisabled);
     }
 
     if ($this->isApproved !== null) {
       $where[] = qsprintf(
         $conn,
         'user.isApproved = %d',
         (int)$this->isApproved);
     }
 
     if ($this->isSystemAgent !== null) {
       $where[] = qsprintf(
         $conn,
         'user.isSystemAgent = %d',
         (int)$this->isSystemAgent);
     }
 
     if ($this->isMailingList !== null) {
       $where[] = qsprintf(
         $conn,
         'user.isMailingList = %d',
         (int)$this->isMailingList);
     }
 
     if (strlen($this->nameLike)) {
       $where[] = qsprintf(
         $conn,
         'user.username LIKE %~ OR user.realname LIKE %~',
         $this->nameLike,
         $this->nameLike);
     }
 
     return $where;
   }
 
   protected function getPrimaryTableAlias() {
     return 'user';
   }
 
   public function getQueryApplicationClass() {
     return 'PhabricatorPeopleApplication';
   }
 
   public function getOrderableColumns() {
     return parent::getOrderableColumns() + array(
       'username' => array(
         'table' => 'user',
         'column' => 'username',
         'type' => 'string',
         'reverse' => true,
         'unique' => true,
       ),
     );
   }
 
   protected function getPagingValueMap($cursor, array $keys) {
     $user = $this->loadCursorObject($cursor);
     return array(
       'id' => $user->getID(),
       'username' => $user->getUsername(),
     );
   }
 
   private function rebuildAvailabilityCache(array $rebuild) {
     $rebuild = mpull($rebuild, null, 'getPHID');
 
     // Limit the window we look at because far-future events are largely
     // irrelevant and this makes the cache cheaper to build and allows it to
     // self-heal over time.
     $min_range = PhabricatorTime::getNow();
     $max_range = $min_range + phutil_units('72 hours in seconds');
 
     // NOTE: We don't need to generate ghosts here, because we only care if
     // the user is attending, and you can't attend a ghost event: RSVP'ing
     // to it creates a real event.
 
     $events = id(new PhabricatorCalendarEventQuery())
       ->setViewer(PhabricatorUser::getOmnipotentUser())
       ->withInvitedPHIDs(array_keys($rebuild))
       ->withIsCancelled(false)
       ->withDateRange($min_range, $max_range)
       ->execute();
 
     // Group all the events by invited user. Only examine events that users
     // are actually attending.
     $map = array();
     $invitee_map = array();
     foreach ($events as $event) {
       foreach ($event->getInvitees() as $invitee) {
         if (!$invitee->isAttending()) {
           continue;
         }
 
         // If the user is set to "Available" for this event, don't consider it
         // when computin their away status.
         if (!$invitee->getDisplayAvailability($event)) {
           continue;
         }
 
         $invitee_phid = $invitee->getInviteePHID();
         if (!isset($rebuild[$invitee_phid])) {
           continue;
         }
 
         $map[$invitee_phid][] = $event;
 
         $event_phid = $event->getPHID();
         $invitee_map[$invitee_phid][$event_phid] = $invitee;
       }
     }
 
     // We need to load these users' timezone settings to figure out their
     // availability if they're attending all-day events.
     $this->needUserSettings(true);
     $this->fillUserCaches($rebuild);
 
     foreach ($rebuild as $phid => $user) {
       $events = idx($map, $phid, array());
 
       // We loaded events with the omnipotent user, but want to shift them
       // into the user's timezone before building the cache because they will
       // be unavailable during their own local day.
       foreach ($events as $event) {
         $event->applyViewerTimezone($user);
       }
 
       $cursor = $min_range;
       $next_event = null;
       if ($events) {
         // Find the next time when the user has no meetings. If we move forward
         // because of an event, we check again for events after that one ends.
         while (true) {
           foreach ($events as $event) {
             $from = $event->getStartDateTimeEpochForCache();
             $to = $event->getEndDateTimeEpoch();
             if (($from <= $cursor) && ($to > $cursor)) {
               $cursor = $to;
               if (!$next_event) {
                 $next_event = $event;
               }
               continue 2;
             }
           }
           break;
         }
       }
 
       if ($cursor > $min_range) {
         $invitee = $invitee_map[$phid][$next_event->getPHID()];
         $availability_type = $invitee->getDisplayAvailability($next_event);
         $availability = array(
           'until' => $cursor,
           'eventPHID' => $event->getPHID(),
           'availability' => $availability_type,
         );
 
         // We only cache this availability until the end of the current event,
         // since the event PHID (and possibly the availability type) are only
         // valid for that long.
 
         // NOTE: This doesn't handle overlapping events with the greatest
         // possible care. In theory, if you're attenting multiple events
         // simultaneously we should accommodate that. However, it's complex
         // to compute, rare, and probably not confusing most of the time.
 
         $availability_ttl = $next_event->getStartDateTimeEpochForCache();
       } else {
         $availability = array(
           'until' => null,
           'eventPHID' => null,
           'availability' => null,
         );
         $availability_ttl = $max_range;
       }
 
       // Never TTL the cache to longer than the maximum range we examined.
       $availability_ttl = min($availability_ttl, $max_range);
 
       $user->writeAvailabilityCache($availability, $availability_ttl);
       $user->attachAvailability($availability);
     }
   }
 
   private function fillUserCaches(array $users) {
     if (!$this->cacheKeys) {
       return;
     }
 
     $user_map = mpull($users, null, 'getPHID');
     $keys = array_keys($this->cacheKeys);
 
     $hashes = array();
     foreach ($keys as $key) {
       $hashes[] = PhabricatorHash::digestForIndex($key);
     }
 
     $types = PhabricatorUserCacheType::getAllCacheTypes();
 
     // First, pull any available caches. If we wanted to be particularly clever
     // we could do this with JOINs in the main query.
 
     $cache_table = new PhabricatorUserCache();
     $cache_conn = $cache_table->establishConnection('r');
 
     $cache_data = queryfx_all(
       $cache_conn,
       'SELECT cacheKey, userPHID, cacheData, cacheType FROM %T
         WHERE cacheIndex IN (%Ls) AND userPHID IN (%Ls)',
       $cache_table->getTableName(),
       $hashes,
       array_keys($user_map));
 
     $skip_validation = array();
 
     // After we read caches from the database, discard any which have data that
     // invalid or out of date. This allows cache types to implement TTLs or
     // versions instead of or in addition to explicit cache clears.
     foreach ($cache_data as $row_key => $row) {
       $cache_type = $row['cacheType'];
 
       if (isset($skip_validation[$cache_type])) {
         continue;
       }
 
       if (empty($types[$cache_type])) {
         unset($cache_data[$row_key]);
         continue;
       }
 
       $type = $types[$cache_type];
       if (!$type->shouldValidateRawCacheData()) {
         $skip_validation[$cache_type] = true;
         continue;
       }
 
       $user = $user_map[$row['userPHID']];
       $raw_data = $row['cacheData'];
       if (!$type->isRawCacheDataValid($user, $row['cacheKey'], $raw_data)) {
         unset($cache_data[$row_key]);
         continue;
       }
     }
 
     $need = array();
 
     $cache_data = igroup($cache_data, 'userPHID');
     foreach ($user_map as $user_phid => $user) {
       $raw_rows = idx($cache_data, $user_phid, array());
       $raw_data = ipull($raw_rows, 'cacheData', 'cacheKey');
 
       foreach ($keys as $key) {
         if (isset($raw_data[$key]) || array_key_exists($key, $raw_data)) {
           continue;
         }
         $need[$key][$user_phid] = $user;
       }
 
       $user->attachRawCacheData($raw_data);
     }
 
     // If we missed any cache values, bulk-construct them now. This is
     // usually much cheaper than generating them on-demand for each user
     // record.
 
     if (!$need) {
       return;
     }
 
     $writes = array();
     foreach ($need as $cache_key => $need_users) {
       $type = PhabricatorUserCacheType::getCacheTypeForKey($cache_key);
       if (!$type) {
         continue;
       }
 
       $data = $type->newValueForUsers($cache_key, $need_users);
 
       foreach ($data as $user_phid => $raw_value) {
         $data[$user_phid] = $raw_value;
         $writes[] = array(
           'userPHID' => $user_phid,
           'key' => $cache_key,
           'type' => $type,
           'value' => $raw_value,
         );
       }
 
       foreach ($need_users as $user_phid => $user) {
         if (isset($data[$user_phid]) || array_key_exists($user_phid, $data)) {
           $user->attachRawCacheData(
             array(
               $cache_key => $data[$user_phid],
             ));
         }
       }
     }
 
     PhabricatorUserCache::writeCaches($writes);
   }
 }
diff --git a/src/applications/people/typeahead/PhabricatorPeopleDatasource.php b/src/applications/people/typeahead/PhabricatorPeopleDatasource.php
index 494b68dbfb..df146808bb 100644
--- a/src/applications/people/typeahead/PhabricatorPeopleDatasource.php
+++ b/src/applications/people/typeahead/PhabricatorPeopleDatasource.php
@@ -1,100 +1,105 @@
 <?php
 
 final class PhabricatorPeopleDatasource
   extends PhabricatorTypeaheadDatasource {
 
   public function getBrowseTitle() {
     return pht('Browse Users');
   }
 
   public function getPlaceholderText() {
     return pht('Type a username...');
   }
 
   public function getDatasourceApplicationClass() {
     return 'PhabricatorPeopleApplication';
   }
 
   public function loadResults() {
     $viewer = $this->getViewer();
-    $tokens = $this->getTokens();
 
     $query = id(new PhabricatorPeopleQuery())
       ->setOrderVector(array('username'));
 
-    if ($tokens) {
-      $query->withNameTokens($tokens);
+    if ($this->getPhase() == self::PHASE_PREFIX) {
+      $prefix = $this->getPrefixQuery();
+      $query->withNamePrefixes(array($prefix));
+    } else {
+      $tokens = $this->getTokens();
+      if ($tokens) {
+        $query->withNameTokens($tokens);
+      }
     }
 
     $users = $this->executeQuery($query);
 
     $is_browse = $this->getIsBrowse();
 
     if ($is_browse && $users) {
       $phids = mpull($users, 'getPHID');
       $handles = id(new PhabricatorHandleQuery())
         ->setViewer($viewer)
         ->withPHIDs($phids)
         ->execute();
     }
 
     $results = array();
     foreach ($users as $user) {
       $phid = $user->getPHID();
 
       $closed = null;
       if ($user->getIsDisabled()) {
         $closed = pht('Disabled');
       } else if ($user->getIsSystemAgent()) {
         $closed = pht('Bot');
       } else if ($user->getIsMailingList()) {
         $closed = pht('Mailing List');
       }
 
       $username = $user->getUsername();
 
       $result = id(new PhabricatorTypeaheadResult())
         ->setName($user->getFullName())
         ->setURI('/p/'.$username.'/')
         ->setPHID($phid)
         ->setPriorityString($username)
         ->setPriorityType('user')
         ->setAutocomplete('@'.$username)
         ->setClosed($closed);
 
       if ($user->getIsMailingList()) {
         $result->setIcon('fa-envelope-o');
       }
 
       if ($is_browse) {
         $handle = $handles[$phid];
 
         $result
           ->setIcon($handle->getIcon())
           ->setImageURI($handle->getImageURI())
           ->addAttribute($handle->getSubtitle());
 
         if ($user->getIsAdmin()) {
           $result->addAttribute(
             array(
               id(new PHUIIconView())->setIcon('fa-star'),
               ' ',
               pht('Administrator'),
             ));
         }
 
         if ($user->getIsAdmin()) {
           $display_type = pht('Administrator');
         } else {
           $display_type = pht('User');
         }
         $result->setDisplayType($display_type);
       }
 
       $results[] = $result;
     }
 
     return $results;
   }
 
 }
diff --git a/src/applications/project/query/PhabricatorProjectQuery.php b/src/applications/project/query/PhabricatorProjectQuery.php
index ab41ecf0ac..87c6bb805e 100644
--- a/src/applications/project/query/PhabricatorProjectQuery.php
+++ b/src/applications/project/query/PhabricatorProjectQuery.php
@@ -1,787 +1,804 @@
 <?php
 
 final class PhabricatorProjectQuery
   extends PhabricatorCursorPagedPolicyAwareQuery {
 
   private $ids;
   private $phids;
   private $memberPHIDs;
   private $watcherPHIDs;
   private $slugs;
   private $slugNormals;
   private $slugMap;
   private $allSlugs;
   private $names;
+  private $namePrefixes;
   private $nameTokens;
   private $icons;
   private $colors;
   private $ancestorPHIDs;
   private $parentPHIDs;
   private $isMilestone;
   private $hasSubprojects;
   private $minDepth;
   private $maxDepth;
   private $minMilestoneNumber;
   private $maxMilestoneNumber;
 
   private $status       = 'status-any';
   const STATUS_ANY      = 'status-any';
   const STATUS_OPEN     = 'status-open';
   const STATUS_CLOSED   = 'status-closed';
   const STATUS_ACTIVE   = 'status-active';
   const STATUS_ARCHIVED = 'status-archived';
   private $statuses;
 
   private $needSlugs;
   private $needMembers;
   private $needAncestorMembers;
   private $needWatchers;
   private $needImages;
 
   public function withIDs(array $ids) {
     $this->ids = $ids;
     return $this;
   }
 
   public function withPHIDs(array $phids) {
     $this->phids = $phids;
     return $this;
   }
 
   public function withStatus($status) {
     $this->status = $status;
     return $this;
   }
 
   public function withStatuses(array $statuses) {
     $this->statuses = $statuses;
     return $this;
   }
 
   public function withMemberPHIDs(array $member_phids) {
     $this->memberPHIDs = $member_phids;
     return $this;
   }
 
   public function withWatcherPHIDs(array $watcher_phids) {
     $this->watcherPHIDs = $watcher_phids;
     return $this;
   }
 
   public function withSlugs(array $slugs) {
     $this->slugs = $slugs;
     return $this;
   }
 
   public function withNames(array $names) {
     $this->names = $names;
     return $this;
   }
 
+  public function withNamePrefixes(array $prefixes) {
+    $this->namePrefixes = $prefixes;
+    return $this;
+  }
+
   public function withNameTokens(array $tokens) {
     $this->nameTokens = array_values($tokens);
     return $this;
   }
 
   public function withIcons(array $icons) {
     $this->icons = $icons;
     return $this;
   }
 
   public function withColors(array $colors) {
     $this->colors = $colors;
     return $this;
   }
 
   public function withParentProjectPHIDs($parent_phids) {
     $this->parentPHIDs = $parent_phids;
     return $this;
   }
 
   public function withAncestorProjectPHIDs($ancestor_phids) {
     $this->ancestorPHIDs = $ancestor_phids;
     return $this;
   }
 
   public function withIsMilestone($is_milestone) {
     $this->isMilestone = $is_milestone;
     return $this;
   }
 
   public function withHasSubprojects($has_subprojects) {
     $this->hasSubprojects = $has_subprojects;
     return $this;
   }
 
   public function withDepthBetween($min, $max) {
     $this->minDepth = $min;
     $this->maxDepth = $max;
     return $this;
   }
 
   public function withMilestoneNumberBetween($min, $max) {
     $this->minMilestoneNumber = $min;
     $this->maxMilestoneNumber = $max;
     return $this;
   }
 
   public function needMembers($need_members) {
     $this->needMembers = $need_members;
     return $this;
   }
 
   public function needAncestorMembers($need_ancestor_members) {
     $this->needAncestorMembers = $need_ancestor_members;
     return $this;
   }
 
   public function needWatchers($need_watchers) {
     $this->needWatchers = $need_watchers;
     return $this;
   }
 
   public function needImages($need_images) {
     $this->needImages = $need_images;
     return $this;
   }
 
   public function needSlugs($need_slugs) {
     $this->needSlugs = $need_slugs;
     return $this;
   }
 
   public function newResultObject() {
     return new PhabricatorProject();
   }
 
   protected function getDefaultOrderVector() {
     return array('name');
   }
 
   public function getBuiltinOrders() {
     return array(
       'name' => array(
         'vector' => array('name'),
         'name' => pht('Name'),
       ),
     ) + parent::getBuiltinOrders();
   }
 
   public function getOrderableColumns() {
     return parent::getOrderableColumns() + array(
       'name' => array(
         'table' => $this->getPrimaryTableAlias(),
         'column' => 'name',
         'reverse' => true,
         'type' => 'string',
         'unique' => true,
       ),
       'milestoneNumber' => array(
         'table' => $this->getPrimaryTableAlias(),
         'column' => 'milestoneNumber',
         'type' => 'int',
       ),
     );
   }
 
   protected function getPagingValueMap($cursor, array $keys) {
     $project = $this->loadCursorObject($cursor);
     return array(
       'id' => $project->getID(),
       'name' => $project->getName(),
     );
   }
 
   public function getSlugMap() {
     if ($this->slugMap === null) {
       throw new PhutilInvalidStateException('execute');
     }
     return $this->slugMap;
   }
 
   protected function willExecute() {
     $this->slugMap = array();
     $this->slugNormals = array();
     $this->allSlugs = array();
     if ($this->slugs) {
       foreach ($this->slugs as $slug) {
         if (PhabricatorSlug::isValidProjectSlug($slug)) {
           $normal = PhabricatorSlug::normalizeProjectSlug($slug);
           $this->slugNormals[$slug] = $normal;
           $this->allSlugs[$normal] = $normal;
         }
 
         // NOTE: At least for now, we query for the normalized slugs but also
         // for the slugs exactly as entered. This allows older projects with
         // slugs that are no longer valid to continue to work.
         $this->allSlugs[$slug] = $slug;
       }
     }
   }
 
   protected function loadPage() {
     return $this->loadStandardPage($this->newResultObject());
   }
 
   protected function willFilterPage(array $projects) {
     $ancestor_paths = array();
     foreach ($projects as $project) {
       foreach ($project->getAncestorProjectPaths() as $path) {
         $ancestor_paths[$path] = $path;
       }
     }
 
     if ($ancestor_paths) {
       $ancestors = id(new PhabricatorProject())->loadAllWhere(
         'projectPath IN (%Ls)',
         $ancestor_paths);
     } else {
       $ancestors = array();
     }
 
     $projects = $this->linkProjectGraph($projects, $ancestors);
 
     $viewer_phid = $this->getViewer()->getPHID();
 
     $material_type = PhabricatorProjectMaterializedMemberEdgeType::EDGECONST;
     $watcher_type = PhabricatorObjectHasWatcherEdgeType::EDGECONST;
 
     $types = array();
     $types[] = $material_type;
     if ($this->needWatchers) {
       $types[] = $watcher_type;
     }
 
     $all_graph = $this->getAllReachableAncestors($projects);
 
     if ($this->needAncestorMembers || $this->needWatchers) {
       $src_projects = $all_graph;
     } else {
       $src_projects = $projects;
     }
 
     $all_sources = array();
     foreach ($src_projects as $project) {
       // For milestones, we need parent members.
       if ($project->isMilestone()) {
         $parent_phid = $project->getParentProjectPHID();
         $all_sources[$parent_phid] = $parent_phid;
       }
 
       $phid = $project->getPHID();
       $all_sources[$phid] = $phid;
     }
 
     $edge_query = id(new PhabricatorEdgeQuery())
       ->withSourcePHIDs($all_sources)
       ->withEdgeTypes($types);
 
     $need_all_edges =
       $this->needMembers ||
       $this->needWatchers ||
       $this->needAncestorMembers;
 
     // If we only need to know if the viewer is a member, we can restrict
     // the query to just their PHID.
     $any_edges = true;
     if (!$need_all_edges) {
       if ($viewer_phid) {
         $edge_query->withDestinationPHIDs(array($viewer_phid));
       } else {
         // If we don't need members or watchers and don't have a viewer PHID
         // (viewer is logged-out or omnipotent), they'll never be a member
         // so we don't need to issue this query at all.
         $any_edges = false;
       }
     }
 
     if ($any_edges) {
       $edge_query->execute();
     }
 
     $membership_projects = array();
     foreach ($src_projects as $project) {
       $project_phid = $project->getPHID();
 
       if ($project->isMilestone()) {
         $source_phids = array($project->getParentProjectPHID());
       } else {
         $source_phids = array($project_phid);
       }
 
       if ($any_edges) {
         $member_phids = $edge_query->getDestinationPHIDs(
           $source_phids,
           array($material_type));
       } else {
         $member_phids = array();
       }
 
       if (in_array($viewer_phid, $member_phids)) {
         $membership_projects[$project_phid] = $project;
       }
 
       if ($this->needMembers || $this->needAncestorMembers) {
         $project->attachMemberPHIDs($member_phids);
       }
 
       if ($this->needWatchers) {
         $watcher_phids = $edge_query->getDestinationPHIDs(
           array($project_phid),
           array($watcher_type));
         $project->attachWatcherPHIDs($watcher_phids);
         $project->setIsUserWatcher(
           $viewer_phid,
           in_array($viewer_phid, $watcher_phids));
       }
     }
 
     // If we loaded ancestor members, we've already populated membership
     // lists above, so we can skip this step.
     if (!$this->needAncestorMembers) {
       $member_graph = $this->getAllReachableAncestors($membership_projects);
 
       foreach ($all_graph as $phid => $project) {
         $is_member = isset($member_graph[$phid]);
         $project->setIsUserMember($viewer_phid, $is_member);
       }
     }
 
     return $projects;
   }
 
   protected function didFilterPage(array $projects) {
     if ($this->needImages) {
       $default = null;
 
       $file_phids = mpull($projects, 'getProfileImagePHID');
       $file_phids = array_filter($file_phids);
       if ($file_phids) {
         $files = id(new PhabricatorFileQuery())
           ->setParentQuery($this)
           ->setViewer($this->getViewer())
           ->withPHIDs($file_phids)
           ->execute();
         $files = mpull($files, null, 'getPHID');
       } else {
         $files = array();
       }
 
       foreach ($projects as $project) {
         $file = idx($files, $project->getProfileImagePHID());
         if (!$file) {
           if (!$default) {
             $default = PhabricatorFile::loadBuiltin(
               $this->getViewer(),
               'project.png');
           }
           $file = $default;
         }
         $project->attachProfileImageFile($file);
       }
     }
 
     $this->loadSlugs($projects);
 
     return $projects;
   }
 
   protected function buildWhereClauseParts(AphrontDatabaseConnection $conn) {
     $where = parent::buildWhereClauseParts($conn);
 
     if ($this->status != self::STATUS_ANY) {
       switch ($this->status) {
         case self::STATUS_OPEN:
         case self::STATUS_ACTIVE:
           $filter = array(
             PhabricatorProjectStatus::STATUS_ACTIVE,
           );
           break;
         case self::STATUS_CLOSED:
         case self::STATUS_ARCHIVED:
           $filter = array(
             PhabricatorProjectStatus::STATUS_ARCHIVED,
           );
           break;
         default:
           throw new Exception(
             pht(
               "Unknown project status '%s'!",
               $this->status));
       }
       $where[] = qsprintf(
         $conn,
         'status IN (%Ld)',
         $filter);
     }
 
     if ($this->statuses !== null) {
       $where[] = qsprintf(
         $conn,
         'status IN (%Ls)',
         $this->statuses);
     }
 
     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->memberPHIDs !== null) {
       $where[] = qsprintf(
         $conn,
         'e.dst IN (%Ls)',
         $this->memberPHIDs);
     }
 
     if ($this->watcherPHIDs !== null) {
       $where[] = qsprintf(
         $conn,
         'w.dst IN (%Ls)',
         $this->watcherPHIDs);
     }
 
     if ($this->slugs !== null) {
       $where[] = qsprintf(
         $conn,
         'slug.slug IN (%Ls)',
         $this->allSlugs);
     }
 
     if ($this->names !== null) {
       $where[] = qsprintf(
         $conn,
         'name IN (%Ls)',
         $this->names);
     }
 
+    if ($this->namePrefixes) {
+      $parts = array();
+      foreach ($this->namePrefixes as $name_prefix) {
+        $parts[] = qsprintf(
+          $conn,
+          'name LIKE %>',
+          $name_prefix);
+      }
+      $where[] = '('.implode(' OR ', $parts).')';
+    }
+
     if ($this->icons !== null) {
       $where[] = qsprintf(
         $conn,
         'icon IN (%Ls)',
         $this->icons);
     }
 
     if ($this->colors !== null) {
       $where[] = qsprintf(
         $conn,
         'color IN (%Ls)',
         $this->colors);
     }
 
     if ($this->parentPHIDs !== null) {
       $where[] = qsprintf(
         $conn,
         'parentProjectPHID IN (%Ls)',
         $this->parentPHIDs);
     }
 
     if ($this->ancestorPHIDs !== null) {
       $ancestor_paths = queryfx_all(
         $conn,
         'SELECT projectPath, projectDepth FROM %T WHERE phid IN (%Ls)',
         id(new PhabricatorProject())->getTableName(),
         $this->ancestorPHIDs);
       if (!$ancestor_paths) {
         throw new PhabricatorEmptyQueryException();
       }
 
       $sql = array();
       foreach ($ancestor_paths as $ancestor_path) {
         $sql[] = qsprintf(
           $conn,
           '(projectPath LIKE %> AND projectDepth > %d)',
           $ancestor_path['projectPath'],
           $ancestor_path['projectDepth']);
       }
 
       $where[] = '('.implode(' OR ', $sql).')';
 
       $where[] = qsprintf(
         $conn,
         'parentProjectPHID IS NOT NULL');
     }
 
     if ($this->isMilestone !== null) {
       if ($this->isMilestone) {
         $where[] = qsprintf(
           $conn,
           'milestoneNumber IS NOT NULL');
       } else {
         $where[] = qsprintf(
           $conn,
           'milestoneNumber IS NULL');
       }
     }
 
 
     if ($this->hasSubprojects !== null) {
       $where[] = qsprintf(
         $conn,
         'hasSubprojects = %d',
         (int)$this->hasSubprojects);
     }
 
     if ($this->minDepth !== null) {
       $where[] = qsprintf(
         $conn,
         'projectDepth >= %d',
         $this->minDepth);
     }
 
     if ($this->maxDepth !== null) {
       $where[] = qsprintf(
         $conn,
         'projectDepth <= %d',
         $this->maxDepth);
     }
 
     if ($this->minMilestoneNumber !== null) {
       $where[] = qsprintf(
         $conn,
         'milestoneNumber >= %d',
         $this->minMilestoneNumber);
     }
 
     if ($this->maxMilestoneNumber !== null) {
       $where[] = qsprintf(
         $conn,
         'milestoneNumber <= %d',
         $this->maxMilestoneNumber);
     }
 
     return $where;
   }
 
   protected function shouldGroupQueryResultRows() {
     if ($this->memberPHIDs || $this->watcherPHIDs || $this->nameTokens) {
       return true;
     }
     return parent::shouldGroupQueryResultRows();
   }
 
   protected function buildJoinClauseParts(AphrontDatabaseConnection $conn) {
     $joins = parent::buildJoinClauseParts($conn);
 
     if ($this->memberPHIDs !== null) {
       $joins[] = qsprintf(
         $conn,
         'JOIN %T e ON e.src = p.phid AND e.type = %d',
         PhabricatorEdgeConfig::TABLE_NAME_EDGE,
         PhabricatorProjectMaterializedMemberEdgeType::EDGECONST);
     }
 
     if ($this->watcherPHIDs !== null) {
       $joins[] = qsprintf(
         $conn,
         'JOIN %T w ON w.src = p.phid AND w.type = %d',
         PhabricatorEdgeConfig::TABLE_NAME_EDGE,
         PhabricatorObjectHasWatcherEdgeType::EDGECONST);
     }
 
     if ($this->slugs !== null) {
       $joins[] = qsprintf(
         $conn,
         'JOIN %T slug on slug.projectPHID = p.phid',
         id(new PhabricatorProjectSlug())->getTableName());
     }
 
     if ($this->nameTokens !== null) {
       foreach ($this->nameTokens as $key => $token) {
         $token_table = 'token_'.$key;
         $joins[] = qsprintf(
           $conn,
           'JOIN %T %T ON %T.projectID = p.id AND %T.token LIKE %>',
           PhabricatorProject::TABLE_DATASOURCE_TOKEN,
           $token_table,
           $token_table,
           $token_table,
           $token);
       }
     }
 
     return $joins;
   }
 
   public function getQueryApplicationClass() {
     return 'PhabricatorProjectApplication';
   }
 
   protected function getPrimaryTableAlias() {
     return 'p';
   }
 
   private function linkProjectGraph(array $projects, array $ancestors) {
     $ancestor_map = mpull($ancestors, null, 'getPHID');
     $projects_map = mpull($projects, null, 'getPHID');
 
     $all_map = $projects_map + $ancestor_map;
 
     $done = array();
     foreach ($projects as $key => $project) {
       $seen = array($project->getPHID() => true);
 
       if (!$this->linkProject($project, $all_map, $done, $seen)) {
         $this->didRejectResult($project);
         unset($projects[$key]);
         continue;
       }
 
       foreach ($project->getAncestorProjects() as $ancestor) {
         $seen[$ancestor->getPHID()] = true;
       }
     }
 
     return $projects;
   }
 
   private function linkProject($project, array $all, array $done, array $seen) {
     $parent_phid = $project->getParentProjectPHID();
 
     // This project has no parent, so just attach `null` and return.
     if (!$parent_phid) {
       $project->attachParentProject(null);
       return true;
     }
 
     // This project has a parent, but it failed to load.
     if (empty($all[$parent_phid])) {
       return false;
     }
 
     // Test for graph cycles. If we encounter one, we're going to hide the
     // entire cycle since we can't meaningfully resolve it.
     if (isset($seen[$parent_phid])) {
       return false;
     }
 
     $seen[$parent_phid] = true;
 
     $parent = $all[$parent_phid];
     $project->attachParentProject($parent);
 
     if (!empty($done[$parent_phid])) {
       return true;
     }
 
     return $this->linkProject($parent, $all, $done, $seen);
   }
 
   private function getAllReachableAncestors(array $projects) {
     $ancestors = array();
 
     $seen = mpull($projects, null, 'getPHID');
 
     $stack = $projects;
     while ($stack) {
       $project = array_pop($stack);
 
       $phid = $project->getPHID();
       $ancestors[$phid] = $project;
 
       $parent_phid = $project->getParentProjectPHID();
       if (!$parent_phid) {
         continue;
       }
 
       if (isset($seen[$parent_phid])) {
         continue;
       }
 
       $seen[$parent_phid] = true;
       $stack[] = $project->getParentProject();
     }
 
     return $ancestors;
   }
 
   private function loadSlugs(array $projects) {
     // Build a map from primary slugs to projects.
     $primary_map = array();
     foreach ($projects as $project) {
       $primary_slug = $project->getPrimarySlug();
       if ($primary_slug === null) {
         continue;
       }
 
       $primary_map[$primary_slug] = $project;
     }
 
     // Link up all of the queried slugs which correspond to primary
     // slugs. If we can link up everything from this (no slugs were queried,
     // or only primary slugs were queried) we don't need to load anything
     // else.
     $unknown = $this->slugNormals;
     foreach ($unknown as $input => $normal) {
       if (isset($primary_map[$input])) {
         $match = $input;
       } else if (isset($primary_map[$normal])) {
         $match = $normal;
       } else {
         continue;
       }
 
       $this->slugMap[$input] = array(
         'slug' => $match,
         'projectPHID' => $primary_map[$match]->getPHID(),
       );
 
       unset($unknown[$input]);
     }
 
     // If we need slugs, we have to load everything.
     // If we still have some queried slugs which we haven't mapped, we only
     // need to look for them.
     // If we've mapped everything, we don't have to do any work.
     $project_phids = mpull($projects, 'getPHID');
     if ($this->needSlugs) {
       $slugs = id(new PhabricatorProjectSlug())->loadAllWhere(
         'projectPHID IN (%Ls)',
         $project_phids);
     } else if ($unknown) {
       $slugs = id(new PhabricatorProjectSlug())->loadAllWhere(
         'projectPHID IN (%Ls) AND slug IN (%Ls)',
         $project_phids,
         $unknown);
     } else {
       $slugs = array();
     }
 
     // Link up any slugs we were not able to link up earlier.
     $extra_map = mpull($slugs, 'getProjectPHID', 'getSlug');
     foreach ($unknown as $input => $normal) {
       if (isset($extra_map[$input])) {
         $match = $input;
       } else if (isset($extra_map[$normal])) {
         $match = $normal;
       } else {
         continue;
       }
 
       $this->slugMap[$input] = array(
         'slug' => $match,
         'projectPHID' => $extra_map[$match],
       );
 
       unset($unknown[$input]);
     }
 
     if ($this->needSlugs) {
       $slug_groups = mgroup($slugs, 'getProjectPHID');
       foreach ($projects as $project) {
         $project_slugs = idx($slug_groups, $project->getPHID(), array());
         $project->attachSlugs($project_slugs);
       }
     }
   }
 
 }
diff --git a/src/applications/project/typeahead/PhabricatorProjectDatasource.php b/src/applications/project/typeahead/PhabricatorProjectDatasource.php
index 03c2424f4a..03a6e39c33 100644
--- a/src/applications/project/typeahead/PhabricatorProjectDatasource.php
+++ b/src/applications/project/typeahead/PhabricatorProjectDatasource.php
@@ -1,146 +1,149 @@
 <?php
 
 final class PhabricatorProjectDatasource
   extends PhabricatorTypeaheadDatasource {
 
   public function getBrowseTitle() {
     return pht('Browse Projects');
   }
 
   public function getPlaceholderText() {
     return pht('Type a project name...');
   }
 
   public function getDatasourceApplicationClass() {
     return 'PhabricatorProjectApplication';
   }
 
   public function loadResults() {
     $viewer = $this->getViewer();
 
     $raw_query = $this->getRawQuery();
 
     // Allow users to type "#qa" or "qa" to find "Quality Assurance".
     $raw_query = ltrim($raw_query, '#');
     $tokens = self::tokenizeString($raw_query);
 
     $query = id(new PhabricatorProjectQuery())
       ->needImages(true)
       ->needSlugs(true);
 
-    if ($tokens) {
+    if ($this->getPhase() == self::PHASE_PREFIX) {
+      $prefix = $this->getPrefixQuery();
+      $query->withNamePrefixes(array($prefix));
+    } else if ($tokens) {
       $query->withNameTokens($tokens);
     }
 
     // If this is for policy selection, prevent users from using milestones.
     $for_policy = $this->getParameter('policy');
     if ($for_policy) {
       $query->withIsMilestone(false);
     }
 
     $for_autocomplete = $this->getParameter('autocomplete');
 
     $projs = $this->executeQuery($query);
 
     $projs = mpull($projs, null, 'getPHID');
 
     $must_have_cols = $this->getParameter('mustHaveColumns', false);
     if ($must_have_cols) {
       $columns = id(new PhabricatorProjectColumnQuery())
         ->setViewer($viewer)
         ->withProjectPHIDs(array_keys($projs))
         ->execute();
       $has_cols = mgroup($columns, 'getProjectPHID');
     } else {
       $has_cols = array_fill_keys(array_keys($projs), true);
     }
 
     $is_browse = $this->getIsBrowse();
     if ($is_browse && $projs) {
       // TODO: This is a little ad-hoc, but we don't currently have
       // infrastructure for bulk querying custom fields efficiently.
       $table = new PhabricatorProjectCustomFieldStorage();
       $descriptions = $table->loadAllWhere(
         'objectPHID IN (%Ls) AND fieldIndex = %s',
         array_keys($projs),
         PhabricatorHash::digestForIndex('std:project:internal:description'));
       $descriptions = mpull($descriptions, 'getFieldValue', 'getObjectPHID');
     } else {
       $descriptions = array();
     }
 
     $results = array();
     foreach ($projs as $proj) {
       $phid = $proj->getPHID();
 
       if (!isset($has_cols[$phid])) {
         continue;
       }
 
       $slug = $proj->getPrimarySlug();
       if (!strlen($slug)) {
         foreach ($proj->getSlugs() as $slug_object) {
           $slug = $slug_object->getSlug();
           if (strlen($slug)) {
             break;
           }
         }
       }
 
       // If we're building results for the autocompleter and this project
       // doesn't have any usable slugs, don't return it as a result.
       if ($for_autocomplete && !strlen($slug)) {
         continue;
       }
 
       $closed = null;
       if ($proj->isArchived()) {
         $closed = pht('Archived');
       }
 
       $all_strings = array();
       $all_strings[] = $proj->getDisplayName();
 
       // Add an extra space after the name so that the original project
       // sorts ahead of milestones. This is kind of a hack but ehh?
       $all_strings[] = null;
 
       foreach ($proj->getSlugs() as $project_slug) {
         $all_strings[] = $project_slug->getSlug();
       }
       $all_strings = implode(' ', $all_strings);
 
       $proj_result = id(new PhabricatorTypeaheadResult())
         ->setName($all_strings)
         ->setDisplayName($proj->getDisplayName())
         ->setDisplayType($proj->getDisplayIconName())
         ->setURI($proj->getURI())
         ->setPHID($phid)
         ->setIcon($proj->getDisplayIconIcon())
         ->setColor($proj->getColor())
         ->setPriorityType('proj')
         ->setClosed($closed);
 
       if (strlen($slug)) {
         $proj_result->setAutocomplete('#'.$slug);
       }
 
       $proj_result->setImageURI($proj->getProfileImageURI());
 
       if ($is_browse) {
         $proj_result->addAttribute($proj->getDisplayIconName());
 
         $description = idx($descriptions, $phid);
         if (strlen($description)) {
           $summary = PhabricatorMarkupEngine::summarize($description);
           $proj_result->addAttribute($summary);
         }
       }
 
       $results[] = $proj_result;
     }
 
     return $results;
   }
 
 }
diff --git a/src/applications/typeahead/controller/PhabricatorTypeaheadModularDatasourceController.php b/src/applications/typeahead/controller/PhabricatorTypeaheadModularDatasourceController.php
index a7c8381bfd..5c641b7c1f 100644
--- a/src/applications/typeahead/controller/PhabricatorTypeaheadModularDatasourceController.php
+++ b/src/applications/typeahead/controller/PhabricatorTypeaheadModularDatasourceController.php
@@ -1,408 +1,413 @@
 <?php
 
 final class PhabricatorTypeaheadModularDatasourceController
   extends PhabricatorTypeaheadDatasourceController {
 
   public function shouldAllowPublic() {
     return true;
   }
 
   public function handleRequest(AphrontRequest $request) {
     $request = $this->getRequest();
     $viewer = $request->getUser();
     $query = $request->getStr('q');
     $offset = $request->getInt('offset');
     $select_phid = null;
     $is_browse = ($request->getURIData('action') == 'browse');
 
     $select = $request->getStr('select');
     if ($select) {
       $select = phutil_json_decode($select);
       $query = idx($select, 'q');
       $offset = idx($select, 'offset');
       $select_phid = idx($select, 'phid');
     }
 
     // Default this to the query string to make debugging a little bit easier.
     $raw_query = nonempty($request->getStr('raw'), $query);
 
     // This makes form submission easier in the debug view.
     $class = nonempty($request->getURIData('class'), $request->getStr('class'));
 
     $sources = id(new PhutilClassMapQuery())
       ->setAncestorClass('PhabricatorTypeaheadDatasource')
       ->execute();
 
     if (isset($sources[$class])) {
       $source = $sources[$class];
       $source->setParameters($request->getRequestData());
       $source->setViewer($viewer);
 
       // NOTE: Wrapping the source in a Composite datasource ensures we perform
       // application visibility checks for the viewer, so we do not need to do
       // those separately.
       $composite = new PhabricatorTypeaheadRuntimeCompositeDatasource();
       $composite->addDatasource($source);
 
       $hard_limit = 1000;
       $limit = 100;
 
       $composite
         ->setViewer($viewer)
         ->setQuery($query)
         ->setRawQuery($raw_query)
         ->setLimit($limit + 1);
 
       if ($is_browse) {
         if (!$composite->isBrowsable()) {
           return new Aphront404Response();
         }
 
         if (($offset + $limit) >= $hard_limit) {
           // Offset-based paging is intrinsically slow; hard-cap how far we're
           // willing to go with it.
           return new Aphront404Response();
         }
 
         $composite
           ->setOffset($offset)
           ->setIsBrowse(true);
       }
 
       $results = $composite->loadResults();
 
       if ($is_browse) {
         // If this is a request for a specific token after the user clicks
         // "Select", return the token in wire format so it can be added to
         // the tokenizer.
         if ($select_phid !== null) {
           $map = mpull($results, null, 'getPHID');
           $token = idx($map, $select_phid);
           if (!$token) {
             return new Aphront404Response();
           }
 
           $payload = array(
             'key' => $token->getPHID(),
             'token' => $token->getWireFormat(),
           );
 
           return id(new AphrontAjaxResponse())->setContent($payload);
         }
 
         $format = $request->getStr('format');
         switch ($format) {
           case 'html':
           case 'dialog':
             // These are the acceptable response formats.
             break;
           default:
             // Return a dialog if format information is missing or invalid.
             $format = 'dialog';
             break;
         }
 
         $next_link = null;
         if (count($results) > $limit) {
           $results = array_slice($results, 0, $limit, $preserve_keys = true);
           if (($offset + (2 * $limit)) < $hard_limit) {
             $next_uri = id(new PhutilURI($request->getRequestURI()))
               ->setQueryParam('offset', $offset + $limit)
               ->setQueryParam('q', $query)
               ->setQueryParam('raw', $raw_query)
               ->setQueryParam('format', 'html');
 
             $next_link = javelin_tag(
               'a',
               array(
                 'href' => $next_uri,
                 'class' => 'typeahead-browse-more',
                 'sigil' => 'typeahead-browse-more',
                 'mustcapture' => true,
               ),
               pht('More Results'));
           } else {
             // If the user has paged through more than 1K results, don't
             // offer to page any further.
             $next_link = javelin_tag(
               'div',
               array(
                 'class' => 'typeahead-browse-hard-limit',
               ),
               pht('You reach the edge of the abyss.'));
           }
         }
 
         $exclude = $request->getStrList('exclude');
         $exclude = array_fuse($exclude);
 
         $select = array(
           'offset' => $offset,
           'q' => $query,
         );
 
         $items = array();
         foreach ($results as $result) {
           // Disable already-selected tokens.
           $disabled = isset($exclude[$result->getPHID()]);
 
           $value = $select + array('phid' => $result->getPHID());
           $value = json_encode($value);
 
           $button = phutil_tag(
             'button',
             array(
               'class' => 'small grey',
               'name' => 'select',
               'value' => $value,
               'disabled' => $disabled ? 'disabled' : null,
             ),
             pht('Select'));
 
           $information = $this->renderBrowseResult($result, $button);
 
           $items[] = phutil_tag(
             'div',
             array(
               'class' => 'typeahead-browse-item grouped',
             ),
             $information);
         }
 
         $markup = array(
           $items,
           $next_link,
         );
 
         if ($format == 'html') {
           $content = array(
             'markup' => hsprintf('%s', $markup),
           );
           return id(new AphrontAjaxResponse())->setContent($content);
         }
 
         $this->requireResource('typeahead-browse-css');
         $this->initBehavior('typeahead-browse');
 
         $input_id = celerity_generate_unique_node_id();
         $frame_id = celerity_generate_unique_node_id();
 
         $config = array(
           'inputID' => $input_id,
           'frameID' => $frame_id,
           'uri' => (string)$request->getRequestURI(),
         );
         $this->initBehavior('typeahead-search', $config);
 
         $search = javelin_tag(
           'input',
           array(
             'type' => 'text',
             'id' => $input_id,
             'class' => 'typeahead-browse-input',
             'autocomplete' => 'off',
             'placeholder' => $source->getPlaceholderText(),
           ));
 
         $frame = phutil_tag(
           'div',
           array(
             'class' => 'typeahead-browse-frame',
             'id' => $frame_id,
           ),
           $markup);
 
         $browser = array(
           phutil_tag(
             'div',
             array(
               'class' => 'typeahead-browse-header',
             ),
             $search),
           $frame,
         );
 
         $function_help = null;
         if ($source->getAllDatasourceFunctions()) {
           $reference_uri = '/typeahead/help/'.get_class($source).'/';
 
           $reference_link = phutil_tag(
             'a',
             array(
               'href' => $reference_uri,
               'target' => '_blank',
             ),
             pht('Reference: Advanced Functions'));
 
           $function_help = array(
             id(new PHUIIconView())
               ->setIcon('fa-book'),
             ' ',
             $reference_link,
           );
         }
 
         return $this->newDialog()
           ->setWidth(AphrontDialogView::WIDTH_FORM)
           ->setRenderDialogAsDiv(true)
           ->setTitle($source->getBrowseTitle())
           ->appendChild($browser)
           ->setResizeX(true)
           ->setResizeY($frame_id)
           ->addFooter($function_help)
           ->addCancelButton('/', pht('Close'));
       }
 
     } else if ($is_browse) {
       return new Aphront404Response();
     } else {
       $results = array();
     }
 
     $content = mpull($results, 'getWireFormat');
     $content = array_values($content);
 
     if ($request->isAjax()) {
       return id(new AphrontAjaxResponse())->setContent($content);
     }
 
     // If there's a non-Ajax request to this endpoint, show results in a tabular
     // format to make it easier to debug typeahead output.
 
     foreach ($sources as $key => $source) {
       // This can happen with composite or generic sources.
       if (!$source->getDatasourceApplicationClass()) {
         continue;
       }
       if (!PhabricatorApplication::isClassInstalledForViewer(
         $source->getDatasourceApplicationClass(),
         $viewer)) {
         unset($sources[$key]);
       }
     }
     $options = array_fuse(array_keys($sources));
     asort($options);
 
     $form = id(new AphrontFormView())
       ->setUser($viewer)
       ->setAction('/typeahead/class/')
       ->appendChild(
         id(new AphrontFormSelectControl())
           ->setLabel(pht('Source Class'))
           ->setName('class')
           ->setValue($class)
           ->setOptions($options))
       ->appendChild(
         id(new AphrontFormTextControl())
           ->setLabel(pht('Query'))
           ->setName('q')
           ->setValue($request->getStr('q')))
       ->appendChild(
         id(new AphrontFormTextControl())
           ->setLabel(pht('Raw Query'))
           ->setName('raw')
           ->setValue($request->getStr('raw')))
       ->appendChild(
         id(new AphrontFormSubmitControl())
           ->setValue(pht('Query')));
 
     $form_box = id(new PHUIObjectBoxView())
       ->setHeaderText(pht('Token Query'))
       ->setBackground(PHUIObjectBoxView::BLUE_PROPERTY)
       ->setForm($form);
 
     $table = new AphrontTableView($content);
     $table->setHeaders(
       array(
         pht('Name'),
         pht('URI'),
         pht('PHID'),
         pht('Priority'),
         pht('Display Name'),
         pht('Display Type'),
         pht('Image URI'),
         pht('Priority Type'),
         pht('Icon'),
         pht('Closed'),
         pht('Sprite'),
+        pht('Color'),
+        pht('Type'),
+        pht('Unique'),
+        pht('Auto'),
+        pht('Phase'),
       ));
 
     $result_box = id(new PHUIObjectBoxView())
       ->setHeaderText(pht('Token Results (%s)', $class))
       ->setBackground(PHUIObjectBoxView::BLUE_PROPERTY)
       ->appendChild($table);
 
     $title = pht('Typeahead Results');
 
     $header = id(new PHUIHeaderView())
       ->setHeader($title);
 
     $view = id(new PHUITwoColumnView())
       ->setHeader($header)
       ->setFooter(array(
         $form_box,
         $result_box,
       ));
 
     return $this->newPage()
       ->setTitle($title)
       ->appendChild($view);
   }
 
   private function renderBrowseResult(
     PhabricatorTypeaheadResult $result,
     $button) {
 
     $class = array();
     $style = array();
     $separator = " \xC2\xB7 ";
 
     $class[] = 'phabricator-main-search-typeahead-result';
 
     $name = phutil_tag(
       'div',
       array(
         'class' => 'result-name',
       ),
       $result->getDisplayName());
 
     $icon = $result->getIcon();
     $icon = id(new PHUIIconView())->setIcon($icon);
 
     $attributes = $result->getAttributes();
     $attributes = phutil_implode_html($separator, $attributes);
     $attributes = array($icon, ' ', $attributes);
 
     $closed = $result->getClosed();
     if ($closed) {
       $class[] = 'result-closed';
       $attributes = array($closed, $separator, $attributes);
     }
 
     $attributes = phutil_tag(
       'div',
       array(
         'class' => 'result-type',
       ),
       $attributes);
 
     $image = $result->getImageURI();
     if ($image) {
       $style[] = 'background-image: url('.$image.');';
       $class[] = 'has-image';
     }
 
     return phutil_tag(
       'div',
       array(
         'class' => implode(' ', $class),
         'style' => implode(' ', $style),
       ),
       array(
         $button,
         $name,
         $attributes,
       ));
   }
 
 }
diff --git a/src/applications/typeahead/datasource/PhabricatorTypeaheadCompositeDatasource.php b/src/applications/typeahead/datasource/PhabricatorTypeaheadCompositeDatasource.php
index 306b33b497..33f06e4ae5 100644
--- a/src/applications/typeahead/datasource/PhabricatorTypeaheadCompositeDatasource.php
+++ b/src/applications/typeahead/datasource/PhabricatorTypeaheadCompositeDatasource.php
@@ -1,194 +1,320 @@
 <?php
 
 abstract class PhabricatorTypeaheadCompositeDatasource
   extends PhabricatorTypeaheadDatasource {
 
   private $usable;
+  private $prefixString;
+  private $prefixLength;
 
   abstract public function getComponentDatasources();
 
   public function isBrowsable() {
     foreach ($this->getUsableDatasources() as $datasource) {
       if (!$datasource->isBrowsable()) {
         return false;
       }
     }
 
     return parent::isBrowsable();
   }
 
   public function getDatasourceApplicationClass() {
     return null;
   }
 
   public function loadResults() {
+    $phases = array();
+
+    // We only need to do a prefix phase query if there's an actual query
+    // string. If the user didn't type anything, nothing can possibly match it.
+    if (strlen($this->getRawQuery())) {
+      $phases[] = self::PHASE_PREFIX;
+    }
+
+    $phases[] = self::PHASE_CONTENT;
+
     $offset = $this->getOffset();
     $limit = $this->getLimit();
 
+    $results = array();
+    foreach ($phases as $phase) {
+      if ($limit) {
+        $phase_limit = ($offset + $limit) - count($results);
+      } else {
+        $phase_limit = 0;
+      }
+
+      $phase_results = $this->loadResultsForPhase(
+        $phase,
+        $phase_limit);
+
+      foreach ($phase_results as $result) {
+        $results[] = $result;
+      }
+
+      if ($limit) {
+        if (count($results) >= $offset + $limit) {
+          break;
+        }
+      }
+    }
+
+    return $results;
+  }
+
+  protected function loadResultsForPhase($phase, $limit) {
+    if ($phase == self::PHASE_PREFIX) {
+      $this->prefixString = $this->getPrefixQuery();
+      $this->prefixLength = strlen($this->prefixString);
+    }
+
     // If the input query is a function like `members(platy`, and we can
     // parse the function, we strip the function off and hand the stripped
     // query to child sources. This makes it easier to implement function
     // sources in terms of real object sources.
     $raw_query = $this->getRawQuery();
 
     $is_function = false;
     if (self::isFunctionToken($raw_query)) {
       $is_function = true;
     }
 
     $stack = $this->getFunctionStack();
     $is_browse = $this->getIsBrowse();
 
     $results = array();
     foreach ($this->getUsableDatasources() as $source) {
       $source_stack = $stack;
 
       $source_query = $raw_query;
       if ($is_function) {
         // If this source can't handle the function, skip it.
         $function = $source->parseFunction($raw_query, $allow_partial = true);
         if (!$function) {
           continue;
         }
 
         // If this source handles the function directly, strip the function.
         // Otherwise, this is something like a composite source which has
         // some internal source which can evaluate the function, but will
         // perform stripping later.
         if ($source->shouldStripFunction($function['name'])) {
           $source_query = head($function['argv']);
           $source_stack[] = $function['name'];
         }
       }
 
       $source
+        ->setPhase($phase)
         ->setFunctionStack($source_stack)
         ->setRawQuery($source_query)
         ->setQuery($this->getQuery())
         ->setViewer($this->getViewer());
 
-      if ($limit) {
-        $source->setLimit($offset + $limit);
-      }
-
       if ($is_browse) {
         $source->setIsBrowse(true);
       }
 
-      $source_results = $source->loadResults();
-      $source_results = $source->didLoadResults($source_results);
+      if ($limit) {
+        // If we are loading results from a source with a limit, it may return
+        // some results which belong to the wrong phase. We need an entire page
+        // of valid results in the correct phase AFTER any results for the
+        // wrong phase are filtered for pagination to work correctly.
+
+        // To make sure we can get there, we fetch more and more results until
+        // enough of them survive filtering to generate a full page.
+
+        // We start by fetching 150% of the results than we think we need, and
+        // double the amount we overfetch by each time.
+        $factor = 1.5;
+        while (true) {
+          $query_source = clone $source;
+          $total = (int)ceil($limit * $factor) + 1;
+          $query_source->setLimit($total);
+
+          $source_results = $query_source->loadResultsForPhase(
+            $phase,
+            $limit);
+
+          // If there are fewer unfiltered results than we asked for, we know
+          // this is the entire result set and we don't need to keep going.
+          if (count($source_results) < $total) {
+            $source_results = $query_source->didLoadResults($source_results);
+            $source_results = $this->filterPhaseResults(
+              $phase,
+              $source_results);
+            break;
+          }
+
+          // Otherwise, this result set have everything we need, or may not.
+          // Filter the results that are part of the wrong phase out first...
+          $source_results = $query_source->didLoadResults($source_results);
+          $source_results = $this->filterPhaseResults($phase, $source_results);
+
+          // Now check if we have enough results left. If we do, we're all set.
+          if (count($source_results) >= $total) {
+            break;
+          }
+
+          // We filtered out too many results to have a full page left, so we
+          // need to run the query again, asking for even more results. We'll
+          // keep doing this until we get a full page or get all of the
+          // results.
+          $factor = $factor * 2;
+        }
+      } else {
+        $source_results = $source->loadResults();
+        $source_results = $source->didLoadResults($source_results);
+        $source_results = $this->filterPhaseResults($phase, $source_results);
+      }
+
       $results[] = $source_results;
     }
 
     $results = array_mergev($results);
     $results = msort($results, 'getSortKey');
 
-    $count = count($results);
+    $results = $this->sliceResults($results);
+
+    return $results;
+  }
+
+  private function filterPhaseResults($phase, $source_results) {
+    foreach ($source_results as $key => $source_result) {
+      $result_phase = $this->getResultPhase($source_result);
+
+      if ($result_phase != $phase) {
+        unset($source_results[$key]);
+        continue;
+      }
+
+      $source_result->setPhase($result_phase);
+    }
+
+    return $source_results;
+  }
+
+  private function getResultPhase(PhabricatorTypeaheadResult $result) {
+    if ($this->prefixLength) {
+      $result_name = phutil_utf8_strtolower($result->getName());
+      if (!strncmp($result_name, $this->prefixString, $this->prefixLength)) {
+        return self::PHASE_PREFIX;
+      }
+    }
+
+    return self::PHASE_CONTENT;
+  }
+
+  protected function sliceResults(array $results) {
+    $offset = $this->getOffset();
+    $limit = $this->getLimit();
+
     if ($offset || $limit) {
       if (!$limit) {
         $limit = count($results);
       }
 
       $results = array_slice($results, $offset, $limit, $preserve_keys = true);
     }
 
     return $results;
   }
 
   private function getUsableDatasources() {
     if ($this->usable === null) {
       $sources = $this->getComponentDatasources();
 
       $usable = array();
       foreach ($sources as $source) {
         $application_class = $source->getDatasourceApplicationClass();
 
         if ($application_class) {
           $result = id(new PhabricatorApplicationQuery())
             ->setViewer($this->getViewer())
             ->withClasses(array($application_class))
             ->execute();
           if (!$result) {
             continue;
           }
         }
 
         $source->setViewer($this->getViewer());
         $usable[] = $source;
       }
       $this->usable = $usable;
     }
 
     return $this->usable;
   }
 
   public function getAllDatasourceFunctions() {
     $results = parent::getAllDatasourceFunctions();
     foreach ($this->getUsableDatasources() as $source) {
       $results += $source->getAllDatasourceFunctions();
     }
     return $results;
   }
 
   protected function didEvaluateTokens(array $results) {
     foreach ($this->getUsableDatasources() as $source) {
       $results = $source->didEvaluateTokens($results);
     }
     return $results;
   }
 
   protected function canEvaluateFunction($function) {
     foreach ($this->getUsableDatasources() as $source) {
       if ($source->canEvaluateFunction($function)) {
         return true;
       }
     }
 
     return parent::canEvaluateFunction($function);
   }
 
   protected function evaluateValues(array $values) {
     foreach ($this->getUsableDatasources() as $source) {
       $values = $source->evaluateValues($values);
     }
 
     return parent::evaluateValues($values);
   }
 
   protected function evaluateFunction($function, array $argv) {
     foreach ($this->getUsableDatasources() as $source) {
       if ($source->canEvaluateFunction($function)) {
         return $source->evaluateFunction($function, $argv);
       }
     }
 
     return parent::evaluateFunction($function, $argv);
   }
 
   public function renderFunctionTokens($function, array $argv_list) {
     foreach ($this->getUsableDatasources() as $source) {
       if ($source->canEvaluateFunction($function)) {
         return $source->renderFunctionTokens($function, $argv_list);
       }
     }
 
     return parent::renderFunctionTokens($function, $argv_list);
   }
 
   protected function renderSpecialTokens(array $values) {
     $result = array();
     foreach ($this->getUsableDatasources() as $source) {
       $special = $source->renderSpecialTokens($values);
       foreach ($special as $key => $token) {
         $result[$key] = $token;
         unset($values[$key]);
       }
       if (!$values) {
         break;
       }
     }
     return $result;
   }
 
 
 }
diff --git a/src/applications/typeahead/datasource/PhabricatorTypeaheadDatasource.php b/src/applications/typeahead/datasource/PhabricatorTypeaheadDatasource.php
index 9fee4b2434..163b6c40b3 100644
--- a/src/applications/typeahead/datasource/PhabricatorTypeaheadDatasource.php
+++ b/src/applications/typeahead/datasource/PhabricatorTypeaheadDatasource.php
@@ -1,503 +1,527 @@
 <?php
 
 /**
  * @task functions Token Functions
  */
 abstract class PhabricatorTypeaheadDatasource extends Phobject {
 
   private $viewer;
   private $query;
   private $rawQuery;
   private $offset;
   private $limit;
   private $parameters = array();
   private $functionStack = array();
   private $isBrowse;
+  private $phase = self::PHASE_CONTENT;
+
+  const PHASE_PREFIX = 'prefix';
+  const PHASE_CONTENT = 'content';
 
   public function setLimit($limit) {
     $this->limit = $limit;
     return $this;
   }
 
   public function getLimit() {
     return $this->limit;
   }
 
   public function setOffset($offset) {
     $this->offset = $offset;
     return $this;
   }
 
   public function getOffset() {
     return $this->offset;
   }
 
   public function setViewer(PhabricatorUser $viewer) {
     $this->viewer = $viewer;
     return $this;
   }
 
   public function getViewer() {
     return $this->viewer;
   }
 
   public function setRawQuery($raw_query) {
     $this->rawQuery = $raw_query;
     return $this;
   }
 
+  public function getPrefixQuery() {
+    return phutil_utf8_strtolower($this->getRawQuery());
+  }
+
   public function getRawQuery() {
     return $this->rawQuery;
   }
 
   public function setQuery($query) {
     $this->query = $query;
     return $this;
   }
 
   public function getQuery() {
     return $this->query;
   }
 
   public function setParameters(array $params) {
     $this->parameters = $params;
     return $this;
   }
 
   public function getParameters() {
     return $this->parameters;
   }
 
   public function getParameter($name, $default = null) {
     return idx($this->parameters, $name, $default);
   }
 
   public function setIsBrowse($is_browse) {
     $this->isBrowse = $is_browse;
     return $this;
   }
 
   public function getIsBrowse() {
     return $this->isBrowse;
   }
 
+  public function setPhase($phase) {
+    $this->phase = $phase;
+    return $this;
+  }
+
+  public function getPhase() {
+    return $this->phase;
+  }
+
   public function getDatasourceURI() {
     $uri = new PhutilURI('/typeahead/class/'.get_class($this).'/');
     $uri->setQueryParams($this->parameters);
     return (string)$uri;
   }
 
   public function getBrowseURI() {
     if (!$this->isBrowsable()) {
       return null;
     }
 
     $uri = new PhutilURI('/typeahead/browse/'.get_class($this).'/');
     $uri->setQueryParams($this->parameters);
     return (string)$uri;
   }
 
   abstract public function getPlaceholderText();
 
   public function getBrowseTitle() {
     return get_class($this);
   }
 
   abstract public function getDatasourceApplicationClass();
   abstract public function loadResults();
 
+  protected function loadResultsForPhase($phase, $limit) {
+    // By default, sources just load all of their results in every phase and
+    // rely on filtering at a higher level to sequence phases correctly.
+    $this->setLimit($limit);
+    return $this->loadResults();
+  }
+
   protected function didLoadResults(array $results) {
     return $results;
   }
 
   public static function tokenizeString($string) {
     $string = phutil_utf8_strtolower($string);
     $string = trim($string);
     if (!strlen($string)) {
       return array();
     }
 
     $tokens = preg_split('/\s+|[-\[\]]/u', $string);
     return array_unique($tokens);
   }
 
   public function getTokens() {
     return self::tokenizeString($this->getRawQuery());
   }
 
   protected function executeQuery(
     PhabricatorCursorPagedPolicyAwareQuery $query) {
 
     return $query
       ->setViewer($this->getViewer())
       ->setOffset($this->getOffset())
       ->setLimit($this->getLimit())
       ->execute();
   }
 
 
   /**
    * Can the user browse through results from this datasource?
    *
    * Browsable datasources allow the user to switch from typeahead mode to
    * a browse mode where they can scroll through all results.
    *
    * By default, datasources are browsable, but some datasources can not
    * generate a meaningful result set or can't filter results on the server.
    *
    * @return bool
    */
   public function isBrowsable() {
     return true;
   }
 
 
   /**
    * Filter a list of results, removing items which don't match the query
    * tokens.
    *
    * This is useful for datasources which return a static list of hard-coded
    * or configured results and can't easily do query filtering in a real
    * query class. Instead, they can just build the entire result set and use
    * this method to filter it.
    *
    * For datasources backed by database objects, this is often much less
    * efficient than filtering at the query level.
    *
    * @param list<PhabricatorTypeaheadResult> List of typeahead results.
    * @return list<PhabricatorTypeaheadResult> Filtered results.
    */
   protected function filterResultsAgainstTokens(array $results) {
     $tokens = $this->getTokens();
     if (!$tokens) {
       return $results;
     }
 
     $map = array();
     foreach ($tokens as $token) {
       $map[$token] = strlen($token);
     }
 
     foreach ($results as $key => $result) {
       $rtokens = self::tokenizeString($result->getName());
 
       // For each token in the query, we need to find a match somewhere
       // in the result name.
       foreach ($map as $token => $length) {
         // Look for a match.
         $match = false;
         foreach ($rtokens as $rtoken) {
           if (!strncmp($rtoken, $token, $length)) {
             // This part of the result name has the query token as a prefix.
             $match = true;
             break;
           }
         }
 
         if (!$match) {
           // We didn't find a match for this query token, so throw the result
           // away. Try with the next result.
           unset($results[$key]);
           break;
         }
       }
     }
 
     return $results;
   }
 
   protected function newFunctionResult() {
     return id(new PhabricatorTypeaheadResult())
       ->setTokenType(PhabricatorTypeaheadTokenView::TYPE_FUNCTION)
       ->setIcon('fa-asterisk')
       ->addAttribute(pht('Function'));
   }
 
   public function newInvalidToken($name) {
     return id(new PhabricatorTypeaheadTokenView())
       ->setValue($name)
       ->setIcon('fa-exclamation-circle')
       ->setTokenType(PhabricatorTypeaheadTokenView::TYPE_INVALID);
   }
 
   public function renderTokens(array $values) {
     $phids = array();
     $setup = array();
     $tokens = array();
 
     foreach ($values as $key => $value) {
       if (!self::isFunctionToken($value)) {
         $phids[$key] = $value;
       } else {
         $function = $this->parseFunction($value);
         if ($function) {
           $setup[$function['name']][$key] = $function;
         } else {
           $name = pht('Invalid Function: %s', $value);
           $tokens[$key] = $this->newInvalidToken($name)
             ->setKey($value);
         }
       }
     }
 
     // Give special non-function tokens which are also not PHIDs (like statuses
     // and priorities) an opportunity to render.
     $type_unknown = PhabricatorPHIDConstants::PHID_TYPE_UNKNOWN;
     $special = array();
     foreach ($values as $key => $value) {
       if (phid_get_type($value) == $type_unknown) {
         $special[$key] = $value;
       }
     }
 
     if ($special) {
       $special_tokens = $this->renderSpecialTokens($special);
       foreach ($special_tokens as $key => $token) {
         $tokens[$key] = $token;
         unset($phids[$key]);
       }
     }
 
     if ($phids) {
       $handles = $this->getViewer()->loadHandles($phids);
       foreach ($phids as $key => $phid) {
         $handle = $handles[$phid];
         $tokens[$key] = PhabricatorTypeaheadTokenView::newFromHandle($handle);
       }
     }
 
     if ($setup) {
       foreach ($setup as $function_name => $argv_list) {
         // Render the function tokens.
         $function_tokens = $this->renderFunctionTokens(
           $function_name,
           ipull($argv_list, 'argv'));
 
         // Rekey the function tokens using the original array keys.
         $function_tokens = array_combine(
           array_keys($argv_list),
           $function_tokens);
 
         // For any functions which were invalid, set their value to the
         // original input value before it was parsed.
         foreach ($function_tokens as $key => $token) {
           $type = $token->getTokenType();
           if ($type == PhabricatorTypeaheadTokenView::TYPE_INVALID) {
             $token->setKey($values[$key]);
           }
         }
 
         $tokens += $function_tokens;
       }
     }
 
     return array_select_keys($tokens, array_keys($values));
   }
 
   protected function renderSpecialTokens(array $values) {
     return array();
   }
 
 /* -(  Token Functions  )---------------------------------------------------- */
 
 
   /**
    * @task functions
    */
   public function getDatasourceFunctions() {
     return array();
   }
 
 
   /**
    * @task functions
    */
   public function getAllDatasourceFunctions() {
     return $this->getDatasourceFunctions();
   }
 
 
   /**
    * @task functions
    */
   protected function canEvaluateFunction($function) {
     return $this->shouldStripFunction($function);
   }
 
 
   /**
    * @task functions
    */
   protected function shouldStripFunction($function) {
     $functions = $this->getDatasourceFunctions();
     return isset($functions[$function]);
   }
 
 
   /**
    * @task functions
    */
   protected function evaluateFunction($function, array $argv_list) {
     throw new PhutilMethodNotImplementedException();
   }
 
 
   /**
    * @task functions
    */
   protected function evaluateValues(array $values) {
     return $values;
   }
 
 
   /**
    * @task functions
    */
   public function evaluateTokens(array $tokens) {
     $results = array();
     $evaluate = array();
     foreach ($tokens as $token) {
       if (!self::isFunctionToken($token)) {
         $results[] = $token;
       } else {
         $evaluate[] = $token;
       }
     }
 
     $results = $this->evaluateValues($results);
 
     foreach ($evaluate as $function) {
       $function = self::parseFunction($function);
       if (!$function) {
         throw new PhabricatorTypeaheadInvalidTokenException();
       }
 
       $name = $function['name'];
       $argv = $function['argv'];
 
       foreach ($this->evaluateFunction($name, array($argv)) as $phid) {
         $results[] = $phid;
       }
     }
 
     $results = $this->didEvaluateTokens($results);
 
     return $results;
   }
 
 
   /**
    * @task functions
    */
   protected function didEvaluateTokens(array $results) {
     return $results;
   }
 
 
   /**
    * @task functions
    */
   public static function isFunctionToken($token) {
     // We're looking for a "(" so that a string like "members(q" is identified
     // and parsed as a function call. This allows us to start generating
     // results immeidately, before the user fully types out "members(quack)".
     return (strpos($token, '(') !== false);
   }
 
 
   /**
    * @task functions
    */
   public function parseFunction($token, $allow_partial = false) {
     $matches = null;
 
     if ($allow_partial) {
       $ok = preg_match('/^([^(]+)\((.*?)\)?$/', $token, $matches);
     } else {
       $ok = preg_match('/^([^(]+)\((.*)\)$/', $token, $matches);
     }
 
     if (!$ok) {
       return null;
     }
 
     $function = trim($matches[1]);
 
     if (!$this->canEvaluateFunction($function)) {
       return null;
     }
 
     return array(
       'name' => $function,
       'argv' => array(trim($matches[2])),
     );
   }
 
 
   /**
    * @task functions
    */
   public function renderFunctionTokens($function, array $argv_list) {
     throw new PhutilMethodNotImplementedException();
   }
 
 
   /**
    * @task functions
    */
   public function setFunctionStack(array $function_stack) {
     $this->functionStack = $function_stack;
     return $this;
   }
 
 
   /**
    * @task functions
    */
   public function getFunctionStack() {
     return $this->functionStack;
   }
 
 
   /**
    * @task functions
    */
   protected function getCurrentFunction() {
     return nonempty(last($this->functionStack), null);
   }
 
   protected function renderTokensFromResults(array $results, array $values) {
     $tokens = array();
     foreach ($values as $key => $value) {
       if (empty($results[$value])) {
         continue;
       }
       $tokens[$key] = PhabricatorTypeaheadTokenView::newFromTypeaheadResult(
         $results[$value]);
     }
 
     return $tokens;
   }
 
   public function getWireTokens(array $values) {
     // TODO: This is a bit hacky for now: we're sort of generating wire
     // results, rendering them, then reverting them back to wire results. This
     // is pretty silly. It would probably be much cleaner to make
     // renderTokens() call this method instead, then render from the result
     // structure.
     $rendered = $this->renderTokens($values);
 
     $tokens = array();
     foreach ($rendered as $key => $render) {
       $tokens[$key] = id(new PhabricatorTypeaheadResult())
         ->setPHID($render->getKey())
         ->setIcon($render->getIcon())
         ->setColor($render->getColor())
         ->setDisplayName($render->getValue())
         ->setTokenType($render->getTokenType());
     }
 
     return mpull($tokens, 'getWireFormat', 'getPHID');
   }
 
 }
diff --git a/src/applications/typeahead/storage/PhabricatorTypeaheadResult.php b/src/applications/typeahead/storage/PhabricatorTypeaheadResult.php
index 4c5c079734..14cbe726dc 100644
--- a/src/applications/typeahead/storage/PhabricatorTypeaheadResult.php
+++ b/src/applications/typeahead/storage/PhabricatorTypeaheadResult.php
@@ -1,214 +1,225 @@
 <?php
 
 final class PhabricatorTypeaheadResult extends Phobject {
 
   private $name;
   private $uri;
   private $phid;
   private $priorityString;
   private $displayName;
   private $displayType;
   private $imageURI;
   private $priorityType;
   private $imageSprite;
   private $icon;
   private $color;
   private $closed;
   private $tokenType;
   private $unique;
   private $autocomplete;
   private $attributes = array();
+  private $phase;
 
   public function setIcon($icon) {
     $this->icon = $icon;
     return $this;
   }
 
   public function setName($name) {
     $this->name = $name;
     return $this;
   }
 
   public function setURI($uri) {
     $this->uri = $uri;
     return $this;
   }
 
   public function setPHID($phid) {
     $this->phid = $phid;
     return $this;
   }
 
   public function setPriorityString($priority_string) {
     $this->priorityString = $priority_string;
     return $this;
   }
 
   public function setDisplayName($display_name) {
     $this->displayName = $display_name;
     return $this;
   }
 
   public function setDisplayType($display_type) {
     $this->displayType = $display_type;
     return $this;
   }
 
   public function setImageURI($image_uri) {
     $this->imageURI = $image_uri;
     return $this;
   }
 
   public function setPriorityType($priority_type) {
     $this->priorityType = $priority_type;
     return $this;
   }
 
   public function setImageSprite($image_sprite) {
     $this->imageSprite = $image_sprite;
     return $this;
   }
 
   public function setClosed($closed) {
     $this->closed = $closed;
     return $this;
   }
 
   public function getName() {
     return $this->name;
   }
 
   public function getDisplayName() {
     return coalesce($this->displayName, $this->getName());
   }
 
   public function getIcon() {
     return nonempty($this->icon, $this->getDefaultIcon());
   }
 
   public function getPHID() {
     return $this->phid;
   }
 
   public function setUnique($unique) {
     $this->unique = $unique;
     return $this;
   }
 
   public function setTokenType($type) {
     $this->tokenType = $type;
     return $this;
   }
 
   public function getTokenType() {
     if ($this->closed && !$this->tokenType) {
       return PhabricatorTypeaheadTokenView::TYPE_DISABLED;
     }
     return $this->tokenType;
   }
 
   public function setColor($color) {
     $this->color = $color;
     return $this;
   }
 
   public function getColor() {
     return $this->color;
   }
 
   public function setAutocomplete($autocomplete) {
     $this->autocomplete = $autocomplete;
     return $this;
   }
 
   public function getAutocomplete() {
     return $this->autocomplete;
   }
 
   public function getSortKey() {
     // Put unique results (special parameter functions) ahead of other
     // results.
     if ($this->unique) {
       $prefix = 'A';
     } else {
       $prefix = 'B';
     }
 
     return $prefix.phutil_utf8_strtolower($this->getName());
   }
 
   public function getWireFormat() {
     $data = array(
       $this->name,
       $this->uri ? (string)$this->uri : null,
       $this->phid,
       $this->priorityString,
       $this->displayName,
       $this->displayType,
       $this->imageURI ? (string)$this->imageURI : null,
       $this->priorityType,
       $this->getIcon(),
       $this->closed,
       $this->imageSprite ? (string)$this->imageSprite : null,
       $this->color,
       $this->tokenType,
       $this->unique ? 1 : null,
       $this->autocomplete,
+      $this->phase,
     );
     while (end($data) === null) {
       array_pop($data);
     }
     return $data;
   }
 
   /**
    * If the datasource did not specify an icon explicitly, try to select a
    * default based on PHID type.
    */
   private function getDefaultIcon() {
     static $icon_map;
     if ($icon_map === null) {
       $types = PhabricatorPHIDType::getAllTypes();
 
       $map = array();
       foreach ($types as $type) {
         $icon = $type->getTypeIcon();
         if ($icon !== null) {
           $map[$type->getTypeConstant()] = $icon;
         }
       }
 
       $icon_map = $map;
     }
 
     $phid_type = phid_get_type($this->phid);
     if (isset($icon_map[$phid_type])) {
       return $icon_map[$phid_type];
     }
 
     return null;
   }
 
   public function getImageURI() {
     return $this->imageURI;
   }
 
   public function getClosed() {
     return $this->closed;
   }
 
   public function resetAttributes() {
     $this->attributes = array();
     return $this;
   }
 
   public function getAttributes() {
     return $this->attributes;
   }
 
   public function addAttribute($attribute) {
     $this->attributes[] = $attribute;
     return $this;
   }
 
+  public function setPhase($phase) {
+    $this->phase = $phase;
+    return $this;
+  }
+
+  public function getPhase() {
+    return $this->phase;
+  }
+
 }