diff --git a/src/applications/remarkup/conduit/RemarkupProcessConduitAPIMethod.php b/src/applications/remarkup/conduit/RemarkupProcessConduitAPIMethod.php
index f9169cd08c..ae181f9860 100644
--- a/src/applications/remarkup/conduit/RemarkupProcessConduitAPIMethod.php
+++ b/src/applications/remarkup/conduit/RemarkupProcessConduitAPIMethod.php
@@ -1,76 +1,76 @@
 <?php
 
 final class RemarkupProcessConduitAPIMethod extends ConduitAPIMethod {
 
   public function getAPIMethodName() {
     return 'remarkup.process';
   }
 
   public function getMethodStatus() {
     return self::METHOD_STATUS_UNSTABLE;
   }
 
   public function getMethodDescription() {
-    return pht('Process text through remarkup in Phabricator context.');
+    return pht('Process text through remarkup.');
   }
 
   protected function defineReturnType() {
     return 'nonempty dict';
   }
 
   protected function defineErrorTypes() {
     return array(
       'ERR-NO-CONTENT' => pht('Content may not be empty.'),
       'ERR-INVALID-ENGINE' => pht('Invalid markup engine.'),
     );
   }
 
   protected function defineParamTypes() {
     $available_contexts = array_keys($this->getEngineContexts());
     $available_const = $this->formatStringConstants($available_contexts);
 
     return array(
       'context' => 'required '.$available_const,
       'contents' => 'required list<string>',
     );
   }
 
   protected function execute(ConduitAPIRequest $request) {
     $contents = $request->getValue('contents');
     $context = $request->getValue('context');
 
     $engine_class = idx($this->getEngineContexts(), $context);
     if (!$engine_class) {
       throw new ConduitException('ERR-INVALID_ENGINE');
     }
 
     $engine = PhabricatorMarkupEngine::$engine_class();
     $engine->setConfig('viewer', $request->getUser());
 
     $results = array();
     foreach ($contents as $content) {
       $text = $engine->markupText($content);
       if ($text) {
         $content = hsprintf('%s', $text)->getHTMLContent();
       } else {
         $content = '';
       }
       $results[] = array(
         'content' => $content,
       );
     }
     return $results;
   }
 
   private function getEngineContexts() {
     return array(
       'phriction' => 'newPhrictionMarkupEngine',
       'maniphest' => 'newManiphestMarkupEngine',
       'differential' => 'newDifferentialMarkupEngine',
       'phame' => 'newPhameMarkupEngine',
       'feed' => 'newFeedMarkupEngine',
       'diffusion' => 'newDiffusionMarkupEngine',
     );
   }
 
 }
diff --git a/src/applications/repository/engine/PhabricatorRepositoryMirrorEngine.php b/src/applications/repository/engine/PhabricatorRepositoryMirrorEngine.php
index ed856957f0..32689d3a77 100644
--- a/src/applications/repository/engine/PhabricatorRepositoryMirrorEngine.php
+++ b/src/applications/repository/engine/PhabricatorRepositoryMirrorEngine.php
@@ -1,133 +1,133 @@
 <?php
 
 /**
  * Pushes a repository to its mirrors.
  */
 final class PhabricatorRepositoryMirrorEngine
   extends PhabricatorRepositoryEngine {
 
   public function pushToMirrors() {
     $viewer = $this->getViewer();
     $repository = $this->getRepository();
 
     if (!$repository->canMirror()) {
       return;
     }
 
     if (PhabricatorEnv::getEnvConfig('phabricator.silent')) {
       $this->log(
-        pht('Phabricator is running in silent mode; declining to mirror.'));
+        pht('This software is running in silent mode; declining to mirror.'));
       return;
     }
 
     $uris = id(new PhabricatorRepositoryURIQuery())
       ->setViewer($viewer)
       ->withRepositories(array($repository))
       ->execute();
 
     $io_mirror = PhabricatorRepositoryURI::IO_MIRROR;
 
     $exceptions = array();
     foreach ($uris as $mirror) {
       if ($mirror->getIsDisabled()) {
         continue;
       }
 
       $io_type = $mirror->getEffectiveIOType();
       if ($io_type != $io_mirror) {
         continue;
       }
 
       try {
         $this->pushRepositoryToMirror($repository, $mirror);
       } catch (Exception $ex) {
         $exceptions[] = $ex;
       }
     }
 
     if ($exceptions) {
       throw new PhutilAggregateException(
         pht(
           'Exceptions occurred while mirroring the "%s" repository.',
           $repository->getDisplayName()),
         $exceptions);
     }
   }
 
   private function pushRepositoryToMirror(
     PhabricatorRepository $repository,
     PhabricatorRepositoryURI $mirror_uri) {
 
     $this->log(
       pht(
         'Pushing to remote "%s"...',
         $mirror_uri->getEffectiveURI()));
 
     if ($repository->isGit()) {
       $this->pushToGitRepository($repository, $mirror_uri);
     } else if ($repository->isHg()) {
       $this->pushToHgRepository($repository, $mirror_uri);
     } else {
       throw new Exception(pht('Unsupported VCS!'));
     }
   }
 
   private function pushToGitRepository(
     PhabricatorRepository $repository,
     PhabricatorRepositoryURI $mirror_uri) {
 
     // See T5965. Test if we have any refs to mirror. If we have nothing, git
     // will exit with an error ("No refs in common and none specified; ...")
     // when we run "git push --mirror".
 
     // If we don't have any refs, we just bail out. (This is arguably sort of
     // the wrong behavior: to mirror an empty repository faithfully we should
     // delete everything in the remote.)
 
     list($stdout) = $repository->execxLocalCommand(
       'for-each-ref --count 1 --');
     if (!strlen($stdout)) {
       return;
     }
 
     $argv = array(
       'push --verbose --mirror -- %P',
       $mirror_uri->getURIEnvelope(),
     );
 
     $future = $mirror_uri->newCommandEngine()
       ->setArgv($argv)
       ->newFuture();
 
     $future
       ->setCWD($repository->getLocalPath())
       ->resolvex();
   }
 
   private function pushToHgRepository(
     PhabricatorRepository $repository,
     PhabricatorRepositoryURI $mirror_uri) {
 
     $argv = array(
       'push --verbose --rev tip -- %P',
       $mirror_uri->getURIEnvelope(),
     );
 
     $future = $mirror_uri->newCommandEngine()
       ->setArgv($argv)
       ->newFuture();
 
     try {
       $future
         ->setCWD($repository->getLocalPath())
         ->resolvex();
     } catch (CommandException $ex) {
       if (preg_match('/no changes found/', $ex->getStdout())) {
         // mercurial says nothing changed, but that's good
       } else {
         throw $ex;
       }
     }
   }
 
 }
diff --git a/src/applications/repository/management/PhabricatorRepositoryManagementCacheWorkflow.php b/src/applications/repository/management/PhabricatorRepositoryManagementCacheWorkflow.php
index a78dff1a73..81955f36f3 100644
--- a/src/applications/repository/management/PhabricatorRepositoryManagementCacheWorkflow.php
+++ b/src/applications/repository/management/PhabricatorRepositoryManagementCacheWorkflow.php
@@ -1,94 +1,94 @@
 <?php
 
 final class PhabricatorRepositoryManagementCacheWorkflow
   extends PhabricatorRepositoryManagementWorkflow {
 
   protected function didConstruct() {
     $this
       ->setName('cache')
       ->setExamples(
         '**cache** [__options__] --commit __commit__ --path __path__')
       ->setSynopsis(pht('Manage the repository graph cache.'))
       ->setArguments(
         array(
           array(
             'name'    => 'commit',
             'param'   => 'commit',
             'help'    => pht('Specify a commit to look up.'),
           ),
           array(
             'name'    => 'path',
             'param'   => 'path',
             'help'    => pht('Specify a path to look up.'),
           ),
         ));
   }
 
   public function execute(PhutilArgumentParser $args) {
 
     $commit_name = $args->getArg('commit');
     if ($commit_name === null) {
       throw new PhutilArgumentUsageException(
         pht(
           'Specify a commit to look up with `%s`.',
           '--commit'));
     }
     $commit = $this->loadNamedCommit($commit_name);
 
     $path_name = $args->getArg('path');
     if ($path_name === null) {
       throw new PhutilArgumentUsageException(
         pht(
           'Specify a path to look up with `%s`.',
           '--path'));
     }
 
     $path_map = id(new DiffusionPathIDQuery(array($path_name)))
       ->loadPathIDs();
     if (empty($path_map[$path_name])) {
       throw new PhutilArgumentUsageException(
-        pht('Path "%s" is not known to Phabricator.', $path_name));
+        pht('Path "%s" is not unknown.', $path_name));
     }
     $path_id = $path_map[$path_name];
 
     $graph_cache = new PhabricatorRepositoryGraphCache();
 
     $t_start = microtime(true);
     $cache_result = $graph_cache->loadLastModifiedCommitID(
       $commit->getID(),
       $path_id);
     $t_end = microtime(true);
 
     $console = PhutilConsole::getConsole();
 
     $console->writeOut(
       "%s\n",
       pht('Query took %s ms.', new PhutilNumber(1000 * ($t_end - $t_start))));
 
     if ($cache_result === false) {
       $console->writeOut("%s\n", pht('Not found in graph cache.'));
     } else if ($cache_result === null) {
       $console->writeOut(
         "%s\n",
         pht('Path not modified in any ancestor commit.'));
     } else {
       $last = id(new DiffusionCommitQuery())
         ->setViewer($this->getViewer())
         ->withIDs(array($cache_result))
         ->executeOne();
       if (!$last) {
         throw new Exception(pht('Cache returned bogus result!'));
       }
 
       $console->writeOut(
         "%s\n",
         pht(
           'Path was last changed at %s.',
           $commit->getRepository()->formatCommitName(
             $last->getcommitIdentifier())));
     }
 
     return 0;
   }
 
 }
diff --git a/src/applications/repository/storage/PhabricatorRepository.php b/src/applications/repository/storage/PhabricatorRepository.php
index 66242f8d15..8f02dd664f 100644
--- a/src/applications/repository/storage/PhabricatorRepository.php
+++ b/src/applications/repository/storage/PhabricatorRepository.php
@@ -1,2882 +1,2883 @@
 <?php
 
 /**
  * @task uri        Repository URI Management
  * @task publishing Publishing
  * @task sync       Cluster Synchronization
  */
 final class PhabricatorRepository extends PhabricatorRepositoryDAO
   implements
     PhabricatorApplicationTransactionInterface,
     PhabricatorPolicyInterface,
     PhabricatorFlaggableInterface,
     PhabricatorMarkupInterface,
     PhabricatorDestructibleInterface,
     PhabricatorDestructibleCodexInterface,
     PhabricatorProjectInterface,
     PhabricatorSpacesInterface,
     PhabricatorConduitResultInterface,
     PhabricatorFulltextInterface,
     PhabricatorFerretInterface {
 
   /**
    * Shortest hash we'll recognize in raw "a829f32" form.
    */
   const MINIMUM_UNQUALIFIED_HASH = 7;
 
   /**
    * Shortest hash we'll recognize in qualified "rXab7ef2f8" form.
    */
   const MINIMUM_QUALIFIED_HASH = 5;
 
   /**
    * Minimum number of commits to an empty repository to trigger "import" mode.
    */
   const IMPORT_THRESHOLD = 7;
 
   const LOWPRI_THRESHOLD = 64;
 
   const TABLE_PATH = 'repository_path';
   const TABLE_PATHCHANGE = 'repository_pathchange';
   const TABLE_FILESYSTEM = 'repository_filesystem';
   const TABLE_SUMMARY = 'repository_summary';
   const TABLE_LINTMESSAGE = 'repository_lintmessage';
   const TABLE_PARENTS = 'repository_parents';
   const TABLE_COVERAGE = 'repository_coverage';
 
   const STATUS_ACTIVE = 'active';
   const STATUS_INACTIVE = 'inactive';
 
   protected $name;
   protected $callsign;
   protected $repositorySlug;
   protected $uuid;
   protected $viewPolicy;
   protected $editPolicy;
   protected $pushPolicy;
   protected $profileImagePHID;
 
   protected $versionControlSystem;
   protected $details = array();
   protected $credentialPHID;
   protected $almanacServicePHID;
   protected $spacePHID;
   protected $localPath;
 
   private $commitCount = self::ATTACHABLE;
   private $mostRecentCommit = self::ATTACHABLE;
   private $projectPHIDs = self::ATTACHABLE;
   private $uris = self::ATTACHABLE;
   private $profileImageFile = self::ATTACHABLE;
 
 
   public static function initializeNewRepository(PhabricatorUser $actor) {
     $app = id(new PhabricatorApplicationQuery())
       ->setViewer($actor)
       ->withClasses(array('PhabricatorDiffusionApplication'))
       ->executeOne();
 
     $view_policy = $app->getPolicy(DiffusionDefaultViewCapability::CAPABILITY);
     $edit_policy = $app->getPolicy(DiffusionDefaultEditCapability::CAPABILITY);
     $push_policy = $app->getPolicy(DiffusionDefaultPushCapability::CAPABILITY);
 
     $repository = id(new PhabricatorRepository())
       ->setViewPolicy($view_policy)
       ->setEditPolicy($edit_policy)
       ->setPushPolicy($push_policy)
       ->setSpacePHID($actor->getDefaultSpacePHID());
 
     // Put the repository in "Importing" mode until we finish
     // parsing it.
     $repository->setDetail('importing', true);
 
     return $repository;
   }
 
   protected function getConfiguration() {
     return array(
       self::CONFIG_AUX_PHID => true,
       self::CONFIG_SERIALIZATION => array(
         'details' => self::SERIALIZATION_JSON,
       ),
       self::CONFIG_COLUMN_SCHEMA => array(
         'name' => 'sort255',
         'callsign' => 'sort32?',
         'repositorySlug' => 'sort64?',
         'versionControlSystem' => 'text32',
         'uuid' => 'text64?',
         'pushPolicy' => 'policy',
         'credentialPHID' => 'phid?',
         'almanacServicePHID' => 'phid?',
         'localPath' => 'text128?',
         'profileImagePHID' => 'phid?',
       ),
       self::CONFIG_KEY_SCHEMA => array(
         'callsign' => array(
           'columns' => array('callsign'),
           'unique' => true,
         ),
         'key_name' => array(
           'columns' => array('name(128)'),
         ),
         'key_vcs' => array(
           'columns' => array('versionControlSystem'),
         ),
         'key_slug' => array(
           'columns' => array('repositorySlug'),
           'unique' => true,
         ),
         'key_local' => array(
           'columns' => array('localPath'),
           'unique' => true,
         ),
       ),
     ) + parent::getConfiguration();
   }
 
   public function generatePHID() {
     return PhabricatorPHID::generateNewPHID(
       PhabricatorRepositoryRepositoryPHIDType::TYPECONST);
   }
 
   public static function getStatusMap() {
     return array(
       self::STATUS_ACTIVE => array(
         'name' => pht('Active'),
         'isTracked' => 1,
       ),
       self::STATUS_INACTIVE => array(
         'name' => pht('Inactive'),
         'isTracked' => 0,
       ),
     );
   }
 
   public static function getStatusNameMap() {
     return ipull(self::getStatusMap(), 'name');
   }
 
   public function getStatus() {
     if ($this->isTracked()) {
       return self::STATUS_ACTIVE;
     } else {
       return self::STATUS_INACTIVE;
     }
   }
 
   public function toDictionary() {
     return array(
       'id'          => $this->getID(),
       'name'        => $this->getName(),
       'phid'        => $this->getPHID(),
       'callsign'    => $this->getCallsign(),
       'monogram'    => $this->getMonogram(),
       'vcs'         => $this->getVersionControlSystem(),
       'uri'         => PhabricatorEnv::getProductionURI($this->getURI()),
       'remoteURI'   => (string)$this->getRemoteURI(),
       'description' => $this->getDetail('description'),
       'isActive'    => $this->isTracked(),
       'isHosted'    => $this->isHosted(),
       'isImporting' => $this->isImporting(),
       'encoding'    => $this->getDefaultTextEncoding(),
       'staging' => array(
         'supported' => $this->supportsStaging(),
         'prefix' => 'phabricator',
         'uri' => $this->getStagingURI(),
       ),
     );
   }
 
   public function getDefaultTextEncoding() {
     return $this->getDetail('encoding', 'UTF-8');
   }
 
   public function getMonogram() {
     $callsign = $this->getCallsign();
     if (strlen($callsign)) {
       return "r{$callsign}";
     }
 
     $id = $this->getID();
     return "R{$id}";
   }
 
   public function getDisplayName() {
     $slug = $this->getRepositorySlug();
-    if (strlen($slug)) {
+
+    if (phutil_nonempty_string($slug)) {
       return $slug;
     }
 
     return $this->getMonogram();
   }
 
   public function getAllMonograms() {
     $monograms = array();
 
     $monograms[] = 'R'.$this->getID();
 
     $callsign = $this->getCallsign();
     if (strlen($callsign)) {
       $monograms[] = 'r'.$callsign;
     }
 
     return $monograms;
   }
 
   public function setLocalPath($path) {
     // Convert any extra slashes ("//") in the path to a single slash ("/").
     $path = preg_replace('(//+)', '/', $path);
 
     return parent::setLocalPath($path);
   }
 
   public function getDetail($key, $default = null) {
     return idx($this->details, $key, $default);
   }
 
   public function setDetail($key, $value) {
     $this->details[$key] = $value;
     return $this;
   }
 
   public function attachCommitCount($count) {
     $this->commitCount = $count;
     return $this;
   }
 
   public function getCommitCount() {
     return $this->assertAttached($this->commitCount);
   }
 
   public function attachMostRecentCommit(
     PhabricatorRepositoryCommit $commit = null) {
     $this->mostRecentCommit = $commit;
     return $this;
   }
 
   public function getMostRecentCommit() {
     return $this->assertAttached($this->mostRecentCommit);
   }
 
   public function getDiffusionBrowseURIForPath(
     PhabricatorUser $user,
     $path,
     $line = null,
     $branch = null) {
 
     $drequest = DiffusionRequest::newFromDictionary(
       array(
         'user' => $user,
         'repository' => $this,
         'path' => $path,
         'branch' => $branch,
       ));
 
     return $drequest->generateURI(
       array(
         'action' => 'browse',
         'line'   => $line,
       ));
   }
 
   public function getSubversionBaseURI($commit = null) {
     $subpath = $this->getDetail('svn-subpath');
 
     if (!phutil_nonempty_string($subpath)) {
       $subpath = null;
     }
 
     return $this->getSubversionPathURI($subpath, $commit);
   }
 
   public function getSubversionPathURI($path = null, $commit = null) {
     $vcs = $this->getVersionControlSystem();
     if ($vcs != PhabricatorRepositoryType::REPOSITORY_TYPE_SVN) {
       throw new Exception(pht('Not a subversion repository!'));
     }
 
     if ($this->isHosted()) {
       $uri = 'file://'.$this->getLocalPath();
     } else {
       $uri = $this->getDetail('remote-uri');
     }
 
     $uri = rtrim($uri, '/');
 
     if (phutil_nonempty_string($path)) {
       $path = rawurlencode($path);
       $path = str_replace('%2F', '/', $path);
       $uri = $uri.'/'.ltrim($path, '/');
     }
 
     if ($path !== null || $commit !== null) {
       $uri .= '@';
     }
 
     if ($commit !== null) {
       $uri .= $commit;
     }
 
     return $uri;
   }
 
   public function attachProjectPHIDs(array $project_phids) {
     $this->projectPHIDs = $project_phids;
     return $this;
   }
 
   public function getProjectPHIDs() {
     return $this->assertAttached($this->projectPHIDs);
   }
 
 
   /**
    * Get the name of the directory this repository should clone or checkout
    * into. For example, if the repository name is "Example Repository", a
    * reasonable name might be "example-repository". This is used to help users
    * get reasonable results when cloning repositories, since they generally do
    * not want to clone into directories called "X/" or "Example Repository/".
    *
    * @return string
    */
   public function getCloneName() {
     $name = $this->getRepositorySlug();
 
     // Make some reasonable effort to produce reasonable default directory
     // names from repository names.
     if (!strlen($name)) {
       $name = $this->getName();
       $name = phutil_utf8_strtolower($name);
       $name = preg_replace('@[ -/:->]+@', '-', $name);
       $name = trim($name, '-');
       if (!strlen($name)) {
         $name = $this->getCallsign();
       }
     }
 
     return $name;
   }
 
   public static function isValidRepositorySlug($slug) {
     try {
       self::assertValidRepositorySlug($slug);
       return true;
     } catch (Exception $ex) {
       return false;
     }
   }
 
   public static function assertValidRepositorySlug($slug) {
     if (!strlen($slug)) {
       throw new Exception(
         pht(
           'The empty string is not a valid repository short name. '.
           'Repository short names must be at least one character long.'));
     }
 
     if (strlen($slug) > 64) {
       throw new Exception(
         pht(
           'The name "%s" is not a valid repository short name. Repository '.
           'short names must not be longer than 64 characters.',
           $slug));
     }
 
     if (preg_match('/[^a-zA-Z0-9._-]/', $slug)) {
       throw new Exception(
         pht(
           'The name "%s" is not a valid repository short name. Repository '.
           'short names may only contain letters, numbers, periods, hyphens '.
           'and underscores.',
           $slug));
     }
 
     if (!preg_match('/^[a-zA-Z0-9]/', $slug)) {
       throw new Exception(
         pht(
           'The name "%s" is not a valid repository short name. Repository '.
           'short names must begin with a letter or number.',
           $slug));
     }
 
     if (!preg_match('/[a-zA-Z0-9]\z/', $slug)) {
       throw new Exception(
         pht(
           'The name "%s" is not a valid repository short name. Repository '.
           'short names must end with a letter or number.',
           $slug));
     }
 
     if (preg_match('/__|--|\\.\\./', $slug)) {
       throw new Exception(
         pht(
           'The name "%s" is not a valid repository short name. Repository '.
           'short names must not contain multiple consecutive underscores, '.
           'hyphens, or periods.',
           $slug));
     }
 
     if (preg_match('/^[A-Z]+\z/', $slug)) {
       throw new Exception(
         pht(
           'The name "%s" is not a valid repository short name. Repository '.
           'short names may not contain only uppercase letters.',
           $slug));
     }
 
     if (preg_match('/^\d+\z/', $slug)) {
       throw new Exception(
         pht(
           'The name "%s" is not a valid repository short name. Repository '.
           'short names may not contain only numbers.',
           $slug));
     }
 
     if (preg_match('/\\.git/', $slug)) {
       throw new Exception(
         pht(
           'The name "%s" is not a valid repository short name. Repository '.
           'short names must not end in ".git". This suffix will be added '.
           'automatically in appropriate contexts.',
           $slug));
     }
   }
 
   public static function assertValidCallsign($callsign) {
     if (!strlen($callsign)) {
       throw new Exception(
         pht(
           'A repository callsign must be at least one character long.'));
     }
 
     if (strlen($callsign) > 32) {
       throw new Exception(
         pht(
           'The callsign "%s" is not a valid repository callsign. Callsigns '.
           'must be no more than 32 bytes long.',
           $callsign));
     }
 
     if (!preg_match('/^[A-Z]+\z/', $callsign)) {
       throw new Exception(
         pht(
           'The callsign "%s" is not a valid repository callsign. Callsigns '.
           'may only contain UPPERCASE letters.',
           $callsign));
     }
   }
 
   public function getProfileImageURI() {
     return $this->getProfileImageFile()->getBestURI();
   }
 
   public function attachProfileImageFile(PhabricatorFile $file) {
     $this->profileImageFile = $file;
     return $this;
   }
 
   public function getProfileImageFile() {
     return $this->assertAttached($this->profileImageFile);
   }
 
 
 
 /* -(  Remote Command Execution  )------------------------------------------- */
 
 
   public function execRemoteCommand($pattern /* , $arg, ... */) {
     $args = func_get_args();
     return $this->newRemoteCommandFuture($args)->resolve();
   }
 
   public function execxRemoteCommand($pattern /* , $arg, ... */) {
     $args = func_get_args();
     return $this->newRemoteCommandFuture($args)->resolvex();
   }
 
   public function getRemoteCommandFuture($pattern /* , $arg, ... */) {
     $args = func_get_args();
     return $this->newRemoteCommandFuture($args);
   }
 
   public function passthruRemoteCommand($pattern /* , $arg, ... */) {
     $args = func_get_args();
     return $this->newRemoteCommandPassthru($args)->resolve();
   }
 
   private function newRemoteCommandFuture(array $argv) {
     return $this->newRemoteCommandEngine($argv)
       ->newFuture();
   }
 
   private function newRemoteCommandPassthru(array $argv) {
     return $this->newRemoteCommandEngine($argv)
       ->setPassthru(true)
       ->newFuture();
   }
 
   private function newRemoteCommandEngine(array $argv) {
     return DiffusionCommandEngine::newCommandEngine($this)
       ->setArgv($argv)
       ->setCredentialPHID($this->getCredentialPHID())
       ->setURI($this->getRemoteURIObject());
   }
 
 /* -(  Local Command Execution  )-------------------------------------------- */
 
 
   public function execLocalCommand($pattern /* , $arg, ... */) {
     $args = func_get_args();
     return $this->newLocalCommandFuture($args)->resolve();
   }
 
   public function execxLocalCommand($pattern /* , $arg, ... */) {
     $args = func_get_args();
     return $this->newLocalCommandFuture($args)->resolvex();
   }
 
   public function getLocalCommandFuture($pattern /* , $arg, ... */) {
     $args = func_get_args();
     return $this->newLocalCommandFuture($args);
   }
 
   public function passthruLocalCommand($pattern /* , $arg, ... */) {
     $args = func_get_args();
     return $this->newLocalCommandPassthru($args)->resolve();
   }
 
   private function newLocalCommandFuture(array $argv) {
     $this->assertLocalExists();
 
     $future = DiffusionCommandEngine::newCommandEngine($this)
       ->setArgv($argv)
       ->newFuture();
 
     if ($this->usesLocalWorkingCopy()) {
       $future->setCWD($this->getLocalPath());
     }
 
     return $future;
   }
 
   private function newLocalCommandPassthru(array $argv) {
     $this->assertLocalExists();
 
     $future = DiffusionCommandEngine::newCommandEngine($this)
       ->setArgv($argv)
       ->setPassthru(true)
       ->newFuture();
 
     if ($this->usesLocalWorkingCopy()) {
       $future->setCWD($this->getLocalPath());
     }
 
     return $future;
   }
 
   public function getURI() {
     $short_name = $this->getRepositorySlug();
     if (phutil_nonempty_string($short_name)) {
       return "/source/{$short_name}/";
     }
 
     $callsign = $this->getCallsign();
     if (phutil_nonempty_string($callsign)) {
       return "/diffusion/{$callsign}/";
     }
 
     $id = $this->getID();
     return "/diffusion/{$id}/";
   }
 
   public function getPathURI($path) {
     return $this->getURI().ltrim($path, '/');
   }
 
   public function getCommitURI($identifier) {
     $callsign = $this->getCallsign();
     if (phutil_nonempty_string($callsign)) {
       return "/r{$callsign}{$identifier}";
     }
 
     $id = $this->getID();
     return "/R{$id}:{$identifier}";
   }
 
   public static function parseRepositoryServicePath($request_path, $vcs) {
     $is_git = ($vcs == PhabricatorRepositoryType::REPOSITORY_TYPE_GIT);
 
     $patterns = array(
       '(^'.
         '(?P<base>/?(?:diffusion|source)/(?P<identifier>[^/]+))'.
         '(?P<path>.*)'.
       '\z)',
     );
 
     $identifier = null;
     foreach ($patterns as $pattern) {
       $matches = null;
       if (!preg_match($pattern, $request_path, $matches)) {
         continue;
       }
 
       $identifier = $matches['identifier'];
       if ($is_git) {
         $identifier = preg_replace('/\\.git\z/', '', $identifier);
       }
 
       $base = $matches['base'];
       $path = $matches['path'];
       break;
     }
 
     if ($identifier === null) {
       return null;
     }
 
     return array(
       'identifier' => $identifier,
       'base' => $base,
       'path' => $path,
     );
   }
 
   public function getCanonicalPath($request_path) {
     $standard_pattern =
       '(^'.
         '(?P<prefix>/(?:diffusion|source)/)'.
         '(?P<identifier>[^/]+)'.
         '(?P<suffix>(?:/.*)?)'.
       '\z)';
 
     $matches = null;
     if (preg_match($standard_pattern, $request_path, $matches)) {
       $suffix = $matches['suffix'];
       return $this->getPathURI($suffix);
     }
 
     $commit_pattern =
       '(^'.
         '(?P<prefix>/)'.
         '(?P<monogram>'.
           '(?:'.
             'r(?P<repositoryCallsign>[A-Z]+)'.
             '|'.
             'R(?P<repositoryID>[1-9]\d*):'.
           ')'.
           '(?P<commit>[a-f0-9]+)'.
         ')'.
       '\z)';
 
     $matches = null;
     if (preg_match($commit_pattern, $request_path, $matches)) {
       $commit = $matches['commit'];
       return $this->getCommitURI($commit);
     }
 
     return null;
   }
 
   public function generateURI(array $params) {
     $req_branch = false;
     $req_commit = false;
 
     $action = idx($params, 'action');
     switch ($action) {
       case 'history':
       case 'clone':
       case 'blame':
       case 'browse':
       case 'document':
       case 'change':
       case 'lastmodified':
       case 'tags':
       case 'branches':
       case 'lint':
       case 'pathtree':
       case 'refs':
       case 'compare':
         break;
       case 'branch':
         // NOTE: This does not actually require a branch, and won't have one
         // in Subversion. Possibly this should be more clear.
         break;
       case 'commit':
       case 'rendering-ref':
         $req_commit = true;
         break;
       default:
         throw new Exception(
           pht(
             'Action "%s" is not a valid repository URI action.',
             $action));
     }
 
     $path     = idx($params, 'path');
     $branch   = idx($params, 'branch');
     $commit   = idx($params, 'commit');
     $line     = idx($params, 'line');
 
     $head = idx($params, 'head');
     $against = idx($params, 'against');
 
     if ($req_commit && !strlen($commit)) {
       throw new Exception(
         pht(
           'Diffusion URI action "%s" requires commit!',
           $action));
     }
 
     if ($req_branch && !strlen($branch)) {
       throw new Exception(
         pht(
           'Diffusion URI action "%s" requires branch!',
           $action));
     }
 
     if ($action === 'commit') {
       return $this->getCommitURI($commit);
     }
 
     if (phutil_nonempty_string($path)) {
       $path = ltrim($path, '/');
       $path = str_replace(array(';', '$'), array(';;', '$$'), $path);
       $path = phutil_escape_uri($path);
     }
 
     $raw_branch = $branch;
     if (phutil_nonempty_string($branch)) {
       $branch = phutil_escape_uri_path_component($branch);
       $path = "{$branch}/{$path}";
     }
 
     $raw_commit = $commit;
     if (phutil_nonempty_string($commit)) {
       $commit = str_replace('$', '$$', $commit);
       $commit = ';'.phutil_escape_uri($commit);
     }
 
     if (phutil_nonempty_string($line)) {
       $line = '$'.phutil_escape_uri($line);
     }
 
     $query = array();
     switch ($action) {
       case 'change':
       case 'history':
       case 'blame':
       case 'browse':
       case 'document':
       case 'lastmodified':
       case 'tags':
       case 'branches':
       case 'lint':
       case 'pathtree':
       case 'refs':
         $uri = $this->getPathURI("/{$action}/{$path}{$commit}{$line}");
         break;
       case 'compare':
         $uri = $this->getPathURI("/{$action}/");
         if (strlen($head)) {
           $query['head'] = $head;
         } else if (strlen($raw_commit)) {
           $query['commit'] = $raw_commit;
         } else if (strlen($raw_branch)) {
           $query['head'] = $raw_branch;
         }
 
         if (strlen($against)) {
           $query['against'] = $against;
         }
         break;
       case 'branch':
         if (strlen($path)) {
           $uri = $this->getPathURI("/repository/{$path}");
         } else {
           $uri = $this->getPathURI('/');
         }
         break;
       case 'external':
         $commit = ltrim($commit, ';');
         $uri = "/diffusion/external/{$commit}/";
         break;
       case 'rendering-ref':
         // This isn't a real URI per se, it's passed as a query parameter to
         // the ajax changeset stuff but then we parse it back out as though
         // it came from a URI.
         $uri = rawurldecode("{$path}{$commit}");
         break;
       case 'clone':
         $uri = $this->getPathURI("/{$action}/");
       break;
     }
 
     if ($action == 'rendering-ref') {
       return $uri;
     }
 
     if (isset($params['lint'])) {
       $params['params'] = idx($params, 'params', array()) + array(
         'lint' => $params['lint'],
       );
     }
 
     $query = idx($params, 'params', array()) + $query;
 
     return new PhutilURI($uri, $query);
   }
 
   public function updateURIIndex() {
     $indexes = array();
 
     $uris = $this->getURIs();
     foreach ($uris as $uri) {
       if ($uri->getIsDisabled()) {
         continue;
       }
 
       $indexes[] = $uri->getNormalizedURI();
     }
 
     PhabricatorRepositoryURIIndex::updateRepositoryURIs(
       $this->getPHID(),
       $indexes);
 
     return $this;
   }
 
   public function isTracked() {
     $status = $this->getDetail('tracking-enabled');
     $map = self::getStatusMap();
     $spec = idx($map, $status);
 
     if (!$spec) {
       if ($status) {
         $status = self::STATUS_ACTIVE;
       } else {
         $status = self::STATUS_INACTIVE;
       }
       $spec = idx($map, $status);
     }
 
     return (bool)idx($spec, 'isTracked', false);
   }
 
   public function getDefaultBranch() {
     $default = $this->getDetail('default-branch');
     if (phutil_nonempty_string($default)) {
       return $default;
     }
 
     $default_branches = array(
       PhabricatorRepositoryType::REPOSITORY_TYPE_GIT        => 'master',
       PhabricatorRepositoryType::REPOSITORY_TYPE_MERCURIAL  => 'default',
     );
 
     return idx($default_branches, $this->getVersionControlSystem());
   }
 
   public function getDefaultArcanistBranch() {
     return coalesce($this->getDefaultBranch(), 'svn');
   }
 
   private function isBranchInFilter($branch, $filter_key) {
     $vcs = $this->getVersionControlSystem();
 
     $is_git = ($vcs == PhabricatorRepositoryType::REPOSITORY_TYPE_GIT);
 
     $use_filter = ($is_git);
     if (!$use_filter) {
       // If this VCS doesn't use filters, pass everything through.
       return true;
     }
 
 
     $filter = $this->getDetail($filter_key, array());
 
     // If there's no filter set, let everything through.
     if (!$filter) {
       return true;
     }
 
     // If this branch isn't literally named `regexp(...)`, and it's in the
     // filter list, let it through.
     if (isset($filter[$branch])) {
       if (self::extractBranchRegexp($branch) === null) {
         return true;
       }
     }
 
     // If the branch matches a regexp, let it through.
     foreach ($filter as $pattern => $ignored) {
       $regexp = self::extractBranchRegexp($pattern);
       if ($regexp !== null) {
         if (preg_match($regexp, $branch)) {
           return true;
         }
       }
     }
 
     // Nothing matched, so filter this branch out.
     return false;
   }
 
   public static function extractBranchRegexp($pattern) {
     $matches = null;
     if (preg_match('/^regexp\\((.*)\\)\z/', $pattern, $matches)) {
       return $matches[1];
     }
     return null;
   }
 
   public function shouldTrackRef(DiffusionRepositoryRef $ref) {
     // At least for now, don't track the staging area tags.
     if ($ref->isTag()) {
       if (preg_match('(^phabricator/)', $ref->getShortName())) {
         return false;
       }
     }
 
     if (!$ref->isBranch()) {
       return true;
     }
 
     return $this->shouldTrackBranch($ref->getShortName());
   }
 
   public function shouldTrackBranch($branch) {
     return $this->isBranchInFilter($branch, 'branch-filter');
   }
 
   public function isBranchPermanentRef($branch) {
     return $this->isBranchInFilter($branch, 'close-commits-filter');
   }
 
   public function formatCommitName($commit_identifier, $local = false) {
     $vcs = $this->getVersionControlSystem();
 
     $type_git = PhabricatorRepositoryType::REPOSITORY_TYPE_GIT;
     $type_hg = PhabricatorRepositoryType::REPOSITORY_TYPE_MERCURIAL;
 
     $is_git = ($vcs == $type_git);
     $is_hg = ($vcs == $type_hg);
     if ($is_git || $is_hg) {
       $name = substr($commit_identifier, 0, 12);
       $need_scope = false;
     } else {
       $name = $commit_identifier;
       $need_scope = true;
     }
 
     if (!$local) {
       $need_scope = true;
     }
 
     if ($need_scope) {
       $callsign = $this->getCallsign();
       if ($callsign) {
         $scope = "r{$callsign}";
       } else {
         $id = $this->getID();
         $scope = "R{$id}:";
       }
       $name = $scope.$name;
     }
 
     return $name;
   }
 
   public function isImporting() {
     return (bool)$this->getDetail('importing', false);
   }
 
   public function isNewlyInitialized() {
     return (bool)$this->getDetail('newly-initialized', false);
   }
 
   public function loadImportProgress() {
     $progress = queryfx_all(
       $this->establishConnection('r'),
       'SELECT importStatus, count(*) N FROM %T WHERE repositoryID = %d
         GROUP BY importStatus',
       id(new PhabricatorRepositoryCommit())->getTableName(),
       $this->getID());
 
     $done = 0;
     $total = 0;
     foreach ($progress as $row) {
       $total += $row['N'] * 3;
       $status = $row['importStatus'];
       if ($status & PhabricatorRepositoryCommit::IMPORTED_MESSAGE) {
         $done += $row['N'];
       }
       if ($status & PhabricatorRepositoryCommit::IMPORTED_CHANGE) {
         $done += $row['N'];
       }
       if ($status & PhabricatorRepositoryCommit::IMPORTED_PUBLISH) {
         $done += $row['N'];
       }
     }
 
     if ($total) {
       $ratio = ($done / $total);
     } else {
       $ratio = 0;
     }
 
     // Cap this at "99.99%", because it's confusing to users when the actual
     // fraction is "99.996%" and it rounds up to "100.00%".
     if ($ratio > 0.9999) {
       $ratio = 0.9999;
     }
 
     return $ratio;
   }
 
 /* -(  Publishing  )--------------------------------------------------------- */
 
   public function newPublisher() {
     return id(new PhabricatorRepositoryPublisher())
       ->setRepository($this);
   }
 
   public function isPublishingDisabled() {
     return $this->getDetail('herald-disabled');
   }
 
   public function getPermanentRefRules() {
     return array_keys($this->getDetail('close-commits-filter', array()));
   }
 
   public function setPermanentRefRules(array $rules) {
     $rules = array_fill_keys($rules, true);
     $this->setDetail('close-commits-filter', $rules);
     return $this;
   }
 
   public function getTrackOnlyRules() {
     return array_keys($this->getDetail('branch-filter', array()));
   }
 
   public function setTrackOnlyRules(array $rules) {
     $rules = array_fill_keys($rules, true);
     $this->setDetail('branch-filter', $rules);
     return $this;
   }
 
   public function supportsFetchRules() {
     if ($this->isGit()) {
       return true;
     }
 
     return false;
   }
 
   public function getFetchRules() {
     return $this->getDetail('fetch-rules', array());
   }
 
   public function setFetchRules(array $rules) {
     return $this->setDetail('fetch-rules', $rules);
   }
 
 
 /* -(  Repository URI Management  )------------------------------------------ */
 
 
   /**
    * Get the remote URI for this repository.
    *
    * @return string
    * @task uri
    */
   public function getRemoteURI() {
     return (string)$this->getRemoteURIObject();
   }
 
 
   /**
    * Get the remote URI for this repository, including credentials if they're
    * used by this repository.
    *
    * @return PhutilOpaqueEnvelope URI, possibly including credentials.
    * @task uri
    */
   public function getRemoteURIEnvelope() {
     $uri = $this->getRemoteURIObject();
 
     $remote_protocol = $this->getRemoteProtocol();
     if ($remote_protocol == 'http' || $remote_protocol == 'https') {
       // For SVN, we use `--username` and `--password` flags separately, so
       // don't add any credentials here.
       if (!$this->isSVN()) {
         $credential_phid = $this->getCredentialPHID();
         if ($credential_phid) {
           $key = PassphrasePasswordKey::loadFromPHID(
             $credential_phid,
             PhabricatorUser::getOmnipotentUser());
 
           $uri->setUser($key->getUsernameEnvelope()->openEnvelope());
           $uri->setPass($key->getPasswordEnvelope()->openEnvelope());
         }
       }
     }
 
     return new PhutilOpaqueEnvelope((string)$uri);
   }
 
 
   /**
    * Get the clone (or checkout) URI for this repository, without authentication
    * information.
    *
    * @return string Repository URI.
    * @task uri
    */
   public function getPublicCloneURI() {
     return (string)$this->getCloneURIObject();
   }
 
 
   /**
    * Get the protocol for the repository's remote.
    *
    * @return string Protocol, like "ssh" or "git".
    * @task uri
    */
   public function getRemoteProtocol() {
     $uri = $this->getRemoteURIObject();
     return $uri->getProtocol();
   }
 
 
   /**
    * Get a parsed object representation of the repository's remote URI..
    *
    * @return wild A @{class@arcanist:PhutilURI}.
    * @task uri
    */
   public function getRemoteURIObject() {
     $raw_uri = $this->getDetail('remote-uri');
     if (!strlen($raw_uri)) {
       return new PhutilURI('');
     }
 
     if (!strncmp($raw_uri, '/', 1)) {
       return new PhutilURI('file://'.$raw_uri);
     }
 
     return new PhutilURI($raw_uri);
   }
 
 
   /**
    * Get the "best" clone/checkout URI for this repository, on any protocol.
    */
   public function getCloneURIObject() {
     if (!$this->isHosted()) {
       if ($this->isSVN()) {
         // Make sure we pick up the "Import Only" path for Subversion, so
         // the user clones the repository starting at the correct path, not
         // from the root.
         $base_uri = $this->getSubversionBaseURI();
         $base_uri = new PhutilURI($base_uri);
         $path = $base_uri->getPath();
         if (!$path) {
           $path = '/';
         }
 
         // If the trailing "@" is not required to escape the URI, strip it for
         // readability.
         if (!preg_match('/@.*@/', $path)) {
           $path = rtrim($path, '@');
         }
 
         $base_uri->setPath($path);
         return $base_uri;
       } else {
         return $this->getRemoteURIObject();
       }
     }
 
     // TODO: This should be cleaned up to deal with all the new URI handling.
     $another_copy = id(new PhabricatorRepositoryQuery())
       ->setViewer(PhabricatorUser::getOmnipotentUser())
       ->withPHIDs(array($this->getPHID()))
       ->needURIs(true)
       ->executeOne();
 
     $clone_uris = $another_copy->getCloneURIs();
     if (!$clone_uris) {
       return null;
     }
 
     return head($clone_uris)->getEffectiveURI();
   }
 
   private function getRawHTTPCloneURIObject() {
     $uri = PhabricatorEnv::getProductionURI($this->getURI());
     $uri = new PhutilURI($uri);
 
     if ($this->isGit()) {
       $uri->setPath($uri->getPath().$this->getCloneName().'.git');
     } else if ($this->isHg()) {
       $uri->setPath($uri->getPath().$this->getCloneName().'/');
     }
 
     return $uri;
   }
 
 
   /**
    * Determine if we should connect to the remote using SSH flags and
    * credentials.
    *
    * @return bool True to use the SSH protocol.
    * @task uri
    */
   private function shouldUseSSH() {
     if ($this->isHosted()) {
       return false;
     }
 
     $protocol = $this->getRemoteProtocol();
     if ($this->isSSHProtocol($protocol)) {
       return true;
     }
 
     return false;
   }
 
 
   /**
    * Determine if we should connect to the remote using HTTP flags and
    * credentials.
    *
    * @return bool True to use the HTTP protocol.
    * @task uri
    */
   private function shouldUseHTTP() {
     if ($this->isHosted()) {
       return false;
     }
 
     $protocol = $this->getRemoteProtocol();
     return ($protocol == 'http' || $protocol == 'https');
   }
 
 
   /**
    * Determine if we should connect to the remote using SVN flags and
    * credentials.
    *
    * @return bool True to use the SVN protocol.
    * @task uri
    */
   private function shouldUseSVNProtocol() {
     if ($this->isHosted()) {
       return false;
     }
 
     $protocol = $this->getRemoteProtocol();
     return ($protocol == 'svn');
   }
 
 
   /**
    * Determine if a protocol is SSH or SSH-like.
    *
    * @param string A protocol string, like "http" or "ssh".
    * @return bool True if the protocol is SSH-like.
    * @task uri
    */
   private function isSSHProtocol($protocol) {
     return ($protocol == 'ssh' || $protocol == 'svn+ssh');
   }
 
   public function delete() {
     $this->openTransaction();
 
       $paths = id(new PhabricatorOwnersPath())
         ->loadAllWhere('repositoryPHID = %s', $this->getPHID());
       foreach ($paths as $path) {
         $path->delete();
       }
 
       queryfx(
         $this->establishConnection('w'),
         'DELETE FROM %T WHERE repositoryPHID = %s',
         id(new PhabricatorRepositorySymbol())->getTableName(),
         $this->getPHID());
 
       $commits = id(new PhabricatorRepositoryCommit())
         ->loadAllWhere('repositoryID = %d', $this->getID());
       foreach ($commits as $commit) {
         // note PhabricatorRepositoryAuditRequests and
         // PhabricatorRepositoryCommitData are deleted here too.
         $commit->delete();
       }
 
       $uris = id(new PhabricatorRepositoryURI())
         ->loadAllWhere('repositoryPHID = %s', $this->getPHID());
       foreach ($uris as $uri) {
         $uri->delete();
       }
 
       $ref_cursors = id(new PhabricatorRepositoryRefCursor())
         ->loadAllWhere('repositoryPHID = %s', $this->getPHID());
       foreach ($ref_cursors as $cursor) {
         $cursor->delete();
       }
 
       $conn_w = $this->establishConnection('w');
 
       queryfx(
         $conn_w,
         'DELETE FROM %T WHERE repositoryID = %d',
         self::TABLE_FILESYSTEM,
         $this->getID());
 
       queryfx(
         $conn_w,
         'DELETE FROM %T WHERE repositoryID = %d',
         self::TABLE_PATHCHANGE,
         $this->getID());
 
       queryfx(
         $conn_w,
         'DELETE FROM %T WHERE repositoryID = %d',
         self::TABLE_SUMMARY,
         $this->getID());
 
       $result = parent::delete();
 
     $this->saveTransaction();
     return $result;
   }
 
   public function isGit() {
     $vcs = $this->getVersionControlSystem();
     return ($vcs == PhabricatorRepositoryType::REPOSITORY_TYPE_GIT);
   }
 
   public function isSVN() {
     $vcs = $this->getVersionControlSystem();
     return ($vcs == PhabricatorRepositoryType::REPOSITORY_TYPE_SVN);
   }
 
   public function isHg() {
     $vcs = $this->getVersionControlSystem();
     return ($vcs == PhabricatorRepositoryType::REPOSITORY_TYPE_MERCURIAL);
   }
 
   public function isHosted() {
     return (bool)$this->getDetail('hosting-enabled', false);
   }
 
   public function setHosted($enabled) {
     return $this->setDetail('hosting-enabled', $enabled);
   }
 
   public function canServeProtocol(
     $protocol,
     $write,
     $is_intracluster = false) {
 
     // See T13192. If a repository is inactive, don't serve it to users. We
     // still synchronize it within the cluster and serve it to other repository
     // nodes.
     if (!$is_intracluster) {
       if (!$this->isTracked()) {
         return false;
       }
     }
 
     $clone_uris = $this->getCloneURIs();
     foreach ($clone_uris as $uri) {
       if ($uri->getBuiltinProtocol() !== $protocol) {
         continue;
       }
 
       $io_type = $uri->getEffectiveIoType();
       if ($io_type == PhabricatorRepositoryURI::IO_READWRITE) {
         return true;
       }
 
       if (!$write) {
         if ($io_type == PhabricatorRepositoryURI::IO_READ) {
           return true;
         }
       }
     }
 
     if ($write) {
       if ($this->isReadOnly()) {
         return false;
       }
     }
 
     return false;
   }
 
   public function hasLocalWorkingCopy() {
     try {
       self::assertLocalExists();
       return true;
     } catch (Exception $ex) {
       return false;
     }
   }
 
   /**
    * Raise more useful errors when there are basic filesystem problems.
    */
   private function assertLocalExists() {
     if (!$this->usesLocalWorkingCopy()) {
       return;
     }
 
     $local = $this->getLocalPath();
     Filesystem::assertExists($local);
     Filesystem::assertIsDirectory($local);
     Filesystem::assertReadable($local);
   }
 
   /**
    * Determine if the working copy is bare or not. In Git, this corresponds
    * to `--bare`. In Mercurial, `--noupdate`.
    */
   public function isWorkingCopyBare() {
     switch ($this->getVersionControlSystem()) {
       case PhabricatorRepositoryType::REPOSITORY_TYPE_SVN:
       case PhabricatorRepositoryType::REPOSITORY_TYPE_MERCURIAL:
         return false;
       case PhabricatorRepositoryType::REPOSITORY_TYPE_GIT:
         $local = $this->getLocalPath();
         if (Filesystem::pathExists($local.'/.git')) {
           return false;
         } else {
           return true;
         }
     }
   }
 
   public function usesLocalWorkingCopy() {
     switch ($this->getVersionControlSystem()) {
       case PhabricatorRepositoryType::REPOSITORY_TYPE_SVN:
         return $this->isHosted();
       case PhabricatorRepositoryType::REPOSITORY_TYPE_GIT:
       case PhabricatorRepositoryType::REPOSITORY_TYPE_MERCURIAL:
         return true;
     }
   }
 
   public function getHookDirectories() {
     $directories = array();
     if (!$this->isHosted()) {
       return $directories;
     }
 
     $root = $this->getLocalPath();
 
     switch ($this->getVersionControlSystem()) {
       case PhabricatorRepositoryType::REPOSITORY_TYPE_GIT:
         if ($this->isWorkingCopyBare()) {
           $directories[] = $root.'/hooks/pre-receive-phabricator.d/';
         } else {
           $directories[] = $root.'/.git/hooks/pre-receive-phabricator.d/';
         }
         break;
       case PhabricatorRepositoryType::REPOSITORY_TYPE_SVN:
         $directories[] = $root.'/hooks/pre-commit-phabricator.d/';
         break;
       case PhabricatorRepositoryType::REPOSITORY_TYPE_MERCURIAL:
         // NOTE: We don't support custom Mercurial hooks for now because they're
         // messy and we can't easily just drop a `hooks.d/` directory next to
         // the hooks.
         break;
     }
 
     return $directories;
   }
 
   public function canDestroyWorkingCopy() {
     if ($this->isHosted()) {
       // Never destroy hosted working copies.
       return false;
     }
 
     $default_path = PhabricatorEnv::getEnvConfig(
       'repository.default-local-path');
     return Filesystem::isDescendant($this->getLocalPath(), $default_path);
   }
 
   public function canUsePathTree() {
     return !$this->isSVN();
   }
 
   public function canUseGitLFS() {
     if (!$this->isGit()) {
       return false;
     }
 
     if (!$this->isHosted()) {
       return false;
     }
 
     if (!PhabricatorEnv::getEnvConfig('diffusion.allow-git-lfs')) {
       return false;
     }
 
     return true;
   }
 
   public function getGitLFSURI($path = null) {
     if (!$this->canUseGitLFS()) {
       throw new Exception(
         pht(
           'This repository does not support Git LFS, so Git LFS URIs can '.
           'not be generated for it.'));
     }
 
     $uri = $this->getRawHTTPCloneURIObject();
     $uri = (string)$uri;
     $uri = $uri.'/'.$path;
 
     return $uri;
   }
 
   public function canMirror() {
     if ($this->isGit() || $this->isHg()) {
       return true;
     }
 
     return false;
   }
 
   public function canAllowDangerousChanges() {
     if (!$this->isHosted()) {
       return false;
     }
 
     // In Git and Mercurial, ref deletions and rewrites are dangerous.
     // In Subversion, editing revprops is dangerous.
 
     return true;
   }
 
   public function shouldAllowDangerousChanges() {
     return (bool)$this->getDetail('allow-dangerous-changes');
   }
 
   public function canAllowEnormousChanges() {
     if (!$this->isHosted()) {
       return false;
     }
 
     return true;
   }
 
   public function shouldAllowEnormousChanges() {
     return (bool)$this->getDetail('allow-enormous-changes');
   }
 
   public function writeStatusMessage(
     $status_type,
     $status_code,
     array $parameters = array()) {
 
     $table = new PhabricatorRepositoryStatusMessage();
     $conn_w = $table->establishConnection('w');
     $table_name = $table->getTableName();
 
     if ($status_code === null) {
       queryfx(
         $conn_w,
         'DELETE FROM %T WHERE repositoryID = %d AND statusType = %s',
         $table_name,
         $this->getID(),
         $status_type);
     } else {
       // If the existing message has the same code (e.g., we just hit an
       // error and also previously hit an error) we increment the message
       // count. This allows us to determine how many times in a row we've
       // run into an error.
 
       // NOTE: The assignments in "ON DUPLICATE KEY UPDATE" are evaluated
       // in order, so the "messageCount" assignment must occur before the
       // "statusCode" assignment. See T11705.
 
       queryfx(
         $conn_w,
         'INSERT INTO %T
           (repositoryID, statusType, statusCode, parameters, epoch,
             messageCount)
           VALUES (%d, %s, %s, %s, %d, %d)
           ON DUPLICATE KEY UPDATE
             messageCount =
               IF(
                 statusCode = VALUES(statusCode),
                 messageCount + VALUES(messageCount),
                 VALUES(messageCount)),
             statusCode = VALUES(statusCode),
             parameters = VALUES(parameters),
             epoch = VALUES(epoch)',
         $table_name,
         $this->getID(),
         $status_type,
         $status_code,
         json_encode($parameters),
         time(),
         1);
     }
 
     return $this;
   }
 
   public static function assertValidRemoteURI($uri) {
     if (trim($uri) != $uri) {
       throw new Exception(
         pht('The remote URI has leading or trailing whitespace.'));
     }
 
     $uri_object = new PhutilURI($uri);
     $protocol = $uri_object->getProtocol();
 
     // Catch confusion between Git/SCP-style URIs and normal URIs. See T3619
     // for discussion. This is usually a user adding "ssh://" to an implicit
     // SSH Git URI.
     if ($protocol == 'ssh') {
       if (preg_match('(^[^:@]+://[^/:]+:[^\d])', $uri)) {
         throw new Exception(
           pht(
             "The remote URI is not formatted correctly. Remote URIs ".
             "with an explicit protocol should be in the form ".
             "'%s', not '%s'. The '%s' syntax is only valid in SCP-style URIs.",
             'proto://domain/path',
             'proto://domain:/path',
             ':/path'));
       }
     }
 
     switch ($protocol) {
       case 'ssh':
       case 'http':
       case 'https':
       case 'git':
       case 'svn':
       case 'svn+ssh':
         break;
       default:
         // NOTE: We're explicitly rejecting 'file://' because it can be
         // used to clone from the working copy of another repository on disk
         // that you don't normally have permission to access.
 
         throw new Exception(
           pht(
             'The URI protocol is unrecognized. It should begin with '.
             '"%s", "%s", "%s", "%s", "%s", "%s", or be in the form "%s".',
             'ssh://',
             'http://',
             'https://',
             'git://',
             'svn://',
             'svn+ssh://',
             'git@domain.com:path'));
     }
 
     return true;
   }
 
 
   /**
    * Load the pull frequency for this repository, based on the time since the
    * last activity.
    *
    * We pull rarely used repositories less frequently. This finds the most
    * recent commit which is older than the current time (which prevents us from
    * spinning on repositories with a silly commit post-dated to some time in
    * 2037). We adjust the pull frequency based on when the most recent commit
    * occurred.
    *
    * @param   int   The minimum update interval to use, in seconds.
    * @return  int   Repository update interval, in seconds.
    */
   public function loadUpdateInterval($minimum = 15) {
     // First, check if we've hit errors recently. If we have, wait one period
     // for each consecutive error. Normally, this corresponds to a backoff of
     // 15s, 30s, 45s, etc.
 
     $message_table = new PhabricatorRepositoryStatusMessage();
     $conn = $message_table->establishConnection('r');
     $error_count = queryfx_one(
       $conn,
       'SELECT MAX(messageCount) error_count FROM %T
         WHERE repositoryID = %d
         AND statusType IN (%Ls)
         AND statusCode IN (%Ls)',
       $message_table->getTableName(),
       $this->getID(),
       array(
         PhabricatorRepositoryStatusMessage::TYPE_INIT,
         PhabricatorRepositoryStatusMessage::TYPE_FETCH,
       ),
       array(
         PhabricatorRepositoryStatusMessage::CODE_ERROR,
       ));
 
     $error_count = (int)$error_count['error_count'];
     if ($error_count > 0) {
       return (int)($minimum * $error_count);
     }
 
     // If a repository is still importing, always pull it as frequently as
     // possible. This prevents us from hanging for a long time at 99.9% when
     // importing an inactive repository.
     if ($this->isImporting()) {
       return $minimum;
     }
 
     $window_start = (PhabricatorTime::getNow() + $minimum);
 
     $table = id(new PhabricatorRepositoryCommit());
     $last_commit = queryfx_one(
       $table->establishConnection('r'),
       'SELECT epoch FROM %T
         WHERE repositoryID = %d AND epoch <= %d
         ORDER BY epoch DESC LIMIT 1',
       $table->getTableName(),
       $this->getID(),
       $window_start);
     if ($last_commit) {
       $time_since_commit = ($window_start - $last_commit['epoch']);
     } else {
       // If the repository has no commits, treat the creation date as
       // though it were the date of the last commit. This makes empty
       // repositories update quickly at first but slow down over time
       // if they don't see any activity.
       $time_since_commit = ($window_start - $this->getDateCreated());
     }
 
     $last_few_days = phutil_units('3 days in seconds');
 
     if ($time_since_commit <= $last_few_days) {
       // For repositories with activity in the recent past, we wait one
       // extra second for every 10 minutes since the last commit. This
       // shorter backoff is intended to handle weekends and other short
       // breaks from development.
       $smart_wait = ($time_since_commit / 600);
     } else {
       // For repositories without recent activity, we wait one extra second
       // for every 4 minutes since the last commit. This longer backoff
       // handles rarely used repositories, up to the maximum.
       $smart_wait = ($time_since_commit / 240);
     }
 
     // We'll never wait more than 6 hours to pull a repository.
     $longest_wait = phutil_units('6 hours in seconds');
     $smart_wait = min($smart_wait, $longest_wait);
     $smart_wait = max($minimum, $smart_wait);
 
     return (int)$smart_wait;
   }
 
 
   /**
    * Time limit for cloning or copying this repository.
    *
    * This limit is used to timeout operations like `git clone` or `git fetch`
    * when doing intracluster synchronization, building working copies, etc.
    *
    * @return int Maximum number of seconds to spend copying this repository.
    */
   public function getCopyTimeLimit() {
     return $this->getDetail('limit.copy');
   }
 
   public function setCopyTimeLimit($limit) {
     return $this->setDetail('limit.copy', $limit);
   }
 
   public function getDefaultCopyTimeLimit() {
     return phutil_units('15 minutes in seconds');
   }
 
   public function getEffectiveCopyTimeLimit() {
     $limit = $this->getCopyTimeLimit();
     if ($limit) {
       return $limit;
     }
 
     return $this->getDefaultCopyTimeLimit();
   }
 
   public function getFilesizeLimit() {
     return $this->getDetail('limit.filesize');
   }
 
   public function setFilesizeLimit($limit) {
     return $this->setDetail('limit.filesize', $limit);
   }
 
   public function getTouchLimit() {
     return $this->getDetail('limit.touch');
   }
 
   public function setTouchLimit($limit) {
     return $this->setDetail('limit.touch', $limit);
   }
 
   /**
    * Retrieve the service URI for the device hosting this repository.
    *
    * See @{method:newConduitClient} for a general discussion of interacting
    * with repository services. This method provides lower-level resolution of
    * services, returning raw URIs.
    *
    * @param PhabricatorUser Viewing user.
    * @param map<string, wild> Constraints on selectable services.
    * @return string|null URI, or `null` for local repositories.
    */
   public function getAlmanacServiceURI(
     PhabricatorUser $viewer,
     array $options) {
 
     $refs = $this->getAlmanacServiceRefs($viewer, $options);
 
     if (!$refs) {
       return null;
     }
 
     $ref = head($refs);
     return $ref->getURI();
   }
 
   public function getAlmanacServiceRefs(
     PhabricatorUser $viewer,
     array $options) {
 
     PhutilTypeSpec::checkMap(
       $options,
       array(
         'neverProxy' => 'bool',
         'protocols' => 'list<string>',
         'writable' => 'optional bool',
       ));
 
     $never_proxy = $options['neverProxy'];
     $protocols = $options['protocols'];
     $writable = idx($options, 'writable', false);
 
     $cache_key = $this->getAlmanacServiceCacheKey();
     if (!$cache_key) {
       return array();
     }
 
     $cache = PhabricatorCaches::getMutableStructureCache();
     $uris = $cache->getKey($cache_key, false);
 
     // If we haven't built the cache yet, build it now.
     if ($uris === false) {
       $uris = $this->buildAlmanacServiceURIs();
       $cache->setKey($cache_key, $uris);
     }
 
     if ($uris === null) {
       return array();
     }
 
     $local_device = AlmanacKeys::getDeviceID();
     if ($never_proxy && !$local_device) {
       throw new Exception(
         pht(
           'Unable to handle proxied service request. This device is not '.
           'registered, so it can not identify local services. Register '.
           'this device before sending requests here.'));
     }
 
     $protocol_map = array_fuse($protocols);
 
     $results = array();
     foreach ($uris as $uri) {
       // If we're never proxying this and it's locally satisfiable, return
       // `null` to tell the caller to handle it locally. If we're allowed to
       // proxy, we skip this check and may proxy the request to ourselves.
       // (That proxied request will end up here with proxying forbidden,
       // return `null`, and then the request will actually run.)
 
       if ($local_device && $never_proxy) {
         if ($uri['device'] == $local_device) {
           return array();
         }
       }
 
       if (isset($protocol_map[$uri['protocol']])) {
         $results[] = $uri;
       }
     }
 
     if (!$results) {
       throw new Exception(
         pht(
           'The Almanac service for this repository is not bound to any '.
           'interfaces which support the required protocols (%s).',
           implode(', ', $protocols)));
     }
 
     if ($never_proxy) {
       // See PHI1030. This error can arise from various device name/address
       // mismatches which are hard to detect, so try to provide as much
       // information as we can.
 
       if ($writable) {
         $request_type = pht('(This is a write request.)');
       } else {
         $request_type = pht('(This is a read request.)');
       }
 
       throw new Exception(
         pht(
           'This repository request (for repository "%s") has been '.
           'incorrectly routed to a cluster host (with device name "%s", '.
           'and hostname "%s") which can not serve the request.'.
           "\n\n".
           'The Almanac device address for the correct device may improperly '.
           'point at this host, or the "device.id" configuration file on '.
           'this host may be incorrect.'.
           "\n\n".
           'Requests routed within the cluster by Phabricator are always '.
           'expected to be sent to a node which can serve the request. To '.
           'prevent loops, this request will not be proxied again.'.
           "\n\n".
           "%s",
           $this->getDisplayName(),
           $local_device,
           php_uname('n'),
           $request_type));
     }
 
     if (count($results) > 1) {
       if (!$this->supportsSynchronization()) {
         throw new Exception(
           pht(
             'Repository "%s" is bound to multiple active repository hosts, '.
             'but this repository does not support cluster synchronization. '.
             'Declusterize this repository or move it to a service with only '.
             'one host.',
             $this->getDisplayName()));
       }
     }
 
     $refs = array();
     foreach ($results as $result) {
       $refs[] = DiffusionServiceRef::newFromDictionary($result);
     }
 
     // If we require a writable device, remove URIs which aren't writable.
     if ($writable) {
       foreach ($refs as $key => $ref) {
         if (!$ref->isWritable()) {
           unset($refs[$key]);
         }
       }
 
       if (!$refs) {
         throw new Exception(
           pht(
             'This repository ("%s") is not writable with the given '.
             'protocols (%s). The Almanac service for this repository has no '.
             'writable bindings that support these protocols.',
             $this->getDisplayName(),
             implode(', ', $protocols)));
       }
     }
 
     if ($writable) {
       $refs = $this->sortWritableAlmanacServiceRefs($refs);
     } else {
       $refs = $this->sortReadableAlmanacServiceRefs($refs);
     }
 
     return array_values($refs);
   }
 
   private function sortReadableAlmanacServiceRefs(array $refs) {
     assert_instances_of($refs, 'DiffusionServiceRef');
     shuffle($refs);
     return $refs;
   }
 
   private function sortWritableAlmanacServiceRefs(array $refs) {
     assert_instances_of($refs, 'DiffusionServiceRef');
 
     // See T13109 for discussion of how this method routes requests.
 
     // In the absence of other rules, we'll send traffic to devices randomly.
     // We also want to select randomly among nodes which are equally good
     // candidates to receive the write, and accomplish that by shuffling the
     // list up front.
     shuffle($refs);
 
     $order = array();
 
     // If some device is currently holding the write lock, send all requests
     // to that device. We're trying to queue writes on a single device so they
     // do not need to wait for read synchronization after earlier writes
     // complete.
     $writer = PhabricatorRepositoryWorkingCopyVersion::loadWriter(
       $this->getPHID());
     if ($writer) {
       $device_phid = $writer->getWriteProperty('devicePHID');
       foreach ($refs as $key => $ref) {
         if ($ref->getDevicePHID() === $device_phid) {
           $order[] = $key;
         }
       }
     }
 
     // If no device is currently holding the write lock, try to send requests
     // to a device which is already up to date and will not need to synchronize
     // before it can accept the write.
     $versions = PhabricatorRepositoryWorkingCopyVersion::loadVersions(
       $this->getPHID());
     if ($versions) {
       $max_version = (int)max(mpull($versions, 'getRepositoryVersion'));
 
       $max_devices = array();
       foreach ($versions as $version) {
         if ($version->getRepositoryVersion() == $max_version) {
           $max_devices[] = $version->getDevicePHID();
         }
       }
       $max_devices = array_fuse($max_devices);
 
       foreach ($refs as $key => $ref) {
         if (isset($max_devices[$ref->getDevicePHID()])) {
           $order[] = $key;
         }
       }
     }
 
     // Reorder the results, putting any we've selected as preferred targets for
     // the write at the head of the list.
     $refs = array_select_keys($refs, $order) + $refs;
 
     return $refs;
   }
 
   public function supportsSynchronization() {
     // TODO: For now, this is only supported for Git.
     if (!$this->isGit()) {
       return false;
     }
 
     return true;
   }
 
 
   public function supportsRefs() {
     if ($this->isSVN()) {
       return false;
     }
 
     return true;
   }
 
   public function getAlmanacServiceCacheKey() {
     $service_phid = $this->getAlmanacServicePHID();
     if (!$service_phid) {
       return null;
     }
 
     $repository_phid = $this->getPHID();
 
     $parts = array(
       "repo({$repository_phid})",
       "serv({$service_phid})",
       'v4',
     );
 
     return implode('.', $parts);
   }
 
   private function buildAlmanacServiceURIs() {
     $service = $this->loadAlmanacService();
     if (!$service) {
       return null;
     }
 
     $bindings = $service->getActiveBindings();
     if (!$bindings) {
       throw new Exception(
         pht(
           'The Almanac service for this repository is not bound to any '.
           'active interfaces.'));
     }
 
     $uris = array();
     foreach ($bindings as $binding) {
       $iface = $binding->getInterface();
 
       $uri = $this->getClusterRepositoryURIFromBinding($binding);
       $protocol = $uri->getProtocol();
       $device_name = $iface->getDevice()->getName();
       $device_phid = $iface->getDevice()->getPHID();
 
       $uris[] = array(
         'protocol' => $protocol,
         'uri' => (string)$uri,
         'device' => $device_name,
         'writable' => (bool)$binding->getAlmanacPropertyValue('writable'),
         'devicePHID' => $device_phid,
       );
     }
 
     return $uris;
   }
 
   /**
    * Build a new Conduit client in order to make a service call to this
    * repository.
    *
    * If the repository is hosted locally, this method may return `null`. The
    * caller should use `ConduitCall` or other local logic to complete the
    * request.
    *
    * By default, we will return a @{class:ConduitClient} for any repository with
    * a service, even if that service is on the current device.
    *
    * We do this because this configuration does not make very much sense in a
    * production context, but is very common in a test/development context
    * (where the developer's machine is both the web host and the repository
    * service). By proxying in development, we get more consistent behavior
    * between development and production, and don't have a major untested
    * codepath.
    *
    * The `$never_proxy` parameter can be used to prevent this local proxying.
    * If the flag is passed:
    *
    *   - The method will return `null` (implying a local service call)
    *     if the repository service is hosted on the current device.
    *   - The method will throw if it would need to return a client.
    *
    * This is used to prevent loops in Conduit: the first request will proxy,
    * even in development, but the second request will be identified as a
    * cluster request and forced not to proxy.
    *
    * For lower-level service resolution, see @{method:getAlmanacServiceURI}.
    *
    * @param PhabricatorUser Viewing user.
    * @param bool `true` to throw if a client would be returned.
    * @return ConduitClient|null Client, or `null` for local repositories.
    */
   public function newConduitClient(
     PhabricatorUser $viewer,
     $never_proxy = false) {
 
     $uri = $this->getAlmanacServiceURI(
       $viewer,
       array(
         'neverProxy' => $never_proxy,
         'protocols' => array(
           'http',
           'https',
         ),
 
         // At least today, no Conduit call can ever write to a repository,
         // so it's fine to send anything to a read-only node.
         'writable' => false,
       ));
     if ($uri === null) {
       return null;
     }
 
     $domain = id(new PhutilURI(PhabricatorEnv::getURI('/')))->getDomain();
 
     $client = id(new ConduitClient($uri))
       ->setHost($domain);
 
     if ($viewer->isOmnipotent()) {
       // If the caller is the omnipotent user (normally, a daemon), we will
       // sign the request with this host's asymmetric keypair.
 
       $public_path = AlmanacKeys::getKeyPath('device.pub');
       try {
         $public_key = Filesystem::readFile($public_path);
       } catch (Exception $ex) {
         throw new PhutilAggregateException(
           pht(
             'Unable to read device public key while attempting to make '.
             'authenticated method call within the Phabricator cluster. '.
             'Use `%s` to register keys for this device. Exception: %s',
             'bin/almanac register',
             $ex->getMessage()),
           array($ex));
       }
 
       $private_path = AlmanacKeys::getKeyPath('device.key');
       try {
         $private_key = Filesystem::readFile($private_path);
         $private_key = new PhutilOpaqueEnvelope($private_key);
       } catch (Exception $ex) {
         throw new PhutilAggregateException(
           pht(
             'Unable to read device private key while attempting to make '.
             'authenticated method call within the Phabricator cluster. '.
             'Use `%s` to register keys for this device. Exception: %s',
             'bin/almanac register',
             $ex->getMessage()),
           array($ex));
       }
 
       $client->setSigningKeys($public_key, $private_key);
     } else {
       // If the caller is a normal user, we generate or retrieve a cluster
       // API token.
 
       $token = PhabricatorConduitToken::loadClusterTokenForUser($viewer);
       if ($token) {
         $client->setConduitToken($token->getToken());
       }
     }
 
     return $client;
   }
 
   public function newConduitClientForRequest(ConduitAPIRequest $request) {
     // Figure out whether we're going to handle this request on this device,
     // or proxy it to another node in the cluster.
 
     // If this is a cluster request and we need to proxy, we'll explode here
     // to prevent infinite recursion.
 
     $viewer = $request->getViewer();
     $is_cluster_request = $request->getIsClusterRequest();
 
     $client = $this->newConduitClient(
       $viewer,
       $is_cluster_request);
 
     return $client;
   }
 
   public function newConduitFuture(
     PhabricatorUser $viewer,
     $method,
     array $params,
     $never_proxy = false) {
 
     $client = $this->newConduitClient(
       $viewer,
       $never_proxy);
 
     if (!$client) {
       $conduit_call = id(new ConduitCall($method, $params))
         ->setUser($viewer);
       $future = new MethodCallFuture($conduit_call, 'execute');
     } else {
       $future = $client->callMethod($method, $params);
     }
 
     return $future;
   }
 
   public function getPassthroughEnvironmentalVariables() {
     $env = $_ENV;
 
     if ($this->isGit()) {
       // $_ENV does not populate in CLI contexts if "E" is missing from
       // "variables_order" in PHP config. Currently, we do not require this
       // to be configured. Since it may not be, explicitly bring expected Git
       // environmental variables into scope. This list is not exhaustive, but
       // only lists variables with a known impact on commit hook behavior.
 
       // This can be removed if we later require "E" in "variables_order".
 
       $git_env = array(
         'GIT_OBJECT_DIRECTORY',
         'GIT_ALTERNATE_OBJECT_DIRECTORIES',
         'GIT_QUARANTINE_PATH',
       );
       foreach ($git_env as $key) {
         $value = getenv($key);
         if (strlen($value)) {
           $env[$key] = $value;
         }
       }
 
       $key = 'GIT_PUSH_OPTION_COUNT';
       $git_count = getenv($key);
       if (strlen($git_count)) {
         $git_count = (int)$git_count;
         $env[$key] = $git_count;
         for ($ii = 0; $ii < $git_count; $ii++) {
           $key = 'GIT_PUSH_OPTION_'.$ii;
           $env[$key] = getenv($key);
         }
       }
     }
 
     $result = array();
     foreach ($env as $key => $value) {
       // In Git, pass anything matching "GIT_*" though. Some of these variables
       // need to be preserved to allow `git` operations to work properly when
       // running from commit hooks.
       if ($this->isGit()) {
         if (preg_match('/^GIT_/', $key)) {
           $result[$key] = $value;
         }
       }
     }
 
     return $result;
   }
 
   public function supportsBranchComparison() {
     return $this->isGit();
   }
 
   public function isReadOnly() {
     return (bool)$this->getDetail('read-only');
   }
 
   public function setReadOnly($read_only) {
     return $this->setDetail('read-only', $read_only);
   }
 
   public function getReadOnlyMessage() {
     return $this->getDetail('read-only-message');
   }
 
   public function setReadOnlyMessage($message) {
     return $this->setDetail('read-only-message', $message);
   }
 
   public function getReadOnlyMessageForDisplay() {
     $parts = array();
     $parts[] = pht(
       'This repository is currently in read-only maintenance mode.');
 
     $message = $this->getReadOnlyMessage();
     if ($message !== null) {
       $parts[] = $message;
     }
 
     return implode("\n\n", $parts);
   }
 
 /* -(  Repository URIs  )---------------------------------------------------- */
 
 
   public function attachURIs(array $uris) {
     $custom_map = array();
     foreach ($uris as $key => $uri) {
       $builtin_key = $uri->getRepositoryURIBuiltinKey();
       if ($builtin_key !== null) {
         $custom_map[$builtin_key] = $key;
       }
     }
 
     $builtin_uris = $this->newBuiltinURIs();
     $seen_builtins = array();
     foreach ($builtin_uris as $builtin_uri) {
       $builtin_key = $builtin_uri->getRepositoryURIBuiltinKey();
       $seen_builtins[$builtin_key] = true;
 
       // If this builtin URI is disabled, don't attach it and remove the
       // persisted version if it exists.
       if ($builtin_uri->getIsDisabled()) {
         if (isset($custom_map[$builtin_key])) {
           unset($uris[$custom_map[$builtin_key]]);
         }
         continue;
       }
 
       // If the URI exists, make sure it's marked as not being disabled.
       if (isset($custom_map[$builtin_key])) {
         $uris[$custom_map[$builtin_key]]->setIsDisabled(false);
       }
     }
 
     // Remove any builtins which no longer exist.
     foreach ($custom_map as $builtin_key => $key) {
       if (empty($seen_builtins[$builtin_key])) {
         unset($uris[$key]);
       }
     }
 
     $this->uris = $uris;
 
     return $this;
   }
 
   public function getURIs() {
     return $this->assertAttached($this->uris);
   }
 
   public function getCloneURIs() {
     $uris = $this->getURIs();
 
     $clone = array();
     foreach ($uris as $uri) {
       if (!$uri->isBuiltin()) {
         continue;
       }
 
       if ($uri->getIsDisabled()) {
         continue;
       }
 
       $io_type = $uri->getEffectiveIoType();
       $is_clone =
         ($io_type == PhabricatorRepositoryURI::IO_READ) ||
         ($io_type == PhabricatorRepositoryURI::IO_READWRITE);
 
       if (!$is_clone) {
         continue;
       }
 
       $clone[] = $uri;
     }
 
     $clone = msort($clone, 'getURIScore');
     $clone = array_reverse($clone);
 
     return $clone;
   }
 
 
   public function newBuiltinURIs() {
     $has_callsign = ($this->getCallsign() !== null);
     $has_shortname = ($this->getRepositorySlug() !== null);
 
     $identifier_map = array(
       PhabricatorRepositoryURI::BUILTIN_IDENTIFIER_CALLSIGN => $has_callsign,
       PhabricatorRepositoryURI::BUILTIN_IDENTIFIER_SHORTNAME => $has_shortname,
       PhabricatorRepositoryURI::BUILTIN_IDENTIFIER_ID => true,
     );
 
     // If the view policy of the repository is public, support anonymous HTTP
     // even if authenticated HTTP is not supported.
     if ($this->getViewPolicy() === PhabricatorPolicies::POLICY_PUBLIC) {
       $allow_http = true;
     } else {
       $allow_http = PhabricatorEnv::getEnvConfig('diffusion.allow-http-auth');
     }
 
     $base_uri = PhabricatorEnv::getURI('/');
     $base_uri = new PhutilURI($base_uri);
     $has_https = ($base_uri->getProtocol() == 'https');
     $has_https = ($has_https && $allow_http);
 
     $has_http = !PhabricatorEnv::getEnvConfig('security.require-https');
     $has_http = ($has_http && $allow_http);
 
     // HTTP is not supported for Subversion.
     if ($this->isSVN()) {
       $has_http = false;
       $has_https = false;
     }
 
     $has_ssh = (bool)strlen(PhabricatorEnv::getEnvConfig('phd.user'));
 
     $protocol_map = array(
       PhabricatorRepositoryURI::BUILTIN_PROTOCOL_SSH => $has_ssh,
       PhabricatorRepositoryURI::BUILTIN_PROTOCOL_HTTPS => $has_https,
       PhabricatorRepositoryURI::BUILTIN_PROTOCOL_HTTP => $has_http,
     );
 
     $uris = array();
     foreach ($protocol_map as $protocol => $proto_supported) {
       foreach ($identifier_map as $identifier => $id_supported) {
         // This is just a dummy value because it can't be empty; we'll force
         // it to a proper value when using it in the UI.
         $builtin_uri = "{$protocol}://{$identifier}";
         $uris[] = PhabricatorRepositoryURI::initializeNewURI()
           ->setRepositoryPHID($this->getPHID())
           ->attachRepository($this)
           ->setBuiltinProtocol($protocol)
           ->setBuiltinIdentifier($identifier)
           ->setURI($builtin_uri)
           ->setIsDisabled((int)(!$proto_supported || !$id_supported));
       }
     }
 
     return $uris;
   }
 
 
   public function getClusterRepositoryURIFromBinding(
     AlmanacBinding $binding) {
     $protocol = $binding->getAlmanacPropertyValue('protocol');
     if ($protocol === null) {
       $protocol = 'https';
     }
 
     $iface = $binding->getInterface();
     $address = $iface->renderDisplayAddress();
 
     $path = $this->getURI();
 
     return id(new PhutilURI("{$protocol}://{$address}"))
       ->setPath($path);
   }
 
   public function loadAlmanacService() {
     $service_phid = $this->getAlmanacServicePHID();
     if (!$service_phid) {
       // No service, so this is a local repository.
       return null;
     }
 
     $service = id(new AlmanacServiceQuery())
       ->setViewer(PhabricatorUser::getOmnipotentUser())
       ->withPHIDs(array($service_phid))
       ->needActiveBindings(true)
       ->needProperties(true)
       ->executeOne();
     if (!$service) {
       throw new Exception(
         pht(
           'The Almanac service for this repository is invalid or could not '.
           'be loaded.'));
     }
 
     $service_type = $service->getServiceImplementation();
     if (!($service_type instanceof AlmanacClusterRepositoryServiceType)) {
       throw new Exception(
         pht(
           'The Almanac service for this repository does not have the correct '.
           'service type.'));
     }
 
     return $service;
   }
 
   public function markImporting() {
     $this->openTransaction();
       $this->beginReadLocking();
         $repository = $this->reload();
         $repository->setDetail('importing', true);
         $repository->save();
       $this->endReadLocking();
     $this->saveTransaction();
 
     return $repository;
   }
 
 
 /* -(  Symbols  )-------------------------------------------------------------*/
 
   public function getSymbolSources() {
     return $this->getDetail('symbol-sources', array());
   }
 
   public function getSymbolLanguages() {
     return $this->getDetail('symbol-languages', array());
   }
 
 
 /* -(  Staging  )------------------------------------------------------------ */
 
 
   public function supportsStaging() {
     return $this->isGit();
   }
 
 
   public function getStagingURI() {
     if (!$this->supportsStaging()) {
       return null;
     }
     return $this->getDetail('staging-uri', null);
   }
 
 
 /* -(  Automation  )--------------------------------------------------------- */
 
 
   public function supportsAutomation() {
     return $this->isGit();
   }
 
   public function canPerformAutomation() {
     if (!$this->supportsAutomation()) {
       return false;
     }
 
     if (!$this->getAutomationBlueprintPHIDs()) {
       return false;
     }
 
     return true;
   }
 
   public function getAutomationBlueprintPHIDs() {
     if (!$this->supportsAutomation()) {
       return array();
     }
     return $this->getDetail('automation.blueprintPHIDs', array());
   }
 
 
 /* -(  PhabricatorApplicationTransactionInterface  )------------------------- */
 
 
   public function getApplicationTransactionEditor() {
     return new PhabricatorRepositoryEditor();
   }
 
   public function getApplicationTransactionTemplate() {
     return new PhabricatorRepositoryTransaction();
   }
 
 
 /* -(  PhabricatorPolicyInterface  )----------------------------------------- */
 
 
   public function getCapabilities() {
     return array(
       PhabricatorPolicyCapability::CAN_VIEW,
       PhabricatorPolicyCapability::CAN_EDIT,
       DiffusionPushCapability::CAPABILITY,
     );
   }
 
   public function getPolicy($capability) {
     switch ($capability) {
       case PhabricatorPolicyCapability::CAN_VIEW:
         return $this->getViewPolicy();
       case PhabricatorPolicyCapability::CAN_EDIT:
         return $this->getEditPolicy();
       case DiffusionPushCapability::CAPABILITY:
         return $this->getPushPolicy();
     }
   }
 
   public function hasAutomaticCapability($capability, PhabricatorUser $user) {
     return false;
   }
 
 
 /* -(  PhabricatorMarkupInterface  )----------------------------------------- */
 
 
   public function getMarkupFieldKey($field) {
     $hash = PhabricatorHash::digestForIndex($this->getMarkupText($field));
     return "repo:{$hash}";
   }
 
   public function newMarkupEngine($field) {
     return PhabricatorMarkupEngine::newMarkupEngine(array());
   }
 
   public function getMarkupText($field) {
     return $this->getDetail('description');
   }
 
   public function didMarkupText(
     $field,
     $output,
     PhutilMarkupEngine $engine) {
     require_celerity_resource('phabricator-remarkup-css');
     return phutil_tag(
       'div',
       array(
         'class' => 'phabricator-remarkup',
       ),
       $output);
   }
 
   public function shouldUseMarkupCache($field) {
     return true;
   }
 
 
 /* -(  PhabricatorDestructibleInterface  )----------------------------------- */
 
 
   public function destroyObjectPermanently(
     PhabricatorDestructionEngine $engine) {
 
     $phid = $this->getPHID();
 
     $this->openTransaction();
 
       $this->delete();
 
       PhabricatorRepositoryURIIndex::updateRepositoryURIs($phid, array());
 
       $books = id(new DivinerBookQuery())
         ->setViewer($engine->getViewer())
         ->withRepositoryPHIDs(array($phid))
         ->execute();
       foreach ($books as $book) {
         $engine->destroyObject($book);
       }
 
       $atoms = id(new DivinerAtomQuery())
         ->setViewer($engine->getViewer())
         ->withRepositoryPHIDs(array($phid))
         ->execute();
       foreach ($atoms as $atom) {
         $engine->destroyObject($atom);
       }
 
       $lfs_refs = id(new PhabricatorRepositoryGitLFSRefQuery())
         ->setViewer($engine->getViewer())
         ->withRepositoryPHIDs(array($phid))
         ->execute();
       foreach ($lfs_refs as $ref) {
         $engine->destroyObject($ref);
       }
 
     $this->saveTransaction();
   }
 
 
 /* -(  PhabricatorDestructibleCodexInterface  )------------------------------ */
 
 
   public function newDestructibleCodex() {
     return new PhabricatorRepositoryDestructibleCodex();
   }
 
 
 /* -(  PhabricatorSpacesInterface  )----------------------------------------- */
 
 
   public function getSpacePHID() {
     return $this->spacePHID;
   }
 
 /* -(  PhabricatorConduitResultInterface  )---------------------------------- */
 
 
   public function getFieldSpecificationsForConduit() {
     return array(
       id(new PhabricatorConduitSearchFieldSpecification())
         ->setKey('name')
         ->setType('string')
         ->setDescription(pht('The repository name.')),
       id(new PhabricatorConduitSearchFieldSpecification())
         ->setKey('vcs')
         ->setType('string')
         ->setDescription(
           pht('The VCS this repository uses ("git", "hg" or "svn").')),
       id(new PhabricatorConduitSearchFieldSpecification())
         ->setKey('callsign')
         ->setType('string')
         ->setDescription(pht('The repository callsign, if it has one.')),
       id(new PhabricatorConduitSearchFieldSpecification())
         ->setKey('shortName')
         ->setType('string')
         ->setDescription(pht('Unique short name, if the repository has one.')),
       id(new PhabricatorConduitSearchFieldSpecification())
         ->setKey('status')
         ->setType('string')
         ->setDescription(pht('Active or inactive status.')),
       id(new PhabricatorConduitSearchFieldSpecification())
         ->setKey('isImporting')
         ->setType('bool')
         ->setDescription(
           pht(
             'True if the repository is importing initial commits.')),
       id(new PhabricatorConduitSearchFieldSpecification())
         ->setKey('almanacServicePHID')
         ->setType('phid?')
         ->setDescription(
           pht(
             'The Almanac Service that hosts this repository, if the '.
             'repository is clustered.')),
       id(new PhabricatorConduitSearchFieldSpecification())
         ->setKey('refRules')
         ->setType('map<string, list<string>>')
         ->setDescription(
           pht(
             'The "Fetch" and "Permanent Ref" rules for this repository.')),
       id(new PhabricatorConduitSearchFieldSpecification())
         ->setKey('defaultBranch')
         ->setType('string?')
         ->setDescription(pht('Default branch name.')),
       id(new PhabricatorConduitSearchFieldSpecification())
         ->setKey('description')
         ->setType('remarkup')
         ->setDescription(pht('Repository description.')),
     );
   }
 
   public function getFieldValuesForConduit() {
     $fetch_rules = $this->getFetchRules();
     $track_rules = $this->getTrackOnlyRules();
     $permanent_rules = $this->getPermanentRefRules();
 
     $fetch_rules = $this->getStringListForConduit($fetch_rules);
     $track_rules = $this->getStringListForConduit($track_rules);
     $permanent_rules = $this->getStringListForConduit($permanent_rules);
 
     $default_branch = $this->getDefaultBranch();
     if (!strlen($default_branch)) {
       $default_branch = null;
     }
 
     return array(
       'name' => $this->getName(),
       'vcs' => $this->getVersionControlSystem(),
       'callsign' => $this->getCallsign(),
       'shortName' => $this->getRepositorySlug(),
       'status' => $this->getStatus(),
       'isImporting' => (bool)$this->isImporting(),
       'almanacServicePHID' => $this->getAlmanacServicePHID(),
       'refRules' => array(
         'fetchRules' => $fetch_rules,
         'trackRules' => $track_rules,
         'permanentRefRules' => $permanent_rules,
       ),
       'defaultBranch' => $default_branch,
       'description' => array(
         'raw' => (string)$this->getDetail('description'),
       ),
     );
   }
 
   private function getStringListForConduit($list) {
     if (!is_array($list)) {
       $list = array();
     }
 
     foreach ($list as $key => $value) {
       $value = (string)$value;
       if (!strlen($value)) {
         unset($list[$key]);
       }
     }
 
     return array_values($list);
   }
 
   public function getConduitSearchAttachments() {
     return array(
       id(new DiffusionRepositoryURIsSearchEngineAttachment())
         ->setAttachmentKey('uris'),
       id(new DiffusionRepositoryMetricsSearchEngineAttachment())
         ->setAttachmentKey('metrics'),
     );
   }
 
 /* -(  PhabricatorFulltextInterface  )--------------------------------------- */
 
 
   public function newFulltextEngine() {
     return new PhabricatorRepositoryFulltextEngine();
   }
 
 
 /* -(  PhabricatorFerretInterface  )----------------------------------------- */
 
 
   public function newFerretEngine() {
     return new PhabricatorRepositoryFerretEngine();
   }
 
 }
diff --git a/src/applications/repository/storage/PhabricatorRepositoryCommit.php b/src/applications/repository/storage/PhabricatorRepositoryCommit.php
index 0303e36919..9e20a36676 100644
--- a/src/applications/repository/storage/PhabricatorRepositoryCommit.php
+++ b/src/applications/repository/storage/PhabricatorRepositoryCommit.php
@@ -1,978 +1,978 @@
 <?php
 
 final class PhabricatorRepositoryCommit
   extends PhabricatorRepositoryDAO
   implements
     PhabricatorPolicyInterface,
     PhabricatorFlaggableInterface,
     PhabricatorProjectInterface,
     PhabricatorTokenReceiverInterface,
     PhabricatorSubscribableInterface,
     PhabricatorMentionableInterface,
     HarbormasterBuildableInterface,
     HarbormasterCircleCIBuildableInterface,
     HarbormasterBuildkiteBuildableInterface,
     PhabricatorCustomFieldInterface,
     PhabricatorApplicationTransactionInterface,
     PhabricatorTimelineInterface,
     PhabricatorFulltextInterface,
     PhabricatorFerretInterface,
     PhabricatorConduitResultInterface,
     PhabricatorDraftInterface {
 
   protected $repositoryID;
   protected $phid;
   protected $authorIdentityPHID;
   protected $committerIdentityPHID;
   protected $commitIdentifier;
   protected $epoch;
   protected $authorPHID;
   protected $auditStatus = DiffusionCommitAuditStatus::NONE;
   protected $summary = '';
   protected $importStatus = 0;
 
   const IMPORTED_MESSAGE = 1;
   const IMPORTED_CHANGE = 2;
   const IMPORTED_PUBLISH = 8;
   const IMPORTED_ALL = 11;
 
   const IMPORTED_PERMANENT = 1024;
   const IMPORTED_UNREACHABLE = 2048;
 
   private $commitData = self::ATTACHABLE;
   private $audits = self::ATTACHABLE;
   private $repository = self::ATTACHABLE;
   private $customFields = self::ATTACHABLE;
   private $authorIdentity = self::ATTACHABLE;
   private $committerIdentity = self::ATTACHABLE;
 
   private $drafts = array();
   private $auditAuthorityPHIDs = array();
 
   public function attachRepository(PhabricatorRepository $repository) {
     $this->repository = $repository;
     return $this;
   }
 
   public function getRepository($assert_attached = true) {
     if ($assert_attached) {
       return $this->assertAttached($this->repository);
     }
     return $this->repository;
   }
 
   public function isPartiallyImported($mask) {
     return (($mask & $this->getImportStatus()) == $mask);
   }
 
   public function isImported() {
     return $this->isPartiallyImported(self::IMPORTED_ALL);
   }
 
   public function isUnreachable() {
     return $this->isPartiallyImported(self::IMPORTED_UNREACHABLE);
   }
 
   public function writeImportStatusFlag($flag) {
     return $this->adjustImportStatusFlag($flag, true);
   }
 
   public function clearImportStatusFlag($flag) {
     return $this->adjustImportStatusFlag($flag, false);
   }
 
   private function adjustImportStatusFlag($flag, $set) {
     $conn_w = $this->establishConnection('w');
     $table_name = $this->getTableName();
     $id = $this->getID();
 
     if ($set) {
       queryfx(
         $conn_w,
         'UPDATE %T SET importStatus = (importStatus | %d) WHERE id = %d',
         $table_name,
         $flag,
         $id);
 
       $this->setImportStatus($this->getImportStatus() | $flag);
     } else {
       queryfx(
         $conn_w,
         'UPDATE %T SET importStatus = (importStatus & ~%d) WHERE id = %d',
         $table_name,
         $flag,
         $id);
 
       $this->setImportStatus($this->getImportStatus() & ~$flag);
     }
 
     return $this;
   }
 
   protected function getConfiguration() {
     return array(
       self::CONFIG_AUX_PHID   => true,
       self::CONFIG_TIMESTAMPS => false,
       self::CONFIG_COLUMN_SCHEMA => array(
         'commitIdentifier' => 'text40',
         'authorPHID' => 'phid?',
         'authorIdentityPHID' => 'phid?',
         'committerIdentityPHID' => 'phid?',
         'auditStatus' => 'text32',
         'summary' => 'text255',
         'importStatus' => 'uint32',
       ),
       self::CONFIG_KEY_SCHEMA => array(
         'key_phid' => null,
         'phid' => array(
           'columns' => array('phid'),
           'unique' => true,
         ),
         'repositoryID' => array(
           'columns' => array('repositoryID', 'importStatus'),
         ),
         'authorPHID' => array(
           'columns' => array('authorPHID', 'auditStatus', 'epoch'),
         ),
         'repositoryID_2' => array(
           'columns' => array('repositoryID', 'epoch'),
         ),
         'key_commit_identity' => array(
           'columns' => array('commitIdentifier', 'repositoryID'),
           'unique' => true,
         ),
         'key_epoch' => array(
           'columns' => array('epoch'),
         ),
         'key_author' => array(
           'columns' => array('authorPHID', 'epoch'),
         ),
       ),
       self::CONFIG_NO_MUTATE => array(
         'importStatus',
       ),
     ) + parent::getConfiguration();
   }
 
   public function generatePHID() {
     return PhabricatorPHID::generateNewPHID(
       PhabricatorRepositoryCommitPHIDType::TYPECONST);
   }
 
   public function loadCommitData() {
     if (!$this->getID()) {
       return null;
     }
     return id(new PhabricatorRepositoryCommitData())->loadOneWhere(
       'commitID = %d',
       $this->getID());
   }
 
   public function attachCommitData(
     PhabricatorRepositoryCommitData $data = null) {
     $this->commitData = $data;
     return $this;
   }
 
   public function hasCommitData() {
     return ($this->commitData !== self::ATTACHABLE) &&
            ($this->commitData !== null);
   }
 
   public function getCommitData() {
     return $this->assertAttached($this->commitData);
   }
 
   public function attachAudits(array $audits) {
     assert_instances_of($audits, 'PhabricatorRepositoryAuditRequest');
     $this->audits = $audits;
     return $this;
   }
 
   public function getAudits() {
     return $this->assertAttached($this->audits);
   }
 
   public function hasAttachedAudits() {
     return ($this->audits !== self::ATTACHABLE);
   }
 
   public function attachIdentities(
     PhabricatorRepositoryIdentity $author = null,
     PhabricatorRepositoryIdentity $committer = null) {
 
     $this->authorIdentity = $author;
     $this->committerIdentity = $committer;
 
     return $this;
   }
 
   public function getAuthorIdentity() {
     return $this->assertAttached($this->authorIdentity);
   }
 
   public function getCommitterIdentity() {
     return $this->assertAttached($this->committerIdentity);
   }
 
   public function attachAuditAuthority(
     PhabricatorUser $user,
     array $authority) {
 
     $user_phid = $user->getPHID();
     if (!$user->getPHID()) {
       throw new Exception(
         pht('You can not attach audit authority for a user with no PHID.'));
     }
 
     $this->auditAuthorityPHIDs[$user_phid] = $authority;
 
     return $this;
   }
 
   public function hasAuditAuthority(
     PhabricatorUser $user,
     PhabricatorRepositoryAuditRequest $audit) {
 
     $user_phid = $user->getPHID();
     if (!$user_phid) {
       return false;
     }
 
     $map = $this->assertAttachedKey($this->auditAuthorityPHIDs, $user_phid);
 
     return isset($map[$audit->getAuditorPHID()]);
   }
 
   public function writeOwnersEdges(array $package_phids) {
     $src_phid = $this->getPHID();
     $edge_type = DiffusionCommitHasPackageEdgeType::EDGECONST;
 
     $editor = new PhabricatorEdgeEditor();
 
     $dst_phids = PhabricatorEdgeQuery::loadDestinationPHIDs(
       $src_phid,
       $edge_type);
 
     foreach ($dst_phids as $dst_phid) {
       $editor->removeEdge($src_phid, $edge_type, $dst_phid);
     }
 
     foreach ($package_phids as $package_phid) {
       $editor->addEdge($src_phid, $edge_type, $package_phid);
     }
 
     $editor->save();
 
     return $this;
   }
 
   public function getAuditorPHIDsForEdit() {
     $audits = $this->getAudits();
     return mpull($audits, 'getAuditorPHID');
   }
 
   public function delete() {
     $data = $this->loadCommitData();
     $audits = id(new PhabricatorRepositoryAuditRequest())
       ->loadAllWhere('commitPHID = %s', $this->getPHID());
     $this->openTransaction();
 
       if ($data) {
         $data->delete();
       }
       foreach ($audits as $audit) {
         $audit->delete();
       }
       $result = parent::delete();
 
     $this->saveTransaction();
     return $result;
   }
 
   public function getDateCreated() {
     // This is primarily to make analysis of commits with the Fact engine work.
     return $this->getEpoch();
   }
 
   public function getURI() {
     return '/'.$this->getMonogram();
   }
 
   /**
    * Synchronize a commit's overall audit status with the individual audit
    * triggers.
    */
   public function updateAuditStatus(array $requests) {
     assert_instances_of($requests, 'PhabricatorRepositoryAuditRequest');
 
     $any_concern = false;
     $any_accept = false;
     $any_need = false;
 
     foreach ($requests as $request) {
       switch ($request->getAuditStatus()) {
         case PhabricatorAuditRequestStatus::AUDIT_REQUIRED:
         case PhabricatorAuditRequestStatus::AUDIT_REQUESTED:
           $any_need = true;
           break;
         case PhabricatorAuditRequestStatus::ACCEPTED:
           $any_accept = true;
           break;
         case PhabricatorAuditRequestStatus::CONCERNED:
           $any_concern = true;
           break;
       }
     }
 
     if ($any_concern) {
       if ($this->isAuditStatusNeedsVerification()) {
         // If the change is in "Needs Verification", we keep it there as
         // long as any auditors still have concerns.
         $status = DiffusionCommitAuditStatus::NEEDS_VERIFICATION;
       } else {
         $status = DiffusionCommitAuditStatus::CONCERN_RAISED;
       }
     } else if ($any_accept) {
       if ($any_need) {
         $status = DiffusionCommitAuditStatus::PARTIALLY_AUDITED;
       } else {
         $status = DiffusionCommitAuditStatus::AUDITED;
       }
     } else if ($any_need) {
       $status = DiffusionCommitAuditStatus::NEEDS_AUDIT;
     } else {
       $status = DiffusionCommitAuditStatus::NONE;
     }
 
     return $this->setAuditStatus($status);
   }
 
   public function getMonogram() {
     $repository = $this->getRepository();
     $callsign = $repository->getCallsign();
     $identifier = $this->getCommitIdentifier();
     if ($callsign !== null) {
       return "r{$callsign}{$identifier}";
     } else {
       $id = $repository->getID();
       return "R{$id}:{$identifier}";
     }
   }
 
   public function getDisplayName() {
     $repository = $this->getRepository();
     $identifier = $this->getCommitIdentifier();
     return $repository->formatCommitName($identifier);
   }
 
   /**
    * Return a local display name for use in the context of the containing
    * repository.
    *
    * In Git and Mercurial, this returns only a short hash, like "abcdef012345".
    * See @{method:getDisplayName} for a short name that always includes
    * repository context.
    *
    * @return string Short human-readable name for use inside a repository.
    */
   public function getLocalName() {
     $repository = $this->getRepository();
     $identifier = $this->getCommitIdentifier();
     return $repository->formatCommitName($identifier, $local = true);
   }
 
   public function loadIdentities(PhabricatorUser $viewer) {
     if ($this->authorIdentity !== self::ATTACHABLE) {
       return $this;
     }
 
     $commit = id(new DiffusionCommitQuery())
       ->setViewer($viewer)
       ->withIDs(array($this->getID()))
       ->needIdentities(true)
       ->executeOne();
 
     $author_identity = $commit->getAuthorIdentity();
     $committer_identity = $commit->getCommitterIdentity();
 
     return $this->attachIdentities($author_identity, $committer_identity);
   }
 
   public function hasCommitterIdentity() {
     return ($this->getCommitterIdentity() !== null);
   }
 
   public function hasAuthorIdentity() {
     return ($this->getAuthorIdentity() !== null);
   }
 
   public function getCommitterDisplayPHID() {
     if ($this->hasCommitterIdentity()) {
       return $this->getCommitterIdentity()->getIdentityDisplayPHID();
     }
 
     $data = $this->getCommitData();
     return $data->getCommitDetail('committerPHID');
   }
 
   public function getAuthorDisplayPHID() {
     if ($this->hasAuthorIdentity()) {
       return $this->getAuthorIdentity()->getIdentityDisplayPHID();
     }
 
     $data = $this->getCommitData();
     return $data->getCommitDetail('authorPHID');
   }
 
   public function getEffectiveAuthorPHID() {
     if ($this->hasAuthorIdentity()) {
       $identity = $this->getAuthorIdentity();
       if ($identity->hasEffectiveUser()) {
         return $identity->getCurrentEffectiveUserPHID();
       }
     }
 
     $data = $this->getCommitData();
     return $data->getCommitDetail('authorPHID');
   }
 
   public function getAuditStatusObject() {
     $status = $this->getAuditStatus();
     return DiffusionCommitAuditStatus::newForStatus($status);
   }
 
   public function isAuditStatusNoAudit() {
     return $this->getAuditStatusObject()->isNoAudit();
   }
 
   public function isAuditStatusNeedsAudit() {
     return $this->getAuditStatusObject()->isNeedsAudit();
   }
 
   public function isAuditStatusConcernRaised() {
     return $this->getAuditStatusObject()->isConcernRaised();
   }
 
   public function isAuditStatusNeedsVerification() {
     return $this->getAuditStatusObject()->isNeedsVerification();
   }
 
   public function isAuditStatusPartiallyAudited() {
     return $this->getAuditStatusObject()->isPartiallyAudited();
   }
 
   public function isAuditStatusAudited() {
     return $this->getAuditStatusObject()->isAudited();
   }
 
   public function isPermanentCommit() {
     return (bool)$this->isPartiallyImported(self::IMPORTED_PERMANENT);
   }
 
   public function newCommitAuthorView(PhabricatorUser $viewer) {
     $author_phid = $this->getAuthorDisplayPHID();
     if ($author_phid) {
       $handles = $viewer->loadHandles(array($author_phid));
       return $handles[$author_phid]->renderLink();
     }
 
     $author = $this->getRawAuthorStringForDisplay();
     if (strlen($author)) {
       return DiffusionView::renderName($author);
     }
 
     return null;
   }
 
   public function newCommitCommitterView(PhabricatorUser $viewer) {
     $committer_phid = $this->getCommitterDisplayPHID();
     if ($committer_phid) {
       $handles = $viewer->loadHandles(array($committer_phid));
       return $handles[$committer_phid]->renderLink();
     }
 
     $committer = $this->getRawCommitterStringForDisplay();
     if (strlen($committer)) {
       return DiffusionView::renderName($committer);
     }
 
     return null;
   }
 
   public function isAuthorSameAsCommitter() {
     $author_phid = $this->getAuthorDisplayPHID();
     $committer_phid = $this->getCommitterDisplayPHID();
 
     if ($author_phid && $committer_phid) {
       return ($author_phid === $committer_phid);
     }
 
     if ($author_phid || $committer_phid) {
       return false;
     }
 
     $author = $this->getRawAuthorStringForDisplay();
     $committer = $this->getRawCommitterStringForDisplay();
 
     return ($author === $committer);
   }
 
   private function getRawAuthorStringForDisplay() {
     $data = $this->getCommitData();
     return $data->getAuthorString();
   }
 
   private function getRawCommitterStringForDisplay() {
     $data = $this->getCommitData();
     return $data->getCommitterString();
   }
 
   public function getCommitMessageForDisplay() {
     $data = $this->getCommitData();
     $message = $data->getCommitMessage();
     return $message;
   }
 
   public function newCommitRef(PhabricatorUser $viewer) {
     $repository = $this->getRepository();
 
     $future = $repository->newConduitFuture(
       $viewer,
       'internal.commit.search',
       array(
         'constraints' => array(
           'repositoryPHIDs' => array($repository->getPHID()),
           'phids' => array($this->getPHID()),
         ),
       ));
     $result = $future->resolve();
 
     $commit_display = $this->getMonogram();
 
     if (empty($result['data'])) {
       throw new Exception(
         pht(
           'Unable to retrieve details for commit "%s"!',
           $commit_display));
     }
 
     if (count($result['data']) !== 1) {
       throw new Exception(
         pht(
           'Got too many results (%s) for commit "%s", expected %s.',
           phutil_count($result['data']),
           $commit_display,
           1));
     }
 
     $record = head($result['data']);
     $ref_record = idxv($record, array('fields', 'ref'));
 
     if (!$ref_record) {
       throw new Exception(
         pht(
           'Unable to retrieve CommitRef record for commit "%s".',
           $commit_display));
     }
 
     return DiffusionCommitRef::newFromDictionary($ref_record);
   }
 
 /* -(  PhabricatorPolicyInterface  )----------------------------------------- */
 
   public function getCapabilities() {
     return array(
       PhabricatorPolicyCapability::CAN_VIEW,
       PhabricatorPolicyCapability::CAN_EDIT,
     );
   }
 
   public function getPolicy($capability) {
     switch ($capability) {
       case PhabricatorPolicyCapability::CAN_VIEW:
         return $this->getRepository()->getPolicy($capability);
       case PhabricatorPolicyCapability::CAN_EDIT:
         return PhabricatorPolicies::POLICY_USER;
     }
   }
 
   public function hasAutomaticCapability($capability, PhabricatorUser $viewer) {
     return $this->getRepository()->hasAutomaticCapability($capability, $viewer);
   }
 
   public function describeAutomaticCapability($capability) {
     return pht(
       'Commits inherit the policies of the repository they belong to.');
   }
 
 
 /* -(  PhabricatorTokenReceiverInterface  )---------------------------------- */
 
   public function getUsersToNotifyOfTokenGiven() {
     return array(
       $this->getAuthorPHID(),
     );
   }
 
 /* -( Stuff for serialization )---------------------------------------------- */
 
   /**
    * NOTE: this is not a complete serialization; only the 'protected' fields are
    * involved. This is due to ease of (ab)using the Lisk abstraction to get this
    * done, as well as complexity of the other fields.
    */
   public function toDictionary() {
     return array(
       'repositoryID' => $this->getRepositoryID(),
       'phid' =>  $this->getPHID(),
       'commitIdentifier' =>  $this->getCommitIdentifier(),
       'epoch' => $this->getEpoch(),
       'authorPHID' => $this->getAuthorPHID(),
       'auditStatus' => $this->getAuditStatus(),
       'summary' => $this->getSummary(),
       'importStatus' => $this->getImportStatus(),
     );
   }
 
   public static function newFromDictionary(array $dict) {
     return id(new PhabricatorRepositoryCommit())
       ->loadFromArray($dict);
   }
 
 
 /* -(  HarbormasterBuildableInterface  )------------------------------------- */
 
 
   public function getHarbormasterBuildableDisplayPHID() {
     return $this->getHarbormasterBuildablePHID();
   }
 
   public function getHarbormasterBuildablePHID() {
     return $this->getPHID();
   }
 
   public function getHarbormasterContainerPHID() {
     return $this->getRepository()->getPHID();
   }
 
   public function getBuildVariables() {
     $results = array();
 
     $results['buildable.commit'] = $this->getCommitIdentifier();
     $repo = $this->getRepository();
 
     $results['repository.callsign'] = $repo->getCallsign();
     $results['repository.phid'] = $repo->getPHID();
     $results['repository.vcs'] = $repo->getVersionControlSystem();
     $results['repository.uri'] = $repo->getPublicCloneURI();
 
     return $results;
   }
 
   public function getAvailableBuildVariables() {
     return array(
       'buildable.commit' => pht('The commit identifier, if applicable.'),
       'repository.callsign' =>
-        pht('The callsign of the repository in Phabricator.'),
+        pht('The callsign of the repository.'),
       'repository.phid' =>
-        pht('The PHID of the repository in Phabricator.'),
+        pht('The PHID of the repository.'),
       'repository.vcs' =>
         pht('The version control system, either "svn", "hg" or "git".'),
       'repository.uri' =>
         pht('The URI to clone or checkout the repository from.'),
     );
   }
 
   public function newBuildableEngine() {
     return new DiffusionBuildableEngine();
   }
 
 
 /* -(  HarbormasterCircleCIBuildableInterface  )----------------------------- */
 
 
   public function getCircleCIGitHubRepositoryURI() {
     $repository = $this->getRepository();
 
     $commit_phid = $this->getPHID();
     $repository_phid = $repository->getPHID();
 
     if ($repository->isHosted()) {
       throw new Exception(
         pht(
           'This commit ("%s") is associated with a hosted repository '.
           '("%s"). Repositories must be imported from GitHub to be built '.
           'with CircleCI.',
           $commit_phid,
           $repository_phid));
     }
 
     $remote_uri = $repository->getRemoteURI();
     $path = HarbormasterCircleCIBuildStepImplementation::getGitHubPath(
       $remote_uri);
     if (!$path) {
       throw new Exception(
         pht(
           'This commit ("%s") is associated with a repository ("%s") which '.
           'has a remote URI ("%s") that does not appear to be hosted on '.
           'GitHub. Repositories must be hosted on GitHub to be built with '.
           'CircleCI.',
           $commit_phid,
           $repository_phid,
           $remote_uri));
     }
 
     return $remote_uri;
   }
 
   public function getCircleCIBuildIdentifierType() {
     return 'revision';
   }
 
   public function getCircleCIBuildIdentifier() {
     return $this->getCommitIdentifier();
   }
 
 
 /* -(  HarbormasterBuildkiteBuildableInterface  )---------------------------- */
 
 
   public function getBuildkiteBranch() {
     $viewer = PhabricatorUser::getOmnipotentUser();
     $repository = $this->getRepository();
 
     $branches = DiffusionQuery::callConduitWithDiffusionRequest(
       $viewer,
       DiffusionRequest::newFromDictionary(
         array(
           'repository' => $repository,
           'user' => $viewer,
         )),
       'diffusion.branchquery',
       array(
         'contains' => $this->getCommitIdentifier(),
         'repository' => $repository->getPHID(),
       ));
 
     if (!$branches) {
       throw new Exception(
         pht(
           'Commit "%s" is not an ancestor of any branch head, so it can not '.
           'be built with Buildkite.',
           $this->getCommitIdentifier()));
     }
 
     $branch = head($branches);
 
     return 'refs/heads/'.$branch['shortName'];
   }
 
   public function getBuildkiteCommit() {
     return $this->getCommitIdentifier();
   }
 
 
 /* -(  PhabricatorCustomFieldInterface  )------------------------------------ */
 
 
   public function getCustomFieldSpecificationForRole($role) {
     return PhabricatorEnv::getEnvConfig('diffusion.fields');
   }
 
   public function getCustomFieldBaseClass() {
     return 'PhabricatorCommitCustomField';
   }
 
   public function getCustomFields() {
     return $this->assertAttached($this->customFields);
   }
 
   public function attachCustomFields(PhabricatorCustomFieldAttachment $fields) {
     $this->customFields = $fields;
     return $this;
   }
 
 
 /* -(  PhabricatorSubscribableInterface  )----------------------------------- */
 
 
   public function isAutomaticallySubscribed($phid) {
 
     // TODO: This should also list auditors, but handling that is a bit messy
     // right now because we are not guaranteed to have the data. (It should not
     // include resigned auditors.)
 
     return ($phid == $this->getAuthorPHID());
   }
 
 
 /* -(  PhabricatorApplicationTransactionInterface  )------------------------- */
 
 
   public function getApplicationTransactionEditor() {
     return new PhabricatorAuditEditor();
   }
 
   public function getApplicationTransactionTemplate() {
     return new PhabricatorAuditTransaction();
   }
 
 /* -(  PhabricatorFulltextInterface  )--------------------------------------- */
 
 
   public function newFulltextEngine() {
     return new DiffusionCommitFulltextEngine();
   }
 
 
 /* -(  PhabricatorFerretInterface  )----------------------------------------- */
 
 
   public function newFerretEngine() {
     return new DiffusionCommitFerretEngine();
   }
 
 
 /* -(  PhabricatorConduitResultInterface  )---------------------------------- */
 
   public function getFieldSpecificationsForConduit() {
     return array(
       id(new PhabricatorConduitSearchFieldSpecification())
         ->setKey('identifier')
         ->setType('string')
         ->setDescription(pht('The commit identifier.')),
       id(new PhabricatorConduitSearchFieldSpecification())
         ->setKey('repositoryPHID')
         ->setType('phid')
         ->setDescription(pht('The repository this commit belongs to.')),
       id(new PhabricatorConduitSearchFieldSpecification())
         ->setKey('author')
         ->setType('map<string, wild>')
         ->setDescription(pht('Information about the commit author.')),
       id(new PhabricatorConduitSearchFieldSpecification())
         ->setKey('committer')
         ->setType('map<string, wild>')
         ->setDescription(pht('Information about the committer.')),
       id(new PhabricatorConduitSearchFieldSpecification())
         ->setKey('isImported')
         ->setType('bool')
         ->setDescription(pht('True if the commit is fully imported.')),
       id(new PhabricatorConduitSearchFieldSpecification())
         ->setKey('isUnreachable')
         ->setType('bool')
         ->setDescription(
           pht(
             'True if the commit is not the ancestor of any tag, branch, or '.
             'ref.')),
       id(new PhabricatorConduitSearchFieldSpecification())
         ->setKey('auditStatus')
         ->setType('map<string, wild>')
         ->setDescription(pht('Information about the current audit status.')),
       id(new PhabricatorConduitSearchFieldSpecification())
         ->setKey('message')
         ->setType('string')
         ->setDescription(pht('The commit message.')),
     );
   }
 
   public function getFieldValuesForConduit() {
     $data = $this->getCommitData();
 
     $author_identity = $this->getAuthorIdentity();
     if ($author_identity) {
       $author_name = $author_identity->getIdentityDisplayName();
       $author_email = $author_identity->getIdentityEmailAddress();
       $author_raw = $author_identity->getIdentityName();
       $author_identity_phid = $author_identity->getPHID();
       $author_user_phid = $author_identity->getCurrentEffectiveUserPHID();
     } else {
       $author_name = null;
       $author_email = null;
       $author_raw = null;
       $author_identity_phid = null;
       $author_user_phid = null;
     }
 
     $committer_identity = $this->getCommitterIdentity();
     if ($committer_identity) {
       $committer_name = $committer_identity->getIdentityDisplayName();
       $committer_email = $committer_identity->getIdentityEmailAddress();
       $committer_raw = $committer_identity->getIdentityName();
       $committer_identity_phid = $committer_identity->getPHID();
       $committer_user_phid = $committer_identity->getCurrentEffectiveUserPHID();
     } else {
       $committer_name = null;
       $committer_email = null;
       $committer_raw = null;
       $committer_identity_phid = null;
       $committer_user_phid = null;
     }
 
     $author_epoch = $data->getAuthorEpoch();
 
     $audit_status = $this->getAuditStatusObject();
 
     return array(
       'identifier' => $this->getCommitIdentifier(),
       'repositoryPHID' => $this->getRepository()->getPHID(),
       'author' => array(
         'name' => $author_name,
         'email' => $author_email,
         'raw' => $author_raw,
         'epoch' => $author_epoch,
         'identityPHID' => $author_identity_phid,
         'userPHID' => $author_user_phid,
       ),
       'committer' => array(
         'name' => $committer_name,
         'email' => $committer_email,
         'raw' => $committer_raw,
         'epoch' => (int)$this->getEpoch(),
         'identityPHID' => $committer_identity_phid,
         'userPHID' => $committer_user_phid,
       ),
       'isUnreachable' => (bool)$this->isUnreachable(),
       'isImported' => (bool)$this->isImported(),
       'auditStatus' => array(
         'value' => $audit_status->getKey(),
         'name' => $audit_status->getName(),
         'closed' => (bool)$audit_status->getIsClosed(),
         'color.ansi' => $audit_status->getAnsiColor(),
       ),
       'message' => $data->getCommitMessage(),
     );
   }
 
   public function getConduitSearchAttachments() {
     return array(
       id(new DiffusionAuditorsSearchEngineAttachment())
         ->setAttachmentKey('auditors'),
     );
   }
 
 
 /* -(  PhabricatorDraftInterface  )------------------------------------------ */
 
   public function newDraftEngine() {
     return new DiffusionCommitDraftEngine();
   }
 
   public function getHasDraft(PhabricatorUser $viewer) {
     return $this->assertAttachedKey($this->drafts, $viewer->getCacheFragment());
   }
 
   public function attachHasDraft(PhabricatorUser $viewer, $has_draft) {
     $this->drafts[$viewer->getCacheFragment()] = $has_draft;
     return $this;
   }
 
 
 /* -(  PhabricatorTimelineInterface  )--------------------------------------- */
 
 
   public function newTimelineEngine() {
     return new DiffusionCommitTimelineEngine();
   }
 
 }
diff --git a/src/applications/repository/storage/PhabricatorRepositoryURI.php b/src/applications/repository/storage/PhabricatorRepositoryURI.php
index 98c08baa00..26db694a66 100644
--- a/src/applications/repository/storage/PhabricatorRepositoryURI.php
+++ b/src/applications/repository/storage/PhabricatorRepositoryURI.php
@@ -1,764 +1,762 @@
 <?php
 
 final class PhabricatorRepositoryURI
   extends PhabricatorRepositoryDAO
   implements
     PhabricatorApplicationTransactionInterface,
     PhabricatorPolicyInterface,
     PhabricatorExtendedPolicyInterface,
     PhabricatorConduitResultInterface {
 
   protected $repositoryPHID;
   protected $uri;
   protected $builtinProtocol;
   protected $builtinIdentifier;
   protected $credentialPHID;
   protected $ioType;
   protected $displayType;
   protected $isDisabled;
 
   private $repository = self::ATTACHABLE;
 
   const BUILTIN_PROTOCOL_SSH = 'ssh';
   const BUILTIN_PROTOCOL_HTTP = 'http';
   const BUILTIN_PROTOCOL_HTTPS = 'https';
 
   const BUILTIN_IDENTIFIER_ID = 'id';
   const BUILTIN_IDENTIFIER_SHORTNAME = 'shortname';
   const BUILTIN_IDENTIFIER_CALLSIGN = 'callsign';
 
   const DISPLAY_DEFAULT = 'default';
   const DISPLAY_NEVER = 'never';
   const DISPLAY_ALWAYS = 'always';
 
   const IO_DEFAULT = 'default';
   const IO_OBSERVE = 'observe';
   const IO_MIRROR = 'mirror';
   const IO_NONE = 'none';
   const IO_READ = 'read';
   const IO_READWRITE = 'readwrite';
 
   protected function getConfiguration() {
     return array(
       self::CONFIG_AUX_PHID => true,
       self::CONFIG_COLUMN_SCHEMA => array(
         'uri' => 'text255',
         'builtinProtocol' => 'text32?',
         'builtinIdentifier' => 'text32?',
         'credentialPHID' => 'phid?',
         'ioType' => 'text32',
         'displayType' => 'text32',
         'isDisabled' => 'bool',
       ),
       self::CONFIG_KEY_SCHEMA => array(
         'key_builtin' => array(
           'columns' => array(
             'repositoryPHID',
             'builtinProtocol',
             'builtinIdentifier',
           ),
           'unique' => true,
         ),
       ),
     ) + parent::getConfiguration();
   }
 
   public static function initializeNewURI() {
     return id(new self())
       ->setIoType(self::IO_DEFAULT)
       ->setDisplayType(self::DISPLAY_DEFAULT)
       ->setIsDisabled(0);
   }
 
   public function generatePHID() {
     return PhabricatorPHID::generateNewPHID(
       PhabricatorRepositoryURIPHIDType::TYPECONST);
   }
 
   public function attachRepository(PhabricatorRepository $repository) {
     $this->repository = $repository;
     return $this;
   }
 
   public function getRepository() {
     return $this->assertAttached($this->repository);
   }
 
   public function getRepositoryURIBuiltinKey() {
     if (!$this->getBuiltinProtocol()) {
       return null;
     }
 
     $parts = array(
       $this->getBuiltinProtocol(),
       $this->getBuiltinIdentifier(),
     );
 
     return implode('.', $parts);
   }
 
   public function isBuiltin() {
     return (bool)$this->getBuiltinProtocol();
   }
 
   public function getEffectiveDisplayType() {
     $display = $this->getDisplayType();
 
     if ($display != self::DISPLAY_DEFAULT) {
       return $display;
     }
 
     return $this->getDefaultDisplayType();
   }
 
   public function getDefaultDisplayType() {
     switch ($this->getEffectiveIOType()) {
       case self::IO_MIRROR:
       case self::IO_OBSERVE:
       case self::IO_NONE:
         return self::DISPLAY_NEVER;
       case self::IO_READ:
       case self::IO_READWRITE:
         // By default, only show the "best" version of the builtin URI, not the
         // other redundant versions.
         $repository = $this->getRepository();
         $other_uris = $repository->getURIs();
 
         $identifier_value = array(
           self::BUILTIN_IDENTIFIER_SHORTNAME => 3,
           self::BUILTIN_IDENTIFIER_CALLSIGN => 2,
           self::BUILTIN_IDENTIFIER_ID => 1,
         );
 
         $have_identifiers = array();
         foreach ($other_uris as $other_uri) {
           if ($other_uri->getIsDisabled()) {
             continue;
           }
 
           $identifier = $other_uri->getBuiltinIdentifier();
           if (!$identifier) {
             continue;
           }
 
           $have_identifiers[$identifier] = $identifier_value[$identifier];
         }
 
         $best_identifier = max($have_identifiers);
         $this_identifier = $identifier_value[$this->getBuiltinIdentifier()];
 
         if ($this_identifier < $best_identifier) {
           return self::DISPLAY_NEVER;
         }
 
         return self::DISPLAY_ALWAYS;
     }
 
     return self::DISPLAY_NEVER;
   }
 
 
   public function getEffectiveIOType() {
     $io = $this->getIoType();
 
     if ($io != self::IO_DEFAULT) {
       return $io;
     }
 
     return $this->getDefaultIOType();
   }
 
   public function getDefaultIOType() {
     if ($this->isBuiltin()) {
       $repository = $this->getRepository();
       $other_uris = $repository->getURIs();
 
       $any_observe = false;
       foreach ($other_uris as $other_uri) {
         if ($other_uri->getIoType() == self::IO_OBSERVE) {
           $any_observe = true;
           break;
         }
       }
 
       if ($any_observe) {
         return self::IO_READ;
       } else {
         return self::IO_READWRITE;
       }
     }
 
     return self::IO_NONE;
   }
 
   public function getNormalizedURI() {
     $vcs = $this->getRepository()->getVersionControlSystem();
 
     $map = array(
       PhabricatorRepositoryType::REPOSITORY_TYPE_GIT =>
         ArcanistRepositoryURINormalizer::TYPE_GIT,
       PhabricatorRepositoryType::REPOSITORY_TYPE_SVN =>
         ArcanistRepositoryURINormalizer::TYPE_SVN,
       PhabricatorRepositoryType::REPOSITORY_TYPE_MERCURIAL =>
         ArcanistRepositoryURINormalizer::TYPE_MERCURIAL,
     );
 
     $type = $map[$vcs];
     $display = (string)$this->getDisplayURI();
 
     $normalizer = new ArcanistRepositoryURINormalizer($type, $display);
 
     $domain_map = self::getURINormalizerDomainMap();
     $normalizer->setDomainMap($domain_map);
 
     return $normalizer->getNormalizedURI();
   }
 
   public function getDisplayURI() {
     return $this->getURIObject();
   }
 
   public function getEffectiveURI() {
     return $this->getURIObject();
   }
 
   public function getURIEnvelope() {
     $uri = $this->getEffectiveURI();
 
     $command_engine = $this->newCommandEngine();
 
     $is_http = $command_engine->isAnyHTTPProtocol();
     // For SVN, we use `--username` and `--password` flags separately in the
     // CommandEngine, so we don't need to add any credentials here.
     $is_svn = $this->getRepository()->isSVN();
     $credential_phid = $this->getCredentialPHID();
 
     if ($is_http && !$is_svn && $credential_phid) {
       $key = PassphrasePasswordKey::loadFromPHID(
         $credential_phid,
         PhabricatorUser::getOmnipotentUser());
 
       $uri->setUser($key->getUsernameEnvelope()->openEnvelope());
       $uri->setPass($key->getPasswordEnvelope()->openEnvelope());
     }
 
     return new PhutilOpaqueEnvelope((string)$uri);
   }
 
   private function getURIObject() {
     // Users can provide Git/SCP-style URIs in the form "user@host:path".
     // In the general case, these are not equivalent to any "ssh://..." form
     // because the path is relative.
 
     if ($this->isBuiltin()) {
       $builtin_protocol = $this->getForcedProtocol();
       $builtin_domain = $this->getForcedHost();
       $raw_uri = "{$builtin_protocol}://{$builtin_domain}";
     } else {
       $raw_uri = $this->getURI();
     }
 
     $port = $this->getForcedPort();
 
     $default_ports = array(
       'ssh' => 22,
       'http' => 80,
       'https' => 443,
     );
 
     $uri = new PhutilURI($raw_uri);
 
     // Make sure to remove any password from the URI before we do anything
     // with it; this should always be provided by the associated credential.
     $uri->setPass(null);
 
     $protocol = $this->getForcedProtocol();
     if ($protocol) {
       $uri->setProtocol($protocol);
     }
 
     if ($port) {
       $uri->setPort($port);
     }
 
     // Remove any explicitly set default ports.
     $uri_port = $uri->getPort();
     $uri_protocol = $uri->getProtocol();
 
     $uri_default = idx($default_ports, $uri_protocol);
     if ($uri_default && ($uri_default == $uri_port)) {
       $uri->setPort(null);
     }
 
     $user = $this->getForcedUser();
     if ($user) {
       $uri->setUser($user);
     }
 
     $host = $this->getForcedHost();
     if ($host) {
       $uri->setDomain($host);
     }
 
     $path = $this->getForcedPath();
     if ($path) {
       $uri->setPath($path);
     }
 
     return $uri;
   }
 
 
   private function getForcedProtocol() {
     $repository = $this->getRepository();
 
     switch ($this->getBuiltinProtocol()) {
       case self::BUILTIN_PROTOCOL_SSH:
         if ($repository->isSVN()) {
           return 'svn+ssh';
         } else {
           return 'ssh';
         }
       case self::BUILTIN_PROTOCOL_HTTP:
         return 'http';
       case self::BUILTIN_PROTOCOL_HTTPS:
         return 'https';
       default:
         return null;
     }
   }
 
   private function getForcedUser() {
     switch ($this->getBuiltinProtocol()) {
       case self::BUILTIN_PROTOCOL_SSH:
         return AlmanacKeys::getClusterSSHUser();
       default:
         return null;
     }
   }
 
   private function getForcedHost() {
     $phabricator_uri = PhabricatorEnv::getURI('/');
     $phabricator_uri = new PhutilURI($phabricator_uri);
 
     $phabricator_host = $phabricator_uri->getDomain();
 
     switch ($this->getBuiltinProtocol()) {
       case self::BUILTIN_PROTOCOL_SSH:
         $ssh_host = PhabricatorEnv::getEnvConfig('diffusion.ssh-host');
         if ($ssh_host !== null) {
           return $ssh_host;
         }
         return $phabricator_host;
       case self::BUILTIN_PROTOCOL_HTTP:
       case self::BUILTIN_PROTOCOL_HTTPS:
         return $phabricator_host;
       default:
         return null;
     }
   }
 
   private function getForcedPort() {
     $protocol = $this->getBuiltinProtocol();
 
     if ($protocol == self::BUILTIN_PROTOCOL_SSH) {
       return PhabricatorEnv::getEnvConfig('diffusion.ssh-port');
     }
 
     // If Phabricator is running on a nonstandard port, use that as the default
     // port for URIs with the same protocol.
 
     $is_http = ($protocol == self::BUILTIN_PROTOCOL_HTTP);
     $is_https = ($protocol == self::BUILTIN_PROTOCOL_HTTPS);
 
     if ($is_http || $is_https) {
       $uri = PhabricatorEnv::getURI('/');
       $uri = new PhutilURI($uri);
 
       $port = $uri->getPort();
       if (!$port) {
         return null;
       }
 
       $uri_protocol = $uri->getProtocol();
       $use_port =
         ($is_http && ($uri_protocol == 'http')) ||
         ($is_https && ($uri_protocol == 'https'));
 
       if (!$use_port) {
         return null;
       }
 
       return $port;
     }
 
     return null;
   }
 
   private function getForcedPath() {
     if (!$this->isBuiltin()) {
       return null;
     }
 
     $repository = $this->getRepository();
 
     $id = $repository->getID();
     $callsign = $repository->getCallsign();
     $short_name = $repository->getRepositorySlug();
 
     $clone_name = $repository->getCloneName();
 
     if ($repository->isGit()) {
       $suffix = '.git';
     } else if ($repository->isHg()) {
       $suffix = '/';
     } else {
       $suffix = '';
       $clone_name = '';
     }
 
     switch ($this->getBuiltinIdentifier()) {
       case self::BUILTIN_IDENTIFIER_ID:
         return "/diffusion/{$id}/{$clone_name}{$suffix}";
       case self::BUILTIN_IDENTIFIER_SHORTNAME:
         return "/source/{$short_name}{$suffix}";
       case self::BUILTIN_IDENTIFIER_CALLSIGN:
         return "/diffusion/{$callsign}/{$clone_name}{$suffix}";
       default:
         return null;
     }
   }
 
   public function getViewURI() {
     $id = $this->getID();
     return $this->getRepository()->getPathURI("uri/view/{$id}/");
   }
 
   public function getEditURI() {
     $id = $this->getID();
     return $this->getRepository()->getPathURI("uri/edit/{$id}/");
   }
 
   public function getAvailableIOTypeOptions() {
     $options = array(
       self::IO_DEFAULT,
       self::IO_NONE,
     );
 
     if ($this->isBuiltin()) {
       $options[] = self::IO_READ;
       $options[] = self::IO_READWRITE;
     } else {
       $options[] = self::IO_OBSERVE;
       $options[] = self::IO_MIRROR;
     }
 
     $map = array();
     $io_map = self::getIOTypeMap();
     foreach ($options as $option) {
       $spec = idx($io_map, $option, array());
 
       $label = idx($spec, 'label', $option);
       $short = idx($spec, 'short');
 
       $name = pht('%s: %s', $label, $short);
       $map[$option] = $name;
     }
 
     return $map;
   }
 
   public function getAvailableDisplayTypeOptions() {
     $options = array(
       self::DISPLAY_DEFAULT,
       self::DISPLAY_ALWAYS,
       self::DISPLAY_NEVER,
     );
 
     $map = array();
     $display_map = self::getDisplayTypeMap();
     foreach ($options as $option) {
       $spec = idx($display_map, $option, array());
 
       $label = idx($spec, 'label', $option);
       $short = idx($spec, 'short');
 
       $name = pht('%s: %s', $label, $short);
       $map[$option] = $name;
     }
 
     return $map;
   }
 
   public static function getIOTypeMap() {
     return array(
       self::IO_DEFAULT => array(
         'label' => pht('Default'),
         'short' => pht('Use default behavior.'),
       ),
       self::IO_OBSERVE => array(
         'icon' => 'fa-download',
         'color' => 'green',
         'label' => pht('Observe'),
         'note' => pht(
-          'Phabricator will observe changes to this URI and copy them.'),
+          'Changes to this URI will be observed and pulled.'),
         'short' => pht('Copy from a remote.'),
       ),
       self::IO_MIRROR => array(
         'icon' => 'fa-upload',
         'color' => 'green',
         'label' => pht('Mirror'),
         'note' => pht(
-          'Phabricator will push a copy of any changes to this URI.'),
+          'A copy of any changes will be pushed to this URI.'),
         'short' => pht('Push a copy to a remote.'),
       ),
       self::IO_NONE => array(
         'icon' => 'fa-times',
         'color' => 'grey',
         'label' => pht('No I/O'),
         'note' => pht(
-          'Phabricator will not push or pull any changes to this URI.'),
+          'No changes will be pushed or pulled from this URI.'),
         'short' => pht('Do not perform any I/O.'),
       ),
       self::IO_READ => array(
         'icon' => 'fa-folder',
         'color' => 'blue',
         'label' => pht('Read Only'),
         'note' => pht(
-          'Phabricator will serve a read-only copy of the repository from '.
-          'this URI.'),
+          'A read-only copy of the repository will be served from this URI.'),
         'short' => pht('Serve repository in read-only mode.'),
       ),
       self::IO_READWRITE => array(
         'icon' => 'fa-folder-open',
         'color' => 'blue',
         'label' => pht('Read/Write'),
         'note' => pht(
-          'Phabricator will serve a read/write copy of the repository from '.
-          'this URI.'),
+          'A read/write copy of the repository will be served from this URI.'),
         'short' => pht('Serve repository in read/write mode.'),
       ),
     );
   }
 
   public static function getDisplayTypeMap() {
     return array(
       self::DISPLAY_DEFAULT => array(
         'label' => pht('Default'),
         'short' => pht('Use default behavior.'),
       ),
       self::DISPLAY_ALWAYS => array(
         'icon' => 'fa-eye',
         'color' => 'green',
         'label' => pht('Visible'),
         'note' => pht('This URI will be shown to users as a clone URI.'),
         'short' => pht('Show as a clone URI.'),
       ),
       self::DISPLAY_NEVER => array(
         'icon' => 'fa-eye-slash',
         'color' => 'grey',
         'label' => pht('Hidden'),
         'note' => pht(
           'This URI will be hidden from users.'),
         'short' => pht('Do not show as a clone URI.'),
       ),
     );
   }
 
   public function newCommandEngine() {
     $repository = $this->getRepository();
 
     return DiffusionCommandEngine::newCommandEngine($repository)
       ->setCredentialPHID($this->getCredentialPHID())
       ->setURI($this->getEffectiveURI());
   }
 
   public function getURIScore() {
     $score = 0;
 
     $io_points = array(
       self::IO_READWRITE => 200,
       self::IO_READ => 100,
     );
     $score += idx($io_points, $this->getEffectiveIOType(), 0);
 
     $protocol_points = array(
       self::BUILTIN_PROTOCOL_SSH => 30,
       self::BUILTIN_PROTOCOL_HTTPS => 20,
       self::BUILTIN_PROTOCOL_HTTP => 10,
     );
     $score += idx($protocol_points, $this->getBuiltinProtocol(), 0);
 
     $identifier_points = array(
       self::BUILTIN_IDENTIFIER_SHORTNAME => 3,
       self::BUILTIN_IDENTIFIER_CALLSIGN => 2,
       self::BUILTIN_IDENTIFIER_ID => 1,
     );
     $score += idx($identifier_points, $this->getBuiltinIdentifier(), 0);
 
     return $score;
   }
 
 
 
 /* -(  PhabricatorApplicationTransactionInterface  )------------------------- */
 
 
   public function getApplicationTransactionEditor() {
     return new DiffusionURIEditor();
   }
 
   public function getApplicationTransactionTemplate() {
     return new PhabricatorRepositoryURITransaction();
   }
 
 
 /* -(  PhabricatorPolicyInterface  )----------------------------------------- */
 
 
   public function getCapabilities() {
     return array(
       PhabricatorPolicyCapability::CAN_VIEW,
       PhabricatorPolicyCapability::CAN_EDIT,
     );
   }
 
   public function getPolicy($capability) {
     switch ($capability) {
       case PhabricatorPolicyCapability::CAN_VIEW:
       case PhabricatorPolicyCapability::CAN_EDIT:
         return PhabricatorPolicies::getMostOpenPolicy();
     }
   }
 
   public function hasAutomaticCapability($capability, PhabricatorUser $viewer) {
     return false;
   }
 
 
 /* -(  PhabricatorExtendedPolicyInterface  )--------------------------------- */
 
 
   public function getExtendedPolicy($capability, PhabricatorUser $viewer) {
     $extended = array();
 
     switch ($capability) {
       case PhabricatorPolicyCapability::CAN_EDIT:
         // To edit a repository URI, you must be able to edit the
         // corresponding repository.
         $extended[] = array($this->getRepository(), $capability);
         break;
     }
 
     return $extended;
   }
 
 
 /* -(  PhabricatorConduitResultInterface  )---------------------------------- */
 
 
   public function getFieldSpecificationsForConduit() {
     return array(
       id(new PhabricatorConduitSearchFieldSpecification())
         ->setKey('repositoryPHID')
         ->setType('phid')
         ->setDescription(pht('The associated repository PHID.')),
       id(new PhabricatorConduitSearchFieldSpecification())
         ->setKey('uri')
         ->setType('map<string, string>')
         ->setDescription(pht('The raw and effective URI.')),
       id(new PhabricatorConduitSearchFieldSpecification())
         ->setKey('io')
         ->setType('map<string, const>')
         ->setDescription(
           pht('The raw, default, and effective I/O Type settings.')),
       id(new PhabricatorConduitSearchFieldSpecification())
         ->setKey('display')
         ->setType('map<string, const>')
         ->setDescription(
           pht('The raw, default, and effective Display Type settings.')),
       id(new PhabricatorConduitSearchFieldSpecification())
         ->setKey('credentialPHID')
         ->setType('phid?')
         ->setDescription(
           pht('The associated credential PHID, if one exists.')),
       id(new PhabricatorConduitSearchFieldSpecification())
         ->setKey('disabled')
         ->setType('bool')
         ->setDescription(pht('True if the URI is disabled.')),
       id(new PhabricatorConduitSearchFieldSpecification())
         ->setKey('builtin')
         ->setType('map<string, string>')
         ->setDescription(
           pht('Information about builtin URIs.')),
       id(new PhabricatorConduitSearchFieldSpecification())
         ->setKey('dateCreated')
         ->setType('int')
         ->setDescription(
           pht('Epoch timestamp when the object was created.')),
       id(new PhabricatorConduitSearchFieldSpecification())
         ->setKey('dateModified')
         ->setType('int')
         ->setDescription(
           pht('Epoch timestamp when the object was last updated.')),
     );
   }
 
   public function getFieldValuesForConduit() {
     return array(
       'repositoryPHID' => $this->getRepositoryPHID(),
       'uri' => array(
         'raw' => $this->getURI(),
         'display' => (string)$this->getDisplayURI(),
         'effective' => (string)$this->getEffectiveURI(),
         'normalized' => (string)$this->getNormalizedURI(),
       ),
       'io' => array(
         'raw' => $this->getIOType(),
         'default' => $this->getDefaultIOType(),
         'effective' => $this->getEffectiveIOType(),
       ),
       'display' => array(
         'raw' => $this->getDisplayType(),
         'default' => $this->getDefaultDisplayType(),
         'effective' => $this->getEffectiveDisplayType(),
       ),
       'credentialPHID' => $this->getCredentialPHID(),
       'disabled' => (bool)$this->getIsDisabled(),
       'builtin' => array(
         'protocol' => $this->getBuiltinProtocol(),
         'identifier' => $this->getBuiltinIdentifier(),
       ),
       'dateCreated' => $this->getDateCreated(),
       'dateModified' => $this->getDateModified(),
     );
   }
 
   public function getConduitSearchAttachments() {
     return array();
   }
 
   public static function getURINormalizerDomainMap() {
     $domain_map = array();
 
     // See T13435. If the domain for a repository URI is same as the install
     // base URI, store it as a "<base-uri>" token instead of the actual domain
     // so that the index does not fall out of date if the install moves.
 
     $base_uri = PhabricatorEnv::getURI('/');
     $base_uri = new PhutilURI($base_uri);
     $base_domain = $base_uri->getDomain();
     $domain_map['<base-uri>'] = $base_domain;
 
     // Likewise, store a token for the "SSH Host" domain so it can be changed
     // without requiring an index rebuild.
 
     $ssh_host = PhabricatorEnv::getEnvConfig('diffusion.ssh-host');
     if (strlen($ssh_host)) {
       $domain_map['<ssh-host>'] = $ssh_host;
     }
 
     return $domain_map;
   }
 
 }
diff --git a/src/applications/settings/panel/PhabricatorExternalEditorSettingsPanel.php b/src/applications/settings/panel/PhabricatorExternalEditorSettingsPanel.php
index c331d3d762..3a49b6c3c3 100644
--- a/src/applications/settings/panel/PhabricatorExternalEditorSettingsPanel.php
+++ b/src/applications/settings/panel/PhabricatorExternalEditorSettingsPanel.php
@@ -1,171 +1,171 @@
 <?php
 
 final class PhabricatorExternalEditorSettingsPanel
   extends PhabricatorEditEngineSettingsPanel {
 
   const PANELKEY = 'editor';
 
   public function getPanelName() {
     return pht('External Editor');
   }
 
   public function getPanelMenuIcon() {
     return 'fa-i-cursor';
   }
 
   public function getPanelGroupKey() {
     return PhabricatorSettingsApplicationsPanelGroup::PANELGROUPKEY;
   }
 
   public function isTemplatePanel() {
     return true;
   }
 
   public function newSettingsPanelEditFormHeadContent(
     PhabricatorEditEnginePageState $state) {
 
     // The "Editor" setting stored in the database may be invalidated by
     // configuration or software changes. If a saved URI becomes invalid
     // (for example, its protocol is removed from the list of allowed
     // protocols), it will stop working.
 
     // If the stored value has a problem like this, show a static error
     // message without requiring the user to save changes.
 
     if ($state->getIsSubmit()) {
       return null;
     }
 
     $viewer = $this->getViewer();
     $pattern = $viewer->getUserSetting(PhabricatorEditorSetting::SETTINGKEY);
 
     if (!strlen($pattern)) {
       return null;
     }
 
     $caught = null;
     try {
       id(new PhabricatorEditorURIEngine())
         ->setPattern($pattern)
         ->validatePattern();
     } catch (PhabricatorEditorURIParserException $ex) {
       $caught = $ex;
     }
 
     if (!$caught) {
       return null;
     }
 
     return id(new PHUIInfoView())
       ->setSeverity(PHUIInfoView::SEVERITY_WARNING)
       ->appendChild($caught->getMessage());
   }
 
   public function newSettingsPanelEditFormTailContent(
     PhabricatorEditEnginePageState $state) {
     $viewer = $this->getViewer();
 
     $variables = PhabricatorEditorURIEngine::getVariableDefinitions();
 
     $rows = array();
     foreach ($variables as $key => $variable) {
       $rows[] = array(
         phutil_tag('tt', array(), '%'.$key),
         $variable['name'],
         $variable['example'],
       );
     }
 
     $table = id(new AphrontTableView($rows))
       ->setHeaders(
         array(
           pht('Variable'),
           pht('Replaced With'),
           pht('Example'),
         ))
       ->setColumnClasses(
         array(
           'center',
           'pri',
           'wide',
         ));
 
     $variables_box = id(new PHUIObjectBoxView())
       ->setBackground(PHUIObjectBoxView::WHITE_CONFIG)
       ->setHeaderText(pht('External Editor URI Variables'))
       ->setTable($table);
 
     $label_map = array(
       'http' => pht('Hypertext Transfer Protocol'),
       'https' => pht('Hypertext Transfer Protocol over SSL'),
       'txmt' => pht('TextMate'),
       'mvim' => pht('MacVim'),
       'subl' => pht('Sublime Text'),
       'vim' => pht('Vim'),
       'emacs' => pht('Emacs'),
       'vscode' => pht('Visual Studio Code'),
       'editor' => pht('Generic Editor'),
       'idea' => pht('IntelliJ IDEA'),
     );
 
     $default_label = phutil_tag('em', array(), pht('Supported Protocol'));
 
     $config_key = 'uri.allowed-editor-protocols';
 
     $protocols = PhabricatorEnv::getEnvConfig($config_key);
     $protocols = array_keys($protocols);
     sort($protocols);
 
     $protocol_rows = array();
     foreach ($protocols as $protocol) {
       $label = idx($label_map, $protocol, $default_label);
 
       $protocol_rows[] = array(
         $protocol.'://',
         $label,
       );
     }
 
     $protocol_table = id(new AphrontTableView($protocol_rows))
       ->setNoDataString(
         pht(
-          'Phabricator is not configured to allow any editor protocols.'))
+          'No allowed editor protocols are configured.'))
       ->setHeaders(
         array(
           pht('Protocol'),
           pht('Description'),
         ))
       ->setColumnClasses(
         array(
           'pri',
           'wide',
         ));
 
     $is_admin = $viewer->getIsAdmin();
 
     $configure_button = id(new PHUIButtonView())
       ->setTag('a')
       ->setText(pht('View Configuration'))
       ->setIcon('fa-sliders')
       ->setHref(
         urisprintf(
           '/config/edit/%s/',
           $config_key))
       ->setDisabled(!$is_admin);
 
     $protocol_header = id(new PHUIHeaderView())
       ->setHeader(pht('Supported Editor Protocols'))
       ->addActionLink($configure_button);
 
     $protocols_box = id(new PHUIObjectBoxView())
       ->setBackground(PHUIObjectBoxView::WHITE_CONFIG)
       ->setHeader($protocol_header)
       ->setTable($protocol_table);
 
     return array(
       $variables_box,
       $protocols_box,
     );
   }
 
 }
diff --git a/src/applications/settings/setting/PhabricatorEmailStampsSetting.php b/src/applications/settings/setting/PhabricatorEmailStampsSetting.php
index 39403f40a0..52497f3c42 100644
--- a/src/applications/settings/setting/PhabricatorEmailStampsSetting.php
+++ b/src/applications/settings/setting/PhabricatorEmailStampsSetting.php
@@ -1,47 +1,47 @@
 <?php
 
 final class PhabricatorEmailStampsSetting
   extends PhabricatorSelectSetting {
 
   const SETTINGKEY = 'stamps';
 
   const VALUE_BODY_STAMPS = 'body';
   const VALUE_HEADER_STAMPS = 'header';
 
   public function getSettingName() {
     return pht('Send Stamps');
   }
 
   public function getSettingPanelKey() {
     return PhabricatorEmailFormatSettingsPanel::PANELKEY;
   }
 
   protected function getSettingOrder() {
     return 400;
   }
 
   protected function getControlInstructions() {
     return pht(<<<EOREMARKUP
-Phabricator stamps mail with labels like `actor(alice)` which can be used to
+Outgoing mail is stamped with labels like `actor(alice)` which can be used to
 write client mail rules to organize mail. By default, these stamps are sent
 in an `X-Phabricator-Stamps` header.
 
 If you use a client which can not use headers to route mail (like Gmail),
 you can also include the stamps in the message body so mail rules based on
 body content can route messages.
 EOREMARKUP
       );
   }
 
   public function getSettingDefaultValue() {
     return self::VALUE_HEADER_STAMPS;
   }
 
   protected function getSelectOptions() {
     return array(
       self::VALUE_HEADER_STAMPS => pht('Mail Headers'),
       self::VALUE_BODY_STAMPS => pht('Mail Headers and Body'),
     );
   }
 
 }
diff --git a/src/applications/settings/setting/PhabricatorTranslationSetting.php b/src/applications/settings/setting/PhabricatorTranslationSetting.php
index 09f77c2ba4..42657e396c 100644
--- a/src/applications/settings/setting/PhabricatorTranslationSetting.php
+++ b/src/applications/settings/setting/PhabricatorTranslationSetting.php
@@ -1,119 +1,119 @@
 <?php
 
 final class PhabricatorTranslationSetting
   extends PhabricatorOptionGroupSetting {
 
   const SETTINGKEY = 'translation';
 
   public function getSettingName() {
     return pht('Translation');
   }
 
   public function getSettingPanelKey() {
     return PhabricatorLanguageSettingsPanel::PANELKEY;
   }
 
   protected function getSettingOrder() {
     return 100;
   }
 
   public function getSettingDefaultValue() {
     return 'en_US';
   }
 
   protected function getControlInstructions() {
     return pht(
-      'Choose which language you would like the Phabricator UI to use.');
+      'Choose which language you would like the UI to use.');
   }
 
   public function assertValidValue($value) {
     $locales = PhutilLocale::loadAllLocales();
     return isset($locales[$value]);
   }
 
   protected function getSelectOptionGroups() {
     $locales = PhutilLocale::loadAllLocales();
 
     $group_labels = array(
       'normal' => pht('Translations'),
       'limited' => pht('Limited Translations'),
       'silly' => pht('Silly Translations'),
       'test' => pht('Developer/Test Translations'),
     );
 
     $groups = array_fill_keys(array_keys($group_labels), array());
 
     $translations = array();
     foreach ($locales as $locale) {
       $code = $locale->getLocaleCode();
 
       // Get the locale's localized name if it's available. For example,
       // "Deutsch" instead of "German". This helps users who do not speak the
       // current language to find the correct setting.
       $raw_scope = PhabricatorEnv::beginScopedLocale($code);
       $name = $locale->getLocaleName();
       unset($raw_scope);
 
       if ($locale->isSillyLocale()) {
         $groups['silly'][$code] = $name;
         continue;
       }
 
       if ($locale->isTestLocale()) {
         $groups['test'][$code] = $name;
         continue;
       }
 
       $strings = PhutilTranslation::getTranslationMapForLocale($code);
       $size = count($strings);
 
       // If a translation is English, assume it can fall back to the default
       // strings and don't caveat its completeness.
       $is_english = (substr($code, 0, 3) == 'en_');
 
       // Arbitrarily pick some number of available strings to promote a
       // translation out of the "limited" group. The major goal is just to
       // keep locales with very few strings out of the main group, so users
       // aren't surprised if a locale has no upstream translations available.
       if ($size > 512 || $is_english) {
         $type = 'normal';
       } else {
         $type = 'limited';
       }
 
       $groups[$type][$code] = $name;
     }
 
     // Omit silly locales on serious business installs.
     $is_serious = PhabricatorEnv::getEnvConfig('phabricator.serious-business');
     if ($is_serious) {
       unset($groups['silly']);
     }
 
     // Omit limited and test translations if Phabricator is not in developer
     // mode.
     $is_dev = PhabricatorEnv::getEnvConfig('phabricator.developer-mode');
     if (!$is_dev) {
       unset($groups['limited']);
       unset($groups['test']);
     }
 
     $results = array();
     foreach ($groups as $key => $group) {
       $label = $group_labels[$key];
       if (!$group) {
         continue;
       }
 
       asort($group);
 
       $results[] = array(
         'label' => $label,
         'options' => $group,
       );
     }
 
     return $results;
   }
 
 }
diff --git a/src/applications/system/controller/PhabricatorSystemReadOnlyController.php b/src/applications/system/controller/PhabricatorSystemReadOnlyController.php
index 7541e9adf4..e83fe67b0e 100644
--- a/src/applications/system/controller/PhabricatorSystemReadOnlyController.php
+++ b/src/applications/system/controller/PhabricatorSystemReadOnlyController.php
@@ -1,134 +1,135 @@
 <?php
 
 final class PhabricatorSystemReadOnlyController
   extends PhabricatorController {
 
   public function shouldRequireLogin() {
     return false;
   }
 
   public function handleRequest(AphrontRequest $request) {
     $viewer = $this->getViewer();
     $reason = $request->getURIData('reason');
 
     $body = array();
     switch ($reason) {
       case PhabricatorEnv::READONLY_CONFIG:
         $title = pht('Administrative Read-Only Mode');
         $body[] = pht(
-          'An administrator has placed Phabricator into read-only mode.');
+          'An administrator has placed this server into read-only mode.');
         $body[] = pht(
           'This mode may be used to perform temporary maintenance, test '.
           'configuration, or archive an installation permanently.');
         $body[] = pht(
           'Read-only mode was enabled by the explicit action of a human '.
           'administrator, so you can get more information about why it '.
           'has been turned on by rolling your chair away from your desk and '.
-          'yelling "Hey! Why is Phabricator in read-only mode??!" using '.
-          'your very loudest outside voice.');
+          'yelling "Hey! Why is %s in read-only mode??!" using '.
+          'your very loudest outside voice.',
+          PlatformSymbols::getPlatformServerSymbol());
         $body[] = pht(
           'This mode is active because it is enabled in the configuration '.
           'option "%s".',
           phutil_tag('tt', array(), 'cluster.read-only'));
         $button = pht('Wait Patiently');
         break;
       case PhabricatorEnv::READONLY_MASTERLESS:
         $title = pht('No Writable Database');
         $body[] = pht(
-          'Phabricator is currently configured with no writable ("master") '.
+          'This server is currently configured with no writable ("master") '.
           'database, so it can not write new information anywhere. '.
-          'Phabricator will run in read-only mode until an administrator '.
+          'This server will run in read-only mode until an administrator '.
           'reconfigures it with a writable database.');
         $body[] = pht(
           'This usually occurs when an administrator is actively working on '.
           'fixing a temporary configuration or deployment problem.');
         $body[] = pht(
           'This mode is active because no database has a "%s" role in '.
           'the configuration option "%s".',
           phutil_tag('tt', array(), 'master'),
           phutil_tag('tt', array(), 'cluster.databases'));
         $button = pht('Wait Patiently');
         break;
       case PhabricatorEnv::READONLY_UNREACHABLE:
         $title = pht('Unable to Reach Master');
         $body[] = pht(
-          'Phabricator was unable to connect to the writable ("master") '.
+          'This server was unable to connect to the writable ("master") '.
           'database while handling this request, and automatically degraded '.
           'into read-only mode.');
         $body[] = pht(
           'This may happen if there is a temporary network anomaly on the '.
           'server side, like cosmic radiation or spooky ghosts. If this '.
           'failure was caused by a transient service interruption, '.
-          'Phabricator will recover momentarily.');
+          'this server will recover momentarily.');
         $body[] = pht(
           'This may also indicate that a more serious failure has occurred. '.
-          'If this interruption does not resolve on its own, Phabricator '.
+          'If this interruption does not resolve on its own, this server '.
           'will soon detect the persistent disruption and degrade into '.
           'read-only mode until the issue is resolved.');
         $button = pht('Quite Unsettling');
         break;
       case PhabricatorEnv::READONLY_SEVERED:
         $title = pht('Severed From Master');
         $body[] = pht(
-          'Phabricator has consistently been unable to reach the writable '.
+          'This server has consistently been unable to reach the writable '.
           '("master") database while processing recent requests.');
         $body[] = pht(
           'This likely indicates a severe misconfiguration or major service '.
           'interruption.');
         $body[] = pht(
-          'Phabricator will periodically retry the connection and recover '.
+          'This server will periodically retry the connection and recover '.
           'once service is restored. Most causes of persistent service '.
           'interruption will require administrative intervention in order '.
           'to restore service.');
         $body[] = pht(
           'Although this may be the result of a misconfiguration or '.
           'operational error, this is also the state you reach if a '.
           'meteor recently obliterated a datacenter.');
         $button = pht('Panic!');
         break;
       default:
         return new Aphront404Response();
     }
 
     switch ($reason) {
       case PhabricatorEnv::READONLY_UNREACHABLE:
       case PhabricatorEnv::READONLY_SEVERED:
         $body[] = pht(
           'This request was served from a replica database. Replica '.
           'databases may lag behind the master, so very recent activity '.
           'may not be reflected in the UI. This data will be restored if '.
           'the master database is restored, but may have been lost if the '.
           'master database has been reduced to a pile of ash.');
         break;
     }
 
     $body[] = pht(
       'In read-only mode you can read existing information, but you will not '.
       'be able to edit objects or create new objects until this mode is '.
       'disabled.');
 
     if ($viewer->getIsAdmin()) {
       $body[] = pht(
         'As an administrator, you can review status information from the '.
         '%s control panel. This may provide more information about the '.
         'current state of affairs.',
         phutil_tag(
           'a',
           array(
             'href' => '/config/cluster/databases/',
           ),
           pht('Cluster Database Status')));
     }
 
     $dialog = $this->newDialog()
       ->setTitle($title)
       ->setWidth(AphrontDialogView::WIDTH_FORM)
       ->addCancelButton('/', $button);
 
     foreach ($body as $paragraph) {
       $dialog->appendParagraph($paragraph);
     }
 
     return $dialog;
   }
 }
diff --git a/src/applications/transactions/conduit/TransactionSearchConduitAPIMethod.php b/src/applications/transactions/conduit/TransactionSearchConduitAPIMethod.php
index 422d570bd0..82eaf08e83 100644
--- a/src/applications/transactions/conduit/TransactionSearchConduitAPIMethod.php
+++ b/src/applications/transactions/conduit/TransactionSearchConduitAPIMethod.php
@@ -1,417 +1,417 @@
 <?php
 
 final class TransactionSearchConduitAPIMethod
   extends ConduitAPIMethod {
 
   public function getAPIMethodName() {
     return 'transaction.search';
   }
 
   public function getMethodDescription() {
     return pht(
       'Read transactions and comments for a particular object '.
       'or an entire object type.');
   }
 
   protected function newDocumentationPages(PhabricatorUser $viewer) {
     $markup = pht(<<<EOREMARKUP
-When an object (like a task) is edited, Phabricator creates a "transaction"
-and applies it. This list of transactions on each object is the basis for
-essentially all edits and comments in Phabricator. Reviewing the transaction
+When an object (like a task) is edited, the relevant application creates a
+"transaction" and applies it. This list of transactions on each object is the
+basis for essentially all edits and comments. Reviewing the transaction
 record allows you to see who edited an object, when, and how their edit changed
 things.
 
 One common reason to call this method is that you're implmenting a webhook and
 just received a notification that an object has changed. See the Webhooks
 documentation for more detailed discussion of this use case.
 
 One Object Type at a Time
 =========================
 
 This API method can query transactions for any type of object which supports
 transactions, but only one type of object can be queried per call. For example:
 you can retrieve transactions affecting Tasks, or you can retrieve transactions
 affecting Revisions, but a single call can not retrieve both.
 
 This is a technical limitation arising because (among other reasons) there is
 no global ordering on transactions.
 
 To find transactions for a specific object (like a particular task), pass the
 object PHID or an appropriate object identifier (like `T123`) as an
 `objectIdentifier`.
 
 To find all transactions for an object type, pass the object type constant as
 an `objectType`. For example, the correct identifier for tasks is `TASK`. (You
 can quickly find an unknown type constant by looking at the PHID of an object
 of that type.)
 
 Constraints
 ===========
 
 These constraints are supported:
 
   - `phids` //Optional list<phid>.// Find specific transactions by PHID. This
     is most likely to be useful if you're responding to a webhook notification
     and want to inspect only the related events.
   - `authorPHIDs` //Optional list<phid>.// Find transactions with particular
     authors.
 
 Transaction Format
 ==================
 
 Each transaction has custom data describing what the transaction did. The
 format varies from transaction to transaction. The easiest way to figure out
 exactly what a particular transaction looks like is to make the associated kind
 of edit to a test object, then query that object.
 
 Not all transactions have data: by default, transactions have a `null` "type"
 and no additional data. This API does not expose raw transaction data because
 some of it is internal, oddly named, misspelled, confusing, not useful, or
 could create security or policy problems to expose directly.
 
 New transactions are exposed (with correctly spelled, comprehensible types and
 useful, reasonable fields) as we become aware of use cases for them.
 
 EOREMARKUP
       );
 
     $markup = $this->newRemarkupDocumentationView($markup);
 
     return array(
       $this->newDocumentationBoxPage($viewer, pht('Method Details'), $markup)
         ->setAnchor('details'),
     );
   }
 
   protected function defineParamTypes() {
     return array(
       'objectIdentifier' => 'optional phid|string',
       'objectType' => 'optional string',
       'constraints' => 'optional map<string, wild>',
     ) + $this->getPagerParamTypes();
   }
 
   protected function defineReturnType() {
     return 'list<dict>';
   }
 
   protected function defineErrorTypes() {
     return array();
   }
 
   protected function execute(ConduitAPIRequest $request) {
     $viewer = $request->getUser();
     $pager = $this->newPager($request);
 
     $object = $this->loadTemplateObject($request);
 
     $xaction_query = PhabricatorApplicationTransactionQuery::newQueryForObject(
       $object);
 
     $xaction_query
       ->needHandles(false)
       ->setViewer($viewer);
 
     if ($object->getPHID()) {
       $xaction_query->withObjectPHIDs(array($object->getPHID()));
     }
 
     $constraints = $request->getValue('constraints', array());
 
     $xaction_query = $this->applyConstraints($constraints, $xaction_query);
 
     $xactions = $xaction_query->executeWithCursorPager($pager);
 
     $comment_map = array();
     if ($xactions) {
       $template = head($xactions)->getApplicationTransactionCommentObject();
       if ($template) {
 
         $query = new PhabricatorApplicationTransactionTemplatedCommentQuery();
 
         $comment_map = $query
           ->setViewer($viewer)
           ->setTemplate($template)
           ->withTransactionPHIDs(mpull($xactions, 'getPHID'))
           ->execute();
 
         $comment_map = msort($comment_map, 'getCommentVersion');
         $comment_map = array_reverse($comment_map);
         $comment_map = mgroup($comment_map, 'getTransactionPHID');
       }
     }
 
     $modular_classes = array();
     $modular_objects = array();
     $modular_xactions = array();
     foreach ($xactions as $xaction) {
       if (!$xaction instanceof PhabricatorModularTransaction) {
         continue;
       }
 
       // TODO: Hack things so certain transactions which don't have a modular
       // type yet can use a pseudotype until they modularize. Some day, we'll
       // modularize everything and remove this.
       switch ($xaction->getTransactionType()) {
         case DifferentialTransaction::TYPE_INLINE:
           $modular_template = new DifferentialRevisionInlineTransaction();
           break;
         default:
           $modular_template = $xaction->getModularType();
           break;
       }
 
       $modular_class = get_class($modular_template);
       if (!isset($modular_objects[$modular_class])) {
         try {
           $modular_object = newv($modular_class, array());
           $modular_objects[$modular_class] = $modular_object;
         } catch (Exception $ex) {
           continue;
         }
       }
 
       $modular_classes[$xaction->getPHID()] = $modular_class;
       $modular_xactions[$modular_class][] = $xaction;
     }
 
     $modular_data_map = array();
     foreach ($modular_objects as $class => $modular_type) {
       $modular_data_map[$class] = $modular_type
         ->setViewer($viewer)
         ->loadTransactionTypeConduitData($modular_xactions[$class]);
     }
 
     $data = array();
     foreach ($xactions as $xaction) {
       $comments = idx($comment_map, $xaction->getPHID());
 
       $comment_data = array();
       if ($comments) {
         $removed = head($comments)->getIsDeleted();
 
         foreach ($comments as $comment) {
           if ($removed) {
             // If the most recent version of the comment has been removed,
             // don't show the history. This is for consistency with the web
             // UI, which also prevents users from retrieving the content of
             // removed comments.
             $content = array(
               'raw' => '',
             );
           } else {
             $content = array(
               'raw' => (string)$comment->getContent(),
             );
           }
 
           $comment_data[] = array(
             'id' => (int)$comment->getID(),
             'phid' => (string)$comment->getPHID(),
             'version' => (int)$comment->getCommentVersion(),
             'authorPHID' => (string)$comment->getAuthorPHID(),
             'dateCreated' => (int)$comment->getDateCreated(),
             'dateModified' => (int)$comment->getDateModified(),
             'removed' => (bool)$comment->getIsDeleted(),
             'content' => $content,
           );
         }
       }
 
       $fields = array();
       $type = null;
 
       if (isset($modular_classes[$xaction->getPHID()])) {
         $modular_class = $modular_classes[$xaction->getPHID()];
         $modular_object = $modular_objects[$modular_class];
         $modular_data = $modular_data_map[$modular_class];
 
         $type = $modular_object->getTransactionTypeForConduit($xaction);
         $fields = $modular_object->getFieldValuesForConduit(
           $xaction,
           $modular_data);
       }
 
       if (!$fields) {
         $fields = (object)$fields;
       }
 
       // If we haven't found a modular type, fallback for some simple core
       // types. Ideally, we'll modularize everything some day.
       if ($type === null) {
         switch ($xaction->getTransactionType()) {
           case PhabricatorTransactions::TYPE_COMMENT:
             $type = 'comment';
             break;
           case PhabricatorTransactions::TYPE_CREATE:
             $type = 'create';
             break;
           case PhabricatorTransactions::TYPE_EDGE:
             switch ($xaction->getMetadataValue('edge:type')) {
               case PhabricatorProjectObjectHasProjectEdgeType::EDGECONST:
                 $type = 'projects';
                 $fields = $this->newEdgeTransactionFields($xaction);
                 break;
             }
             break;
           case PhabricatorTransactions::TYPE_SUBSCRIBERS:
             $type = 'subscribers';
             $fields = $this->newEdgeTransactionFields($xaction);
             break;
         }
       }
 
       $group_id = $xaction->getTransactionGroupID();
       if (!strlen($group_id)) {
         $group_id = null;
       } else {
         $group_id = (string)$group_id;
       }
 
       $data[] = array(
         'id' => (int)$xaction->getID(),
         'phid' => (string)$xaction->getPHID(),
         'type' => $type,
         'authorPHID' => (string)$xaction->getAuthorPHID(),
         'objectPHID' => (string)$xaction->getObjectPHID(),
         'dateCreated' => (int)$xaction->getDateCreated(),
         'dateModified' => (int)$xaction->getDateModified(),
         'groupID' => $group_id,
         'comments' => $comment_data,
         'fields' => $fields,
       );
     }
 
     $results = array(
       'data' => $data,
     );
 
     return $this->addPagerResults($results, $pager);
   }
 
   private function applyConstraints(
     array $constraints,
     PhabricatorApplicationTransactionQuery $query) {
 
     PhutilTypeSpec::checkMap(
       $constraints,
       array(
         'phids' => 'optional list<string>',
         'authorPHIDs' => 'optional list<string>',
       ));
 
     $with_phids = idx($constraints, 'phids');
 
     if ($with_phids === array()) {
       throw new Exception(
         pht(
           'Constraint "phids" to "transaction.search" requires nonempty list, '.
           'empty list provided.'));
     }
 
     if ($with_phids) {
       $query->withPHIDs($with_phids);
     }
 
     $with_authors = idx($constraints, 'authorPHIDs');
     if ($with_authors === array()) {
       throw new Exception(
         pht(
           'Constraint "authorPHIDs" to "transaction.search" requires '.
           'nonempty list, empty list provided.'));
     }
 
     if ($with_authors) {
       $query->withAuthorPHIDs($with_authors);
     }
 
     return $query;
   }
 
   private function newEdgeTransactionFields(
     PhabricatorApplicationTransaction $xaction) {
 
     $record = PhabricatorEdgeChangeRecord::newFromTransaction($xaction);
 
     $operations = array();
     foreach ($record->getAddedPHIDs() as $phid) {
       $operations[] = array(
         'operation' => 'add',
         'phid' => $phid,
       );
     }
 
     foreach ($record->getRemovedPHIDs() as $phid) {
       $operations[] = array(
         'operation' => 'remove',
         'phid' => $phid,
       );
     }
 
     return array(
       'operations' => $operations,
     );
   }
 
   private function loadTemplateObject(ConduitAPIRequest $request) {
     $viewer = $request->getUser();
 
     $object_identifier = $request->getValue('objectIdentifier');
     $object_type = $request->getValue('objectType');
 
     $has_identifier = ($object_identifier !== null);
     $has_type = ($object_type !== null);
 
     if (!$has_type && !$has_identifier) {
       throw new Exception(
         pht(
           'Calls to "transaction.search" must specify either an "objectType" '.
           'or an "objectIdentifier"'));
     } else if ($has_type && $has_identifier) {
       throw new Exception(
         pht(
           'Calls to "transaction.search" must not specify both an '.
           '"objectType" and an "objectIdentifier".'));
     }
 
     if ($has_type) {
       $all_types = PhabricatorPHIDType::getAllTypes();
 
       if (!isset($all_types[$object_type])) {
         ksort($all_types);
         throw new Exception(
           pht(
             'In call to "transaction.search", specified "objectType" ("%s") '.
             'is unknown. Valid object types are: %s.',
             $object_type,
             implode(', ', array_keys($all_types))));
       }
 
       $object = $all_types[$object_type]->newObject();
     } else {
       $object = id(new PhabricatorObjectQuery())
         ->setViewer($viewer)
         ->withNames(array($object_identifier))
         ->executeOne();
       if (!$object) {
         throw new Exception(
           pht(
             'In call to "transaction.search", specified "objectIdentifier" '.
             '("%s") does not exist.',
             $object_identifier));
       }
     }
 
     if (!($object instanceof PhabricatorApplicationTransactionInterface)) {
       throw new Exception(
         pht(
           'In call to "transaction.search", selected object (of type "%s") '.
           'does not implement "%s", so transactions can not be loaded for it.',
           get_class($object),
           'PhabricatorApplicationTransactionInterface'));
     }
 
     return $object;
   }
 
 }