diff --git a/src/applications/herald/controller/HeraldRuleController.php b/src/applications/herald/controller/HeraldRuleController.php
index c16a45b47e..6780693031 100644
--- a/src/applications/herald/controller/HeraldRuleController.php
+++ b/src/applications/herald/controller/HeraldRuleController.php
@@ -1,672 +1,675 @@
 <?php
 
 final class HeraldRuleController extends HeraldController {
 
   private $id;
   private $filter;
 
   public function willProcessRequest(array $data) {
     $this->id = (int)idx($data, 'id');
   }
 
   public function processRequest() {
     $request = $this->getRequest();
     $user = $request->getUser();
 
     $content_type_map = HeraldAdapter::getEnabledAdapterMap($user);
     $rule_type_map = HeraldRuleTypeConfig::getRuleTypeMap();
 
     if ($this->id) {
       $id = $this->id;
       $rule = id(new HeraldRuleQuery())
         ->setViewer($user)
         ->withIDs(array($id))
         ->requireCapabilities(
           array(
             PhabricatorPolicyCapability::CAN_VIEW,
             PhabricatorPolicyCapability::CAN_EDIT,
           ))
         ->executeOne();
       if (!$rule) {
         return new Aphront404Response();
       }
       $cancel_uri = $this->getApplicationURI("rule/{$id}/");
     } else {
       $rule = new HeraldRule();
       $rule->setAuthorPHID($user->getPHID());
       $rule->setMustMatchAll(1);
 
       $content_type = $request->getStr('content_type');
       $rule->setContentType($content_type);
 
       $rule_type = $request->getStr('rule_type');
       if (!isset($rule_type_map[$rule_type])) {
         $rule_type = HeraldRuleTypeConfig::RULE_TYPE_PERSONAL;
       }
       $rule->setRuleType($rule_type);
 
       $adapter = HeraldAdapter::getAdapterForContentType(
         $rule->getContentType());
 
       if (!$adapter->supportsRuleType($rule->getRuleType())) {
         throw new Exception(
           pht(
             "This rule's content type does not support the selected rule ".
             "type."));
       }
 
       if ($rule->isObjectRule()) {
         $rule->setTriggerObjectPHID($request->getStr('targetPHID'));
         $object = id(new PhabricatorObjectQuery())
           ->setViewer($user)
           ->withPHIDs(array($rule->getTriggerObjectPHID()))
           ->requireCapabilities(
             array(
               PhabricatorPolicyCapability::CAN_VIEW,
               PhabricatorPolicyCapability::CAN_EDIT,
             ))
           ->executeOne();
         if (!$object) {
           throw new Exception(
             pht('No valid object provided for object rule!'));
         }
 
         if (!$adapter->canTriggerOnObject($object)) {
           throw new Exception(
             pht('Object is of wrong type for adapter!'));
         }
       }
 
       $cancel_uri = $this->getApplicationURI();
     }
 
     if ($rule->isGlobalRule()) {
       $this->requireApplicationCapability(
         HeraldManageGlobalRulesCapability::CAPABILITY);
     }
 
     $adapter = HeraldAdapter::getAdapterForContentType($rule->getContentType());
 
     $local_version = id(new HeraldRule())->getConfigVersion();
     if ($rule->getConfigVersion() > $local_version) {
       throw new Exception(
         pht(
           'This rule was created with a newer version of Herald. You can not '.
           'view or edit it in this older version. Upgrade your Phabricator '.
           'deployment.'));
     }
 
     // Upgrade rule version to our version, since we might add newly-defined
     // conditions, etc.
     $rule->setConfigVersion($local_version);
 
     $rule_conditions = $rule->loadConditions();
     $rule_actions = $rule->loadActions();
 
     $rule->attachConditions($rule_conditions);
     $rule->attachActions($rule_actions);
 
     $e_name = true;
     $errors = array();
     if ($request->isFormPost() && $request->getStr('save')) {
       list($e_name, $errors) = $this->saveRule($adapter, $rule, $request);
       if (!$errors) {
         $id = $rule->getID();
         $uri = $this->getApplicationURI("rule/{$id}/");
         return id(new AphrontRedirectResponse())->setURI($uri);
       }
     }
 
     $must_match_selector = $this->renderMustMatchSelector($rule);
     $repetition_selector = $this->renderRepetitionSelector($rule, $adapter);
 
     $handles = $this->loadHandlesForRule($rule);
 
     require_celerity_resource('herald-css');
 
     $content_type_name = $content_type_map[$rule->getContentType()];
     $rule_type_name = $rule_type_map[$rule->getRuleType()];
 
     $form = id(new AphrontFormView())
       ->setUser($user)
       ->setID('herald-rule-edit-form')
       ->addHiddenInput('content_type', $rule->getContentType())
       ->addHiddenInput('rule_type', $rule->getRuleType())
       ->addHiddenInput('save', 1)
       ->appendChild(
         // Build this explicitly (instead of using addHiddenInput())
         // so we can add a sigil to it.
         javelin_tag(
           'input',
           array(
             'type'  => 'hidden',
             'name'  => 'rule',
             'sigil' => 'rule',
           )))
       ->appendChild(
         id(new AphrontFormTextControl())
           ->setLabel(pht('Rule Name'))
           ->setName('name')
           ->setError($e_name)
           ->setValue($rule->getName()));
 
     $trigger_object_control = false;
     if ($rule->isObjectRule()) {
       $trigger_object_control = id(new AphrontFormStaticControl())
         ->setValue(
           pht(
             'This rule triggers for %s.',
             $handles[$rule->getTriggerObjectPHID()]->renderLink()));
     }
 
 
     $form
       ->appendChild(
         id(new AphrontFormMarkupControl())
           ->setValue(pht(
             'This %s rule triggers for %s.',
             phutil_tag('strong', array(), $rule_type_name),
             phutil_tag('strong', array(), $content_type_name))))
       ->appendChild($trigger_object_control)
       ->appendChild(
         id(new PHUIFormInsetView())
           ->setTitle(pht('Conditions'))
           ->setRightButton(javelin_tag(
             'a',
             array(
               'href' => '#',
               'class' => 'button green',
               'sigil' => 'create-condition',
               'mustcapture' => true,
             ),
             pht('New Condition')))
           ->setDescription(
             pht('When %s these conditions are met:', $must_match_selector))
           ->setContent(javelin_tag(
             'table',
             array(
               'sigil' => 'rule-conditions',
               'class' => 'herald-condition-table',
             ),
             '')))
       ->appendChild(
         id(new PHUIFormInsetView())
           ->setTitle(pht('Action'))
           ->setRightButton(javelin_tag(
             'a',
             array(
               'href' => '#',
               'class' => 'button green',
               'sigil' => 'create-action',
               'mustcapture' => true,
             ),
             pht('New Action')))
           ->setDescription(pht(
             'Take these actions %s this rule matches:',
             $repetition_selector))
           ->setContent(javelin_tag(
               'table',
               array(
                 'sigil' => 'rule-actions',
                 'class' => 'herald-action-table',
               ),
               '')))
       ->appendChild(
         id(new AphrontFormSubmitControl())
           ->setValue(pht('Save Rule'))
           ->addCancelButton($cancel_uri));
 
     $this->setupEditorBehavior($rule, $handles, $adapter);
 
     $title = $rule->getID()
         ? pht('Edit Herald Rule')
         : pht('Create Herald Rule');
 
     $form_box = id(new PHUIObjectBoxView())
       ->setHeaderText($title)
       ->setFormErrors($errors)
       ->setForm($form);
 
     $crumbs = $this
       ->buildApplicationCrumbs()
       ->addTextCrumb($title);
 
     return $this->buildApplicationPage(
       array(
         $crumbs,
         $form_box,
       ),
       array(
         'title' => pht('Edit Rule'),
       ));
   }
 
   private function saveRule(HeraldAdapter $adapter, $rule, $request) {
     $rule->setName($request->getStr('name'));
     $match_all = ($request->getStr('must_match') == 'all');
     $rule->setMustMatchAll((int)$match_all);
 
     $repetition_policy_param = $request->getStr('repetition_policy');
     $rule->setRepetitionPolicy(
       HeraldRepetitionPolicyConfig::toInt($repetition_policy_param));
 
     $e_name = true;
     $errors = array();
 
     if (!strlen($rule->getName())) {
       $e_name = pht('Required');
       $errors[] = pht('Rule must have a name.');
     }
 
     $data = json_decode($request->getStr('rule'), true);
     if (!is_array($data) ||
         !$data['conditions'] ||
         !$data['actions']) {
       throw new Exception('Failed to decode rule data.');
     }
 
     $conditions = array();
     foreach ($data['conditions'] as $condition) {
       if ($condition === null) {
         // We manage this as a sparse array on the client, so may receive
         // NULL if conditions have been removed.
         continue;
       }
 
       $obj = new HeraldCondition();
       $obj->setFieldName($condition[0]);
       $obj->setFieldCondition($condition[1]);
 
       if (is_array($condition[2])) {
         $obj->setValue(array_keys($condition[2]));
       } else {
         $obj->setValue($condition[2]);
       }
 
       try {
         $adapter->willSaveCondition($obj);
       } catch (HeraldInvalidConditionException $ex) {
         $errors[] = $ex->getMessage();
       }
 
       $conditions[] = $obj;
     }
 
     $actions = array();
     foreach ($data['actions'] as $action) {
       if ($action === null) {
         // Sparse on the client; removals can give us NULLs.
         continue;
       }
 
       if (!isset($action[1])) {
         // Legitimate for any action which doesn't need a target, like
         // "Do nothing".
         $action[1] = null;
       }
 
       $obj = new HeraldAction();
       $obj->setAction($action[0]);
       $obj->setTarget($action[1]);
 
       try {
         $adapter->willSaveAction($rule, $obj);
       } catch (HeraldInvalidActionException $ex) {
         $errors[] = $ex;
       }
 
       $actions[] = $obj;
     }
 
     $rule->attachConditions($conditions);
     $rule->attachActions($actions);
 
     if (!$errors) {
       $edit_action = $rule->getID() ? 'edit' : 'create';
 
       $rule->openTransaction();
         $rule->save();
         $rule->saveConditions($conditions);
         $rule->saveActions($actions);
       $rule->saveTransaction();
     }
 
     return array($e_name, $errors);
   }
 
   private function setupEditorBehavior(
     HeraldRule $rule,
     array $handles,
     HeraldAdapter $adapter) {
 
     $serial_conditions = array(
       array('default', 'default', ''),
     );
 
     if ($rule->getConditions()) {
       $serial_conditions = array();
       foreach ($rule->getConditions() as $condition) {
 
         $value = $condition->getValue();
         switch ($condition->getFieldName()) {
           case HeraldAdapter::FIELD_TASK_PRIORITY:
             $value_map = array();
             $priority_map = ManiphestTaskPriority::getTaskPriorityMap();
             foreach ($value as $priority) {
               $value_map[$priority] = idx($priority_map, $priority);
             }
             $value = $value_map;
             break;
           case HeraldAdapter::FIELD_TASK_STATUS:
             $value_map = array();
             $status_map = ManiphestTaskStatus::getTaskStatusMap();
             foreach ($value as $status) {
               $value_map[$status] = idx($status_map, $status);
             }
             $value = $value_map;
             break;
           default:
             if (is_array($value)) {
               $value_map = array();
               foreach ($value as $k => $fbid) {
                 $value_map[$fbid] = $handles[$fbid]->getName();
               }
               $value = $value_map;
             }
             break;
         }
         $serial_conditions[] = array(
           $condition->getFieldName(),
           $condition->getFieldCondition(),
           $value,
         );
       }
     }
 
     $serial_actions = array(
       array('default', ''),
     );
     if ($rule->getActions()) {
       $serial_actions = array();
       foreach ($rule->getActions() as $action) {
 
         switch ($action->getAction()) {
           case HeraldAdapter::ACTION_FLAG:
           case HeraldAdapter::ACTION_BLOCK:
             $current_value = $action->getTarget();
             break;
           default:
             if (is_array($action->getTarget())) {
               $target_map = array();
               foreach ((array)$action->getTarget() as $fbid) {
                 $target_map[$fbid] = $handles[$fbid]->getName();
               }
               $current_value = $target_map;
             } else {
               $current_value = $action->getTarget();
             }
             break;
         }
 
         $serial_actions[] = array(
           $action->getAction(),
           $current_value,
         );
       }
     }
 
     $all_rules = $this->loadRulesThisRuleMayDependUpon($rule);
     $all_rules = mpull($all_rules, 'getName', 'getPHID');
     asort($all_rules);
 
     $all_fields = $adapter->getFieldNameMap();
     $all_conditions = $adapter->getConditionNameMap();
     $all_actions = $adapter->getActionNameMap($rule->getRuleType());
 
     $fields = $adapter->getFields();
     $field_map = array_select_keys($all_fields, $fields);
 
     // Populate any fields which exist in the rule but which we don't know the
     // names of, so that saving a rule without touching anything doesn't change
     // it.
     foreach ($rule->getConditions() as $condition) {
       if (empty($field_map[$condition->getFieldName()])) {
         $field_map[$condition->getFieldName()] = pht('<Unknown Field>');
       }
     }
 
     $actions = $adapter->getActions($rule->getRuleType());
     $action_map = array_select_keys($all_actions, $actions);
 
     $config_info = array();
     $config_info['fields'] = $field_map;
     $config_info['conditions'] = $all_conditions;
     $config_info['actions'] = $action_map;
 
     foreach ($config_info['fields'] as $field => $name) {
       $field_conditions = $adapter->getConditionsForField($field);
       $config_info['conditionMap'][$field] = $field_conditions;
     }
 
     foreach ($config_info['fields'] as $field => $fname) {
       foreach ($config_info['conditionMap'][$field] as $condition) {
         $value_type = $adapter->getValueTypeForFieldAndCondition(
           $field,
           $condition);
         $config_info['values'][$field][$condition] = $value_type;
       }
     }
 
     $config_info['rule_type'] = $rule->getRuleType();
 
     foreach ($config_info['actions'] as $action => $name) {
       $config_info['targets'][$action] = $adapter->getValueTypeForAction(
         $action,
        $rule->getRuleType());
     }
 
     $changeflag_options =
       PhabricatorRepositoryPushLog::getHeraldChangeFlagConditionOptions();
     Javelin::initBehavior(
       'herald-rule-editor',
       array(
         'root' => 'herald-rule-edit-form',
         'conditions' => (object)$serial_conditions,
         'actions' => (object)$serial_actions,
         'select' => array(
           HeraldAdapter::VALUE_CONTENT_SOURCE => array(
             'options' => PhabricatorContentSource::getSourceNameMap(),
             'default' => PhabricatorContentSource::SOURCE_WEB,
           ),
           HeraldAdapter::VALUE_FLAG_COLOR => array(
             'options' => PhabricatorFlagColor::getColorNameMap(),
             'default' => PhabricatorFlagColor::COLOR_BLUE,
           ),
           HeraldPreCommitRefAdapter::VALUE_REF_TYPE => array(
             'options' => array(
               PhabricatorRepositoryPushLog::REFTYPE_BRANCH
                 => pht('branch (git/hg)'),
               PhabricatorRepositoryPushLog::REFTYPE_TAG
                 => pht('tag (git)'),
               PhabricatorRepositoryPushLog::REFTYPE_BOOKMARK
                 => pht('bookmark (hg)'),
             ),
             'default' => PhabricatorRepositoryPushLog::REFTYPE_BRANCH,
           ),
           HeraldPreCommitRefAdapter::VALUE_REF_CHANGE => array(
             'options' => $changeflag_options,
             'default' => PhabricatorRepositoryPushLog::CHANGEFLAG_ADD,
           ),
         ),
         'template' => $this->buildTokenizerTemplates($handles) + array(
           'rules' => $all_rules,
         ),
         'author' => array(
           $rule->getAuthorPHID() =>
             $handles[$rule->getAuthorPHID()]->getName(),
         ),
         'info' => $config_info,
       ));
   }
 
   private function loadHandlesForRule($rule) {
     $phids = array();
 
     foreach ($rule->getActions() as $action) {
       if (!is_array($action->getTarget())) {
         continue;
       }
       foreach ($action->getTarget() as $target) {
         $target = (array)$target;
         foreach ($target as $phid) {
           $phids[] = $phid;
         }
       }
     }
 
     foreach ($rule->getConditions() as $condition) {
       $value = $condition->getValue();
       if (is_array($value)) {
         foreach ($value as $phid) {
           $phids[] = $phid;
         }
       }
     }
 
     $phids[] = $rule->getAuthorPHID();
 
     if ($rule->isObjectRule()) {
       $phids[] = $rule->getTriggerObjectPHID();
     }
 
     return $this->loadViewerHandles($phids);
   }
 
 
   /**
    * Render the selector for the "When (all of | any of) these conditions are
    * met:" element.
    */
   private function renderMustMatchSelector($rule) {
     return AphrontFormSelectControl::renderSelectTag(
       $rule->getMustMatchAll() ? 'all' : 'any',
       array(
         'all' => pht('all of'),
         'any' => pht('any of'),
       ),
       array(
         'name' => 'must_match',
       ));
   }
 
 
   /**
    * Render the selector for "Take these actions (every time | only the first
    * time) this rule matches..." element.
    */
   private function renderRepetitionSelector($rule, HeraldAdapter $adapter) {
     $repetition_policy = HeraldRepetitionPolicyConfig::toString(
       $rule->getRepetitionPolicy());
 
     $repetition_options = $adapter->getRepetitionOptions();
     $repetition_names = HeraldRepetitionPolicyConfig::getMap();
     $repetition_map = array_select_keys($repetition_names, $repetition_options);
 
     if (count($repetition_map) < 2) {
       return head($repetition_names);
     } else {
       return AphrontFormSelectControl::renderSelectTag(
         $repetition_policy,
         $repetition_map,
         array(
           'name' => 'repetition_policy',
         ));
     }
   }
 
 
   protected function buildTokenizerTemplates(array $handles) {
     $template = new AphrontTokenizerTemplateView();
     $template = $template->render();
 
     $sources = array(
       'repository' => new DiffusionRepositoryDatasource(),
       'legaldocuments' => new LegalpadDocumentDatasource(),
       'taskpriority' => new ManiphestTaskPriorityDatasource(),
       'taskstatus' => new ManiphestTaskStatusDatasource(),
       'buildplan' => new HarbormasterBuildPlanDatasource(),
       'arcanistprojects' => new DiffusionArcanistProjectDatasource(),
       'package' => new PhabricatorOwnersPackageDatasource(),
       'project' => new PhabricatorProjectDatasource(),
       'user' => new PhabricatorPeopleDatasource(),
       'email' => new PhabricatorMetaMTAMailableDatasource(),
       'userorproject' => new PhabricatorProjectOrUserDatasource(),
       'applicationemail' => new PhabricatorMetaMTAApplicationEmailDatasource(),
     );
 
     foreach ($sources as $key => $source) {
+      $source->setViewer($this->getViewer());
+
       $sources[$key] = array(
         'uri' => $source->getDatasourceURI(),
         'placeholder' => $source->getPlaceholderText(),
+        'browseURI' => $source->getBrowseURI(),
       );
     }
 
     return array(
       'source' => $sources,
       'username' => $this->getRequest()->getUser()->getUserName(),
       'icons' => mpull($handles, 'getTypeIcon', 'getPHID'),
       'markup' => $template,
     );
   }
 
 
   /**
    * Load rules for the "Another Herald rule..." condition dropdown, which
    * allows one rule to depend upon the success or failure of another rule.
    */
   private function loadRulesThisRuleMayDependUpon(HeraldRule $rule) {
     $viewer = $this->getRequest()->getUser();
 
     // Any rule can depend on a global rule.
     $all_rules = id(new HeraldRuleQuery())
       ->setViewer($viewer)
       ->withRuleTypes(array(HeraldRuleTypeConfig::RULE_TYPE_GLOBAL))
       ->withContentTypes(array($rule->getContentType()))
       ->execute();
 
     if ($rule->isObjectRule()) {
       // Object rules may depend on other rules for the same object.
       $all_rules += id(new HeraldRuleQuery())
         ->setViewer($viewer)
         ->withRuleTypes(array(HeraldRuleTypeConfig::RULE_TYPE_OBJECT))
         ->withContentTypes(array($rule->getContentType()))
         ->withTriggerObjectPHIDs(array($rule->getTriggerObjectPHID()))
         ->execute();
     }
 
     if ($rule->isPersonalRule()) {
       // Personal rules may depend upon your other personal rules.
       $all_rules += id(new HeraldRuleQuery())
         ->setViewer($viewer)
         ->withRuleTypes(array(HeraldRuleTypeConfig::RULE_TYPE_PERSONAL))
         ->withContentTypes(array($rule->getContentType()))
         ->withAuthorPHIDs(array($rule->getAuthorPHID()))
         ->execute();
     }
 
     // mark disabled rules as disabled since they are not useful as such;
     // don't filter though to keep edit cases sane / expected
     foreach ($all_rules as $current_rule) {
       if ($current_rule->getIsDisabled()) {
         $current_rule->makeEphemeral();
         $current_rule->setName($rule->getName().' '.pht('(Disabled)'));
       }
     }
 
     // A rule can not depend upon itself.
     unset($all_rules[$rule->getID()]);
 
     return $all_rules;
   }
 
 }
diff --git a/src/applications/mailinglists/typeahead/PhabricatorMailingListDatasource.php b/src/applications/mailinglists/typeahead/PhabricatorMailingListDatasource.php
index c08da2a30d..b9435e0b4a 100644
--- a/src/applications/mailinglists/typeahead/PhabricatorMailingListDatasource.php
+++ b/src/applications/mailinglists/typeahead/PhabricatorMailingListDatasource.php
@@ -1,38 +1,35 @@
 <?php
 
 final class PhabricatorMailingListDatasource
   extends PhabricatorTypeaheadDatasource {
 
-  public function isBrowsable() {
-    // TODO: Make this browsable if we don't delete it before then.
-    return false;
-  }
-
   public function getPlaceholderText() {
     return pht('Type a mailing list name...');
   }
 
   public function getDatasourceApplicationClass() {
     return 'PhabricatorMailingListsApplication';
   }
 
   public function loadResults() {
     $viewer = $this->getViewer();
     $raw_query = $this->getRawQuery();
 
-    $results = array();
+    $query = id(new PhabricatorMailingListQuery());
+    $lists = $this->executeQuery($query);
 
-    $lists = id(new PhabricatorMailingListQuery())
-      ->setViewer($viewer)
-      ->execute();
+    $results = array();
     foreach ($lists as $list) {
       $results[] = id(new PhabricatorTypeaheadResult())
         ->setName($list->getName())
         ->setURI($list->getURI())
         ->setPHID($list->getPHID());
     }
 
-    return $results;
+    // TODO: It would be slightly preferable to do this as part of the query,
+    // this is just simpler for the moment.
+
+    return $this->filterResultsAgainstTokens($results);
   }
 
 }
diff --git a/src/applications/maniphest/controller/ManiphestBatchEditController.php b/src/applications/maniphest/controller/ManiphestBatchEditController.php
index f22269c10e..f604d58d0c 100644
--- a/src/applications/maniphest/controller/ManiphestBatchEditController.php
+++ b/src/applications/maniphest/controller/ManiphestBatchEditController.php
@@ -1,379 +1,384 @@
 <?php
 
 final class ManiphestBatchEditController extends ManiphestController {
 
   public function processRequest() {
     $this->requireApplicationCapability(
       ManiphestBulkEditCapability::CAPABILITY);
 
     $request = $this->getRequest();
     $user = $request->getUser();
 
     $task_ids = $request->getArr('batch');
     $tasks = id(new ManiphestTaskQuery())
       ->setViewer($user)
       ->withIDs($task_ids)
       ->requireCapabilities(
         array(
           PhabricatorPolicyCapability::CAN_VIEW,
           PhabricatorPolicyCapability::CAN_EDIT,
         ))
       ->needSubscriberPHIDs(true)
       ->needProjectPHIDs(true)
       ->execute();
 
     $actions = $request->getStr('actions');
     if ($actions) {
       $actions = json_decode($actions, true);
     }
 
     if ($request->isFormPost() && is_array($actions)) {
       foreach ($tasks as $task) {
         $field_list = PhabricatorCustomField::getObjectFields(
           $task,
           PhabricatorCustomField::ROLE_EDIT);
         $field_list->readFieldsFromStorage($task);
 
         $xactions = $this->buildTransactions($actions, $task);
         if ($xactions) {
           // TODO: Set content source to "batch edit".
 
           $editor = id(new ManiphestTransactionEditor())
             ->setActor($user)
             ->setContentSourceFromRequest($request)
             ->setContinueOnNoEffect(true)
             ->setContinueOnMissingFields(true)
             ->applyTransactions($task, $xactions);
         }
       }
 
       $task_ids = implode(',', mpull($tasks, 'getID'));
 
       return id(new AphrontRedirectResponse())
         ->setURI('/maniphest/?ids='.$task_ids);
     }
 
     $handles = ManiphestTaskListView::loadTaskHandles($user, $tasks);
 
     $list = new ManiphestTaskListView();
     $list->setTasks($tasks);
     $list->setUser($user);
     $list->setHandles($handles);
 
     $template = new AphrontTokenizerTemplateView();
     $template = $template->render();
 
     $projects_source = new PhabricatorProjectDatasource();
     $mailable_source = new PhabricatorMetaMTAMailableDatasource();
+    $mailable_source->setViewer($user);
     $owner_source = new PhabricatorTypeaheadOwnerDatasource();
+    $owner_source->setViewer($user);
 
     require_celerity_resource('maniphest-batch-editor');
     Javelin::initBehavior(
       'maniphest-batch-editor',
       array(
         'root' => 'maniphest-batch-edit-form',
         'tokenizerTemplate' => $template,
         'sources' => array(
           'project' => array(
-            'src'           => $projects_source->getDatasourceURI(),
-            'placeholder'   => $projects_source->getPlaceholderText(),
+            'src' => $projects_source->getDatasourceURI(),
+            'placeholder' => $projects_source->getPlaceholderText(),
+            'browseURI' => $projects_source->getBrowseURI(),
           ),
           'owner' => array(
-            'src'           => $owner_source->getDatasourceURI(),
-            'placeholder'   => $owner_source->getPlaceholderText(),
-            'limit'         => 1,
+            'src' => $owner_source->getDatasourceURI(),
+            'placeholder' => $owner_source->getPlaceholderText(),
+            'browseURI' => $owner_source->getBrowseURI(),
+            'limit' => 1,
           ),
-          'cc'    => array(
-            'src'           => $mailable_source->getDatasourceURI(),
-            'placeholder'   => $mailable_source->getPlaceholderText(),
+          'cc' => array(
+            'src' => $mailable_source->getDatasourceURI(),
+            'placeholder' => $mailable_source->getPlaceholderText(),
+            'browseURI' => $mailable_source->getBrowseURI(),
           ),
         ),
         'input' => 'batch-form-actions',
         'priorityMap' => ManiphestTaskPriority::getTaskPriorityMap(),
         'statusMap'   => ManiphestTaskStatus::getTaskStatusMap(),
       ));
 
     $form = new AphrontFormView();
     $form->setUser($user);
     $form->setID('maniphest-batch-edit-form');
 
     foreach ($tasks as $task) {
       $form->appendChild(
         phutil_tag(
           'input',
           array(
             'type' => 'hidden',
             'name' => 'batch[]',
             'value' => $task->getID(),
           )));
     }
 
     $form->appendChild(
       phutil_tag(
         'input',
         array(
           'type' => 'hidden',
           'name' => 'actions',
           'id'   => 'batch-form-actions',
         )));
     $form->appendChild(
       id(new PHUIFormInsetView())
         ->setTitle(pht('Actions'))
         ->setRightButton(javelin_tag(
             'a',
             array(
               'href' => '#',
               'class' => 'button green',
               'sigil' => 'add-action',
               'mustcapture' => true,
             ),
             pht('Add Another Action')))
         ->setContent(javelin_tag(
           'table',
           array(
             'sigil' => 'maniphest-batch-actions',
             'class' => 'maniphest-batch-actions-table',
           ),
           '')))
       ->appendChild(
         id(new AphrontFormSubmitControl())
           ->setValue(pht('Update Tasks'))
           ->addCancelButton('/maniphest/'));
 
     $title = pht('Batch Editor');
 
     $crumbs = $this->buildApplicationCrumbs();
     $crumbs->addTextCrumb($title);
 
     $task_box = id(new PHUIObjectBoxView())
       ->setHeaderText(pht('Selected Tasks'))
       ->appendChild($list);
 
     $form_box = id(new PHUIObjectBoxView())
       ->setHeaderText(pht('Batch Editor'))
       ->setForm($form);
 
     return $this->buildApplicationPage(
       array(
         $crumbs,
         $task_box,
         $form_box,
       ),
       array(
         'title' => $title,
       ));
   }
 
   private function buildTransactions($actions, ManiphestTask $task) {
     $value_map = array();
     $type_map = array(
       'add_comment'     => PhabricatorTransactions::TYPE_COMMENT,
       'assign'          => ManiphestTransaction::TYPE_OWNER,
       'status'          => ManiphestTransaction::TYPE_STATUS,
       'priority'        => ManiphestTransaction::TYPE_PRIORITY,
       'add_project'     => PhabricatorTransactions::TYPE_EDGE,
       'remove_project'  => PhabricatorTransactions::TYPE_EDGE,
       'add_ccs'         => PhabricatorTransactions::TYPE_SUBSCRIBERS,
       'remove_ccs'      => PhabricatorTransactions::TYPE_SUBSCRIBERS,
     );
 
     $edge_edit_types = array(
       'add_project'    => true,
       'remove_project' => true,
       'add_ccs'        => true,
       'remove_ccs'     => true,
     );
 
     $xactions = array();
     foreach ($actions as $action) {
       if (empty($type_map[$action['action']])) {
         throw new Exception("Unknown batch edit action '{$action}'!");
       }
 
       $type = $type_map[$action['action']];
 
       // Figure out the current value, possibly after modifications by other
       // batch actions of the same type. For example, if the user chooses to
       // "Add Comment" twice, we should add both comments. More notably, if the
       // user chooses "Remove Project..." and also "Add Project...", we should
       // avoid restoring the removed project in the second transaction.
 
       if (array_key_exists($type, $value_map)) {
         $current = $value_map[$type];
       } else {
         switch ($type) {
           case PhabricatorTransactions::TYPE_COMMENT:
             $current = null;
             break;
           case ManiphestTransaction::TYPE_OWNER:
             $current = $task->getOwnerPHID();
             break;
           case ManiphestTransaction::TYPE_STATUS:
             $current = $task->getStatus();
             break;
           case ManiphestTransaction::TYPE_PRIORITY:
             $current = $task->getPriority();
             break;
           case PhabricatorTransactions::TYPE_EDGE:
             $current = $task->getProjectPHIDs();
             break;
           case PhabricatorTransactions::TYPE_SUBSCRIBERS:
             $current = $task->getSubscriberPHIDs();
             break;
         }
       }
 
       // Check if the value is meaningful / provided, and normalize it if
       // necessary. This discards, e.g., empty comments and empty owner
       // changes.
 
       $value = $action['value'];
       switch ($type) {
         case PhabricatorTransactions::TYPE_COMMENT:
           if (!strlen($value)) {
             continue 2;
           }
           break;
         case ManiphestTransaction::TYPE_OWNER:
           if (empty($value)) {
             continue 2;
           }
           $value = head($value);
           if ($value === ManiphestTaskOwner::OWNER_UP_FOR_GRABS) {
             $value = null;
           }
           break;
         case PhabricatorTransactions::TYPE_EDGE:
           if (empty($value)) {
             continue 2;
           }
           break;
         case PhabricatorTransactions::TYPE_SUBSCRIBERS:
           if (empty($value)) {
             continue 2;
           }
           break;
       }
 
       // If the edit doesn't change anything, go to the next action. This
       // check is only valid for changes like "owner", "status", etc, not
       // for edge edits, because we should still apply an edit like
       // "Remove Projects: A, B" to a task with projects "A, B".
 
       if (empty($edge_edit_types[$action['action']])) {
         if ($value == $current) {
           continue;
         }
       }
 
       // Apply the value change; for most edits this is just replacement, but
       // some need to merge the current and edited values (add/remove project).
 
       switch ($type) {
         case PhabricatorTransactions::TYPE_COMMENT:
           if (strlen($current)) {
             $value = $current."\n\n".$value;
           }
           break;
         case PhabricatorTransactions::TYPE_EDGE:
           $is_remove = $action['action'] == 'remove_project';
 
           $current = array_fill_keys($current, true);
           $value   = array_fill_keys($value, true);
 
           $new = $current;
           $did_something = false;
 
           if ($is_remove) {
             foreach ($value as $phid => $ignored) {
               if (isset($new[$phid])) {
                 unset($new[$phid]);
                 $did_something = true;
               }
             }
           } else {
             foreach ($value as $phid => $ignored) {
               if (empty($new[$phid])) {
                 $new[$phid] = true;
                 $did_something = true;
               }
             }
           }
 
           if (!$did_something) {
             continue 2;
           }
 
           $value = array_keys($new);
           break;
         case PhabricatorTransactions::TYPE_SUBSCRIBERS:
           $is_remove = $action['action'] == 'remove_ccs';
 
           $current = array_fill_keys($current, true);
 
           $new = array();
           $did_something = false;
 
           if ($is_remove) {
             foreach ($value as $phid) {
               if (isset($current[$phid])) {
                 $new[$phid] = true;
                 $did_something = true;
               }
             }
             if ($new) {
               $value = array('-' => array_keys($new));
             }
           } else {
             $new = array();
             foreach ($value as $phid) {
               $new[$phid] = true;
               $did_something = true;
             }
             if ($new) {
               $value = array('+' => array_keys($new));
             }
           }
           if (!$did_something) {
             continue 2;
           }
 
           break;
       }
 
       $value_map[$type] = $value;
     }
 
     $template = new ManiphestTransaction();
 
     foreach ($value_map as $type => $value) {
       $xaction = clone $template;
       $xaction->setTransactionType($type);
 
       switch ($type) {
         case PhabricatorTransactions::TYPE_COMMENT:
           $xaction->attachComment(
             id(new ManiphestTransactionComment())
               ->setContent($value));
           break;
         case PhabricatorTransactions::TYPE_EDGE:
           $project_type = PhabricatorProjectObjectHasProjectEdgeType::EDGECONST;
           $xaction
             ->setMetadataValue('edge:type', $project_type)
             ->setNewValue(
               array(
                 '=' => array_fuse($value),
               ));
           break;
         default:
           $xaction->setNewValue($value);
           break;
       }
 
       $xactions[] = $xaction;
     }
 
     return $xactions;
   }
 
 }
diff --git a/src/applications/policy/rule/PhabricatorLegalpadSignaturePolicyRule.php b/src/applications/policy/rule/PhabricatorLegalpadSignaturePolicyRule.php
index 14d207b4d8..9797d5ef80 100644
--- a/src/applications/policy/rule/PhabricatorLegalpadSignaturePolicyRule.php
+++ b/src/applications/policy/rule/PhabricatorLegalpadSignaturePolicyRule.php
@@ -1,74 +1,68 @@
 <?php
 
 final class PhabricatorLegalpadSignaturePolicyRule
   extends PhabricatorPolicyRule {
 
   private $signatures = array();
 
   public function getRuleDescription() {
     return pht('signers of legalpad documents');
   }
 
   public function willApplyRules(PhabricatorUser $viewer, array $values) {
     $values = array_unique(array_filter(array_mergev($values)));
     if (!$values) {
       return;
     }
 
     // TODO: This accepts signature of any version of the document, even an
     // older version.
 
     $documents = id(new LegalpadDocumentQuery())
       ->setViewer(PhabricatorUser::getOmnipotentUser())
       ->withPHIDs($values)
       ->withSignerPHIDs(array($viewer->getPHID()))
       ->execute();
     $this->signatures = mpull($documents, 'getPHID', 'getPHID');
   }
 
   public function applyRule(PhabricatorUser $viewer, $value) {
     foreach ($value as $document_phid) {
       if (!isset($this->signatures[$document_phid])) {
         return false;
       }
     }
     return true;
   }
 
   public function getValueControlType() {
     return self::CONTROL_TYPE_TOKENIZER;
   }
 
   public function getValueControlTemplate() {
-    $datasource = new LegalpadDocumentDatasource();
-
-    return array(
-      'markup' => new AphrontTokenizerTemplateView(),
-      'uri' => $datasource->getDatasourceURI(),
-      'placeholder' => $datasource->getPlaceholderText(),
-    );
+    return $this->getDatasourceTemplate(new LegalpadDocumentDatasource());
   }
 
   public function getRuleOrder() {
     return 900;
   }
 
   public function getValueForStorage($value) {
     PhutilTypeSpec::newFromString('list<string>')->check($value);
     return array_values($value);
   }
 
   public function getValueForDisplay(PhabricatorUser $viewer, $value) {
     $handles = id(new PhabricatorHandleQuery())
       ->setViewer($viewer)
       ->withPHIDs($value)
       ->execute();
 
     return mpull($handles, 'getFullName', 'getPHID');
   }
 
   public function ruleHasEffect($value) {
     return (bool)$value;
   }
 
 }
diff --git a/src/applications/policy/rule/PhabricatorPolicyRule.php b/src/applications/policy/rule/PhabricatorPolicyRule.php
index 6540d797df..eaa04e1e9e 100644
--- a/src/applications/policy/rule/PhabricatorPolicyRule.php
+++ b/src/applications/policy/rule/PhabricatorPolicyRule.php
@@ -1,70 +1,80 @@
 <?php
 
 abstract class PhabricatorPolicyRule {
 
   const CONTROL_TYPE_TEXT       = 'text';
   const CONTROL_TYPE_SELECT     = 'select';
   const CONTROL_TYPE_TOKENIZER  = 'tokenizer';
   const CONTROL_TYPE_NONE       = 'none';
 
   abstract public function getRuleDescription();
   abstract public function applyRule(PhabricatorUser $viewer, $value);
 
   public function willApplyRules(PhabricatorUser $viewer, array $values) {
     return;
   }
 
   public function getValueControlType() {
     return self::CONTROL_TYPE_TEXT;
   }
 
   public function getValueControlTemplate() {
     return null;
   }
 
+  protected function getDatasourceTemplate(
+    PhabricatorTypeaheadDatasource $datasource) {
+    return array(
+      'markup' => new AphrontTokenizerTemplateView(),
+      'uri' => $datasource->getDatasourceURI(),
+      'placeholder' => $datasource->getPlaceholderText(),
+      'browseURI' => $datasource->getBrowseURI(),
+    );
+  }
+
   public function getRuleOrder() {
     return 500;
   }
 
   public function getValueForStorage($value) {
     return $value;
   }
 
   public function getValueForDisplay(PhabricatorUser $viewer, $value) {
     return $value;
   }
 
   public function getRequiredHandlePHIDsForSummary($value) {
     $phids = array();
     switch ($this->getValueControlType()) {
       case self::CONTROL_TYPE_TOKENIZER:
         $phids = $value;
         break;
       case self::CONTROL_TYPE_TEXT:
       case self::CONTROL_TYPE_SELECT:
       case self::CONTROL_TYPE_NONE:
       default:
         if (phid_get_type($value) !=
             PhabricatorPHIDConstants::PHID_TYPE_UNKNOWN) {
           $phids = array($value);
         } else {
           $phids = array();
         }
         break;
     }
 
     return $phids;
   }
 
   /**
    * Return true if the given value creates a rule with a meaningful effect.
    * An example of a rule with no meaningful effect is a "users" rule with no
    * users specified.
    *
    * @return bool True if the value creates a meaningful rule.
    */
   public function ruleHasEffect($value) {
     return true;
   }
 
 }
diff --git a/src/applications/policy/rule/PhabricatorProjectsPolicyRule.php b/src/applications/policy/rule/PhabricatorProjectsPolicyRule.php
index 7bd75495c8..eca97ce37d 100644
--- a/src/applications/policy/rule/PhabricatorProjectsPolicyRule.php
+++ b/src/applications/policy/rule/PhabricatorProjectsPolicyRule.php
@@ -1,72 +1,66 @@
 <?php
 
 final class PhabricatorProjectsPolicyRule extends PhabricatorPolicyRule {
 
   private $memberships = array();
 
   public function getRuleDescription() {
     return pht('members of projects');
   }
 
   public function willApplyRules(PhabricatorUser $viewer, array $values) {
     $values = array_unique(array_filter(array_mergev($values)));
     if (!$values) {
       return;
     }
 
     $projects = id(new PhabricatorProjectQuery())
       ->setViewer(PhabricatorUser::getOmnipotentUser())
       ->withMemberPHIDs(array($viewer->getPHID()))
       ->withPHIDs($values)
       ->execute();
     foreach ($projects as $project) {
       $this->memberships[$viewer->getPHID()][$project->getPHID()] = true;
     }
   }
 
   public function applyRule(PhabricatorUser $viewer, $value) {
     foreach ($value as $project_phid) {
       if (isset($this->memberships[$viewer->getPHID()][$project_phid])) {
         return true;
       }
     }
     return false;
   }
 
   public function getValueControlType() {
     return self::CONTROL_TYPE_TOKENIZER;
   }
 
   public function getValueControlTemplate() {
-    $projects_source = new PhabricatorProjectDatasource();
-
-    return array(
-      'markup' => new AphrontTokenizerTemplateView(),
-      'uri' => $projects_source->getDatasourceURI(),
-      'placeholder' => $projects_source->getPlaceholderText(),
-    );
+    return $this->getDatasourceTemplate(new PhabricatorProjectDatasource());
   }
 
   public function getRuleOrder() {
     return 200;
   }
 
   public function getValueForStorage($value) {
     PhutilTypeSpec::newFromString('list<string>')->check($value);
     return array_values($value);
   }
 
   public function getValueForDisplay(PhabricatorUser $viewer, $value) {
     $handles = id(new PhabricatorHandleQuery())
       ->setViewer($viewer)
       ->withPHIDs($value)
       ->execute();
 
     return mpull($handles, 'getFullName', 'getPHID');
   }
 
   public function ruleHasEffect($value) {
     return (bool)$value;
   }
 
 }
diff --git a/src/applications/policy/rule/PhabricatorUsersPolicyRule.php b/src/applications/policy/rule/PhabricatorUsersPolicyRule.php
index 03be81e064..c60e43abb6 100644
--- a/src/applications/policy/rule/PhabricatorUsersPolicyRule.php
+++ b/src/applications/policy/rule/PhabricatorUsersPolicyRule.php
@@ -1,58 +1,52 @@
 <?php
 
 final class PhabricatorUsersPolicyRule extends PhabricatorPolicyRule {
 
   public function getRuleDescription() {
     return pht('users');
   }
 
   public function applyRule(PhabricatorUser $viewer, $value) {
     foreach ($value as $phid) {
       if ($phid == $viewer->getPHID()) {
         return true;
       }
     }
     return false;
   }
 
   public function getValueControlType() {
     return self::CONTROL_TYPE_TOKENIZER;
   }
 
   public function getValueControlTemplate() {
-    $users_datasource = new PhabricatorPeopleDatasource();
-
-    return array(
-      'markup' => new AphrontTokenizerTemplateView(),
-      'uri' => $users_datasource->getDatasourceURI(),
-      'placeholder' => $users_datasource->getPlaceholderText(),
-    );
+    return $this->getDatasourceTemplate(new PhabricatorPeopleDatasource());
   }
 
   public function getRuleOrder() {
     return 100;
   }
 
   public function getValueForStorage($value) {
     PhutilTypeSpec::newFromString('list<string>')->check($value);
     return array_values($value);
   }
 
   public function getValueForDisplay(PhabricatorUser $viewer, $value) {
     if (!$value) {
       return array();
     }
 
     $handles = id(new PhabricatorHandleQuery())
       ->setViewer($viewer)
       ->withPHIDs($value)
       ->execute();
 
     return mpull($handles, 'getFullName', 'getPHID');
   }
 
   public function ruleHasEffect($value) {
     return (bool)$value;
   }
 
 }
diff --git a/src/view/control/AphrontTokenizerTemplateView.php b/src/view/control/AphrontTokenizerTemplateView.php
index 009f3e134e..f0e34f2b1e 100644
--- a/src/view/control/AphrontTokenizerTemplateView.php
+++ b/src/view/control/AphrontTokenizerTemplateView.php
@@ -1,131 +1,136 @@
 <?php
 
 final class AphrontTokenizerTemplateView extends AphrontView {
 
   private $value;
   private $name;
   private $id;
   private $browseURI;
 
   public function setBrowseURI($browse_uri) {
     $this->browseURI = $browse_uri;
     return $this;
   }
 
   public function setID($id) {
     $this->id = $id;
     return $this;
   }
 
   public function setValue(array $value) {
     assert_instances_of($value, 'PhabricatorObjectHandle');
     $this->value = $value;
     return $this;
   }
 
   public function getValue() {
     return $this->value;
   }
 
   public function setName($name) {
     $this->name = $name;
     return $this;
   }
 
   public function getName() {
     return $this->name;
   }
 
   public function render() {
     require_celerity_resource('aphront-tokenizer-control-css');
 
     $id = $this->id;
     $name = $this->getName();
     $values = nonempty($this->getValue(), array());
 
     $tokens = array();
     foreach ($values as $key => $value) {
       $tokens[] = $this->renderToken(
         $value->getPHID(),
         $value->getFullName(),
         $value->getType());
     }
 
     $input = javelin_tag(
       'input',
       array(
         'mustcapture' => true,
         'name'        => $name,
         'class'       => 'jx-tokenizer-input',
         'sigil'       => 'tokenizer-input',
         'style'       => 'width: 0px;',
         'disabled'    => 'disabled',
         'type'        => 'text',
       ));
 
     $content = $tokens;
     $content[] = $input;
     $content[] = phutil_tag('div', array('style' => 'clear: both;'), '');
 
-    $container = phutil_tag(
+    $container = javelin_tag(
       'div',
       array(
         'id' => $id,
         'class' => 'jx-tokenizer-container',
+        'sigil' => 'tokenizer-container',
       ),
       $content);
 
-    $browse = null;
+    $icon = id(new PHUIIconView())
+      ->setIconFont('fa-list-ul');
+
+    // TODO: This thing is ugly and the ugliness is not intentional.
+    // We have to give it text or PHUIButtonView collapses. It should likely
+    // just be an icon and look more integrated into the input.
+    $browse = id(new PHUIButtonView())
+      ->setTag('a')
+      ->setIcon($icon)
+      ->addSigil('tokenizer-browse')
+      ->setColor(PHUIButtonView::GREY)
+      ->setSize(PHUIButtonView::SMALL)
+      ->setText(pht('Browse...'));
+
+    $classes = array();
+    $classes[] = 'jx-tokenizer-frame';
+
     if ($this->browseURI) {
-      $icon = id(new PHUIIconView())
-        ->setIconFont('fa-list-ul');
-
-      // TODO: This thing is ugly and the ugliness is not intentional.
-      // We have to give it text or PHUIButtonView collapses. It should likely
-      // just be an icon and look more integrated into the input.
-      $browse = id(new PHUIButtonView())
-        ->setTag('a')
-        ->setIcon($icon)
-        ->addSigil('tokenizer-browse')
-        ->setColor(PHUIButtonView::GREY)
-        ->setSize(PHUIButtonView::SMALL)
-        ->setText(pht('Browse...'));
+      $classes[] = 'has-browse';
     }
 
     $frame = javelin_tag(
       'table',
       array(
-        'class' => 'jx-tokenizer-frame',
+        'class' => implode(' ', $classes),
         'sigil' => 'tokenizer-frame',
       ),
       phutil_tag(
         'tr',
         array(
         ),
         array(
           phutil_tag(
             'td',
             array(
               'class' => 'jx-tokenizer-frame-input',
             ),
             $container),
           phutil_tag(
             'td',
             array(
               'class' => 'jx-tokenizer-frame-browse',
             ),
             $browse),
         )));
 
     return $frame;
   }
 
   private function renderToken($key, $value, $icon) {
     return id(new PhabricatorTypeaheadTokenView())
       ->setKey($key)
       ->setValue($value)
       ->setIcon($icon)
       ->setInputName($this->getName());
   }
 
 }
diff --git a/webroot/rsrc/css/aphront/tokenizer.css b/webroot/rsrc/css/aphront/tokenizer.css
index 074f54e5d8..2056c88c31 100644
--- a/webroot/rsrc/css/aphront/tokenizer.css
+++ b/webroot/rsrc/css/aphront/tokenizer.css
@@ -1,120 +1,128 @@
 /**
  * @provides aphront-tokenizer-control-css
  * @requires aphront-typeahead-control-css
  */
 
 body div.jx-tokenizer {
   background: transparent;
   position: relative;
   width: 100%;
 }
 
 body div.jx-tokenizer-container {
   position: relative;
   display: block;
   padding: 0 0 2px 0;
   min-height: 30px;
   height: auto;
 }
 
 var.jx-tokenizer-metrics {
   position: absolute;
   left: 20px;
   top: 20px;
 }
 
 body input.jx-tokenizer-input {
   border: 1px solid transparent;
   border-width: 1px 0px;
   padding: 3px;
   outline: none;
   float: left;
   width: 100%;
   border-shadow: none;
   box-shadow: none;
   -webkit-box-shadow: none;
   font-size: 13px;
   color: #333;
   height: 26px;
 }
 
 body input.jx-tokenizer-input:focus {
   box-shadow: none;
   -webkit-box-shadow: none;
   border-color: transparent;
 }
 
 body input.jx-typeahead-placeholder {
   margin-left: 4px;
   color: {$greytext};
 }
 
 a.jx-tokenizer-x {
   margin-left: 4px;
   color: {$bluetext};
 }
 
 a.jx-tokenizer-x:hover {
   color: {$darkbluetext};
   text-decoration: none;
 }
 
 a.jx-tokenizer-token {
   padding: 2px 6px 3px;
   border:  1px solid {$lightblueborder};
   margin: 3px 2px 0 4px;
   background: #dee7f8;
   float: left;
   cursor: pointer;
   border-radius: 3px;
   color: {$darkbluetext};
   min-height: 16px;
 }
 
 a.jx-tokenizer-token:hover {
   text-decoration: none;
   border-color: {$blueborder};
   background: #CDD9F0;
 }
 
 .jx-tokenizer-token .phui-icon-view {
   display: inline-block;
   margin: 2px 4px -3px 0;
   color: {$bluetext};
 }
 
 .tokenizer-result {
   position: relative;
   padding: 5px 8px 5px 28px;
 }
 
 .tokenizer-result .phui-icon-view {
   display: inline-block;
   width: 24px;
   height: 24px;
   position: absolute;
   top: 5px;
   left: 8px;
 }
 
 .tokenizer-result-closed {
   color: {$greytext};
 }
 
 .tokenizer-closed {
   margin-top: 2px;
 }
 
 .jx-tokenizer-frame {
   width: 100%;
 }
 
-.jx-tokenizer-frame-input {
+.jx-tokenizer-frame .jx-tokenizer-frame-browse {
+  display: none;
+}
+
+.has-browse .jx-tokenizer-frame-browse {
+  display: table-cell;
+}
+
+.jx-tokenizer-frame td.jx-tokenizer-frame-input {
   width: 100%;
 }
 
 .jx-tokenizer-frame-browse {
   width: 100px;
   vertical-align: middle;
   padding: 0 0 0 4px;
 }
diff --git a/webroot/rsrc/externals/javelin/lib/control/tokenizer/Tokenizer.js b/webroot/rsrc/externals/javelin/lib/control/tokenizer/Tokenizer.js
index bdde22fb88..93e540ece3 100644
--- a/webroot/rsrc/externals/javelin/lib/control/tokenizer/Tokenizer.js
+++ b/webroot/rsrc/externals/javelin/lib/control/tokenizer/Tokenizer.js
@@ -1,469 +1,470 @@
 /**
  * @requires javelin-dom
  *           javelin-util
  *           javelin-stratcom
  *           javelin-install
  * @provides javelin-tokenizer
  * @javelin
  */
 
 /**
  * A tokenizer is a UI component similar to a text input, except that it
  * allows the user to input a list of items ("tokens"), generally from a fixed
  * set of results. A familiar example of this UI is the "To:" field of most
  * email clients, where the control autocompletes addresses from the user's
  * address book.
  *
  * @{JX.Tokenizer} is built on top of @{JX.Typeahead}, and primarily adds the
  * ability to choose multiple items.
  *
  * To build a @{JX.Tokenizer}, you need to do four things:
  *
  *  1. Construct it, padding a DOM node for it to attach to. See the constructor
  *     for more information.
  *  2. Build a {@JX.Typeahead} and configure it with setTypeahead().
  *  3. Configure any special options you want.
  *  4. Call start().
  *
  * If you do this correctly, the input should suggest items and enter them as
  * tokens as the user types.
  *
  * When the tokenizer is focused, the CSS class `jx-tokenizer-container-focused`
  * is added to the container node.
  */
 JX.install('Tokenizer', {
   construct : function(containerNode) {
     this._containerNode = containerNode;
   },
 
   events : [
     /**
      * Emitted when the value of the tokenizer changes, similar to an 'onchange'
      * from a <select />.
      */
     'change'],
 
   properties : {
     limit : null,
     renderTokenCallback : null,
     browseURI: null
   },
 
   members : {
     _containerNode : null,
     _root : null,
     _frame: null,
     _focus : null,
     _orig : null,
     _typeahead : null,
     _tokenid : 0,
     _tokens : null,
     _tokenMap : null,
     _initialValue : null,
     _seq : 0,
     _lastvalue : null,
     _placeholder : null,
 
     start : function() {
       if (__DEV__) {
         if (!this._typeahead) {
           throw new Error(
             'JX.Tokenizer.start(): ' +
             'No typeahead configured! Use setTypeahead() to provide a ' +
             'typeahead.');
         }
       }
 
       this._orig = JX.DOM.find(this._containerNode, 'input', 'tokenizer-input');
       this._tokens = [];
       this._tokenMap = {};
 
       try {
         this._frame = JX.DOM.findAbove(this._orig, 'table', 'tokenizer-frame');
       } catch (e) {
         // Ignore, this tokenizer doesn't have a frame.
       }
 
       if (this._frame) {
+        JX.DOM.alterClass(this._frame, 'has-browse', !!this.getBrowseURI());
         JX.DOM.listen(
           this._frame,
           'click',
           'tokenizer-browse',
           JX.bind(this, this._onbrowse));
       }
 
       var focus = this.buildInput(this._orig.value);
       this._focus = focus;
 
       var input_container = JX.DOM.scry(
         this._containerNode,
         'div',
         'tokenizer-input-container'
       );
       input_container = input_container[0] || this._containerNode;
 
       JX.DOM.listen(
         focus,
         ['click', 'focus', 'blur', 'keydown', 'keypress', 'paste'],
         null,
         JX.bind(this, this.handleEvent));
 
       // NOTE: Safari on the iPhone does not normally delegate click events on
       // <div /> tags. This causes the event to fire. We want a click (in this
       // case, a touch) anywhere in the div to trigger this event so that we
       // can focus the input. Without this, you must tap an arbitrary area on
       // the left side of the input to focus it.
       //
       // http://www.quirksmode.org/blog/archives/2010/09/click_event_del.html
       input_container.onclick = JX.bag;
 
       JX.DOM.listen(
         input_container,
         'click',
         null,
         JX.bind(
           this,
           function(e) {
             if (e.getNode('remove')) {
               this._remove(e.getNodeData('token').key, true);
             } else if (e.getTarget() == this._root) {
               this.focus();
             }
           }));
 
       var root = JX.$N('div');
       root.id = this._orig.id;
       JX.DOM.alterClass(root, 'jx-tokenizer', true);
       root.style.cursor = 'text';
       this._root = root;
 
       root.appendChild(focus);
 
       var typeahead = this._typeahead;
       typeahead.setInputNode(this._focus);
       typeahead.start();
 
       setTimeout(JX.bind(this, function() {
         var container = this._orig.parentNode;
         JX.DOM.setContent(container, root);
         var map = this._initialValue || {};
         for (var k in map) {
           this.addToken(k, map[k]);
         }
         JX.DOM.appendContent(
           root,
           JX.$N('div', {style: {clear: 'both'}})
         );
         this._redraw();
       }), 0);
     },
 
     setInitialValue : function(map) {
       this._initialValue = map;
       return this;
     },
 
     setTypeahead : function(typeahead) {
 
       typeahead.setAllowNullSelection(false);
       typeahead.removeListener();
 
       typeahead.listen(
         'choose',
         JX.bind(this, function(result) {
           JX.Stratcom.context().prevent();
           if (this.addToken(result.rel, result.name)) {
             if (this.shouldHideResultsOnChoose()) {
               this._typeahead.hide();
             }
             this._typeahead.clear();
             this._redraw();
             this.focus();
           }
         })
       );
 
       typeahead.listen(
         'query',
         JX.bind(
           this,
           function(query) {
 
           // TODO: We should emit a 'query' event here to allow the caller to
           // generate tokens on the fly, e.g. email addresses or other freeform
           // or algorithmic tokens.
 
           // Then do this if something handles the event.
           // this._focus.value = '';
           // this._redraw();
           // this.focus();
 
           if (query.length) {
             // Prevent this event if there's any text, so that we don't submit
             // the form (either we created a token or we failed to create a
             // token; in either case we shouldn't submit). If the query is
             // empty, allow the event so that the form submission takes place.
             JX.Stratcom.context().prevent();
           }
         }));
 
       this._typeahead = typeahead;
 
       return this;
     },
 
     shouldHideResultsOnChoose : function() {
       return true;
     },
 
     handleEvent : function(e) {
       this._typeahead.handleEvent(e);
       if (e.getPrevented()) {
         return;
       }
 
       if (e.getType() == 'click') {
         if (e.getTarget() == this._root) {
           this.focus();
           e.prevent();
           return;
         }
       } else if (e.getType() == 'keydown') {
         this._onkeydown(e);
       } else if (e.getType() == 'blur') {
         this._didblur();
 
         // Explicitly update the placeholder since we just wiped the field
         // value.
         this._typeahead.updatePlaceholder();
       } else if (e.getType() == 'focus') {
         this._didfocus();
       } else if (e.getType() == 'paste') {
         setTimeout(JX.bind(this, this._redraw), 0);
       }
 
     },
 
     refresh : function() {
       this._redraw(true);
       return this;
     },
 
     _redraw : function(force) {
 
       // If there are tokens in the tokenizer, never show a placeholder.
       // Otherwise, show one if one is configured.
       if (JX.keys(this._tokenMap).length) {
         this._typeahead.setPlaceholder(null);
       } else {
         this._typeahead.setPlaceholder(this._placeholder);
       }
 
       var focus = this._focus;
 
       if (focus.value === this._lastvalue && !force) {
         return;
       }
       this._lastvalue = focus.value;
 
       var metrics = JX.DOM.textMetrics(
         this._focus,
         'jx-tokenizer-metrics');
       metrics.y = null;
       metrics.x += 24;
       metrics.setDim(focus);
 
       // NOTE: Once, long ago, we set "focus.value = focus.value;" here to fix
       // an issue with copy/paste in Firefox not redrawing correctly. However,
       // this breaks input of Japanese glyphs in Chrome, and I can't reproduce
       // the original issue in modern Firefox.
       //
       // If future changes muck around with things here, test that Japanese
       // inputs still work. Example:
       //
       //   - Switch to Hiragana mode.
       //   - Type "ni".
       //   - This should produce a glyph, not the value "n".
       //
       // With the assignment, Chrome loses the partial input on the "n" when
       // the value is assigned.
     },
 
     setPlaceholder : function(string) {
       this._placeholder = string;
       return this;
     },
 
     addToken : function(key, value) {
       if (key in this._tokenMap) {
         return false;
       }
 
       var focus = this._focus;
       var root = this._root;
       var token = this.buildToken(key, value);
 
       this._tokenMap[key] = {
         value : value,
         key : key,
         node : token
       };
       this._tokens.push(key);
 
       root.insertBefore(token, focus);
 
       this.invoke('change', this);
 
       return true;
     },
 
     removeToken : function(key) {
       return this._remove(key, false);
     },
 
     buildInput: function(value) {
       return JX.$N('input', {
         className: 'jx-tokenizer-input',
         type: 'text',
         autocomplete: 'off',
         value: value
       });
     },
 
     /**
      * Generate a token based on a key and value. The "token" and "remove"
      * sigils are observed by a listener in start().
      */
     buildToken: function(key, value) {
       var input = JX.$N('input', {
         type: 'hidden',
         value: key,
         name: this._orig.name + '[' + (this._seq++) + ']'
       });
 
       var remove = JX.$N('a', {
         className: 'jx-tokenizer-x',
         sigil: 'remove'
       }, '\u00d7'); // U+00D7 multiplication sign
 
       var display_token = value;
       var render_callback = this.getRenderTokenCallback();
       if (render_callback) {
         display_token = render_callback(value, key);
       }
 
       return JX.$N('a', {
         className: 'jx-tokenizer-token',
         sigil: 'token',
         meta: {key: key}
       }, [display_token, input, remove]);
     },
 
     getTokens : function() {
       var result = {};
       for (var key in this._tokenMap) {
         result[key] = this._tokenMap[key].value;
       }
       return result;
     },
 
     _onkeydown : function(e) {
       var raw = e.getRawEvent();
       if (raw.ctrlKey || raw.metaKey || raw.altKey) {
         return;
       }
 
       switch (e.getSpecialKey()) {
         case 'tab':
           var completed = this._typeahead.submit();
           if (!completed) {
             this._focus.value = '';
           }
           break;
         case 'delete':
           if (!this._focus.value.length) {
             var tok;
             while ((tok = this._tokens.pop())) {
               if (this._remove(tok, true)) {
                 break;
               }
             }
           }
           break;
         case 'return':
           // Don't subject this to token limits.
           break;
         default:
           if (this.getLimit() &&
               JX.keys(this._tokenMap).length == this.getLimit()) {
             e.prevent();
           }
           setTimeout(JX.bind(this, this._redraw), 0);
           break;
       }
     },
 
     _remove : function(index, focus) {
       if (!this._tokenMap[index]) {
         return false;
       }
       JX.DOM.remove(this._tokenMap[index].node);
       delete this._tokenMap[index];
       this._redraw(true);
       focus && this.focus();
 
       this.invoke('change', this);
 
       return true;
     },
 
     focus : function() {
       var focus = this._focus;
       JX.DOM.show(focus);
 
       // NOTE: We must fire this focus event immediately (during event
       // handling) for the iPhone to bring up the keyboard. Previously this
       // focus was wrapped in setTimeout(), but it's unclear why that was
       // necessary. If this is adjusted later, make sure tapping the inactive
       // area of the tokenizer to focus it on the iPhone still brings up the
       // keyboard.
 
       JX.DOM.focus(focus);
     },
 
     _didfocus : function() {
       JX.DOM.alterClass(
         this._containerNode,
         'jx-tokenizer-container-focused',
         true);
     },
 
     _didblur : function() {
       JX.DOM.alterClass(
         this._containerNode,
         'jx-tokenizer-container-focused',
         false);
       this._focus.value = '';
       this._redraw();
     },
 
     _onbrowse: function(e) {
       e.kill();
 
       var uri = this.getBrowseURI();
       if (!uri) {
         return;
       }
 
       new JX.Workflow(uri, {exclude: JX.keys(this.getTokens()).join(',')})
         .setHandler(
           JX.bind(this, function(r) {
             this._typeahead.getDatasource().addResult(r.token);
             this.addToken(r.key);
             this.focus();
           }))
         .start();
     }
 
   }
 });
diff --git a/webroot/rsrc/js/application/herald/HeraldRuleEditor.js b/webroot/rsrc/js/application/herald/HeraldRuleEditor.js
index 36f28bc865..abf645ba29 100644
--- a/webroot/rsrc/js/application/herald/HeraldRuleEditor.js
+++ b/webroot/rsrc/js/application/herald/HeraldRuleEditor.js
@@ -1,377 +1,373 @@
 /**
  * @requires multirow-row-manager
  *           javelin-install
  *           javelin-util
  *           javelin-dom
  *           javelin-stratcom
  *           javelin-json
  *           phabricator-prefab
  * @provides herald-rule-editor
  * @javelin
  */
 
 JX.install('HeraldRuleEditor', {
   construct : function(config) {
     var root = JX.$(config.root);
     this._root = root;
 
     JX.DOM.listen(
       root,
       'click',
       'create-condition',
       JX.bind(this, this._onnewcondition));
 
     JX.DOM.listen(
       root,
       'click',
       'create-action',
       JX.bind(this, this._onnewaction));
 
     JX.DOM.listen(root, 'change', null, JX.bind(this, this._onchange));
     JX.DOM.listen(root, 'submit', null, JX.bind(this, this._onsubmit));
 
     var conditionsTable = JX.DOM.find(root, 'table', 'rule-conditions');
     var actionsTable = JX.DOM.find(root, 'table', 'rule-actions');
 
     this._conditionsRowManager = new JX.MultirowRowManager(conditionsTable);
     this._conditionsRowManager.listen(
       'row-removed',
       JX.bind(this, function(row_id) {
           delete this._config.conditions[row_id];
         }));
 
     this._actionsRowManager = new JX.MultirowRowManager(actionsTable);
     this._actionsRowManager.listen(
       'row-removed',
       JX.bind(this, function(row_id) {
           delete this._config.actions[row_id];
         }));
 
     this._conditionGetters = {};
     this._conditionTypes = {};
     this._actionGetters = {};
     this._actionTypes = {};
 
     this._config = config;
 
     var conditions = this._config.conditions;
     this._config.conditions = [];
 
     var actions = this._config.actions;
     this._config.actions = [];
 
     this._renderConditions(conditions);
     this._renderActions(actions);
   },
 
   members : {
     _config : null,
     _root : null,
     _conditionGetters : null,
     _conditionTypes : null,
     _actionGetters : null,
     _actionTypes : null,
     _conditionsRowManager : null,
     _actionsRowManager : null,
 
     _onnewcondition : function(e) {
       this._newCondition();
       e.kill();
     },
     _onnewaction : function(e) {
       this._newAction();
       e.kill();
     },
     _onchange : function(e) {
       var target = e.getTarget();
 
       var row = e.getNode(JX.MultirowRowManager.getRowSigil());
       if (!row) {
         // Changing the "when all of / any of these..." dropdown.
         return;
       }
 
       if (JX.Stratcom.hasSigil(target, 'field-select')) {
         this._onfieldchange(row);
       } else if (JX.Stratcom.hasSigil(target, 'condition-select')) {
         this._onconditionchange(row);
       } else if (JX.Stratcom.hasSigil(target, 'action-select')) {
         this._onactionchange(row);
       }
     },
     _onsubmit : function() {
       var rule = JX.DOM.find(this._root, 'input', 'rule');
 
       var k;
 
       for (k in this._config.conditions) {
         this._config.conditions[k][2] = this._getConditionValue(k);
       }
 
       for (k in this._config.actions) {
         this._config.actions[k][1] = this._getActionTarget(k);
       }
       rule.value = JX.JSON.stringify({
         conditions: this._config.conditions,
         actions: this._config.actions
       });
     },
 
     _getConditionValue : function(id) {
       if (this._conditionGetters[id]) {
         return this._conditionGetters[id]();
       }
       return this._config.conditions[id][2];
     },
 
     _getActionTarget : function(id) {
       if (this._actionGetters[id]) {
         return this._actionGetters[id]();
       }
       return this._config.actions[id][1];
     },
 
     _onactionchange : function(r) {
       var target = JX.DOM.find(r, 'select', 'action-select');
       var row_id = this._actionsRowManager.getRowID(r);
 
       this._config.actions[row_id][0] = target.value;
 
       var target_cell = JX.DOM.find(r, 'td', 'target-cell');
       var target_input = this._renderTargetInputForRow(row_id);
 
       JX.DOM.setContent(target_cell, target_input);
     },
     _onfieldchange : function(r) {
       var target = JX.DOM.find(r, 'select', 'field-select');
       var row_id = this._actionsRowManager.getRowID(r);
 
       this._config.conditions[row_id][0] = target.value;
 
       var condition_cell = JX.DOM.find(r, 'td', 'condition-cell');
       var condition_select = this._renderSelect(
         this._selectKeys(
           this._config.info.conditions,
           this._config.info.conditionMap[target.value]),
         this._config.conditions[row_id][1],
         'condition-select');
 
       JX.DOM.setContent(condition_cell, condition_select);
 
       this._onconditionchange(r);
 
       var condition_name = this._config.conditions[row_id][1];
       if (condition_name == 'unconditionally') {
         JX.DOM.hide(condition_select);
       }
     },
     _onconditionchange : function(r) {
       var target = JX.DOM.find(r, 'select', 'condition-select');
       var row_id = this._conditionsRowManager.getRowID(r);
 
       this._config.conditions[row_id][1] = target.value;
 
       var value_cell = JX.DOM.find(r, 'td', 'value-cell');
       var value_input = this._renderValueInputForRow(row_id);
       JX.DOM.setContent(value_cell, value_input);
     },
 
     _renderTargetInputForRow : function(row_id) {
       var action = this._config.actions[row_id];
       var type = this._config.info.targets[action[0]];
 
       var input = this._buildInput(type);
       var node = input[0];
       var get_fn = input[1];
       var set_fn = input[2];
 
       if (node) {
         JX.Stratcom.addSigil(node, 'action-target');
       }
 
       var old_type = this._actionTypes[row_id];
       if (old_type == type || !old_type) {
         set_fn(this._getActionTarget(row_id));
       }
 
       this._actionTypes[row_id] = type;
       this._actionGetters[row_id] = get_fn;
 
       return node;
     },
 
     _buildInput : function(type) {
       var input;
       var get_fn;
       var set_fn;
       switch (type) {
         case 'rule':
           input = this._renderSelect(this._config.template.rules);
           get_fn = function() { return input.value; };
           set_fn = function(v) { input.value = v; };
           break;
         case 'email':
         case 'user':
         case 'repository':
         case 'tag':
         case 'package':
         case 'project':
         case 'userorproject':
         case 'buildplan':
         case 'taskpriority':
         case 'taskstatus':
         case 'arcanistprojects':
         case 'legaldocuments':
         case 'applicationemail':
           var tokenizer = this._newTokenizer(type);
           input = tokenizer[0];
           get_fn = tokenizer[1];
           set_fn = tokenizer[2];
           break;
         case 'none':
           input = '';
           get_fn = JX.bag;
           set_fn = JX.bag;
           break;
         case 'contentsource':
         case 'flagcolor':
         case 'value-ref-type':
         case 'value-ref-change':
           input = this._renderSelect(this._config.select[type].options);
           get_fn = function() { return input.value; };
           set_fn = function(v) { input.value = v; };
           set_fn(this._config.select[type]['default']);
           break;
         default:
           input = JX.$N('input', {type: 'text'});
           get_fn = function() { return input.value; };
           set_fn = function(v) { input.value = v; };
           break;
       }
 
       return [input, get_fn, set_fn];
     },
 
     _renderValueInputForRow : function(row_id) {
       var cond = this._config.conditions[row_id];
       var type = this._config.info.values[cond[0]][cond[1]];
 
       var input = this._buildInput(type);
       var node = input[0];
       var get_fn = input[1];
       var set_fn = input[2];
 
       if (node) {
         JX.Stratcom.addSigil(node, 'condition-value');
       }
 
       var old_type = this._conditionTypes[row_id];
       if (old_type == type || !old_type) {
         set_fn(this._getConditionValue(row_id));
       }
 
       this._conditionTypes[row_id] = type;
       this._conditionGetters[row_id] = get_fn;
 
       return node;
     },
 
     _newTokenizer : function(type) {
-      var template = JX.$N(
-        'div',
-        JX.$H(this._config.template.markup));
-      template = template.firstChild;
-      template.id = '';
-
       var tokenizerConfig = {
-        root : template,
         src : this._config.template.source[type].uri,
         placeholder: this._config.template.source[type].placeholder,
+        browseURI: this._config.template.source[type].browseURI,
         icons : this._config.template.icons,
         username : this._config.username
       };
 
-      var build = JX.Prefab.buildTokenizer(tokenizerConfig);
+      var build = JX.Prefab.newTokenizerFromTemplate(
+        this._config.template.markup,
+        tokenizerConfig);
       build.tokenizer.start();
 
       return [
-        template,
+        build.node,
         function() {
           return build.tokenizer.getTokens();
         },
         function(map) {
           for (var k in map) {
             build.tokenizer.addToken(k, map[k]);
           }
         }];
     },
     _selectKeys : function(map, keys) {
       var r = {};
       for (var ii = 0; ii < keys.length; ii++) {
         r[keys[ii]] = map[keys[ii]];
       }
       return r;
     },
     _renderConditions : function(conditions) {
       for (var k in conditions) {
         this._newCondition(conditions[k]);
       }
     },
     _newCondition : function(data) {
       var row = this._conditionsRowManager.addRow([]);
       var row_id = this._conditionsRowManager.getRowID(row);
       this._config.conditions[row_id] = data || [null, null, ''];
       var r = this._conditionsRowManager.updateRow(
         row_id,
         this._renderCondition(row_id));
 
       this._onfieldchange(r);
     },
     _renderCondition : function(row_id) {
       var field_select = this._renderSelect(
         this._config.info.fields,
         this._config.conditions[row_id][0],
         'field-select');
       var field_cell = JX.$N('td', {sigil: 'field-cell'}, field_select);
 
       var condition_cell = JX.$N('td', {sigil: 'condition-cell'});
       var value_cell = JX.$N('td', {className : 'value', sigil: 'value-cell'});
 
       return [field_cell, condition_cell, value_cell];
     },
     _renderActions : function(actions) {
       for (var k in actions) {
         this._newAction(actions[k]);
         delete actions[k];
       }
     },
     _newAction : function(data) {
       data = data || [];
       var temprow = this._actionsRowManager.addRow([]);
       var row_id = this._actionsRowManager.getRowID(temprow);
       this._config.actions[row_id] = data;
       var r = this._actionsRowManager.updateRow(row_id,
                                                 this._renderAction(data));
       this._onactionchange(r);
     },
     _renderAction : function(action) {
       var action_select = this._renderSelect(
         this._config.info.actions,
         action[0],
         'action-select');
       var action_cell = JX.$N('td', {sigil: 'action-cell'}, action_select);
 
       var target_cell = JX.$N(
         'td',
         {className : 'target', sigil : 'target-cell'});
 
       return [action_cell, target_cell];
     },
     _renderSelect : function(map, selected, sigil) {
       var attrs = {
         sigil : sigil
       };
       return JX.Prefab.renderSelect(map, selected, attrs);
     }
   }
 });
diff --git a/webroot/rsrc/js/application/maniphest/behavior-batch-editor.js b/webroot/rsrc/js/application/maniphest/behavior-batch-editor.js
index 6b7768615f..5cf568ce2c 100644
--- a/webroot/rsrc/js/application/maniphest/behavior-batch-editor.js
+++ b/webroot/rsrc/js/application/maniphest/behavior-batch-editor.js
@@ -1,154 +1,150 @@
 /**
  * @provides javelin-behavior-maniphest-batch-editor
  * @requires javelin-behavior
  *           javelin-dom
  *           javelin-util
  *           phabricator-prefab
  *           multirow-row-manager
  *           javelin-json
  */
 
 JX.behavior('maniphest-batch-editor', function(config) {
   var root = JX.$(config.root);
   var editor_table = JX.DOM.find(root, 'table', 'maniphest-batch-actions');
   var manager = new JX.MultirowRowManager(editor_table);
   var action_rows = [];
 
   function renderRow() {
     var action_select = JX.Prefab.renderSelect(
       {
         'add_project': 'Add Projects',
         'remove_project' : 'Remove Projects',
         'priority': 'Change Priority',
         'status': 'Change Status',
         'add_comment': 'Comment',
         'assign': 'Assign',
         'add_ccs' : 'Add CCs',
         'remove_ccs' : 'Remove CCs'
       });
 
     var proj_tokenizer = build_tokenizer(config.sources.project);
     var owner_tokenizer = build_tokenizer(config.sources.owner);
     var cc_tokenizer = build_tokenizer(config.sources.cc);
 
     var priority_select = JX.Prefab.renderSelect(config.priorityMap);
     var status_select = JX.Prefab.renderSelect(config.statusMap);
     var comment_input = JX.$N('input', {style: {width: '100%'}});
 
     var cell = JX.$N('td', {className: 'batch-editor-input'});
     var vfunc = null;
 
     function update() {
       switch (action_select.value) {
         case 'add_project':
         case 'remove_project':
           JX.DOM.setContent(cell, proj_tokenizer.template);
           vfunc = function() {
             return JX.keys(proj_tokenizer.object.getTokens());
           };
           break;
         case 'add_ccs':
         case 'remove_ccs':
           JX.DOM.setContent(cell, cc_tokenizer.template);
           vfunc = function() {
             return JX.keys(cc_tokenizer.object.getTokens());
           };
           break;
         case 'assign':
           JX.DOM.setContent(cell, owner_tokenizer.template);
           vfunc = function() {
             return JX.keys(owner_tokenizer.object.getTokens());
           };
           break;
         case 'add_comment':
           JX.DOM.setContent(cell, comment_input);
           vfunc = function() {
             return comment_input.value;
           };
           break;
         case 'priority':
           JX.DOM.setContent(cell, priority_select);
           vfunc = function() { return priority_select.value; };
           break;
         case 'status':
           JX.DOM.setContent(cell, status_select);
           vfunc = function() { return status_select.value; };
           break;
       }
     }
 
     JX.DOM.listen(action_select, 'change', null, update);
     update();
 
     return {
       nodes : [JX.$N('td', {}, action_select), cell],
       dataCallback : function() {
         return {
           action: action_select.value,
           value: vfunc()
         };
       }
     };
   }
 
   function onaddaction(e) {
     e.kill();
     addRow({});
   }
 
   function addRow(info) {
     var data = renderRow(info);
     var row = manager.addRow(data.nodes);
     var id = manager.getRowID(row);
 
     action_rows[id] = data.dataCallback;
   }
 
   function onsubmit() {
     var input = JX.$(config.input);
 
     var actions = [];
     for (var k in action_rows) {
       actions.push(action_rows[k]());
     }
 
     input.value = JX.JSON.stringify(actions);
   }
 
   addRow({});
 
   JX.DOM.listen(
     root,
     'click',
     'add-action',
     onaddaction);
 
   JX.DOM.listen(
     root,
     'submit',
     null,
     onsubmit);
 
   manager.listen(
     'row-removed',
     function(row_id) {
       delete action_rows[row_id];
     });
 
   function build_tokenizer(tconfig) {
-    var template = JX.$N('div', JX.$H(config.tokenizerTemplate)).firstChild;
-    template.id = '';
-
-    var build_config = JX.copy({}, tconfig);
-    build_config.root = template;
-
-    var built = JX.Prefab.buildTokenizer(build_config);
+    var built = JX.Prefab.newTokenizerFromTemplate(
+      config.tokenizerTemplate,
+      JX.copy({}, tconfig));
     built.tokenizer.start();
 
     return {
       object: built.tokenizer,
-      template: template
+      template: built.node
     };
   }
 
 });
diff --git a/webroot/rsrc/js/application/policy/behavior-policy-rule-editor.js b/webroot/rsrc/js/application/policy/behavior-policy-rule-editor.js
index 3da2cdad5c..fd790644a1 100644
--- a/webroot/rsrc/js/application/policy/behavior-policy-rule-editor.js
+++ b/webroot/rsrc/js/application/policy/behavior-policy-rule-editor.js
@@ -1,175 +1,178 @@
 /**
  * @provides javelin-behavior-policy-rule-editor
  * @requires javelin-behavior
  *           multirow-row-manager
  *           javelin-dom
  *           javelin-util
  *           phabricator-prefab
  *           javelin-json
  */
 JX.behavior('policy-rule-editor', function(config) {
   var root = JX.$(config.rootID);
   var rows = [];
   var data = {};
 
   JX.DOM.listen(
     root,
     'click',
     'create-rule',
     function(e) {
       e.kill();
       new_rule(config.defaultRule);
     });
 
   JX.DOM.listen(
     root,
     'change',
     'rule-select',
     function(e) {
       e.kill();
 
       var row = e.getNode(JX.MultirowRowManager.getRowSigil());
       var row_id = rules_manager.getRowID(row);
 
       data[row_id].rule = data[row_id].ruleNode.value;
       data[row_id].value = null;
 
       redraw(row_id);
     });
 
   JX.DOM.listen(
     JX.DOM.findAbove(root, 'form'),
     ['submit', 'didWorkflowSubmit'],
     null,
     function(e) {
       var rules = JX.DOM.find(e.getNode('tag:form'), 'input', 'rules');
 
       var value = [];
       for (var ii = 0; ii < rows.length; ii++) {
         var row_data = data[rows[ii]];
 
         var row_dict = {
           action: row_data.actionNode.value,
           rule: row_data.rule,
           value: row_data.getValue()
         };
 
         value.push(row_dict);
       }
 
       rules.value = JX.JSON.stringify(value);
     });
 
 
   var rules_table = JX.DOM.find(root, 'table', 'rules');
   var rules_manager = new JX.MultirowRowManager(rules_table);
   rules_manager.listen(
     'row-removed',
     function(row_id) {
       delete data[row_id];
       for (var ii = 0; ii < rows.length; ii++) {
         if (rows[ii] == row_id) {
           rows.splice(ii, 1);
           break;
         }
       }
     });
 
 
   function new_rule(spec) {
     var row = rules_manager.addRow([]);
     var row_id = rules_manager.getRowID(row);
 
     rows.push(row_id);
     data[row_id] = JX.copy({}, spec);
 
     redraw(row_id);
   }
 
   function redraw(row_id) {
     var action_content = JX.Prefab.renderSelect(
       config.actions,
       data[row_id].action);
     data[row_id].actionNode = action_content;
     var action_cell = JX.$N('td', {className: 'action-cell'}, action_content);
 
     var rule_content = JX.Prefab.renderSelect(
       config.rules,
       data[row_id].rule,
       {sigil: 'rule-select'});
     data[row_id].ruleNode = rule_content;
     var rule_cell = JX.$N('td', {className: 'rule-cell'}, rule_content);
 
     var input = render_input(data[row_id].rule, null);
 
     var value_content = input.node;
     data[row_id].getValue = input.get;
     input.set(data[row_id].value);
 
     var value_cell = JX.$N('td', {className: 'value-cell'}, value_content);
 
     rules_manager.updateRow(row_id, [action_cell, rule_cell, value_cell]);
   }
 
   function render_input(rule, value) {
     var node, get_fn, set_fn;
     var type = config.types[rule];
     var template = config.templates[rule];
 
     switch (type) {
       case 'tokenizer':
-        node = JX.$H(template.markup).getNode();
-        node.id = '';
-
         var options = {
-          root: node,
           src: template.uri,
           placeholder: template.placeholder,
+          browseURI: template.browseURI,
           limit: template.limit
         };
 
-        var tokenizer = JX.Prefab.buildTokenizer(options).tokenizer;
+        var build = JX.Prefab.newTokenizerFromTemplate(
+          template.markup,
+          options);
+
+        node = build.node;
+
+        var tokenizer = build.tokenizer;
         tokenizer.start();
 
         get_fn = function() { return JX.keys(tokenizer.getTokens()); };
         set_fn = function(map) {
           if (!map) {
             return;
           }
           for (var k in map) {
             tokenizer.addToken(k, map[k]);
           }
         };
         break;
       case 'none':
         node = null;
         get_fn = JX.bag;
         set_fn = JX.bag;
         break;
       case 'select':
         node = JX.Prefab.renderSelect(
           config.templates[rule].options,
           value);
         get_fn = function() { return node.value; };
         set_fn = function(v) { node.value = v; };
         break;
       default:
       case 'text':
         node = JX.$N('input', {type: 'text'});
         get_fn = function() { return node.value; };
         set_fn = function(v) { node.value = v; };
         break;
     }
 
     return {
       node: node,
       get: get_fn,
       set: set_fn
     };
   }
 
   for (var ii = 0; ii < config.data.length; ii++) {
     new_rule(config.data[ii]);
   }
 
 });
diff --git a/webroot/rsrc/js/core/Prefab.js b/webroot/rsrc/js/core/Prefab.js
index 70e7e5946e..5856322fd3 100644
--- a/webroot/rsrc/js/core/Prefab.js
+++ b/webroot/rsrc/js/core/Prefab.js
@@ -1,291 +1,302 @@
 /**
  * @provides phabricator-prefab
  * @requires javelin-install
  *           javelin-util
  *           javelin-dom
  *           javelin-typeahead
  *           javelin-tokenizer
  *           javelin-typeahead-preloaded-source
  *           javelin-typeahead-ondemand-source
  *           javelin-dom
  *           javelin-stratcom
  *           javelin-util
  * @javelin
  */
 
 /**
  * Utilities for client-side rendering (the greatest thing in the world).
  */
 JX.install('Prefab', {
 
   statics : {
     renderSelect : function(map, selected, attrs) {
       var select = JX.$N('select', attrs || {});
       for (var k in map) {
         select.options[select.options.length] = new Option(map[k], k);
         if (k == selected) {
           select.value = k;
         }
       }
       select.value = select.value || JX.keys(map)[0];
       return select;
     },
 
+    newTokenizerFromTemplate: function(markup, config) {
+      var template = JX.$H(markup).getFragment().firstChild;
+      var container = JX.DOM.find(template, 'div', 'tokenizer-container');
+
+      container.id = '';
+      config.root = container;
+
+      var build = JX.Prefab.buildTokenizer(config);
+      build.node = template;
+      return build;
+    },
 
     /**
      * Build a Phabricator tokenizer out of a configuration with application
      * sorting, datasource and placeholder rules.
      *
      *   - `id` Root tokenizer ID (alternatively, pass `root`).
      *   - `root` Root tokenizer node (replaces `id`).
      *   - `src` Datasource URI.
      *   - `ondemand` Optional, use an ondemand source.
      *   - `value` Optional, initial value.
      *   - `limit` Optional, token limit.
      *   - `placeholder` Optional, placeholder text.
      *   - `username` Optional, username to sort first (i.e., viewer).
      *   - `icons` Optional, map of icons.
      *
      */
     buildTokenizer : function(config) {
       config.icons = config.icons || {};
 
       var root;
 
       try {
         root = config.root || JX.$(config.id);
       } catch (ex) {
         // If the root element does not exist, just return without building
         // anything. This happens in some cases -- like Conpherence -- where we
         // may load a tokenizer but not put it in the document.
         return;
       }
 
       var datasource;
 
       // Default to an ondemand source if no alternate configuration is
       // provided.
       var ondemand = true;
       if ('ondemand' in config) {
         ondemand = config.ondemand;
       }
 
       if (ondemand) {
         datasource = new JX.TypeaheadOnDemandSource(config.src);
       } else {
         datasource = new JX.TypeaheadPreloadedSource(config.src);
       }
 
       // Sort results so that the viewing user always comes up first; after
       // that, prefer unixname matches to realname matches.
 
       var sort_handler = function(value, list, cmp) {
         var priority_hits = {};
         var self_hits     = {};
 
         var tokens = this.tokenize(value);
 
         for (var ii = 0; ii < list.length; ii++) {
           var item = list[ii];
 
           for (var jj = 0; jj < tokens.length; jj++) {
             if (item.name.indexOf(tokens[jj]) === 0) {
               priority_hits[item.id] = true;
             }
           }
 
           if (!item.priority) {
             continue;
           }
 
           if (config.username && item.priority == config.username) {
             self_hits[item.id] = true;
           }
 
           for (var hh = 0; hh < tokens.length; hh++) {
             if (item.priority.substr(0, tokens[hh].length) == tokens[hh]) {
               priority_hits[item.id] = true;
             }
           }
         }
 
         list.sort(function(u, v) {
           if (self_hits[u.id] != self_hits[v.id]) {
             return self_hits[v.id] ? 1 : -1;
           }
 
           // If one result is open and one is closed, show the open result
           // first. The "!" tricks here are becaused closed values are display
           // strings, so the value is either `null` or some truthy string. If
           // we compare the values directly, we'll apply this rule to two
           // objects which are both closed but for different reasons, like
           // "Archived" and "Disabled".
 
           var u_open = !u.closed;
           var v_open = !v.closed;
 
           if (u_open != v_open) {
             if (u_open) {
               return -1;
             } else {
               return 1;
             }
           }
 
           if (priority_hits[u.id] != priority_hits[v.id]) {
             return priority_hits[v.id] ? 1 : -1;
           }
 
           // Sort users ahead of other result types.
           if (u.priorityType != v.priorityType) {
             if (u.priorityType == 'user') {
               return -1;
             }
             if (v.priorityType == 'user') {
               return 1;
             }
           }
 
           return cmp(u, v);
         });
       };
 
       datasource.setSortHandler(JX.bind(datasource, sort_handler));
       datasource.setFilterHandler(JX.Prefab.filterClosedResults);
       datasource.setTransformer(JX.Prefab.transformDatasourceResults);
 
       var typeahead = new JX.Typeahead(
         root,
         JX.DOM.find(root, 'input', 'tokenizer-input'));
       typeahead.setDatasource(datasource);
 
       var tokenizer = new JX.Tokenizer(root);
       tokenizer.setTypeahead(typeahead);
       tokenizer.setRenderTokenCallback(function(value, key) {
         var result = datasource.getResult(key);
 
         var icon;
         if (result) {
           icon = result.icon;
           value = result.displayName;
         } else {
           icon = config.icons[key];
         }
 
         if (icon) {
           icon = JX.Prefab._renderIcon(icon);
         }
 
         // TODO: Maybe we should render these closed tags in grey? Figure out
         // how we're going to use color.
 
         return [icon, value];
       });
 
       if (config.placeholder) {
         tokenizer.setPlaceholder(config.placeholder);
       }
 
       if (config.limit) {
         tokenizer.setLimit(config.limit);
       }
 
       if (config.value) {
         tokenizer.setInitialValue(config.value);
       }
 
       if (config.browseURI) {
         tokenizer.setBrowseURI(config.browseURI);
       }
 
       JX.Stratcom.addData(root, {'tokenizer' : tokenizer});
 
       return {
         tokenizer: tokenizer
       };
     },
 
     /**
      * Filter callback for tokenizers and typeaheads which filters out closed
      * or disabled objects unless they are the only options.
      */
     filterClosedResults: function(value, list) {
       // Look for any open result.
       var has_open = false;
       var ii;
       for (ii = 0; ii < list.length; ii++) {
         if (!list[ii].closed) {
           has_open = true;
           break;
         }
       }
 
       if (!has_open) {
         // Everything is closed, so just use it as-is.
         return list;
       }
 
       // Otherwise, only display the open results.
       var results = [];
       for (ii = 0; ii < list.length; ii++) {
         if (!list[ii].closed) {
           results.push(list[ii]);
         }
       }
 
       return results;
     },
 
     /**
      * Transform results from a wire format into a usable format in a standard
      * way.
      */
     transformDatasourceResults: function(fields) {
       var closed = fields[9];
       var closed_ui;
       if (closed) {
         closed_ui = JX.$N(
           'div',
           {className: 'tokenizer-closed'},
           closed);
       }
 
       var icon = fields[8];
       var icon_ui;
       if (icon) {
         icon_ui = JX.Prefab._renderIcon(icon);
       }
 
       var display = JX.$N(
         'div',
         {className: 'tokenizer-result'},
         [icon_ui, fields[4] || fields[0], closed_ui]);
       if (closed) {
         JX.DOM.alterClass(display, 'tokenizer-result-closed', true);
       }
 
       return {
         name: fields[0],
         displayName: fields[4] || fields[0],
         display: display,
         uri: fields[1],
         id: fields[2],
         priority: fields[3],
         priorityType: fields[7],
         imageURI: fields[6],
         icon: icon,
         closed: closed,
         type: fields[5],
         sprite: fields[10]
       };
     },
 
     _renderIcon: function(icon) {
       return JX.$N(
         'span',
         {className: 'phui-icon-view phui-font-fa ' + icon});
     }
 
   }
 
 });