diff --git a/src/applications/base/controller/PhabricatorController.php b/src/applications/base/controller/PhabricatorController.php
index 62c882d131..39d5881d23 100644
--- a/src/applications/base/controller/PhabricatorController.php
+++ b/src/applications/base/controller/PhabricatorController.php
@@ -1,353 +1,372 @@
 <?php
 
 abstract class PhabricatorController extends AphrontController {
 
   private $handles;
 
   public function shouldRequireLogin() {
     return true;
   }
 
   public function shouldRequireAdmin() {
     return false;
   }
 
   public function shouldRequireEnabledUser() {
     return true;
   }
 
   public function shouldAllowPublic() {
     return false;
   }
 
   public function shouldRequireEmailVerification() {
     return PhabricatorUserEmail::isEmailVerificationRequired();
   }
 
   final public function willBeginExecution() {
 
     $request = $this->getRequest();
     if ($request->getUser()) {
       // NOTE: Unit tests can set a user explicitly. Normal requests are not
       // permitted to do this.
       PhabricatorTestCase::assertExecutingUnitTests();
       $user = $request->getUser();
     } else {
       $user = new PhabricatorUser();
 
       $phusr = $request->getCookie('phusr');
       $phsid = $request->getCookie('phsid');
 
       if (strlen($phusr) && $phsid) {
         $info = queryfx_one(
           $user->establishConnection('r'),
           'SELECT u.* FROM %T u JOIN %T s ON u.phid = s.userPHID
             AND s.type LIKE %> AND s.sessionKey = %s',
           $user->getTableName(),
           'phabricator_session',
           'web-',
           PhabricatorHash::digest($phsid));
         if ($info) {
           $user->loadFromArray($info);
         }
       }
 
       $request->setUser($user);
     }
 
     $translation = $user->getTranslation();
     if ($translation &&
         $translation != PhabricatorEnv::getEnvConfig('translation.provider')) {
       $translation = newv($translation, array());
       PhutilTranslator::getInstance()
         ->setLanguage($translation->getLanguage())
         ->addTranslations($translation->getTranslations());
     }
 
     $preferences = $user->loadPreferences();
     if (PhabricatorEnv::getEnvConfig('darkconsole.enabled')) {
       $dark_console = PhabricatorUserPreferences::PREFERENCE_DARK_CONSOLE;
       if ($preferences->getPreference($dark_console) ||
          PhabricatorEnv::getEnvConfig('darkconsole.always-on')) {
         $console = new DarkConsoleCore();
         $request->getApplicationConfiguration()->setConsole($console);
       }
     }
 
     if ($user->getIsDisabled() && $this->shouldRequireEnabledUser()) {
       $disabled_user_controller = new PhabricatorDisabledUserController(
         $request);
       return $this->delegateToController($disabled_user_controller);
     }
 
     $event = new PhabricatorEvent(
       PhabricatorEventType::TYPE_CONTROLLER_CHECKREQUEST,
       array(
         'request' => $request,
         'controller' => $this,
       ));
     $event->setUser($user);
     PhutilEventEngine::dispatchEvent($event);
     $checker_controller = $event->getValue('controller');
     if ($checker_controller != $this) {
       return $this->delegateToController($checker_controller);
     }
 
     if ($this->shouldRequireLogin()) {
       // This actually means we need either:
       //   - a valid user, or a public controller; and
       //   - permission to see the application.
 
       $auth_class = 'PhabricatorApplicationAuth';
       $auth_application = PhabricatorApplication::getByClass($auth_class);
 
       $allow_public = $this->shouldAllowPublic() &&
                       PhabricatorEnv::getEnvConfig('policy.allow-public');
 
       // If this controller isn't public, and the user isn't logged in, require
       // login.
       if (!$allow_public && !$user->isLoggedIn()) {
         $login_controller = new PhabricatorAuthStartController($request);
         $this->setCurrentApplication($auth_application);
         return $this->delegateToController($login_controller);
       }
 
       if ($user->isLoggedIn()) {
         if ($this->shouldRequireEmailVerification()) {
           $email = $user->loadPrimaryEmail();
           if (!$email) {
             throw new Exception(
               "No primary email address associated with this account!");
           }
           if (!$email->getIsVerified()) {
             $controller = new PhabricatorMustVerifyEmailController($request);
             $this->setCurrentApplication($auth_application);
             return $this->delegateToController($controller);
           }
         }
       }
 
       // If the user doesn't have access to the application, don't let them use
       // any of its controllers. We query the application in order to generate
       // a policy exception if the viewer doesn't have permission.
 
       $application = $this->getCurrentApplication();
       if ($application) {
         id(new PhabricatorApplicationQuery())
           ->setViewer($user)
           ->withPHIDs(array($application->getPHID()))
           ->executeOne();
       }
     }
 
     // NOTE: We do this last so that users get a login page instead of a 403
     // if they need to login.
     if ($this->shouldRequireAdmin() && !$user->getIsAdmin()) {
       return new Aphront403Response();
     }
 
   }
 
   public function buildStandardPageView() {
     $view = new PhabricatorStandardPageView();
     $view->setRequest($this->getRequest());
     $view->setController($this);
     return $view;
   }
 
   public function buildStandardPageResponse($view, array $data) {
     $page = $this->buildStandardPageView();
     $page->appendChild($view);
     $response = new AphrontWebpageResponse();
     $response->setContent($page->render());
     return $response;
   }
 
   public function getApplicationURI($path = '') {
     if (!$this->getCurrentApplication()) {
       throw new Exception("No application!");
     }
     return $this->getCurrentApplication()->getApplicationURI($path);
   }
 
   public function buildApplicationPage($view, array $options) {
     $page = $this->buildStandardPageView();
 
     $title = PhabricatorEnv::getEnvConfig('phabricator.serious-business') ?
       'Phabricator' :
       pht('Bacon Ice Cream for Breakfast');
 
     $application = $this->getCurrentApplication();
     $page->setTitle(idx($options, 'title', $title));
     if ($application) {
       $page->setApplicationName($application->getName());
       if ($application->getTitleGlyph()) {
         $page->setGlyph($application->getTitleGlyph());
       }
     }
 
     if (!($view instanceof AphrontSideNavFilterView)) {
       $nav = new AphrontSideNavFilterView();
       $nav->appendChild($view);
       $view = $nav;
     }
 
     $user = $this->getRequest()->getUser();
     $view->setUser($user);
 
     $page->appendChild($view);
 
     $object_phids = idx($options, 'pageObjects', array());
     if ($object_phids) {
       $page->appendPageObjects($object_phids);
       foreach ($object_phids as $object_phid) {
         PhabricatorFeedStoryNotification::updateObjectNotificationViews(
           $user,
           $object_phid);
       }
     }
 
     if (idx($options, 'device')) {
       $page->setDeviceReady(true);
     }
 
     $page->setShowChrome(idx($options, 'chrome', true));
 
     $application_menu = $this->buildApplicationMenu();
     if ($application_menu) {
       $page->setApplicationMenu($application_menu);
     }
 
     $response = new AphrontWebpageResponse();
     return $response->setContent($page->render());
   }
 
   public function didProcessRequest($response) {
     $request = $this->getRequest();
     $response->setRequest($request);
 
     $seen = array();
     while ($response instanceof AphrontProxyResponse) {
 
       $hash = spl_object_hash($response);
       if (isset($seen[$hash])) {
         $seen[] = get_class($response);
         throw new Exception(
           "Cycle while reducing proxy responses: ".
           implode(' -> ', $seen));
       }
       $seen[$hash] = get_class($response);
 
       $response = $response->reduceProxyResponse();
     }
 
     if ($response instanceof AphrontDialogResponse) {
       if (!$request->isAjax()) {
         $view = new PhabricatorStandardPageView();
         $view->setRequest($request);
         $view->setController($this);
         $view->appendChild(hsprintf(
           '<div style="padding: 2em 0;">%s</div>',
           $response->buildResponseString()));
         $response = new AphrontWebpageResponse();
         $response->setContent($view->render());
         return $response;
       } else {
         $response->getDialog()->setIsStandalone(true);
 
         return id(new AphrontAjaxResponse())
           ->setContent(array(
             'dialog' => $response->buildResponseString(),
           ));
       }
     } else if ($response instanceof AphrontRedirectResponse) {
       if ($request->isAjax()) {
         return id(new AphrontAjaxResponse())
           ->setContent(
             array(
               'redirect' => $response->getURI(),
             ));
       }
     }
     return $response;
   }
 
   protected function getHandle($phid) {
     if (empty($this->handles[$phid])) {
       throw new Exception(
         "Attempting to access handle which wasn't loaded: {$phid}");
     }
     return $this->handles[$phid];
   }
 
   protected function loadHandles(array $phids) {
     $phids = array_filter($phids);
     $this->handles = $this->loadViewerHandles($phids);
     return $this;
   }
 
   protected function getLoadedHandles() {
     return $this->handles;
   }
 
   protected function loadViewerHandles(array $phids) {
     return id(new PhabricatorHandleQuery())
       ->setViewer($this->getRequest()->getUser())
       ->withPHIDs($phids)
       ->execute();
   }
 
 
   /**
    * Render a list of links to handles, identified by PHIDs. The handles must
    * already be loaded.
    *
    * @param   list<phid>  List of PHIDs to render links to.
    * @param   string      Style, one of "\n" (to put each item on its own line)
    *                      or "," (to list items inline, separated by commas).
    * @return  string      Rendered list of handle links.
    */
   protected function renderHandlesForPHIDs(array $phids, $style = "\n") {
     $style_map = array(
       "\n"  => phutil_tag('br'),
       ','   => ', ',
     );
 
     if (empty($style_map[$style])) {
       throw new Exception("Unknown handle list style '{$style}'!");
     }
 
     return implode_selected_handle_links($style_map[$style],
       $this->getLoadedHandles(),
       $phids);
   }
 
   protected function buildApplicationMenu() {
     return null;
   }
 
   protected function buildApplicationCrumbs() {
 
     $crumbs = array();
 
     $application = $this->getCurrentApplication();
     if ($application) {
       $sprite = $application->getIconName();
       if (!$sprite) {
         $sprite = 'application';
       }
 
       $crumbs[] = id(new PhabricatorCrumbView())
         ->setHref($this->getApplicationURI())
         ->setIcon($sprite);
     }
 
     $view = new PhabricatorCrumbsView();
     foreach ($crumbs as $crumb) {
       $view->addCrumb($crumb);
     }
 
     return $view;
   }
 
+  protected function hasApplicationCapability($capability) {
+    return PhabricatorPolicyFilter::hasCapability(
+      $this->getRequest()->getUser(),
+      $this->getCurrentApplication(),
+      $capability);
+  }
+
+  protected function requireApplicationCapability($capability) {
+    PhabricatorPolicyFilter::requireCapability(
+      $this->getRequest()->getUser(),
+      $this->getCurrentApplication(),
+      $capability);
+  }
+
+  protected function explainApplicationCapability($capability, $message) {
+    // TODO: Render a link to get more information.
+    return $message;
+  }
+
 }
diff --git a/src/applications/herald/adapter/HeraldAdapter.php b/src/applications/herald/adapter/HeraldAdapter.php
index 76876ef728..4495691ff7 100644
--- a/src/applications/herald/adapter/HeraldAdapter.php
+++ b/src/applications/herald/adapter/HeraldAdapter.php
@@ -1,874 +1,878 @@
 <?php
 
 /**
  * @group herald
  */
 abstract class HeraldAdapter {
 
   const FIELD_TITLE                  = 'title';
   const FIELD_BODY                   = 'body';
   const FIELD_AUTHOR                 = 'author';
   const FIELD_REVIEWER               = 'reviewer';
   const FIELD_REVIEWERS              = 'reviewers';
   const FIELD_COMMITTER              = 'committer';
   const FIELD_CC                     = 'cc';
   const FIELD_TAGS                   = 'tags';
   const FIELD_DIFF_FILE              = 'diff-file';
   const FIELD_DIFF_CONTENT           = 'diff-content';
   const FIELD_DIFF_ADDED_CONTENT     = 'diff-added-content';
   const FIELD_DIFF_REMOVED_CONTENT   = 'diff-removed-content';
   const FIELD_REPOSITORY             = 'repository';
   const FIELD_RULE                   = 'rule';
   const FIELD_AFFECTED_PACKAGE       = 'affected-package';
   const FIELD_AFFECTED_PACKAGE_OWNER = 'affected-package-owner';
   const FIELD_CONTENT_SOURCE         = 'contentsource';
   const FIELD_ALWAYS                 = 'always';
 
   const CONDITION_CONTAINS        = 'contains';
   const CONDITION_NOT_CONTAINS    = '!contains';
   const CONDITION_IS              = 'is';
   const CONDITION_IS_NOT          = '!is';
   const CONDITION_IS_ANY          = 'isany';
   const CONDITION_IS_NOT_ANY      = '!isany';
   const CONDITION_INCLUDE_ALL     = 'all';
   const CONDITION_INCLUDE_ANY     = 'any';
   const CONDITION_INCLUDE_NONE    = 'none';
   const CONDITION_IS_ME           = 'me';
   const CONDITION_IS_NOT_ME       = '!me';
   const CONDITION_REGEXP          = 'regexp';
   const CONDITION_RULE            = 'conditions';
   const CONDITION_NOT_RULE        = '!conditions';
   const CONDITION_EXISTS          = 'exists';
   const CONDITION_NOT_EXISTS      = '!exists';
   const CONDITION_UNCONDITIONALLY = 'unconditionally';
   const CONDITION_REGEXP_PAIR     = 'regexp-pair';
 
   const ACTION_ADD_CC       = 'addcc';
   const ACTION_REMOVE_CC    = 'remcc';
   const ACTION_EMAIL        = 'email';
   const ACTION_NOTHING      = 'nothing';
   const ACTION_AUDIT        = 'audit';
   const ACTION_FLAG         = 'flag';
   const ACTION_ASSIGN_TASK  = 'assigntask';
   const ACTION_ADD_PROJECTS = 'addprojects';
 
   const VALUE_TEXT            = 'text';
   const VALUE_NONE            = 'none';
   const VALUE_EMAIL           = 'email';
   const VALUE_USER            = 'user';
   const VALUE_TAG             = 'tag';
   const VALUE_RULE            = 'rule';
   const VALUE_REPOSITORY      = 'repository';
   const VALUE_OWNERS_PACKAGE  = 'package';
   const VALUE_PROJECT         = 'project';
   const VALUE_FLAG_COLOR      = 'flagcolor';
   const VALUE_CONTENT_SOURCE  = 'contentsource';
 
   private $contentSource;
 
   public function setContentSource(PhabricatorContentSource $content_source) {
     $this->contentSource = $content_source;
     return $this;
   }
   public function getContentSource() {
     return $this->contentSource;
   }
 
   abstract public function getPHID();
   abstract public function getHeraldName();
 
   public function getHeraldField($field_name) {
     switch ($field_name) {
       case self::FIELD_RULE:
         return null;
       case self::FIELD_CONTENT_SOURCE:
         return $this->getContentSource()->getSource();
       case self::FIELD_ALWAYS:
         return true;
       default:
         throw new Exception(
           "Unknown field '{$field_name}'!");
     }
   }
 
   abstract public function applyHeraldEffects(array $effects);
 
   public function isEnabled() {
     return true;
   }
 
+  public function isAvailableToUser(PhabricatorUser $viewer) {
+    $applications = id(new PhabricatorApplicationQuery())
+      ->setViewer($viewer)
+      ->withInstalled(true)
+      ->withClasses(array($this->getAdapterApplicationClass()))
+      ->execute();
+
+    return !empty($applications);
+  }
+
+
   /**
    * NOTE: You generally should not override this; it exists to support legacy
    * adapters which had hard-coded content types.
    */
   public function getAdapterContentType() {
     return get_class($this);
   }
 
   abstract public function getAdapterContentName();
+  abstract public function getAdapterApplicationClass();
 
 
 /* -(  Fields  )------------------------------------------------------------- */
 
 
   public function getFields() {
     return array(
       self::FIELD_ALWAYS,
     );
   }
 
   public function getFieldNameMap() {
     return array(
       self::FIELD_TITLE => pht('Title'),
       self::FIELD_BODY => pht('Body'),
       self::FIELD_AUTHOR => pht('Author'),
       self::FIELD_COMMITTER => pht('Committer'),
       self::FIELD_REVIEWER => pht('Reviewer'),
       self::FIELD_REVIEWERS => pht('Reviewers'),
       self::FIELD_CC => pht('CCs'),
       self::FIELD_TAGS => pht('Tags'),
       self::FIELD_DIFF_FILE => pht('Any changed filename'),
       self::FIELD_DIFF_CONTENT => pht('Any changed file content'),
       self::FIELD_DIFF_ADDED_CONTENT => pht('Any added file content'),
       self::FIELD_DIFF_REMOVED_CONTENT => pht('Any removed file content'),
       self::FIELD_REPOSITORY => pht('Repository'),
       self::FIELD_RULE => pht('Another Herald rule'),
       self::FIELD_AFFECTED_PACKAGE => pht('Any affected package'),
       self::FIELD_AFFECTED_PACKAGE_OWNER =>
         pht("Any affected package's owner"),
       self::FIELD_CONTENT_SOURCE => pht('Content Source'),
       self::FIELD_ALWAYS => pht('Always'),
     );
   }
 
 
 /* -(  Conditions  )--------------------------------------------------------- */
 
 
   public function getConditionNameMap() {
     return array(
       self::CONDITION_CONTAINS        => pht('contains'),
       self::CONDITION_NOT_CONTAINS    => pht('does not contain'),
       self::CONDITION_IS              => pht('is'),
       self::CONDITION_IS_NOT          => pht('is not'),
       self::CONDITION_IS_ANY          => pht('is any of'),
       self::CONDITION_IS_NOT_ANY      => pht('is not any of'),
       self::CONDITION_INCLUDE_ALL     => pht('include all of'),
       self::CONDITION_INCLUDE_ANY     => pht('include any of'),
       self::CONDITION_INCLUDE_NONE    => pht('include none of'),
       self::CONDITION_IS_ME           => pht('is myself'),
       self::CONDITION_IS_NOT_ME       => pht('is not myself'),
       self::CONDITION_REGEXP          => pht('matches regexp'),
       self::CONDITION_RULE            => pht('matches:'),
       self::CONDITION_NOT_RULE        => pht('does not match:'),
       self::CONDITION_EXISTS          => pht('exists'),
       self::CONDITION_NOT_EXISTS      => pht('does not exist'),
       self::CONDITION_UNCONDITIONALLY => '',  // don't show anything!
       self::CONDITION_REGEXP_PAIR     => pht('matches regexp pair'),
     );
   }
 
   public function getConditionsForField($field) {
     switch ($field) {
       case self::FIELD_TITLE:
       case self::FIELD_BODY:
         return array(
           self::CONDITION_CONTAINS,
           self::CONDITION_NOT_CONTAINS,
           self::CONDITION_IS,
           self::CONDITION_IS_NOT,
           self::CONDITION_REGEXP,
         );
       case self::FIELD_AUTHOR:
       case self::FIELD_COMMITTER:
       case self::FIELD_REPOSITORY:
       case self::FIELD_REVIEWER:
         return array(
           self::CONDITION_IS_ANY,
           self::CONDITION_IS_NOT_ANY,
         );
       case self::FIELD_TAGS:
       case self::FIELD_REVIEWERS:
       case self::FIELD_CC:
         return array(
           self::CONDITION_INCLUDE_ALL,
           self::CONDITION_INCLUDE_ANY,
           self::CONDITION_INCLUDE_NONE,
         );
       case self::FIELD_DIFF_FILE:
         return array(
           self::CONDITION_CONTAINS,
           self::CONDITION_REGEXP,
         );
       case self::FIELD_DIFF_CONTENT:
       case self::FIELD_DIFF_ADDED_CONTENT:
       case self::FIELD_DIFF_REMOVED_CONTENT:
         return array(
           self::CONDITION_CONTAINS,
           self::CONDITION_REGEXP,
           self::CONDITION_REGEXP_PAIR,
         );
       case self::FIELD_RULE:
         return array(
           self::CONDITION_RULE,
           self::CONDITION_NOT_RULE,
         );
       case self::FIELD_AFFECTED_PACKAGE:
       case self::FIELD_AFFECTED_PACKAGE_OWNER:
         return array(
           self::CONDITION_INCLUDE_ANY,
           self::CONDITION_INCLUDE_NONE,
         );
       case self::FIELD_CONTENT_SOURCE:
         return array(
           self::CONDITION_IS,
           self::CONDITION_IS_NOT,
         );
       case self::FIELD_ALWAYS:
         return array(
           self::CONDITION_UNCONDITIONALLY,
         );
       default:
         throw new Exception(
           "This adapter does not define conditions for field '{$field}'!");
     }
   }
 
   public function doesConditionMatch(
     HeraldEngine $engine,
     HeraldRule $rule,
     HeraldCondition $condition,
     $field_value) {
 
     $condition_type = $condition->getFieldCondition();
     $condition_value = $condition->getValue();
 
     switch ($condition_type) {
       case self::CONDITION_CONTAINS:
         // "Contains" can take an array of strings, as in "Any changed
         // filename" for diffs.
         foreach ((array)$field_value as $value) {
           if (stripos($value, $condition_value) !== false) {
             return true;
           }
         }
         return false;
       case self::CONDITION_NOT_CONTAINS:
         return (stripos($field_value, $condition_value) === false);
       case self::CONDITION_IS:
         return ($field_value == $condition_value);
       case self::CONDITION_IS_NOT:
         return ($field_value != $condition_value);
       case self::CONDITION_IS_ME:
         return ($field_value == $rule->getAuthorPHID());
       case self::CONDITION_IS_NOT_ME:
         return ($field_value != $rule->getAuthorPHID());
       case self::CONDITION_IS_ANY:
         if (!is_array($condition_value)) {
           throw new HeraldInvalidConditionException(
             "Expected condition value to be an array.");
         }
         $condition_value = array_fuse($condition_value);
         return isset($condition_value[$field_value]);
       case self::CONDITION_IS_NOT_ANY:
         if (!is_array($condition_value)) {
           throw new HeraldInvalidConditionException(
             "Expected condition value to be an array.");
         }
         $condition_value = array_fuse($condition_value);
         return !isset($condition_value[$field_value]);
       case self::CONDITION_INCLUDE_ALL:
         if (!is_array($field_value)) {
           throw new HeraldInvalidConditionException(
             "Object produced non-array value!");
         }
         if (!is_array($condition_value)) {
           throw new HeraldInvalidConditionException(
             "Expected conditionv value to be an array.");
         }
 
         $have = array_select_keys(array_fuse($field_value), $condition_value);
         return (count($have) == count($condition_value));
       case self::CONDITION_INCLUDE_ANY:
         return (bool)array_select_keys(
           array_fuse($field_value),
           $condition_value);
       case self::CONDITION_INCLUDE_NONE:
         return !array_select_keys(
           array_fuse($field_value),
           $condition_value);
       case self::CONDITION_EXISTS:
         return (bool)$field_value;
       case self::CONDITION_NOT_EXISTS:
         return !$field_value;
       case self::CONDITION_UNCONDITIONALLY:
         return (bool)$field_value;
       case self::CONDITION_REGEXP:
         foreach ((array)$field_value as $value) {
           // We add the 'S' flag because we use the regexp multiple times.
           // It shouldn't cause any troubles if the flag is already there
           // - /.*/S is evaluated same as /.*/SS.
           $result = @preg_match($condition_value . 'S', $value);
           if ($result === false) {
             throw new HeraldInvalidConditionException(
               "Regular expression is not valid!");
           }
           if ($result) {
             return true;
           }
         }
         return false;
       case self::CONDITION_REGEXP_PAIR:
         // Match a JSON-encoded pair of regular expressions against a
         // dictionary. The first regexp must match the dictionary key, and the
         // second regexp must match the dictionary value. If any key/value pair
         // in the dictionary matches both regexps, the condition is satisfied.
         $regexp_pair = json_decode($condition_value, true);
         if (!is_array($regexp_pair)) {
           throw new HeraldInvalidConditionException(
             "Regular expression pair is not valid JSON!");
         }
         if (count($regexp_pair) != 2) {
           throw new HeraldInvalidConditionException(
             "Regular expression pair is not a pair!");
         }
 
         $key_regexp   = array_shift($regexp_pair);
         $value_regexp = array_shift($regexp_pair);
 
         foreach ((array)$field_value as $key => $value) {
           $key_matches = @preg_match($key_regexp, $key);
           if ($key_matches === false) {
             throw new HeraldInvalidConditionException(
               "First regular expression is invalid!");
           }
           if ($key_matches) {
             $value_matches = @preg_match($value_regexp, $value);
             if ($value_matches === false) {
               throw new HeraldInvalidConditionException(
                 "Second regular expression is invalid!");
             }
             if ($value_matches) {
               return true;
             }
           }
         }
         return false;
       case self::CONDITION_RULE:
       case self::CONDITION_NOT_RULE:
         $rule = $engine->getRule($condition_value);
         if (!$rule) {
           throw new HeraldInvalidConditionException(
             "Condition references a rule which does not exist!");
         }
 
         $is_not = ($condition_type == self::CONDITION_NOT_RULE);
         $result = $engine->doesRuleMatch($rule, $this);
         if ($is_not) {
           $result = !$result;
         }
         return $result;
       default:
         throw new HeraldInvalidConditionException(
           "Unknown condition '{$condition_type}'.");
     }
   }
 
   public function willSaveCondition(HeraldCondition $condition) {
     $condition_type = $condition->getFieldCondition();
     $condition_value = $condition->getValue();
 
     switch ($condition_type) {
       case self::CONDITION_REGEXP:
         $ok = @preg_match($condition_value, '');
         if ($ok === false) {
           throw new HeraldInvalidConditionException(
             pht(
               'The regular expression "%s" is not valid. Regular expressions '.
               'must have enclosing characters (e.g. "@/path/to/file@", not '.
               '"/path/to/file") and be syntactically correct.',
               $condition_value));
         }
         break;
       case self::CONDITION_REGEXP_PAIR:
         $json = json_decode($condition_value, true);
         if (!is_array($json)) {
           throw new HeraldInvalidConditionException(
             pht(
               'The regular expression pair "%s" is not valid JSON. Enter a '.
               'valid JSON array with two elements.',
               $condition_value));
         }
 
         if (count($json) != 2) {
           throw new HeraldInvalidConditionException(
             pht(
               'The regular expression pair "%s" must have exactly two '.
               'elements.',
               $condition_value));
         }
 
         $key_regexp = array_shift($json);
         $val_regexp = array_shift($json);
 
         $key_ok = @preg_match($key_regexp, '');
         if ($key_ok === false) {
           throw new HeraldInvalidConditionException(
             pht(
               'The first regexp in the regexp pair, "%s", is not a valid '.
               'regexp.',
               $key_regexp));
         }
 
         $val_ok = @preg_match($val_regexp, '');
         if ($val_ok === false) {
           throw new HeraldInvalidConditionException(
             pht(
               'The second regexp in the regexp pair, "%s", is not a valid '.
               'regexp.',
               $val_regexp));
         }
         break;
       case self::CONDITION_CONTAINS:
       case self::CONDITION_NOT_CONTAINS:
       case self::CONDITION_IS:
       case self::CONDITION_IS_NOT:
       case self::CONDITION_IS_ANY:
       case self::CONDITION_IS_NOT_ANY:
       case self::CONDITION_INCLUDE_ALL:
       case self::CONDITION_INCLUDE_ANY:
       case self::CONDITION_INCLUDE_NONE:
       case self::CONDITION_IS_ME:
       case self::CONDITION_IS_NOT_ME:
       case self::CONDITION_RULE:
       case self::CONDITION_NOT_RULE:
       case self::CONDITION_EXISTS:
       case self::CONDITION_NOT_EXISTS:
       case self::CONDITION_UNCONDITIONALLY:
         // No explicit validation for these types, although there probably
         // should be in some cases.
         break;
       default:
         throw new HeraldInvalidConditionException(
           pht(
             'Unknown condition "%s"!',
             $condition_type));
     }
   }
 
 
 /* -(  Actions  )------------------------------------------------------------ */
 
   abstract public function getActions($rule_type);
 
   public function getActionNameMap($rule_type) {
     switch ($rule_type) {
       case HeraldRuleTypeConfig::RULE_TYPE_GLOBAL:
         return array(
           self::ACTION_NOTHING      => pht('Do nothing'),
           self::ACTION_ADD_CC       => pht('Add emails to CC'),
           self::ACTION_REMOVE_CC    => pht('Remove emails from CC'),
           self::ACTION_EMAIL        => pht('Send an email to'),
           self::ACTION_AUDIT        => pht('Trigger an Audit by'),
           self::ACTION_FLAG         => pht('Mark with flag'),
           self::ACTION_ASSIGN_TASK  => pht('Assign task to'),
           self::ACTION_ADD_PROJECTS => pht('Add projects'),
         );
       case HeraldRuleTypeConfig::RULE_TYPE_PERSONAL:
         return array(
           self::ACTION_NOTHING      => pht('Do nothing'),
           self::ACTION_ADD_CC       => pht('Add me to CC'),
           self::ACTION_REMOVE_CC    => pht('Remove me from CC'),
           self::ACTION_EMAIL        => pht('Send me an email'),
           self::ACTION_AUDIT        => pht('Trigger an Audit by me'),
           self::ACTION_FLAG         => pht('Mark with flag'),
           self::ACTION_ASSIGN_TASK  => pht('Assign task to me.'),
           self::ACTION_ADD_PROJECTS => pht('Add projects'),
         );
       default:
         throw new Exception("Unknown rule type '{$rule_type}'!");
     }
   }
 
   public function willSaveAction(
     HeraldRule $rule,
     HeraldAction $action) {
 
     $target = $action->getTarget();
     if (is_array($target)) {
       $target = array_keys($target);
     }
 
     $author_phid = $rule->getAuthorPHID();
 
     $rule_type = $rule->getRuleType();
     if ($rule_type == HeraldRuleTypeConfig::RULE_TYPE_PERSONAL) {
       switch ($action->getAction()) {
         case self::ACTION_EMAIL:
         case self::ACTION_ADD_CC:
         case self::ACTION_REMOVE_CC:
         case self::ACTION_AUDIT:
         case self::ACTION_ASSIGN_TASK:
           // For personal rules, force these actions to target the rule owner.
           $target = array($author_phid);
           break;
         case self::ACTION_FLAG:
           // Make sure flag color is valid; set to blue if not.
           $color_map = PhabricatorFlagColor::getColorNameMap();
           if (empty($color_map[$target])) {
             $target = PhabricatorFlagColor::COLOR_BLUE;
           }
           break;
         case self::ACTION_NOTHING:
           break;
         default:
           throw new HeraldInvalidActionException(
             pht(
               'Unrecognized action type "%s"!',
               $action->getAction()));
       }
     }
 
     $action->setTarget($target);
   }
 
 
 
 /* -(  Values  )------------------------------------------------------------- */
 
 
   public function getValueTypeForFieldAndCondition($field, $condition) {
     switch ($condition) {
       case self::CONDITION_CONTAINS:
       case self::CONDITION_NOT_CONTAINS:
       case self::CONDITION_REGEXP:
       case self::CONDITION_REGEXP_PAIR:
         return self::VALUE_TEXT;
       case self::CONDITION_IS:
       case self::CONDITION_IS_NOT:
         switch ($field) {
           case self::FIELD_CONTENT_SOURCE:
             return self::VALUE_CONTENT_SOURCE;
           default:
             return self::VALUE_TEXT;
         }
         break;
       case self::CONDITION_IS_ANY:
       case self::CONDITION_IS_NOT_ANY:
         switch ($field) {
           case self::FIELD_REPOSITORY:
             return self::VALUE_REPOSITORY;
           default:
             return self::VALUE_USER;
         }
         break;
       case self::CONDITION_INCLUDE_ALL:
       case self::CONDITION_INCLUDE_ANY:
       case self::CONDITION_INCLUDE_NONE:
         switch ($field) {
           case self::FIELD_REPOSITORY:
             return self::VALUE_REPOSITORY;
           case self::FIELD_CC:
             return self::VALUE_EMAIL;
           case self::FIELD_TAGS:
             return self::VALUE_TAG;
           case self::FIELD_AFFECTED_PACKAGE:
             return self::VALUE_OWNERS_PACKAGE;
           default:
             return self::VALUE_USER;
         }
         break;
       case self::CONDITION_IS_ME:
       case self::CONDITION_IS_NOT_ME:
       case self::CONDITION_EXISTS:
       case self::CONDITION_NOT_EXISTS:
       case self::CONDITION_UNCONDITIONALLY:
         return self::VALUE_NONE;
       case self::CONDITION_RULE:
       case self::CONDITION_NOT_RULE:
         return self::VALUE_RULE;
       default:
         throw new Exception("Unknown condition '{$condition}'.");
     }
   }
 
   public static function getValueTypeForAction($action, $rule_type) {
     $is_personal = ($rule_type == HeraldRuleTypeConfig::RULE_TYPE_PERSONAL);
 
     if ($is_personal) {
       switch ($action) {
         case self::ACTION_ADD_CC:
         case self::ACTION_REMOVE_CC:
         case self::ACTION_EMAIL:
         case self::ACTION_NOTHING:
         case self::ACTION_AUDIT:
         case self::ACTION_ASSIGN_TASK:
           return self::VALUE_NONE;
         case self::ACTION_FLAG:
           return self::VALUE_FLAG_COLOR;
         case self::ACTION_ADD_PROJECTS:
           return self::VALUE_PROJECT;
         default:
           throw new Exception("Unknown or invalid action '{$action}'.");
       }
     } else {
       switch ($action) {
         case self::ACTION_ADD_CC:
         case self::ACTION_REMOVE_CC:
         case self::ACTION_EMAIL:
           return self::VALUE_EMAIL;
         case self::ACTION_NOTHING:
           return self::VALUE_NONE;
         case self::ACTION_AUDIT:
         case self::ACTION_ADD_PROJECTS:
           return self::VALUE_PROJECT;
         case self::ACTION_FLAG:
           return self::VALUE_FLAG_COLOR;
         case self::ACTION_ASSIGN_TASK:
           return self::VALUE_USER;
         default:
           throw new Exception("Unknown or invalid action '{$action}'.");
       }
     }
   }
 
 
 /* -(  Repetition  )--------------------------------------------------------- */
 
 
   public function getRepetitionOptions() {
     return array(
       HeraldRepetitionPolicyConfig::EVERY,
     );
   }
 
 
   public static function applyFlagEffect(HeraldEffect $effect, $phid) {
     $color = $effect->getTarget();
 
     // TODO: Silly that we need to load this again here.
     $rule = id(new HeraldRule())->load($effect->getRuleID());
     $user = id(new PhabricatorUser())->loadOneWhere(
       'phid = %s',
       $rule->getAuthorPHID());
 
     $flag = PhabricatorFlagQuery::loadUserFlag($user, $phid);
     if ($flag) {
       return new HeraldApplyTranscript(
         $effect,
         false,
         pht('Object already flagged.'));
     }
 
     $handle = id(new PhabricatorHandleQuery())
       ->setViewer($user)
       ->withPHIDs(array($phid))
       ->executeOne();
 
     $flag = new PhabricatorFlag();
     $flag->setOwnerPHID($user->getPHID());
     $flag->setType($handle->getType());
     $flag->setObjectPHID($handle->getPHID());
 
     // TOOD: Should really be transcript PHID, but it doesn't exist yet.
     $flag->setReasonPHID($user->getPHID());
 
     $flag->setColor($color);
     $flag->setNote(
       pht('Flagged by Herald Rule "%s".', $rule->getName()));
     $flag->save();
 
     return new HeraldApplyTranscript(
       $effect,
       true,
       pht('Added flag.'));
   }
 
   public static function getAllAdapters() {
     static $adapters;
     if (!$adapters) {
       $adapters = id(new PhutilSymbolLoader())
         ->setAncestorClass(__CLASS__)
         ->loadObjects();
     }
     return $adapters;
   }
 
-  public static function getAllEnabledAdapters() {
-    $adapters = self::getAllAdapters();
-    foreach ($adapters as $key => $adapter) {
-      if (!$adapter->isEnabled()) {
-        unset($adapters[$key]);
-      }
-    }
-    return $adapters;
-  }
-
   public static function getAdapterForContentType($content_type) {
     $adapters = self::getAllAdapters();
 
     foreach ($adapters as $adapter) {
       if ($adapter->getAdapterContentType() == $content_type) {
         return $adapter;
       }
     }
 
     throw new Exception(
       pht(
         'No adapter exists for Herald content type "%s".',
         $content_type));
   }
 
-  public static function getEnabledAdapterMap() {
+  public static function getEnabledAdapterMap(PhabricatorUser $viewer) {
     $map = array();
 
-    $adapters = HeraldAdapter::getAllEnabledAdapters();
+    $adapters = HeraldAdapter::getAllAdapters();
     foreach ($adapters as $adapter) {
+      if (!$adapter->isAvailableToUser($viewer)) {
+        continue;
+      }
       $type = $adapter->getAdapterContentType();
       $name = $adapter->getAdapterContentName();
       $map[$type] = $name;
     }
 
     asort($map);
     return $map;
   }
 
-
   public function renderRuleAsText(HeraldRule $rule, array $handles) {
     assert_instances_of($handles, 'PhabricatorObjectHandle');
 
     $out = array();
 
     if ($rule->getMustMatchAll()) {
       $out[] = pht('When all of these conditions are met:');
     } else {
       $out[] = pht('When any of these conditions are met:');
     }
 
     $out[] = null;
     foreach ($rule->getConditions() as $condition) {
       $out[] = $this->renderConditionAsText($condition, $handles);
     }
     $out[] = null;
 
     if ($rule->getRepetitionPolicy() == HeraldRepetitionPolicyConfig::EVERY) {
       $out[] = pht('Take these actions every time this rule matches:');
     } else {
       $out[] = pht('Take these actions the first time this rule matches:');
     }
 
     $out[] = null;
     foreach ($rule->getActions() as $action) {
       $out[] = $this->renderActionAsText($action, $handles);
     }
 
     return phutil_implode_html("\n", $out);
   }
 
   private function renderConditionAsText(
     HeraldCondition $condition,
     array $handles) {
     $field_type = $condition->getFieldName();
     $field_name = idx($this->getFieldNameMap(), $field_type);
 
     $condition_type = $condition->getFieldCondition();
     $condition_name = idx($this->getConditionNameMap(), $condition_type);
 
     $value = $this->renderConditionValueAsText($condition, $handles);
 
     return hsprintf('    %s %s %s', $field_name, $condition_name, $value);
   }
 
   private function renderActionAsText(
     HeraldAction $action,
     array $handles) {
     $rule_global = HeraldRuleTypeConfig::RULE_TYPE_GLOBAL;
 
     $action_type = $action->getAction();
     $action_name = idx($this->getActionNameMap($rule_global), $action_type);
 
     $target = $this->renderActionTargetAsText($action, $handles);
 
     return hsprintf('    %s %s', $action_name, $target);
   }
 
   private function renderConditionValueAsText(
     HeraldCondition $condition,
     array $handles) {
 
     $value = $condition->getValue();
     if (!is_array($value)) {
       $value = array($value);
     }
     foreach ($value as $index => $val) {
       $handle = idx($handles, $val);
       if ($handle) {
         $value[$index] = $handle->renderLink();
       }
     }
     $value = phutil_implode_html(', ', $value);
     return $value;
   }
 
   private function renderActionTargetAsText(
     HeraldAction $action,
     array $handles) {
 
     $target = $action->getTarget();
     if (!is_array($target)) {
       $target = array($target);
     }
     foreach ($target as $index => $val) {
       $handle = idx($handles, $val);
       if ($handle) {
         $target[$index] = $handle->renderLink();
       }
     }
     $target = phutil_implode_html(', ', $target);
     return $target;
   }
 
   /**
    * Given a @{class:HeraldRule}, this function extracts all the phids that
    * we'll want to load as handles later.
    *
    * This function performs a somewhat hacky approach to figuring out what
    * is and is not a phid - try to get the phid type and if the type is
    * *not* unknown assume its a valid phid.
    *
    * Don't try this at home. Use more strongly typed data at home.
    *
    * Think of the children.
    */
   public static function getHandlePHIDs(HeraldRule $rule) {
     $phids = array($rule->getAuthorPHID());
     foreach ($rule->getConditions() as $condition) {
       $value = $condition->getValue();
       if (!is_array($value)) {
         $value = array($value);
       }
       foreach ($value as $val) {
         if (phid_get_type($val) !=
             PhabricatorPHIDConstants::PHID_TYPE_UNKNOWN) {
           $phids[] = $val;
         }
       }
     }
 
     foreach ($rule->getActions() as $action) {
       $target = $action->getTarget();
       if (!is_array($target)) {
         $target = array($target);
       }
       foreach ($target as $val) {
         if (phid_get_type($val) !=
             PhabricatorPHIDConstants::PHID_TYPE_UNKNOWN) {
           $phids[] = $val;
         }
       }
     }
     return $phids;
   }
 
 }
 
diff --git a/src/applications/herald/adapter/HeraldCommitAdapter.php b/src/applications/herald/adapter/HeraldCommitAdapter.php
index a3ec223d6c..36e5d87375 100644
--- a/src/applications/herald/adapter/HeraldCommitAdapter.php
+++ b/src/applications/herald/adapter/HeraldCommitAdapter.php
@@ -1,415 +1,414 @@
 <?php
 
 /**
  * @group herald
  */
 final class HeraldCommitAdapter extends HeraldAdapter {
 
   const FIELD_NEED_AUDIT_FOR_PACKAGE      = 'need-audit-for-package';
   const FIELD_DIFFERENTIAL_REVISION       = 'differential-revision';
   const FIELD_DIFFERENTIAL_REVIEWERS      = 'differential-reviewers';
   const FIELD_DIFFERENTIAL_CCS            = 'differential-ccs';
   const FIELD_REPOSITORY_AUTOCLOSE_BRANCH = 'repository-autoclose-branch';
 
   protected $diff;
   protected $revision;
 
   protected $repository;
   protected $commit;
   protected $commitData;
 
   protected $emailPHIDs = array();
   protected $addCCPHIDs = array();
   protected $auditMap = array();
 
   protected $affectedPaths;
   protected $affectedRevision;
   protected $affectedPackages;
   protected $auditNeededPackages;
 
-  public function isEnabled() {
-    $app = 'PhabricatorApplicationDiffusion';
-    return PhabricatorApplication::isClassInstalled($app);
+  public function getAdapterApplicationClass() {
+    return 'PhabricatorApplicationDiffusion';
   }
 
   public function getAdapterContentType() {
     return 'commit';
   }
 
   public function getAdapterContentName() {
     return pht('Commits');
   }
 
   public function getFieldNameMap() {
     return array(
       self::FIELD_NEED_AUDIT_FOR_PACKAGE =>
         pht('Affected packages that need audit'),
       self::FIELD_DIFFERENTIAL_REVISION => pht('Differential revision'),
       self::FIELD_DIFFERENTIAL_REVIEWERS => pht('Differential reviewers'),
       self::FIELD_DIFFERENTIAL_CCS => pht('Differential CCs'),
       self::FIELD_REPOSITORY_AUTOCLOSE_BRANCH => pht('On autoclose branch'),
     ) + parent::getFieldNameMap();
   }
 
   public function getFields() {
     return array_merge(
       array(
         self::FIELD_BODY,
         self::FIELD_AUTHOR,
         self::FIELD_COMMITTER,
         self::FIELD_REVIEWER,
         self::FIELD_REPOSITORY,
         self::FIELD_DIFF_FILE,
         self::FIELD_DIFF_CONTENT,
         self::FIELD_DIFF_ADDED_CONTENT,
         self::FIELD_DIFF_REMOVED_CONTENT,
         self::FIELD_RULE,
         self::FIELD_AFFECTED_PACKAGE,
         self::FIELD_AFFECTED_PACKAGE_OWNER,
         self::FIELD_NEED_AUDIT_FOR_PACKAGE,
         self::FIELD_DIFFERENTIAL_REVISION,
         self::FIELD_DIFFERENTIAL_REVIEWERS,
         self::FIELD_DIFFERENTIAL_CCS,
         self::FIELD_REPOSITORY_AUTOCLOSE_BRANCH,
       ),
       parent::getFields());
   }
 
   public function getConditionsForField($field) {
     switch ($field) {
       case self::FIELD_DIFFERENTIAL_REVIEWERS:
         return array(
           self::CONDITION_EXISTS,
           self::CONDITION_NOT_EXISTS,
           self::CONDITION_INCLUDE_ALL,
           self::CONDITION_INCLUDE_ANY,
           self::CONDITION_INCLUDE_NONE,
         );
       case self::FIELD_DIFFERENTIAL_CCS:
         return array(
           self::CONDITION_INCLUDE_ALL,
           self::CONDITION_INCLUDE_ANY,
           self::CONDITION_INCLUDE_NONE,
         );
       case self::FIELD_DIFFERENTIAL_REVISION:
         return array(
           self::CONDITION_EXISTS,
           self::CONDITION_NOT_EXISTS,
         );
       case self::FIELD_NEED_AUDIT_FOR_PACKAGE:
         return array(
           self::CONDITION_INCLUDE_ANY,
           self::CONDITION_INCLUDE_NONE,
         );
       case self::FIELD_REPOSITORY_AUTOCLOSE_BRANCH:
         return array(
           self::CONDITION_UNCONDITIONALLY,
         );
     }
     return parent::getConditionsForField($field);
   }
 
   public function getActions($rule_type) {
     switch ($rule_type) {
       case HeraldRuleTypeConfig::RULE_TYPE_GLOBAL:
         return array(
           self::ACTION_ADD_CC,
           self::ACTION_EMAIL,
           self::ACTION_AUDIT,
           self::ACTION_NOTHING,
         );
       case HeraldRuleTypeConfig::RULE_TYPE_PERSONAL:
         return array(
           self::ACTION_ADD_CC,
           self::ACTION_EMAIL,
           self::ACTION_FLAG,
           self::ACTION_AUDIT,
           self::ACTION_NOTHING,
         );
     }
   }
 
   public function getValueTypeForFieldAndCondition($field, $condition) {
     switch ($field) {
       case self::FIELD_DIFFERENTIAL_CCS:
         return self::VALUE_EMAIL;
       case self::FIELD_NEED_AUDIT_FOR_PACKAGE:
         return self::VALUE_OWNERS_PACKAGE;
     }
 
     return parent::getValueTypeForFieldAndCondition($field, $condition);
   }
 
   public static function newLegacyAdapter(
     PhabricatorRepository $repository,
     PhabricatorRepositoryCommit $commit,
     PhabricatorRepositoryCommitData $commit_data) {
 
     $object = new HeraldCommitAdapter();
 
     $object->repository = $repository;
     $object->commit = $commit;
     $object->commitData = $commit_data;
 
     return $object;
   }
 
   public function getPHID() {
     return $this->commit->getPHID();
   }
 
   public function getEmailPHIDs() {
     return array_keys($this->emailPHIDs);
   }
 
   public function getAddCCMap() {
     return $this->addCCPHIDs;
   }
 
   public function getAuditMap() {
     return $this->auditMap;
   }
 
   public function getHeraldName() {
     return
       'r'.
       $this->repository->getCallsign().
       $this->commit->getCommitIdentifier();
   }
 
   public function loadAffectedPaths() {
     if ($this->affectedPaths === null) {
       $result = PhabricatorOwnerPathQuery::loadAffectedPaths(
         $this->repository,
         $this->commit,
         PhabricatorUser::getOmnipotentUser());
       $this->affectedPaths = $result;
     }
     return $this->affectedPaths;
   }
 
   public function loadAffectedPackages() {
     if ($this->affectedPackages === null) {
       $packages = PhabricatorOwnersPackage::loadAffectedPackages(
         $this->repository,
         $this->loadAffectedPaths());
       $this->affectedPackages = $packages;
     }
     return $this->affectedPackages;
   }
 
   public function loadAuditNeededPackage() {
     if ($this->auditNeededPackages === null) {
       $status_arr = array(
         PhabricatorAuditStatusConstants::AUDIT_REQUIRED,
         PhabricatorAuditStatusConstants::CONCERNED,
       );
       $requests = id(new PhabricatorRepositoryAuditRequest())
           ->loadAllWhere(
         "commitPHID = %s AND auditStatus IN (%Ls)",
         $this->commit->getPHID(),
         $status_arr);
 
       $packages = mpull($requests, 'getAuditorPHID');
       $this->auditNeededPackages = $packages;
     }
     return $this->auditNeededPackages;
   }
 
   public function loadDifferentialRevision() {
     if ($this->affectedRevision === null) {
       $this->affectedRevision = false;
       $data = $this->commitData;
       $revision_id = $data->getCommitDetail('differential.revisionID');
       if ($revision_id) {
         // TODO: (T603) Herald policy stuff.
         $revision = id(new DifferentialRevision())->load($revision_id);
         if ($revision) {
           $revision->loadRelationships();
           $this->affectedRevision = $revision;
         }
       }
     }
     return $this->affectedRevision;
   }
 
   private function loadCommitDiff() {
     $drequest = DiffusionRequest::newFromDictionary(
       array(
         'user' => PhabricatorUser::getOmnipotentUser(),
         'repository' => $this->repository,
         'commit' => $this->commit->getCommitIdentifier(),
       ));
 
     $raw = DiffusionQuery::callConduitWithDiffusionRequest(
       PhabricatorUser::getOmnipotentUser(),
       $drequest,
       'diffusion.rawdiffquery',
       array(
         'commit' => $this->commit->getCommitIdentifier(),
         'timeout' => 60 * 60 * 15,
         'linesOfContext' => 0));
 
     $parser = new ArcanistDiffParser();
     $changes = $parser->parseDiff($raw);
 
     $diff = DifferentialDiff::newFromRawChanges($changes);
     return $diff;
   }
 
   private function loadChangesets() {
     try {
       $diff = $this->loadCommitDiff();
     } catch (Exception $ex) {
       return array(
         '<<< Failed to load diff, this may mean the change was '.
         'unimaginably enormous. >>>');
     }
     return $diff->getChangesets();
   }
 
   public function getHeraldField($field) {
     $data = $this->commitData;
     switch ($field) {
       case self::FIELD_BODY:
         return $data->getCommitMessage();
       case self::FIELD_AUTHOR:
         return $data->getCommitDetail('authorPHID');
       case self::FIELD_COMMITTER:
         return $data->getCommitDetail('committerPHID');
       case self::FIELD_REVIEWER:
         return $data->getCommitDetail('reviewerPHID');
       case self::FIELD_DIFF_FILE:
         return $this->loadAffectedPaths();
       case self::FIELD_REPOSITORY:
         return $this->repository->getPHID();
       case self::FIELD_DIFF_CONTENT:
         $dict = array();
         $lines = array();
         $changes = $this->loadChangesets();
         foreach ($changes as $change) {
           $lines = array();
           foreach ($change->getHunks() as $hunk) {
             $lines[] = $hunk->makeChanges();
           }
           $dict[$change->getFilename()] = implode("\n", $lines);
         }
         return $dict;
       case self::FIELD_DIFF_ADDED_CONTENT:
         $dict = array();
         $lines = array();
         $changes = $this->loadChangesets();
         foreach ($changes as $change) {
           $lines = array();
           foreach ($change->getHunks() as $hunk) {
             $lines[] = implode('', $hunk->getAddedLines());
           }
           $dict[$change->getFilename()] = implode("\n", $lines);
         }
         return $dict;
       case self::FIELD_DIFF_REMOVED_CONTENT:
         $dict = array();
         $lines = array();
         $changes = $this->loadChangesets();
         foreach ($changes as $change) {
           $lines = array();
           foreach ($change->getHunks() as $hunk) {
             $lines[] = implode('', $hunk->getRemovedLines());
           }
           $dict[$change->getFilename()] = implode("\n", $lines);
         }
         return $dict;
       case self::FIELD_AFFECTED_PACKAGE:
         $packages = $this->loadAffectedPackages();
         return mpull($packages, 'getPHID');
       case self::FIELD_AFFECTED_PACKAGE_OWNER:
         $packages = $this->loadAffectedPackages();
         $owners = PhabricatorOwnersOwner::loadAllForPackages($packages);
         return mpull($owners, 'getUserPHID');
       case self::FIELD_NEED_AUDIT_FOR_PACKAGE:
         return $this->loadAuditNeededPackage();
       case self::FIELD_DIFFERENTIAL_REVISION:
         $revision = $this->loadDifferentialRevision();
         if (!$revision) {
           return null;
         }
         return $revision->getID();
       case self::FIELD_DIFFERENTIAL_REVIEWERS:
         $revision = $this->loadDifferentialRevision();
         if (!$revision) {
           return array();
         }
         return $revision->getReviewers();
       case self::FIELD_DIFFERENTIAL_CCS:
         $revision = $this->loadDifferentialRevision();
         if (!$revision) {
           return array();
         }
         return $revision->getCCPHIDs();
       case self::FIELD_REPOSITORY_AUTOCLOSE_BRANCH:
         return $this->repository->shouldAutocloseCommit(
           $this->commit,
           $this->commitData);
     }
 
     return parent::getHeraldField($field);
   }
 
   public function applyHeraldEffects(array $effects) {
     assert_instances_of($effects, 'HeraldEffect');
 
     $result = array();
     foreach ($effects as $effect) {
       $action = $effect->getAction();
       switch ($action) {
         case self::ACTION_NOTHING:
           $result[] = new HeraldApplyTranscript(
             $effect,
             true,
             pht('Great success at doing nothing.'));
           break;
         case self::ACTION_EMAIL:
           foreach ($effect->getTarget() as $phid) {
             $this->emailPHIDs[$phid] = true;
           }
           $result[] = new HeraldApplyTranscript(
             $effect,
             true,
             pht('Added address to email targets.'));
           break;
         case self::ACTION_ADD_CC:
           foreach ($effect->getTarget() as $phid) {
             if (empty($this->addCCPHIDs[$phid])) {
               $this->addCCPHIDs[$phid] = array();
             }
             $this->addCCPHIDs[$phid][] = $effect->getRuleID();
           }
           $result[] = new HeraldApplyTranscript(
             $effect,
             true,
             pht('Added address to CC.'));
           break;
         case self::ACTION_AUDIT:
           foreach ($effect->getTarget() as $phid) {
             if (empty($this->auditMap[$phid])) {
               $this->auditMap[$phid] = array();
             }
             $this->auditMap[$phid][] = $effect->getRuleID();
           }
           $result[] = new HeraldApplyTranscript(
             $effect,
             true,
             pht('Triggered an audit.'));
           break;
         case self::ACTION_FLAG:
           $result[] = parent::applyFlagEffect(
             $effect,
             $this->commit->getPHID());
           break;
         default:
           throw new Exception("No rules to handle action '{$action}'.");
       }
     }
     return $result;
   }
 }
diff --git a/src/applications/herald/adapter/HeraldDifferentialRevisionAdapter.php b/src/applications/herald/adapter/HeraldDifferentialRevisionAdapter.php
index 5559d8cdc5..7776330d1a 100644
--- a/src/applications/herald/adapter/HeraldDifferentialRevisionAdapter.php
+++ b/src/applications/herald/adapter/HeraldDifferentialRevisionAdapter.php
@@ -1,424 +1,423 @@
 <?php
 
 /**
  * @group herald
  */
 final class HeraldDifferentialRevisionAdapter extends HeraldAdapter {
 
   protected $revision;
   protected $diff;
 
   protected $explicitCCs;
   protected $explicitReviewers;
   protected $forbiddenCCs;
 
   protected $newCCs = array();
   protected $remCCs = array();
   protected $emailPHIDs = array();
 
   protected $repository;
   protected $affectedPackages;
   protected $changesets;
 
-  public function isEnabled() {
-    $app = 'PhabricatorApplicationDifferential';
-    return PhabricatorApplication::isClassInstalled($app);
+  public function getAdapterApplicationClass() {
+    return 'PhabricatorApplicationDifferential';
   }
 
   public function getAdapterContentType() {
     return 'differential';
   }
 
   public function getAdapterContentName() {
     return pht('Differential Revisions');
   }
 
   public function getFields() {
     return array_merge(
       array(
         self::FIELD_TITLE,
         self::FIELD_BODY,
         self::FIELD_AUTHOR,
         self::FIELD_REVIEWERS,
         self::FIELD_CC,
         self::FIELD_REPOSITORY,
         self::FIELD_DIFF_FILE,
         self::FIELD_DIFF_CONTENT,
         self::FIELD_DIFF_ADDED_CONTENT,
         self::FIELD_DIFF_REMOVED_CONTENT,
         self::FIELD_RULE,
         self::FIELD_AFFECTED_PACKAGE,
         self::FIELD_AFFECTED_PACKAGE_OWNER,
       ),
       parent::getFields());
   }
 
   public function getRepetitionOptions() {
     return array(
       HeraldRepetitionPolicyConfig::EVERY,
       HeraldRepetitionPolicyConfig::FIRST,
     );
   }
 
   public static function newLegacyAdapter(
     DifferentialRevision $revision,
     DifferentialDiff $diff) {
 
     $object = new HeraldDifferentialRevisionAdapter();
 
     $revision->loadRelationships();
     $object->revision = $revision;
     $object->diff = $diff;
 
     return $object;
   }
 
   public function setExplicitCCs($explicit_ccs) {
     $this->explicitCCs = $explicit_ccs;
     return $this;
   }
 
   public function setExplicitReviewers($explicit_reviewers) {
     $this->explicitReviewers = $explicit_reviewers;
     return $this;
   }
 
   public function setForbiddenCCs($forbidden_ccs) {
     $this->forbiddenCCs = $forbidden_ccs;
     return $this;
   }
 
   public function getCCsAddedByHerald() {
     return array_diff_key($this->newCCs, $this->remCCs);
   }
 
   public function getCCsRemovedByHerald() {
     return $this->remCCs;
   }
 
   public function getEmailPHIDsAddedByHerald() {
     return $this->emailPHIDs;
   }
 
   public function getPHID() {
     return $this->revision->getPHID();
   }
 
   public function getHeraldName() {
     return $this->revision->getTitle();
   }
 
   public function loadRepository() {
     if ($this->repository === null) {
       $this->repository = false;
 
       // TODO: (T603) Implement policy stuff in Herald.
       $viewer = PhabricatorUser::getOmnipotentUser();
 
       $revision = $this->revision;
       if ($revision->getRepositoryPHID()) {
         $repositories = id(new PhabricatorRepositoryQuery())
           ->setViewer($viewer)
           ->withPHIDs(array($revision->getRepositoryPHID()))
           ->execute();
         if ($repositories) {
           $this->repository = head($repositories);
           return $this->repository;
         }
       }
 
       $repository = id(new DifferentialRepositoryLookup())
         ->setViewer($viewer)
         ->setDiff($this->diff)
         ->lookupRepository();
       if ($repository) {
         $this->repository = $repository;
         return $this->repository;
       }
 
       $repository = false;
     }
     return $this->repository;
   }
 
   protected function loadChangesets() {
     if ($this->changesets === null) {
       $this->changesets = $this->diff->loadChangesets();
     }
     return $this->changesets;
   }
 
   protected function loadAffectedPaths() {
     $changesets = $this->loadChangesets();
 
     $paths = array();
     foreach ($changesets as $changeset) {
       $paths[] = $this->getAbsoluteRepositoryPathForChangeset($changeset);
     }
     return $paths;
   }
 
   protected function getAbsoluteRepositoryPathForChangeset(
     DifferentialChangeset $changeset) {
 
     $repository = $this->loadRepository();
     if (!$repository) {
       return '/'.ltrim($changeset->getFilename(), '/');
     }
 
     $diff = $this->diff;
 
     return $changeset->getAbsoluteRepositoryPath($repository, $diff);
   }
 
   protected function loadContentDictionary() {
     $changesets = $this->loadChangesets();
 
     $hunks = array();
     if ($changesets) {
       $hunks = id(new DifferentialHunk())->loadAllWhere(
         'changesetID in (%Ld)',
         mpull($changesets, 'getID'));
     }
 
     $dict = array();
     $hunks = mgroup($hunks, 'getChangesetID');
     $changesets = mpull($changesets, null, 'getID');
     foreach ($changesets as $id => $changeset) {
       $path = $this->getAbsoluteRepositoryPathForChangeset($changeset);
       $content = array();
       foreach (idx($hunks, $id, array()) as $hunk) {
         $content[] = $hunk->makeChanges();
       }
       $dict[$path] = implode("\n", $content);
     }
 
     return $dict;
   }
 
   protected function loadAddedContentDictionary() {
     $changesets = $this->loadChangesets();
 
     $hunks = array();
     if ($changesets) {
       $hunks = id(new DifferentialHunk())->loadAllWhere(
         'changesetID in (%Ld)',
         mpull($changesets, 'getID'));
     }
 
     $dict = array();
     $hunks = mgroup($hunks, 'getChangesetID');
     $changesets = mpull($changesets, null, 'getID');
     foreach ($changesets as $id => $changeset) {
       $path = $this->getAbsoluteRepositoryPathForChangeset($changeset);
       $content = array();
       foreach (idx($hunks, $id, array()) as $hunk) {
         $content[] = implode('', $hunk->getAddedLines());
       }
       $dict[$path] = implode("\n", $content);
     }
 
     return $dict;
   }
 
   protected function loadRemovedContentDictionary() {
     $changesets = $this->loadChangesets();
 
     $hunks = array();
     if ($changesets) {
       $hunks = id(new DifferentialHunk())->loadAllWhere(
         'changesetID in (%Ld)',
         mpull($changesets, 'getID'));
     }
 
     $dict = array();
     $hunks = mgroup($hunks, 'getChangesetID');
     $changesets = mpull($changesets, null, 'getID');
     foreach ($changesets as $id => $changeset) {
       $path = $this->getAbsoluteRepositoryPathForChangeset($changeset);
       $content = array();
       foreach (idx($hunks, $id, array()) as $hunk) {
         $content[] = implode('', $hunk->getRemovedLines());
       }
       $dict[$path] = implode("\n", $content);
     }
 
     return $dict;
   }
 
   public function loadAffectedPackages() {
     if ($this->affectedPackages === null) {
       $this->affectedPackages = array();
 
       $repository = $this->loadRepository();
       if ($repository) {
         $packages = PhabricatorOwnersPackage::loadAffectedPackages(
           $repository,
           $this->loadAffectedPaths());
         $this->affectedPackages = $packages;
       }
     }
     return $this->affectedPackages;
   }
 
   public function getHeraldField($field) {
     switch ($field) {
       case self::FIELD_TITLE:
         return $this->revision->getTitle();
         break;
       case self::FIELD_BODY:
         return $this->revision->getSummary()."\n".
                $this->revision->getTestPlan();
         break;
       case self::FIELD_AUTHOR:
         return $this->revision->getAuthorPHID();
         break;
       case self::FIELD_DIFF_FILE:
         return $this->loadAffectedPaths();
       case self::FIELD_CC:
         if (isset($this->explicitCCs)) {
           return array_keys($this->explicitCCs);
         } else {
           return $this->revision->getCCPHIDs();
         }
       case self::FIELD_REVIEWERS:
         if (isset($this->explicitReviewers)) {
           return array_keys($this->explicitReviewers);
         } else {
           return $this->revision->getReviewers();
         }
       case self::FIELD_REPOSITORY:
         $repository = $this->loadRepository();
         if (!$repository) {
           return null;
         }
         return $repository->getPHID();
       case self::FIELD_DIFF_CONTENT:
         return $this->loadContentDictionary();
       case self::FIELD_DIFF_ADDED_CONTENT:
         return $this->loadAddedContentDictionary();
       case self::FIELD_DIFF_REMOVED_CONTENT:
         return $this->loadRemovedContentDictionary();
       case self::FIELD_AFFECTED_PACKAGE:
         $packages = $this->loadAffectedPackages();
         return mpull($packages, 'getPHID');
       case self::FIELD_AFFECTED_PACKAGE_OWNER:
         $packages = $this->loadAffectedPackages();
         return PhabricatorOwnersOwner::loadAffiliatedUserPHIDs(
           mpull($packages, 'getID'));
     }
 
     return parent::getHeraldField($field);
   }
 
   public function getActions($rule_type) {
     switch ($rule_type) {
       case HeraldRuleTypeConfig::RULE_TYPE_GLOBAL:
         return array(
           self::ACTION_ADD_CC,
           self::ACTION_REMOVE_CC,
           self::ACTION_EMAIL,
           self::ACTION_NOTHING,
         );
       case HeraldRuleTypeConfig::RULE_TYPE_PERSONAL:
         return array(
           self::ACTION_ADD_CC,
           self::ACTION_REMOVE_CC,
           self::ACTION_EMAIL,
           self::ACTION_FLAG,
           self::ACTION_NOTHING,
         );
     }
   }
 
   public function applyHeraldEffects(array $effects) {
     assert_instances_of($effects, 'HeraldEffect');
 
     $result = array();
     if ($this->explicitCCs) {
       $effect = new HeraldEffect();
       $effect->setAction(self::ACTION_ADD_CC);
       $effect->setTarget(array_keys($this->explicitCCs));
       $effect->setReason(
         pht('CCs provided explicitly by revision author or carried over '.
         'from a previous version of the revision.'));
       $result[] = new HeraldApplyTranscript(
         $effect,
         true,
         pht('Added addresses to CC list.'));
     }
 
     $forbidden_ccs = array_fill_keys(
       nonempty($this->forbiddenCCs, array()),
       true);
 
     foreach ($effects as $effect) {
       $action = $effect->getAction();
       switch ($action) {
         case self::ACTION_NOTHING:
           $result[] = new HeraldApplyTranscript(
             $effect,
             true,
             pht('OK, did nothing.'));
           break;
         case self::ACTION_FLAG:
           $result[] = parent::applyFlagEffect(
             $effect,
             $this->revision->getPHID());
           break;
         case self::ACTION_EMAIL:
         case self::ACTION_ADD_CC:
           $op = ($action == self::ACTION_EMAIL) ? 'email' : 'CC';
           $base_target = $effect->getTarget();
           $forbidden = array();
           foreach ($base_target as $key => $fbid) {
             if (isset($forbidden_ccs[$fbid])) {
               $forbidden[] = $fbid;
               unset($base_target[$key]);
             } else {
               if ($action == self::ACTION_EMAIL) {
                 $this->emailPHIDs[$fbid] = true;
               } else {
                 $this->newCCs[$fbid] = true;
               }
             }
           }
 
           if ($forbidden) {
             $failed = clone $effect;
             $failed->setTarget($forbidden);
             if ($base_target) {
               $effect->setTarget($base_target);
               $result[] = new HeraldApplyTranscript(
                 $effect,
                 true,
                 pht('Added these addresses to %s list. '.
                 'Others could not be added.', $op));
             }
             $result[] = new HeraldApplyTranscript(
               $failed,
               false,
               pht('%s forbidden, these addresses have unsubscribed.', $op));
           } else {
             $result[] = new HeraldApplyTranscript(
               $effect,
               true,
               pht('Added addresses to %s list.', $op));
           }
           break;
         case self::ACTION_REMOVE_CC:
           foreach ($effect->getTarget() as $fbid) {
             $this->remCCs[$fbid] = true;
           }
           $result[] = new HeraldApplyTranscript(
             $effect,
             true,
             pht('Removed addresses from CC list.'));
           break;
         default:
           throw new Exception("No rules to handle action '{$action}'.");
       }
     }
     return $result;
   }
 }
diff --git a/src/applications/herald/adapter/HeraldManiphestTaskAdapter.php b/src/applications/herald/adapter/HeraldManiphestTaskAdapter.php
index 5c461f8e89..68329e7818 100644
--- a/src/applications/herald/adapter/HeraldManiphestTaskAdapter.php
+++ b/src/applications/herald/adapter/HeraldManiphestTaskAdapter.php
@@ -1,158 +1,162 @@
 <?php
 
 /**
  * @group herald
  */
 final class HeraldManiphestTaskAdapter extends HeraldAdapter {
 
   private $task;
   private $ccPHIDs = array();
   private $assignPHID;
   private $projectPHIDs = array();
 
+  public function getAdapterApplicationClass() {
+    return 'PhabricatorApplicationManiphest';
+  }
+
   public function setTask(ManiphestTask $task) {
     $this->task = $task;
     return $this;
   }
   public function getTask() {
     return $this->task;
   }
 
   private function setCcPHIDs(array $cc_phids) {
     $this->ccPHIDs = $cc_phids;
     return $this;
   }
   public function getCcPHIDs() {
     return $this->ccPHIDs;
   }
 
   public function setAssignPHID($assign_phid) {
     $this->assignPHID = $assign_phid;
     return $this;
   }
   public function getAssignPHID() {
     return $this->assignPHID;
   }
 
   public function setProjectPHIDs(array $project_phids) {
     $this->projectPHIDs = $project_phids;
     return $this;
   }
   public function getProjectPHIDs() {
     return $this->projectPHIDs;
   }
 
   public function getAdapterContentName() {
     return pht('Maniphest Tasks');
   }
 
   public function getFields() {
     return array_merge(
       array(
         self::FIELD_TITLE,
         self::FIELD_BODY,
         self::FIELD_AUTHOR,
         self::FIELD_CC,
         self::FIELD_CONTENT_SOURCE,
       ),
       parent::getFields());
   }
 
   public function getActions($rule_type) {
     switch ($rule_type) {
       case HeraldRuleTypeConfig::RULE_TYPE_GLOBAL:
         return array(
           self::ACTION_ADD_CC,
           self::ACTION_ASSIGN_TASK,
           self::ACTION_ADD_PROJECTS,
           self::ACTION_NOTHING,
         );
       case HeraldRuleTypeConfig::RULE_TYPE_PERSONAL:
         return array(
           self::ACTION_ADD_CC,
           self::ACTION_FLAG,
           self::ACTION_ASSIGN_TASK,
           self::ACTION_NOTHING,
         );
     }
   }
 
   public function getPHID() {
     return $this->getTask()->getPHID();
   }
 
   public function getHeraldName() {
     return 'T'.$this->getTask()->getID();
   }
 
   public function getHeraldField($field) {
     switch ($field) {
       case self::FIELD_TITLE:
         return $this->getTask()->getTitle();
       case self::FIELD_BODY:
         return $this->getTask()->getDescription();
       case self::FIELD_AUTHOR:
         return $this->getTask()->getAuthorPHID();
       case self::FIELD_CC:
         return $this->getTask()->getCCPHIDs();
     }
 
     return parent::getHeraldField($field);
   }
 
   public function applyHeraldEffects(array $effects) {
     assert_instances_of($effects, 'HeraldEffect');
 
     $result = array();
     foreach ($effects as $effect) {
       $action = $effect->getAction();
       switch ($action) {
         case self::ACTION_NOTHING:
           $result[] = new HeraldApplyTranscript(
             $effect,
             true,
             pht('Great success at doing nothing.'));
           break;
         case self::ACTION_ADD_CC:
           $add_cc = array();
           foreach ($effect->getTarget() as $phid) {
             $add_cc[$phid] = true;
           }
           $this->setCcPHIDs(array_keys($add_cc));
           $result[] = new HeraldApplyTranscript(
             $effect,
             true,
             pht('Added address to cc list.'));
           break;
         case self::ACTION_FLAG:
           $result[] = parent::applyFlagEffect(
             $effect,
             $this->getTask()->getPHID());
           break;
         case self::ACTION_ASSIGN_TASK:
           $target_array = $effect->getTarget();
           $assign_phid = reset($target_array);
           $this->setAssignPHID($assign_phid);
           $result[] = new HeraldApplyTranscript(
             $effect,
             true,
             pht('Assigned task.'));
           break;
         case self::ACTION_ADD_PROJECTS:
           $add_projects = array();
           foreach ($effect->getTarget() as $phid) {
             $add_projects[$phid] = true;
           }
           $this->setProjectPHIDs(array_keys($add_projects));
           $result[] = new HeraldApplyTranscript(
             $effect,
             true,
             pht('Added projects.'));
           break;
         default:
           throw new Exception("No rules to handle action '{$action}'.");
       }
     }
     return $result;
   }
 }
diff --git a/src/applications/herald/adapter/HeraldPholioMockAdapter.php b/src/applications/herald/adapter/HeraldPholioMockAdapter.php
index 8c5fb1c1de..bdf6e8a5f5 100644
--- a/src/applications/herald/adapter/HeraldPholioMockAdapter.php
+++ b/src/applications/herald/adapter/HeraldPholioMockAdapter.php
@@ -1,117 +1,121 @@
 <?php
 
 /**
  * @group herald
  */
 final class HeraldPholioMockAdapter extends HeraldAdapter {
 
   private $mock;
   private $ccPHIDs = array();
 
+  public function getAdapterApplicationClass() {
+    return 'PhabricatorApplicationPholio';
+  }
+
   public function setMock(PholioMock $mock) {
     $this->mock = $mock;
     return $this;
   }
   public function getMock() {
     return $this->mock;
   }
 
   private function setCcPHIDs(array $cc_phids) {
     $this->ccPHIDs = $cc_phids;
     return $this;
   }
   public function getCcPHIDs() {
     return $this->ccPHIDs;
   }
 
   public function getAdapterContentName() {
     return pht('Pholio Mocks');
   }
 
   public function getFields() {
     return array_merge(
       array(
         self::FIELD_TITLE,
         self::FIELD_BODY,
         self::FIELD_AUTHOR,
         self::FIELD_CC,
       ),
       parent::getFields());
   }
 
   public function getActions($rule_type) {
     switch ($rule_type) {
       case HeraldRuleTypeConfig::RULE_TYPE_GLOBAL:
         return array(
           self::ACTION_ADD_CC,
           self::ACTION_NOTHING,
         );
       case HeraldRuleTypeConfig::RULE_TYPE_PERSONAL:
         return array(
           self::ACTION_ADD_CC,
           self::ACTION_FLAG,
           self::ACTION_NOTHING,
         );
     }
   }
 
   public function getPHID() {
     return $this->getMock()->getPHID();
   }
 
   public function getHeraldName() {
     return 'M'.$this->getMock()->getID();
   }
 
   public function getHeraldField($field) {
     switch ($field) {
       case self::FIELD_TITLE:
         return $this->getMock()->getName();
       case self::FIELD_BODY:
         return $this->getMock()->getDescription();
       case self::FIELD_AUTHOR:
         return $this->getMock()->getAuthorPHID();
       case self::FIELD_CC:
         return PhabricatorSubscribersQuery::loadSubscribersForPHID(
                 $this->getMock()->getPHID());
     }
 
     return parent::getHeraldField($field);
   }
 
   public function applyHeraldEffects(array $effects) {
     assert_instances_of($effects, 'HeraldEffect');
 
     $result = array();
     foreach ($effects as $effect) {
       $action = $effect->getAction();
       switch ($action) {
         case self::ACTION_NOTHING:
           $result[] = new HeraldApplyTranscript(
             $effect,
             true,
             pht('Great success at doing nothing.'));
           break;
         case self::ACTION_ADD_CC:
           $add_cc = array();
           foreach ($effect->getTarget() as $phid) {
             $add_cc[$phid] = true;
           }
           $this->setCcPHIDs(array_keys($add_cc));
           $result[] = new HeraldApplyTranscript(
             $effect,
             true,
             pht('Added address to cc list.'));
           break;
         case self::ACTION_FLAG:
           $result[] = parent::applyFlagEffect(
             $effect,
             $this->getMock()->getPHID());
           break;
         default:
           throw new Exception("No rules to handle action '{$action}'.");
       }
     }
     return $result;
   }
 }
diff --git a/src/applications/herald/application/PhabricatorApplicationHerald.php b/src/applications/herald/application/PhabricatorApplicationHerald.php
index ce172d72e3..692e37d8be 100644
--- a/src/applications/herald/application/PhabricatorApplicationHerald.php
+++ b/src/applications/herald/application/PhabricatorApplicationHerald.php
@@ -1,51 +1,68 @@
 <?php
 
 final class PhabricatorApplicationHerald extends PhabricatorApplication {
 
+  const CAN_CREATE_RULE = 'herald.create';
+  const CAN_CREATE_GLOBAL_RULE = 'herald.global';
+
   public function getBaseURI() {
     return '/herald/';
   }
 
   public function getIconName() {
     return 'herald';
   }
 
   public function getShortDescription() {
     return pht('Create Notification Rules');
   }
 
   public function getTitleGlyph() {
     return "\xE2\x98\xBF";
   }
 
   public function getHelpURI() {
     return PhabricatorEnv::getDoclink('article/Herald_User_Guide.html');
   }
 
   public function getFlavorText() {
     return pht('Watch for danger!');
   }
 
   public function getApplicationGroup() {
     return self::GROUP_ORGANIZATION;
   }
 
   public function getRoutes() {
     return array(
       '/herald/' => array(
         '(?:query/(?P<queryKey>[^/]+)/)?' => 'HeraldRuleListController',
         'new/(?:(?P<type>[^/]+)/(?:(?P<rule_type>[^/]+)/)?)?'
           => 'HeraldNewController',
         'rule/(?P<id>[1-9]\d*)/' => 'HeraldRuleViewController',
         'edit/(?:(?P<id>[1-9]\d*)/)?' => 'HeraldRuleController',
         'history/(?:(?P<id>[1-9]\d*)/)?' => 'HeraldRuleEditHistoryController',
         'delete/(?P<id>[1-9]\d*)/' => 'HeraldDeleteController',
         'test/' => 'HeraldTestConsoleController',
         'transcript/' => 'HeraldTranscriptListController',
         'transcript/(?P<id>[1-9]\d*)/(?:(?P<filter>\w+)/)?'
           => 'HeraldTranscriptController',
       ),
     );
   }
 
+  protected function getCustomCapabilities() {
+    return array(
+      self::CAN_CREATE_RULE => array(
+        'label' => pht('Can Create Rules'),
+      ),
+      self::CAN_CREATE_GLOBAL_RULE => array(
+        'label' => pht('Can Create Global Rules'),
+        'caption' => pht('Global rules can bypass access controls.'),
+        'default' => PhabricatorPolicies::POLICY_ADMIN,
+      ),
+    );
+  }
+
+
 }
diff --git a/src/applications/herald/controller/HeraldController.php b/src/applications/herald/controller/HeraldController.php
index a4f4eab1e0..4f1e0df62f 100644
--- a/src/applications/herald/controller/HeraldController.php
+++ b/src/applications/herald/controller/HeraldController.php
@@ -1,60 +1,64 @@
 <?php
 
 abstract class HeraldController extends PhabricatorController {
 
   public function buildStandardPageResponse($view, array $data) {
     $page = $this->buildStandardPageView();
 
     $page->setApplicationName(pht('Herald'));
     $page->setBaseURI('/herald/');
     $page->setTitle(idx($data, 'title'));
     $page->setGlyph("\xE2\x98\xBF");
 
     $page->appendChild($view);
 
     $response = new AphrontWebpageResponse();
     return $response->setContent($page->render());
   }
 
   public function buildApplicationMenu() {
     return $this->buildSideNavView(true)->getMenu();
   }
 
   public function buildApplicationCrumbs() {
     $crumbs = parent::buildApplicationCrumbs();
 
+    $can_create = $this->hasApplicationCapability(
+      PhabricatorApplicationHerald::CAN_CREATE_RULE);
+
     $crumbs->addAction(
       id(new PHUIListItemView())
         ->setName(pht('Create Herald Rule'))
         ->setHref($this->getApplicationURI('new/'))
-        ->setIcon('create'));
+        ->setIcon('create')
+        ->setDisabled(!$can_create));
 
     return $crumbs;
   }
 
   public function buildSideNavView($for_app = false) {
     $user = $this->getRequest()->getUser();
 
     $nav = new AphrontSideNavFilterView();
     $nav->setBaseURI(new PhutilURI($this->getApplicationURI()));
 
     if ($for_app) {
       $nav->addFilter('create', pht('Create Rule'));
     }
 
     id(new HeraldRuleSearchEngine())
       ->setViewer($user)
       ->addNavigationItems($nav->getMenu());
 
     $nav
       ->addLabel(pht('Utilities'))
       ->addFilter('test',       pht('Test Console'))
       ->addFilter('transcript', pht('Transcripts'))
       ->addFilter('history',    pht('Edit Log'));
 
     $nav->selectFilter(null);
 
     return $nav;
   }
 
 }
diff --git a/src/applications/herald/controller/HeraldNewController.php b/src/applications/herald/controller/HeraldNewController.php
index 725ea7ae62..ab87985440 100644
--- a/src/applications/herald/controller/HeraldNewController.php
+++ b/src/applications/herald/controller/HeraldNewController.php
@@ -1,93 +1,118 @@
 <?php
 
 final class HeraldNewController extends HeraldController {
 
   private $contentType;
   private $ruleType;
 
   public function willProcessRequest(array $data) {
     $this->contentType = idx($data, 'type');
     $this->ruleType = idx($data, 'rule_type');
   }
 
   public function processRequest() {
-
     $request = $this->getRequest();
     $user = $request->getUser();
 
-    $content_type_map = HeraldAdapter::getEnabledAdapterMap();
+    $this->requireApplicationCapability(
+      PhabricatorApplicationHerald::CAN_CREATE_RULE);
+
+    $can_global = $this->hasApplicationCapability(
+      PhabricatorApplicationHerald::CAN_CREATE_GLOBAL_RULE);
+
+    $content_type_map = HeraldAdapter::getEnabledAdapterMap($user);
     if (empty($content_type_map[$this->contentType])) {
       $this->contentType = head_key($content_type_map);
     }
 
     $rule_type_map = HeraldRuleTypeConfig::getRuleTypeMap();
     if (empty($rule_type_map[$this->ruleType])) {
       $this->ruleType = HeraldRuleTypeConfig::RULE_TYPE_PERSONAL;
     }
 
     // Reorder array to put "personal" first.
     $rule_type_map = array_select_keys(
       $rule_type_map,
       array(
         HeraldRuleTypeConfig::RULE_TYPE_PERSONAL,
       )) + $rule_type_map;
 
+    if (!$can_global) {
+      $global_link = $this->explainApplicationCapability(
+        PhabricatorApplicationHerald::CAN_CREATE_GLOBAL_RULE,
+        pht('You do not have permission to create or manage global rules.'));
+    } else {
+      $global_link = null;
+    }
+
     $captions = array(
       HeraldRuleTypeConfig::RULE_TYPE_PERSONAL =>
-        pht('Personal rules notify you about events. You own them, but '.
-        'they can only affect you.'),
+        pht(
+          'Personal rules notify you about events. You own them, but they can '.
+          'only affect you.'),
       HeraldRuleTypeConfig::RULE_TYPE_GLOBAL =>
-        pht('Global rules notify anyone about events. No one owns them, and '.
-        'anyone can edit them. Usually, Global rules are used to notify '.
-        'mailing lists.'),
+        phutil_implode_html(
+          phutil_tag('br'),
+          array_filter(
+            array(
+              pht(
+                'Global rules notify anyone about events. Global rules can '.
+                'bypass access control policies.'),
+              $global_link,
+            ))),
     );
 
     $radio = id(new AphrontFormRadioButtonControl())
       ->setLabel(pht('Type'))
       ->setName('rule_type')
       ->setValue($this->ruleType);
 
     foreach ($rule_type_map as $value => $name) {
+      $disabled = ($value == HeraldRuleTypeConfig::RULE_TYPE_GLOBAL) &&
+                  (!$can_global);
+
       $radio->addButton(
         $value,
         $name,
-        idx($captions, $value));
+        idx($captions, $value),
+        $disabled ? 'disabled' : null,
+        $disabled);
     }
 
     $form = id(new AphrontFormView())
       ->setUser($user)
       ->setAction('/herald/edit/')
       ->appendChild(
         id(new AphrontFormSelectControl())
           ->setLabel(pht('New Rule for'))
           ->setName('content_type')
           ->setValue($this->contentType)
           ->setOptions($content_type_map))
       ->appendChild($radio)
       ->appendChild(
         id(new AphrontFormSubmitControl())
           ->setValue(pht('Create Rule'))
           ->addCancelButton($this->getApplicationURI()));
 
     $form_box = id(new PHUIObjectBoxView())
       ->setHeaderText(pht('Create Herald Rule'))
       ->setForm($form);
 
     $crumbs = $this
       ->buildApplicationCrumbs()
       ->addCrumb(
         id(new PhabricatorCrumbView())
           ->setName(pht('Create Rule')));
 
     return $this->buildApplicationPage(
       array(
         $crumbs,
         $form_box,
       ),
       array(
         'title' => pht('Create Herald Rule'),
         'device' => true,
       ));
   }
 
 }
diff --git a/src/applications/herald/controller/HeraldRuleController.php b/src/applications/herald/controller/HeraldRuleController.php
index c3868ebbd5..75458a249d 100644
--- a/src/applications/herald/controller/HeraldRuleController.php
+++ b/src/applications/herald/controller/HeraldRuleController.php
@@ -1,545 +1,553 @@
 <?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();
+    $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_GLOBAL;
+        $rule_type = HeraldRuleTypeConfig::RULE_TYPE_PERSONAL;
       }
       $rule->setRuleType($rule_type);
 
       $cancel_uri = $this->getApplicationURI();
+
+      $this->requireApplicationCapability(
+        PhabricatorApplicationHerald::CAN_CREATE_RULE);
+    }
+
+    if ($rule->getRuleType() == HeraldRuleTypeConfig::RULE_TYPE_GLOBAL) {
+      $this->requireApplicationCapability(
+        PhabricatorApplicationHerald::CAN_CREATE_GLOBAL_RULE);
     }
 
     $adapter = HeraldAdapter::getAdapterForContentType($rule->getContentType());
 
     $local_version = id(new HeraldRule())->getConfigVersion();
     if ($rule->getConfigVersion() > $local_version) {
       throw new Exception(
         "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);
       }
     }
 
     if ($errors) {
       $error_view = new AphrontErrorView();
       $error_view->setTitle(pht('Form Errors'));
       $error_view->setErrors($errors);
     } else {
       $error_view = null;
     }
 
     $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()));
 
     $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(
         id(new AphrontFormInsetView())
           ->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 AphrontFormInsetView())
           ->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)
       ->setFormError($error_view)
       ->setForm($form);
 
     $crumbs = $this
       ->buildApplicationCrumbs()
       ->addCrumb(
         id(new PhabricatorCrumbView())
           ->setName($title));
 
     return $this->buildApplicationPage(
       array(
         $crumbs,
         $form_box,
       ),
       array(
         'title' => pht('Edit Rule'),
         'device' => true,
       ));
   }
 
   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) {
       try {
 
         $edit_action = $rule->getID() ? 'edit' : 'create';
 
         $rule->openTransaction();
           $rule->save();
           $rule->saveConditions($conditions);
           $rule->saveActions($actions);
           $rule->logEdit($request->getUser()->getPHID(), $edit_action);
         $rule->saveTransaction();
 
       } catch (AphrontQueryDuplicateKeyException $ex) {
         $e_name = pht("Not Unique");
         $errors[] = pht("Rule name is not unique. Choose a unique name.");
       }
     }
 
     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();
         if (is_array($value)) {
           $value_map = array();
           foreach ($value as $k => $fbid) {
             $value_map[$fbid] = $handles[$fbid]->getName();
           }
           $value = $value_map;
         }
 
         $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:
             $current_value = $action->getTarget();
             break;
           default:
             $target_map = array();
             foreach ((array)$action->getTarget() as $fbid) {
               $target_map[$fbid] = $handles[$fbid]->getName();
             }
             $current_value = $target_map;
             break;
         }
 
         $serial_actions[] = array(
           $action->getAction(),
           $current_value,
         );
       }
     }
 
     $all_rules = $this->loadRulesThisRuleMayDependUpon($rule);
     $all_rules = mpull($all_rules, 'getName', 'getID');
     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);
 
     $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());
     }
 
     Javelin::initBehavior(
       'herald-rule-editor',
       array(
         'root' => 'herald-rule-edit-form',
         'conditions' => (object)$serial_conditions,
         'actions' => (object)$serial_actions,
         'template' => $this->buildTokenizerTemplates() + array(
           'rules' => $all_rules,
           'colors' => PhabricatorFlagColor::getColorNameMap(),
           'defaultColor' => PhabricatorFlagColor::COLOR_BLUE,
           'contentSources' => PhabricatorContentSource::getSourceNameMap(),
           'defaultSource' => PhabricatorContentSource::SOURCE_WEB
         ),
         '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();
 
     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() {
     $template = new AphrontTokenizerTemplateView();
     $template = $template->render();
 
     return array(
       'source' => array(
         'email'       => '/typeahead/common/mailable/',
         'user'        => '/typeahead/common/users/',
         'repository'  => '/typeahead/common/repositories/',
         'package'     => '/typeahead/common/packages/',
         'project'     => '/typeahead/common/projects/',
       ),
       '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->getRuleType() == HeraldRuleTypeConfig::RULE_TYPE_PERSONAL) {
       // 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();
     }
 
     // A rule can not depend upon itself.
     unset($all_rules[$rule->getID()]);
 
     return $all_rules;
   }
 
 
 }
diff --git a/src/applications/herald/controller/HeraldRuleListController.php b/src/applications/herald/controller/HeraldRuleListController.php
index dacf0ec859..9a937c37e9 100644
--- a/src/applications/herald/controller/HeraldRuleListController.php
+++ b/src/applications/herald/controller/HeraldRuleListController.php
@@ -1,78 +1,78 @@
 <?php
 
 final class HeraldRuleListController extends HeraldController
   implements PhabricatorApplicationSearchResultsControllerInterface {
 
   private $queryKey;
 
   public function shouldAllowPublic() {
     return true;
   }
 
   public function willProcessRequest(array $data) {
     $this->queryKey = idx($data, 'queryKey');
   }
 
   public function processRequest() {
     $request = $this->getRequest();
     $controller = id(new PhabricatorApplicationSearchController($request))
       ->setQueryKey($this->queryKey)
       ->setSearchEngine(new HeraldRuleSearchEngine())
       ->setNavigation($this->buildSideNavView());
 
     return $this->delegateToController($controller);
   }
 
   public function renderResultsList(
     array $rules,
     PhabricatorSavedQuery $query) {
     assert_instances_of($rules, 'HeraldRule');
 
     $viewer = $this->getRequest()->getUser();
 
     $phids = mpull($rules, 'getAuthorPHID');
     $this->loadHandles($phids);
 
-    $content_type_map = HeraldAdapter::getEnabledAdapterMap();
+    $content_type_map = HeraldAdapter::getEnabledAdapterMap($viewer);
 
     $list = id(new PHUIObjectItemListView())
       ->setUser($viewer);
     foreach ($rules as $rule) {
       $id = $rule->getID();
 
       $item = id(new PHUIObjectItemView())
         ->setObjectName(pht('Rule %s', $rule->getID()))
         ->setHeader($rule->getName())
         ->setHref($this->getApplicationURI("rule/{$id}/"));
 
       if ($rule->isPersonalRule()) {
         $item->addByline(
           pht(
             'Authored by %s',
             $this->getHandle($rule->getAuthorPHID())->renderLink()));
       } else {
         $item->addIcon('world', pht('Global Rule'));
       }
 
       $item->addAction(
         id(new PHUIListItemView())
           ->setHref($this->getApplicationURI("history/{$id}/"))
           ->setIcon('transcript')
           ->setName(pht('Edit Log')));
 
       $item->addAction(
         id(new PHUIListItemView())
           ->setHref('/herald/delete/'.$rule->getID().'/')
           ->setIcon('delete')
           ->setWorkflow(true));
 
       $content_type_name = idx($content_type_map, $rule->getContentType());
       $item->addAttribute(pht('Affects: %s', $content_type_name));
 
       $list->addItem($item);
     }
 
     return $list;
   }
 
 }
diff --git a/src/applications/herald/controller/HeraldRuleViewController.php b/src/applications/herald/controller/HeraldRuleViewController.php
index b7b6f582bc..13dbf9e75e 100644
--- a/src/applications/herald/controller/HeraldRuleViewController.php
+++ b/src/applications/herald/controller/HeraldRuleViewController.php
@@ -1,116 +1,118 @@
 <?php
 
 final class HeraldRuleViewController extends HeraldController {
 
   private $id;
 
   public function willProcessRequest(array $data) {
     $this->id = $data['id'];
   }
 
   public function processRequest() {
     $request = $this->getRequest();
     $viewer = $request->getUser();
 
     $rule = id(new HeraldRuleQuery())
       ->setViewer($viewer)
       ->withIDs(array($this->id))
       ->needConditionsAndActions(true)
       ->executeOne();
     if (!$rule) {
       return new Aphront404Response();
     }
 
     $header = id(new PHUIHeaderView())
       ->setHeader($rule->getName());
 
     $actions = $this->buildActionView($rule);
     $properties = $this->buildPropertyView($rule);
 
     $crumbs = $this->buildApplicationCrumbs();
     $crumbs->addCrumb(
       id(new PhabricatorCrumbView())
         ->setName(pht('Rule %d', $rule->getID())));
 
     $object_box = id(new PHUIObjectBoxView())
       ->setHeader($header)
       ->setActionList($actions)
       ->setPropertyList($properties);
 
     return $this->buildApplicationPage(
       array(
         $crumbs,
         $object_box,
       ),
       array(
         'title' => $rule->getName(),
         'device' => true,
       ));
   }
 
   private function buildActionView(HeraldRule $rule) {
     $viewer = $this->getRequest()->getUser();
     $id = $rule->getID();
 
     $view = id(new PhabricatorActionListView())
       ->setUser($viewer)
       ->setObject($rule)
       ->setObjectURI($this->getApplicationURI("rule/{$id}/"));
 
     $can_edit = PhabricatorPolicyFilter::hasCapability(
       $viewer,
       $rule,
       PhabricatorPolicyCapability::CAN_EDIT);
 
     $view->addAction(
       id(new PhabricatorActionView())
         ->setName(pht('Edit Rule'))
         ->setHref($this->getApplicationURI("edit/{$id}/"))
         ->setIcon('edit')
         ->setDisabled(!$can_edit)
         ->setWorkflow(!$can_edit));
 
     return $view;
   }
 
   private function buildPropertyView(HeraldRule $rule) {
     $viewer = $this->getRequest()->getUser();
 
     $this->loadHandles(HeraldAdapter::getHandlePHIDs($rule));
 
     $view = id(new PhabricatorPropertyListView())
       ->setUser($viewer)
       ->setObject($rule);
 
     $view->addProperty(
       pht('Rule Type'),
       idx(HeraldRuleTypeConfig::getRuleTypeMap(), $rule->getRuleType()));
 
     if ($rule->isPersonalRule()) {
       $view->addProperty(
         pht('Author'),
         $this->getHandle($rule->getAuthorPHID())->renderLink());
     }
 
     $adapter = HeraldAdapter::getAdapterForContentType($rule->getContentType());
     if ($adapter) {
       $view->addProperty(
         pht('Applies To'),
-        idx(HeraldAdapter::getEnabledAdapterMap(), $rule->getContentType()));
+        idx(
+          HeraldAdapter::getEnabledAdapterMap($viewer),
+          $rule->getContentType()));
 
       $view->invokeWillRenderEvent();
 
       $view->addSectionHeader(pht('Rule Description'));
       $view->addTextContent(
         phutil_tag(
           'div',
           array(
             'style' => 'white-space: pre-wrap;',
           ),
           $adapter->renderRuleAsText($rule, $this->getLoadedHandles())));
     }
 
     return $view;
   }
 
 }
diff --git a/src/applications/herald/query/HeraldRuleQuery.php b/src/applications/herald/query/HeraldRuleQuery.php
index 7b23231e6f..4e1ea93545 100644
--- a/src/applications/herald/query/HeraldRuleQuery.php
+++ b/src/applications/herald/query/HeraldRuleQuery.php
@@ -1,207 +1,217 @@
 <?php
 
 final class HeraldRuleQuery
   extends PhabricatorCursorPagedPolicyAwareQuery {
 
   private $ids;
   private $phids;
   private $authorPHIDs;
   private $ruleTypes;
   private $contentTypes;
 
   private $needConditionsAndActions;
   private $needAppliedToPHIDs;
   private $needValidateAuthors;
 
   public function withIDs(array $ids) {
     $this->ids = $ids;
     return $this;
   }
 
   public function withPHIDs(array $phids) {
     $this->phids = $phids;
     return $this;
   }
 
   public function withAuthorPHIDs(array $author_phids) {
     $this->authorPHIDs = $author_phids;
     return $this;
   }
 
   public function withRuleTypes(array $types) {
     $this->ruleTypes = $types;
     return $this;
   }
 
   public function withContentTypes(array $types) {
     $this->contentTypes = $types;
     return $this;
   }
 
   public function withExecutableRules($executable) {
     $this->executable = $executable;
     return $this;
   }
 
   public function needConditionsAndActions($need) {
     $this->needConditionsAndActions = $need;
     return $this;
   }
 
   public function needAppliedToPHIDs(array $phids) {
     $this->needAppliedToPHIDs = $phids;
     return $this;
   }
 
   public function needValidateAuthors($need) {
     $this->needValidateAuthors = $need;
     return $this;
   }
 
   public function loadPage() {
     $table = new HeraldRule();
     $conn_r = $table->establishConnection('r');
 
     $data = queryfx_all(
       $conn_r,
       'SELECT rule.* FROM %T rule %Q %Q %Q',
       $table->getTableName(),
       $this->buildWhereClause($conn_r),
       $this->buildOrderClause($conn_r),
       $this->buildLimitClause($conn_r));
 
     return $table->loadAllFromArray($data);
   }
 
   public function willFilterPage(array $rules) {
     $rule_ids = mpull($rules, 'getID');
 
+    // Filter out any rules that have invalid adapters, or have adapters the
+    // viewer isn't permitted to see or use (for example, Differential rules
+    // if the user can't use Differential or Differential is not installed).
+    $types = HeraldAdapter::getEnabledAdapterMap($this->getViewer());
+    foreach ($rules as $key => $rule) {
+      if (empty($types[$rule->getContentType()])) {
+        unset($rules[$key]);
+      }
+    }
+
     if ($this->needValidateAuthors) {
       $this->validateRuleAuthors($rules);
     }
 
     if ($this->needConditionsAndActions) {
       $conditions = id(new HeraldCondition())->loadAllWhere(
         'ruleID IN (%Ld)',
         $rule_ids);
       $conditions = mgroup($conditions, 'getRuleID');
 
       $actions = id(new HeraldAction())->loadAllWhere(
         'ruleID IN (%Ld)',
         $rule_ids);
       $actions = mgroup($actions, 'getRuleID');
 
       foreach ($rules as $rule) {
         $rule->attachActions(idx($actions, $rule->getID(), array()));
         $rule->attachConditions(idx($conditions, $rule->getID(), array()));
       }
     }
 
     if ($this->needAppliedToPHIDs) {
       $conn_r = id(new HeraldRule())->establishConnection('r');
       $applied = queryfx_all(
         $conn_r,
         'SELECT * FROM %T WHERE ruleID IN (%Ld) AND phid IN (%Ls)',
         HeraldRule::TABLE_RULE_APPLIED,
         $rule_ids,
         $this->needAppliedToPHIDs);
 
       $map = array();
       foreach ($applied as $row) {
         $map[$row['ruleID']][$row['phid']] = true;
       }
 
       foreach ($rules as $rule) {
         foreach ($this->needAppliedToPHIDs as $phid) {
           $rule->setRuleApplied(
             $phid,
             isset($map[$rule->getID()][$phid]));
         }
       }
     }
 
     return $rules;
   }
 
   private function buildWhereClause($conn_r) {
     $where = array();
 
     if ($this->ids) {
       $where[] = qsprintf(
         $conn_r,
         'rule.id IN (%Ld)',
         $this->ids);
     }
 
     if ($this->phids) {
       $where[] = qsprintf(
         $conn_r,
         'rule.phid IN (%Ls)',
         $this->phids);
     }
 
     if ($this->authorPHIDs) {
       $where[] = qsprintf(
         $conn_r,
         'rule.authorPHID IN (%Ls)',
         $this->authorPHIDs);
     }
 
     if ($this->ruleTypes) {
       $where[] = qsprintf(
         $conn_r,
         'rule.ruleType IN (%Ls)',
         $this->ruleTypes);
     }
 
     if ($this->contentTypes) {
       $where[] = qsprintf(
         $conn_r,
         'rule.contentType IN (%Ls)',
         $this->contentTypes);
     }
 
     $where[] = $this->buildPagingClause($conn_r);
 
     return $this->formatWhereClause($where);
   }
 
   private function validateRuleAuthors(array $rules) {
 
     // "Global" rules always have valid authors.
     foreach ($rules as $key => $rule) {
       if ($rule->isGlobalRule()) {
         $rule->attachValidAuthor(true);
         unset($rules[$key]);
         continue;
       }
     }
 
     if (!$rules) {
       return;
     }
 
     // For personal rules, the author needs to exist and not be disabled.
     $user_phids = mpull($rules, 'getAuthorPHID');
     $users = id(new PhabricatorPeopleQuery())
       ->setViewer($this->getViewer())
       ->withPHIDs($user_phids)
       ->execute();
     $users = mpull($users, null, 'getPHID');
 
     foreach ($rules as $key => $rule) {
       $author_phid = $rule->getAuthorPHID();
       if (empty($users[$author_phid])) {
         $rule->attachValidAuthor(false);
         continue;
       }
       if ($users[$author_phid]->getIsDisabled()) {
         $rule->attachValidAuthor(false);
         continue;
       }
 
       $rule->attachValidAuthor(true);
     }
   }
 
 }
diff --git a/src/applications/herald/query/HeraldRuleSearchEngine.php b/src/applications/herald/query/HeraldRuleSearchEngine.php
index a875ca648f..0ad2416181 100644
--- a/src/applications/herald/query/HeraldRuleSearchEngine.php
+++ b/src/applications/herald/query/HeraldRuleSearchEngine.php
@@ -1,130 +1,132 @@
 <?php
 
 final class HeraldRuleSearchEngine
   extends PhabricatorApplicationSearchEngine {
 
   public function buildSavedQueryFromRequest(AphrontRequest $request) {
     $saved = new PhabricatorSavedQuery();
 
     $saved->setParameter(
       'authorPHIDs',
       $this->readUsersFromRequest($request, 'authors'));
 
     $saved->setParameter('contentType', $request->getStr('contentType'));
     $saved->setParameter('ruleType', $request->getStr('ruleType'));
 
     return $saved;
   }
 
   public function buildQueryFromSavedQuery(PhabricatorSavedQuery $saved) {
     $query = id(new HeraldRuleQuery());
 
     $author_phids = $saved->getParameter('authorPHIDs');
     if ($author_phids) {
       $query->withAuthorPHIDs($author_phids);
     }
 
     $content_type = $saved->getParameter('contentType');
     $content_type = idx($this->getContentTypeValues(), $content_type);
     if ($content_type) {
       $query->withContentTypes(array($content_type));
     }
 
     $rule_type = $saved->getParameter('ruleType');
     $rule_type = idx($this->getRuleTypeValues(), $rule_type);
     if ($rule_type) {
       $query->withRuleTypes(array($rule_type));
     }
 
     return $query;
   }
 
   public function buildSearchForm(
     AphrontFormView $form,
     PhabricatorSavedQuery $saved_query) {
 
     $phids = $saved_query->getParameter('authorPHIDs', array());
     $handles = id(new PhabricatorHandleQuery())
       ->setViewer($this->requireViewer())
       ->withPHIDs($phids)
       ->execute();
     $author_tokens = mpull($handles, 'getFullName', 'getPHID');
 
     $content_type = $saved_query->getParameter('contentType');
     $rule_type = $saved_query->getParameter('ruleType');
 
     $form
       ->appendChild(
         id(new AphrontFormTokenizerControl())
           ->setDatasource('/typeahead/common/users/')
           ->setName('authors')
           ->setLabel(pht('Authors'))
           ->setValue($author_tokens))
       ->appendChild(
         id(new AphrontFormSelectControl())
           ->setName('contentType')
           ->setLabel(pht('Content Type'))
           ->setValue($content_type)
           ->setOptions($this->getContentTypeOptions()))
       ->appendChild(
         id(new AphrontFormSelectControl())
           ->setName('ruleType')
           ->setLabel(pht('Rule Type'))
           ->setValue($rule_type)
           ->setOptions($this->getRuleTypeOptions()));
   }
 
   protected function getURI($path) {
     return '/herald/'.$path;
   }
 
   public function getBuiltinQueryNames() {
     $names = array();
 
     if ($this->requireViewer()->isLoggedIn()) {
       $names['authored'] = pht('Authored');
     }
 
     $names['all'] = pht('All');
 
     return $names;
   }
 
   public function buildSavedQueryFromBuiltin($query_key) {
 
     $query = $this->newSavedQuery();
     $query->setQueryKey($query_key);
 
     switch ($query_key) {
       case 'all':
         return $query;
       case 'authored':
         return $query->setParameter(
           'authorPHIDs',
           array($this->requireViewer()->getPHID()));
     }
 
     return parent::buildSavedQueryFromBuiltin($query_key);
   }
 
   private function getContentTypeOptions() {
     return array(
       '' => pht('(All Content Types)'),
-    ) + HeraldAdapter::getEnabledAdapterMap();
+    ) + HeraldAdapter::getEnabledAdapterMap($this->requireViewer());
   }
 
   private function getContentTypeValues() {
-    return array_fuse(array_keys(HeraldAdapter::getEnabledAdapterMap()));
+    return array_fuse(
+      array_keys(
+        HeraldAdapter::getEnabledAdapterMap($this->requireViewer())));
   }
 
   private function getRuleTypeOptions() {
     return array(
       '' => pht('(All Rule Types)'),
     ) + HeraldRuleTypeConfig::getRuleTypeMap();
   }
 
   private function getRuleTypeValues() {
     return array_fuse(array_keys(HeraldRuleTypeConfig::getRuleTypeMap()));
   }
 
 }
diff --git a/src/applications/policy/filter/PhabricatorPolicyFilter.php b/src/applications/policy/filter/PhabricatorPolicyFilter.php
index a20080a795..d831c4d462 100644
--- a/src/applications/policy/filter/PhabricatorPolicyFilter.php
+++ b/src/applications/policy/filter/PhabricatorPolicyFilter.php
@@ -1,380 +1,387 @@
 <?php
 
 final class PhabricatorPolicyFilter {
 
   private $viewer;
   private $objects;
   private $capabilities;
   private $raisePolicyExceptions;
   private $userProjects;
 
   public static function mustRetainCapability(
     PhabricatorUser $user,
     PhabricatorPolicyInterface $object,
     $capability) {
 
     if (!self::hasCapability($user, $object, $capability)) {
       throw new Exception(
         "You can not make that edit, because it would remove your ability ".
         "to '{$capability}' the object.");
     }
   }
 
   public static function requireCapability(
     PhabricatorUser $user,
     PhabricatorPolicyInterface $object,
     $capability) {
     $filter = new PhabricatorPolicyFilter();
     $filter->setViewer($user);
     $filter->requireCapabilities(array($capability));
     $filter->raisePolicyExceptions(true);
     $filter->apply(array($object));
   }
 
   public static function hasCapability(
     PhabricatorUser $user,
     PhabricatorPolicyInterface $object,
     $capability) {
 
     $filter = new PhabricatorPolicyFilter();
     $filter->setViewer($user);
     $filter->requireCapabilities(array($capability));
     $result = $filter->apply(array($object));
 
     return (count($result) == 1);
   }
 
   public function setViewer(PhabricatorUser $user) {
     $this->viewer = $user;
     return $this;
   }
 
   public function requireCapabilities(array $capabilities) {
     $this->capabilities = $capabilities;
     return $this;
   }
 
   public function raisePolicyExceptions($raise) {
     $this->raisePolicyExceptions = $raise;
     return $this;
   }
 
   public function apply(array $objects) {
     assert_instances_of($objects, 'PhabricatorPolicyInterface');
 
     $viewer       = $this->viewer;
     $capabilities = $this->capabilities;
 
     if (!$viewer || !$capabilities) {
       throw new Exception(
         'Call setViewer() and requireCapabilities() before apply()!');
     }
 
     // If the viewer is omnipotent, short circuit all the checks and just
     // return the input unmodified. This is an optimization; we know the
     // result already.
     if ($viewer->isOmnipotent()) {
       return $objects;
     }
 
     $filtered = array();
     $viewer_phid = $viewer->getPHID();
 
     if (empty($this->userProjects[$viewer_phid])) {
       $this->userProjects[$viewer_phid] = array();
     }
 
     $need_projects = array();
     foreach ($objects as $key => $object) {
       $object_capabilities = $object->getCapabilities();
       foreach ($capabilities as $capability) {
         if (!in_array($capability, $object_capabilities)) {
           throw new Exception(
             "Testing for capability '{$capability}' on an object which does ".
             "not have that capability!");
         }
 
         $policy = $object->getPolicy($capability);
         $type = phid_get_type($policy);
         if ($type == PhabricatorProjectPHIDTypeProject::TYPECONST) {
           $need_projects[$policy] = $policy;
         }
       }
     }
 
     // If we need projects, check if any of the projects we need are also the
     // objects we're filtering. Because of how project rules work, this is a
     // common case.
     if ($need_projects) {
       foreach ($objects as $object) {
         if ($object instanceof PhabricatorProject) {
           $project_phid = $object->getPHID();
           if (isset($need_projects[$project_phid])) {
             $is_member = $object->isUserMember($viewer_phid);
             $this->userProjects[$viewer_phid][$project_phid] = $is_member;
             unset($need_projects[$project_phid]);
           }
         }
       }
     }
 
     if ($need_projects) {
       $need_projects = array_unique($need_projects);
 
       // NOTE: We're using the omnipotent user here to avoid a recursive
       // descent into madness. We don't actually need to know if the user can
       // see these projects or not, since: the check is "user is member of
       // project", not "user can see project"; and membership implies
       // visibility anyway. Without this, we may load other projects and
       // re-enter the policy filter and generally create a huge mess.
 
       $projects = id(new PhabricatorProjectQuery())
         ->setViewer(PhabricatorUser::getOmnipotentUser())
         ->withMemberPHIDs(array($viewer->getPHID()))
         ->withPHIDs($need_projects)
         ->execute();
 
       foreach ($projects as $project) {
         $this->userProjects[$viewer_phid][$project->getPHID()] = true;
       }
     }
 
     foreach ($objects as $key => $object) {
       $object_capabilities = $object->getCapabilities();
       foreach ($capabilities as $capability) {
         if (!$this->checkCapability($object, $capability)) {
           // If we're missing any capability, move on to the next object.
           continue 2;
         }
 
         // If we make it here, we have all of the required capabilities.
         $filtered[$key] = $object;
       }
     }
 
     return $filtered;
   }
 
   private function checkCapability(
     PhabricatorPolicyInterface $object,
     $capability) {
 
     $policy = $object->getPolicy($capability);
 
     if (!$policy) {
       // TODO: Formalize this somehow?
       $policy = PhabricatorPolicies::POLICY_USER;
     }
 
     if ($policy == PhabricatorPolicies::POLICY_PUBLIC) {
       // If the object is set to "public" but that policy is disabled for this
       // install, restrict the policy to "user".
       if (!PhabricatorEnv::getEnvConfig('policy.allow-public')) {
         $policy = PhabricatorPolicies::POLICY_USER;
       }
 
       // If the object is set to "public" but the capability is anything other
       // than "view", restrict the policy to "user".
       if ($capability != PhabricatorPolicyCapability::CAN_VIEW) {
         $policy = PhabricatorPolicies::POLICY_USER;
       }
     }
 
     $viewer = $this->viewer;
 
     if ($viewer->isOmnipotent()) {
       return true;
     }
 
     if ($object->hasAutomaticCapability($capability, $viewer)) {
       return true;
     }
 
     switch ($policy) {
       case PhabricatorPolicies::POLICY_PUBLIC:
         return true;
       case PhabricatorPolicies::POLICY_USER:
         if ($viewer->getPHID()) {
           return true;
         } else {
           $this->rejectObject($object, $policy, $capability);
         }
         break;
       case PhabricatorPolicies::POLICY_ADMIN:
         if ($viewer->getIsAdmin()) {
           return true;
         } else {
           $this->rejectObject($object, $policy, $capability);
         }
         break;
       case PhabricatorPolicies::POLICY_NOONE:
         $this->rejectObject($object, $policy, $capability);
         break;
       default:
         $type = phid_get_type($policy);
         if ($type == PhabricatorProjectPHIDTypeProject::TYPECONST) {
           if (!empty($this->userProjects[$viewer->getPHID()][$policy])) {
             return true;
           } else {
             $this->rejectObject($object, $policy, $capability);
           }
         } else if ($type == PhabricatorPeoplePHIDTypeUser::TYPECONST) {
           if ($viewer->getPHID() == $policy) {
             return true;
           } else {
             $this->rejectObject($object, $policy, $capability);
           }
         } else {
           // Reject objects with unknown policies.
           $this->rejectObject($object, false, $capability);
         }
     }
 
     return false;
   }
 
   private function rejectImpossiblePolicy(
     PhabricatorPolicyInterface $object,
     $policy,
     $capability) {
 
     if (!$this->raisePolicyExceptions) {
       return;
     }
 
     switch ($capability) {
       case PhabricatorPolicyCapability::CAN_VIEW:
         $message = pht("This object has an impossible view policy.");
         break;
       case PhabricatorPolicyCapability::CAN_EDIT:
         $message = pht("This object has an impossible edit policy.");
         break;
       case PhabricatorPolicyCapability::CAN_JOIN:
         $message = pht("This object has an impossible join policy.");
         break;
       default:
         $message = pht("This object has an impossible policy.");
         break;
     }
 
     throw new PhabricatorPolicyException($message);
   }
 
   public function rejectObject(
     PhabricatorPolicyInterface $object,
     $policy,
     $capability) {
 
     if (!$this->raisePolicyExceptions) {
       return;
     }
 
     $more = array();
     switch ($capability) {
       case PhabricatorPolicyCapability::CAN_VIEW:
         $message = pht(
           'This object exists, but you do not have permission to view it.');
         break;
       case PhabricatorPolicyCapability::CAN_EDIT:
         $message = pht('You do not have permission to edit this object.');
         break;
       case PhabricatorPolicyCapability::CAN_JOIN:
         $message = pht('You do not have permission to join this object.');
         break;
+      default:
+        // TODO: Farm these out to applications?
+        $message = pht(
+          'You do not have a required capability ("%s") to do whatever you '.
+          'are trying to do.',
+          $capability);
+        break;
     }
 
     switch ($policy) {
       case PhabricatorPolicies::POLICY_PUBLIC:
         // Presumably, this is a bug, so we don't bother specializing the
         // strings.
         $more = pht('This object is public.');
         break;
       case PhabricatorPolicies::POLICY_USER:
         // We always raise this as "log in", so we don't need to specialize.
         $more = pht('This object is available to logged in users.');
         break;
       case PhabricatorPolicies::POLICY_ADMIN:
         switch ($capability) {
           case PhabricatorPolicyCapability::CAN_VIEW:
             $more = pht('Administrators can view this object.');
             break;
           case PhabricatorPolicyCapability::CAN_EDIT:
             $more = pht('Administrators can edit this object.');
             break;
           case PhabricatorPolicyCapability::CAN_JOIN:
             $more = pht('Administrators can join this object.');
             break;
         }
         break;
       case PhabricatorPolicies::POLICY_NOONE:
         switch ($capability) {
           case PhabricatorPolicyCapability::CAN_VIEW:
             $more = pht('By default, no one can view this object.');
             break;
           case PhabricatorPolicyCapability::CAN_EDIT:
             $more = pht('By default, no one can edit this object.');
             break;
           case PhabricatorPolicyCapability::CAN_JOIN:
             $more = pht('By default, no one can join this object.');
             break;
         }
         break;
       default:
         $handle = id(new PhabricatorHandleQuery())
           ->setViewer($this->viewer)
           ->withPHIDs(array($policy))
           ->executeOne();
 
         $type = phid_get_type($policy);
         if ($type == PhabricatorProjectPHIDTypeProject::TYPECONST) {
           switch ($capability) {
             case PhabricatorPolicyCapability::CAN_VIEW:
               $more = pht(
                 'This object is visible to members of the project "%s".',
                 $handle->getFullName());
               break;
             case PhabricatorPolicyCapability::CAN_EDIT:
               $more = pht(
                 'This object can be edited by members of the project "%s".',
                 $handle->getFullName());
               break;
             case PhabricatorPolicyCapability::CAN_JOIN:
               $more = pht(
                 'This object can be joined by members of the project "%s".',
                 $handle->getFullName());
               break;
           }
         } else if ($type == PhabricatorPeoplePHIDTypeUser::TYPECONST) {
           switch ($capability) {
             case PhabricatorPolicyCapability::CAN_VIEW:
               $more = pht(
                 '%s can view this object.',
                 $handle->getFullName());
               break;
             case PhabricatorPolicyCapability::CAN_EDIT:
               $more = pht(
                 '%s can edit this object.',
                 $handle->getFullName());
               break;
             case PhabricatorPolicyCapability::CAN_JOIN:
               $more = pht(
                 '%s can join this object.',
                 $handle->getFullName());
               break;
           }
         } else {
           $more = pht("This object has an unknown or invalid policy setting.");
         }
         break;
     }
 
     $more = array_merge(
-      array($more),
+      array_filter(array($more)),
       array_filter((array)$object->describeAutomaticCapability($capability)));
 
     $exception = new PhabricatorPolicyException($message);
     $exception->setMoreInfo($more);
 
     throw $exception;
   }
 }