diff --git a/scripts/arcanist.php b/scripts/arcanist.php
index af296a11..f0723caa 100755
--- a/scripts/arcanist.php
+++ b/scripts/arcanist.php
@@ -1,698 +1,708 @@
 #!/usr/bin/env php
 <?php
 
 sanity_check_environment();
 
 require_once dirname(__FILE__).'/__init_script__.php';
 
 /**
  * Adjust 'include_path' to add locations where we'll search for libraries.
  * We look in these places:
  *
  *  - Next to 'arcanist/'.
  *  - Anywhere in the normal PHP 'include_path'.
  *  - Inside 'arcanist/externals/includes/'.
  */
 function arcanist_adjust_php_include_path() {
   // The 'arcanist/' directory.
   $arcanist_dir = dirname(dirname(__FILE__));
 
   // The parent directory of 'arcanist/'.
   $parent_dir = dirname($arcanist_dir);
 
   // The 'arcanist/externals/includes/' directory.
   $include_dir = implode(
     DIRECTORY_SEPARATOR,
     array(
       $arcanist_dir,
       'externals',
       'includes',
     ));
 
   $php_include_path = ini_get('include_path');
   $php_include_path = implode(
     PATH_SEPARATOR,
     array(
       $parent_dir,
       $php_include_path,
       $include_dir,
     ));
 
   ini_set('include_path', $php_include_path);
 }
 arcanist_adjust_php_include_path();
 
 ini_set('memory_limit', -1);
 
 $original_argv = $argv;
 $base_args = new PhutilArgumentParser($argv);
 $base_args->parseStandardArguments();
 $base_args->parsePartial(
   array(
     array(
       'name'    => 'load-phutil-library',
       'param'   => 'path',
       'help'    => pht('Load a libphutil library.'),
       'repeat'  => true,
     ),
     array(
       'name'    => 'library',
       'param'   => 'path',
       'help'    => pht('Load a library (same as --load-phutil-library).'),
       'repeat'  => true,
     ),
     array(
       'name'    => 'arcrc-file',
       'param'   => 'filename',
     ),
     array(
       'name'    => 'conduit-uri',
       'param'   => 'uri',
-      'help'    => pht('Connect to Phabricator install specified by __uri__.'),
+      'help'    => pht(
+        'Connect to the %s (or compatible software) server specified by '.
+        '__uri__.',
+        PlatformSymbols::getPlatformServerName()),
     ),
     array(
       'name' => 'conduit-token',
       'param' => 'token',
       'help' => pht('Use a specific authentication token.'),
     ),
     array(
       'name' => 'anonymous',
       'help' => pht('Run workflow as a public user, without authenticating.'),
     ),
     array(
       'name'   => 'config',
       'param'  => 'key=value',
       'repeat' => true,
       'help'   => pht(
         'Specify a runtime configuration value. This will take precedence '.
-        'over static values, and only affect the current arcanist invocation.'),
+        'over static values, and only affect the current process: the '.
+        'setting is not saved anywhere.'),
     ),
 ));
 
 $config_trace_mode = $base_args->getArg('trace');
 
 $force_conduit = $base_args->getArg('conduit-uri');
 $force_token = $base_args->getArg('conduit-token');
 $custom_arcrc = $base_args->getArg('arcrc-file');
 $is_anonymous = $base_args->getArg('anonymous');
 $load = array_merge(
   $base_args->getArg('load-phutil-library'),
   $base_args->getArg('library'));
 $help = $base_args->getArg('help');
 $args = array_values($base_args->getUnconsumedArgumentVector());
 
 $working_directory = getcwd();
 $console = PhutilConsole::getConsole();
 $config = null;
 $workflow = null;
 
 try {
   if ($config_trace_mode) {
     echo tsprintf(
       "**<bg:magenta> %s </bg>** %s\n",
       pht('ARGV'),
       csprintf('%Ls', $original_argv));
 
     $libraries = array(
       'arcanist',
     );
 
     foreach ($libraries as $library_name) {
       echo tsprintf(
         "**<bg:magenta> %s </bg>** %s\n",
         pht('LOAD'),
         pht(
           'Loaded "%s" from "%s".',
           $library_name,
           phutil_get_library_root($library_name)));
     }
   }
 
   if (!$args) {
     if ($help) {
       $args = array('help');
     } else {
       throw new ArcanistUsageException(
         pht('No command provided. Try `%s`.', 'arc help'));
     }
   } else if ($help) {
     array_unshift($args, 'help');
   }
 
   $configuration_manager = new ArcanistConfigurationManager();
   if ($custom_arcrc) {
     $configuration_manager->setUserConfigurationFileLocation($custom_arcrc);
   }
 
   $global_config = $configuration_manager->readUserArcConfig();
   $system_config = $configuration_manager->readSystemArcConfig();
   $runtime_config = $configuration_manager->applyRuntimeArcConfig($base_args);
 
   $working_copy =
     ArcanistWorkingCopyIdentity::newFromPath($working_directory);
   $configuration_manager->setWorkingCopyIdentity($working_copy);
 
   // Load additional libraries, which can provide new classes like configuration
   // overrides, linters and lint engines, unit test engines, etc.
 
   // If the user specified "--load-phutil-library" one or more times from
   // the command line, we load those libraries **instead** of whatever else
   // is configured. This is basically a debugging feature to let you force
   // specific libraries to load regardless of the state of the world.
   if ($load) {
     $console->writeLog(
       "%s\n",
       pht(
         'Using `%s` flag, configuration will be ignored and configured '.
         'libraries will not be loaded.',
         '--load-phutil-library'));
     // Load the flag libraries. These must load, since the user specified them
     // explicitly.
     arcanist_load_libraries(
       $load,
       $must_load = true,
       $lib_source = pht('a "%s" flag', '--load-phutil-library'),
       $working_copy);
   } else {
     // Load libraries in system 'load' config. In contrast to global config, we
     // fail hard here because this file is edited manually, so if 'arc' breaks
     // that doesn't make it any more difficult to correct.
     arcanist_load_libraries(
       idx($system_config, 'load', array()),
       $must_load = true,
       $lib_source = pht('the "%s" setting in system config', 'load'),
       $working_copy);
 
     // Load libraries in global 'load' config, as per "arc set-config load". We
     // need to fail softly if these break because errors would prevent the user
     // from running "arc set-config" to correct them.
     arcanist_load_libraries(
       idx($global_config, 'load', array()),
       $must_load = false,
       $lib_source = pht('the "%s" setting in global config', 'load'),
       $working_copy);
 
     // Load libraries in ".arcconfig". Libraries here must load.
     arcanist_load_libraries(
       $working_copy->getProjectConfig('load'),
       $must_load = true,
       $lib_source = pht('the "%s" setting in "%s"', 'load', '.arcconfig'),
       $working_copy);
 
     // Load libraries in ".arcconfig". Libraries here must load.
     arcanist_load_libraries(
       idx($runtime_config, 'load', array()),
       $must_load = true,
       $lib_source = pht('the %s argument', '--config "load=[...]"'),
       $working_copy);
   }
 
   $user_config = $configuration_manager->readUserConfigurationFile();
   $config = new ArcanistConfiguration();
 
   $command = strtolower($args[0]);
   $args = array_slice($args, 1);
   $workflow = $config->selectWorkflow(
     $command,
     $args,
     $configuration_manager,
     $console);
   $workflow->setConfigurationManager($configuration_manager);
   $workflow->setArcanistConfiguration($config);
   $workflow->setCommand($command);
   $workflow->setWorkingDirectory($working_directory);
   $workflow->parseArguments($args);
 
   // Write the command into the environment so that scripts (for example, local
   // Git commit hooks) can detect that they're being run via `arc` and change
   // their behaviors.
   putenv('ARCANIST='.$command);
 
   $need_working_copy = $workflow->requiresWorkingCopy();
 
   $supported_vcs_types = $workflow->getSupportedRevisionControlSystems();
   $vcs_type = $working_copy->getVCSType();
   if ($vcs_type || $need_working_copy) {
     if (!in_array($vcs_type, $supported_vcs_types)) {
       throw new ArcanistUsageException(
         pht(
           '`%s %s` is only supported under %s.',
           'arc',
           $workflow->getWorkflowName(),
           implode(', ', $supported_vcs_types)));
     }
   }
 
   $need_conduit         = $workflow->requiresConduit();
   $need_auth            = $workflow->requiresAuthentication();
   $need_repository_api  = $workflow->requiresRepositoryAPI();
 
   $want_repository_api = $workflow->desiresRepositoryAPI();
   $want_working_copy = $workflow->desiresWorkingCopy() ||
                        $want_repository_api;
 
   $need_conduit       = $need_conduit ||
                         $need_auth;
   $need_working_copy  = $need_working_copy ||
                         $need_repository_api;
 
   if ($need_working_copy || $want_working_copy) {
     if ($need_working_copy && !$working_copy->getVCSType()) {
       throw new ArcanistUsageException(
         pht(
           'This command must be run in a Git, Mercurial or Subversion '.
           'working copy.'));
     }
     $configuration_manager->setWorkingCopyIdentity($working_copy);
   }
 
   if ($force_conduit) {
     $conduit_uri = $force_conduit;
   } else {
     $conduit_uri = $configuration_manager->getConfigFromAnySource(
       'phabricator.uri');
     if ($conduit_uri === null) {
       $conduit_uri = $configuration_manager->getConfigFromAnySource('default');
     }
   }
 
   if ($conduit_uri) {
     // Set the URI path to '/api/'. TODO: Originally, I contemplated letting
     // you deploy Phabricator somewhere other than the domain root, but ended
     // up never pursuing that. We should get rid of all "/api/" silliness
     // in things users are expected to configure. This is already happening
     // to some degree, e.g. "arc install-certificate" does it for you.
     $conduit_uri = new PhutilURI($conduit_uri);
     $conduit_uri->setPath('/api/');
     $conduit_uri = (string)$conduit_uri;
   }
   $workflow->setConduitURI($conduit_uri);
 
   // Apply global CA bundle from configs.
   $ca_bundle = $configuration_manager->getConfigFromAnySource('https.cabundle');
   if ($ca_bundle) {
     $ca_bundle = Filesystem::resolvePath(
       $ca_bundle, $working_copy->getProjectRoot());
     HTTPSFuture::setGlobalCABundleFromPath($ca_bundle);
   }
 
   $blind_key = 'https.blindly-trust-domains';
   $blind_trust = $configuration_manager->getConfigFromAnySource($blind_key);
   if ($blind_trust) {
     $trust_extension = PhutilHTTPEngineExtension::requireExtension(
       ArcanistBlindlyTrustHTTPEngineExtension::EXTENSIONKEY);
     $trust_extension->setDomains($blind_trust);
   }
 
   if ($need_conduit) {
     if (!$conduit_uri) {
 
       $message = phutil_console_format(
         "%s\n\n  - %s\n  - %s\n  - %s\n",
         pht(
-          'This command requires arc to connect to a Phabricator install, '.
-          'but no Phabricator installation is configured. To configure a '.
-          'Phabricator URI:'),
+          'This command requires %s to connect to a %s (or compatible '.
+          'software) server, but no %s server is configured. To configure a '.
+          '%s server URI:',
+          PlatformSymbols::getPlatformClientName(),
+          PlatformSymbols::getPlatformServerName(),
+          PlatformSymbols::getPlatformServerName(),
+          PlatformSymbols::getPlatformServerName()),
         pht(
           'set a default location with `%s`; or',
           'arc set-config default <uri>'),
         pht(
           'specify `%s` explicitly; or',
           '--conduit-uri=uri'),
         pht(
           "run `%s` in a working copy with an '%s'.",
           'arc',
           '.arcconfig'));
 
       $message = phutil_console_wrap($message);
       throw new ArcanistUsageException($message);
     }
     $workflow->establishConduit();
   }
 
   $hosts_config = idx($user_config, 'hosts', array());
   $host_config = idx($hosts_config, $conduit_uri, array());
   $user_name = idx($host_config, 'user');
   $certificate = idx($host_config, 'cert');
   $conduit_token = idx($host_config, 'token');
   if ($force_token) {
     $conduit_token = $force_token;
   }
 
   if ($is_anonymous) {
     $conduit_token = null;
   }
 
   $description = implode(' ', $original_argv);
   $credentials = array(
     'user' => $user_name,
     'certificate' => $certificate,
     'description' => $description,
     'token' => $conduit_token,
   );
   $workflow->setConduitCredentials($credentials);
 
   $engine = id(new ArcanistConduitEngine())
     ->setConduitURI($conduit_uri)
     ->setConduitToken($conduit_token);
 
   $workflow->setConduitEngine($engine);
 
   if ($need_auth) {
     if ((!$user_name || !$certificate) && (!$conduit_token)) {
       $arc = 'arc';
       if ($force_conduit) {
         $arc .= csprintf(' --conduit-uri=%s', $conduit_uri);
       }
 
       $conduit_domain = id(new PhutilURI($conduit_uri))->getDomain();
 
       throw new ArcanistUsageException(
         phutil_console_format(
           "%s\n\n%s\n\n%s **%s:**\n\n      $ **{$arc} install-certificate**\n",
           pht('YOU NEED TO AUTHENTICATE TO CONTINUE'),
           pht(
             'You are trying to connect to a server (%s) that you '.
             'do not have any credentials stored for.',
             $conduit_domain),
           pht('To retrieve and store credentials for this server,'),
           pht('run this command')));
     }
     $workflow->authenticateConduit();
   }
 
   if ($need_repository_api ||
       ($want_repository_api && $working_copy->getVCSType())) {
     $repository_api = ArcanistRepositoryAPI::newAPIFromConfigurationManager(
       $configuration_manager);
     $workflow->setRepositoryAPI($repository_api);
   }
 
   $listeners = $configuration_manager->getConfigFromAnySource(
     'events.listeners');
   if ($listeners) {
     foreach ($listeners as $listener) {
       $console->writeLog(
         "%s\n",
         pht("Registering event listener '%s'.", $listener));
       try {
         id(new $listener())->register();
       } catch (PhutilMissingSymbolException $ex) {
         // Continue anyway, since you may otherwise be unable to run commands
         // like `arc set-config events.listeners` in order to repair the damage
         // you've caused. We're writing out the entire exception here because
         // it might not have been triggered by the listener itself (for example,
         // the listener might use a bad class in its register() method).
         $console->writeErr(
           "%s\n",
           pht(
             "ERROR: Failed to load event listener '%s': %s",
             $listener,
             $ex->getMessage()));
       }
     }
   }
 
   $config->willRunWorkflow($command, $workflow);
   $workflow->willRunWorkflow();
   try {
     $err = $workflow->run();
     $config->didRunWorkflow($command, $workflow, $err);
   } catch (Exception $e) {
     $workflow->finalize();
     throw $e;
   }
   $workflow->finalize();
   exit((int)$err);
 
 } catch (ArcanistNoEffectException $ex) {
   echo $ex->getMessage()."\n";
 
 } catch (Exception $ex) {
   $is_usage = ($ex instanceof ArcanistUsageException);
   if ($is_usage) {
     fwrite(STDERR, phutil_console_format(
       "**%s** %s\n",
       pht('Usage Exception:'),
       rtrim($ex->getMessage())));
   }
 
   if ($config) {
     $config->didAbortWorkflow($command, $workflow, $ex);
   }
 
   if ($config_trace_mode) {
     fwrite(STDERR, "\n");
     throw $ex;
   }
 
   if (!$is_usage) {
     fwrite(STDERR, phutil_console_format(
       "<bg:red>** %s **</bg>\n", pht('Exception')));
 
     while ($ex) {
       fwrite(STDERR, $ex->getMessage()."\n");
 
       if ($ex instanceof PhutilProxyException) {
         $ex = $ex->getPreviousException();
       } else {
         $ex = null;
       }
     }
 
     fwrite(STDERR, phutil_console_format(
       "(%s)\n",
       pht('Run with `%s` for a full exception trace.', '--trace')));
   }
 
   exit(1);
 }
 
 
 /**
  * Perform some sanity checks against the possible diversity of PHP builds in
  * the wild, like very old versions and builds that were compiled with flags
  * that exclude core functionality.
  */
 function sanity_check_environment() {
   // NOTE: We don't have phutil_is_windows() yet here.
   $is_windows = (DIRECTORY_SEPARATOR != '/');
 
   // We use stream_socket_pair() which is not available on Windows earlier.
   $min_version = ($is_windows ? '5.3.0' : '5.2.3');
   $cur_version = phpversion();
   if (version_compare($cur_version, $min_version, '<')) {
     die_with_bad_php(
       "You are running PHP version '{$cur_version}', which is older than ".
       "the minimum version, '{$min_version}'. Update to at least ".
       "'{$min_version}'.");
   }
 
   if ($is_windows) {
     $need_functions = array(
       'curl_init'     => array('builtin-dll', 'php_curl.dll'),
     );
   } else {
     $need_functions = array(
       'curl_init'     => array(
         'text',
         "You need to install the cURL PHP extension, maybe with ".
         "'apt-get install php5-curl' or 'yum install php53-curl' or ".
         "something similar.",
       ),
       'json_decode'   => array('flag', '--without-json'),
     );
   }
 
   $problems = array();
 
   $config = null;
   $show_config = false;
   foreach ($need_functions as $fname => $resolution) {
     if (function_exists($fname)) {
       continue;
     }
 
     static $info;
     if ($info === null) {
       ob_start();
       phpinfo(INFO_GENERAL);
       $info = ob_get_clean();
       $matches = null;
       if (preg_match('/^Configure Command =>\s*(.*?)$/m', $info, $matches)) {
         $config = $matches[1];
       }
     }
 
     $generic = true;
     list($what, $which) = $resolution;
 
     if ($what == 'flag' && strpos($config, $which) !== false) {
       $show_config = true;
       $generic = false;
       $problems[] =
         "This build of PHP was compiled with the configure flag '{$which}', ".
         "which means it does not have the function '{$fname}()'. This ".
         "function is required for arc to run. Rebuild PHP without this flag. ".
         "You may also be able to build or install the relevant extension ".
         "separately.";
     }
 
     if ($what == 'builtin-dll') {
       $generic = false;
       $problems[] =
         "Your install of PHP does not have the '{$which}' extension enabled. ".
         "Edit your php.ini file and uncomment the line which reads ".
         "'extension={$which}'.";
     }
 
     if ($what == 'text') {
       $generic = false;
       $problems[] = $which;
     }
 
     if ($generic) {
       $problems[] =
         "This build of PHP is missing the required function '{$fname}()'. ".
         "Rebuild PHP or install the extension which provides '{$fname}()'.";
     }
   }
 
   if ($problems) {
     if ($show_config) {
       $problems[] = "PHP was built with this configure command:\n\n{$config}";
     }
     die_with_bad_php(implode("\n\n", $problems));
   }
 }
 
 function die_with_bad_php($message) {
   // NOTE: We're bailing because PHP is broken. We can't call any library
   // functions because they won't be loaded yet.
 
   echo "\n";
   echo 'PHP CONFIGURATION ERRORS';
   echo "\n\n";
   echo $message;
   echo "\n\n";
   exit(1);
 }
 
 function arcanist_load_libraries(
   $load,
   $must_load,
   $lib_source,
   ArcanistWorkingCopyIdentity $working_copy) {
 
   if (!$load) {
     return;
   }
 
   if (!is_array($load)) {
     $error = pht(
       'Libraries specified by %s are invalid; expected a list. '.
       'Check your configuration.',
       $lib_source);
     $console = PhutilConsole::getConsole();
     $console->writeErr("%s: %s\n", pht('WARNING'), $error);
     return;
   }
 
   foreach ($load as $location) {
 
     // Try to resolve the library location. We look in several places, in
     // order:
     //
     //  1. Inside the working copy. This is for phutil libraries within the
     //     project. For instance "library/src" will resolve to
     //     "./library/src" if it exists.
     //  2. In the same directory as the working copy. This allows you to
     //     check out a library alongside a working copy and reference it.
     //     If we haven't resolved yet, "library/src" will try to resolve to
     //     "../library/src" if it exists.
     //  3. Using normal libphutil resolution rules. Generally, this means
     //     that it checks for libraries next to libphutil, then libraries
     //     in the PHP include_path.
     //
     // Note that absolute paths will just resolve absolutely through rule (1).
 
     $resolved = false;
 
     // Check inside the working copy. This also checks absolute paths, since
     // they'll resolve absolute and just ignore the project root.
     $resolved_location = Filesystem::resolvePath(
       $location,
       $working_copy->getProjectRoot());
     if (Filesystem::pathExists($resolved_location)) {
       $location = $resolved_location;
       $resolved = true;
     }
 
     // If we didn't find anything, check alongside the working copy.
     if (!$resolved) {
       $resolved_location = Filesystem::resolvePath(
         $location,
         dirname($working_copy->getProjectRoot()));
       if (Filesystem::pathExists($resolved_location)) {
         $location = $resolved_location;
         $resolved = true;
       }
     }
 
     $console = PhutilConsole::getConsole();
     $console->writeLog(
       "%s\n",
       pht("Loading phutil library from '%s'...", $location));
 
     $error = null;
     try {
       phutil_load_library($location);
     } catch (PhutilBootloaderException $ex) {
       $error = pht(
         "Failed to load phutil library at location '%s'. This library ".
         "is specified by %s. Check that the setting is correct and the ".
         "library is located in the right place.",
         $location,
         $lib_source);
       if ($must_load) {
         throw new ArcanistUsageException($error);
       } else {
         fwrite(STDERR, phutil_console_wrap(
           phutil_console_format("%s: %s\n",
                                 pht('WARNING'),
                                 $error)));
       }
     } catch (PhutilLibraryConflictException $ex) {
       if ($ex->getLibrary() != 'arcanist') {
         throw $ex;
       }
 
       // NOTE: If you are running `arc` against itself, we ignore the library
       // conflict created by loading the local `arc` library (in the current
       // working directory) and continue without loading it.
 
       // This means we only execute code in the `arcanist/` directory which is
       // associated with the binary you are running, whereas we would normally
       // execute local code.
 
       // This can make `arc` development slightly confusing if your setup is
       // especially bizarre, but it allows `arc` to be used in automation
       // workflows more easily. For some context, see PHI13.
 
       $executing_directory = dirname(dirname(__FILE__));
       $working_directory = dirname($location);
 
       fwrite(
         STDERR,
         tsprintf(
           "**<bg:yellow> %s </bg>** %s\n",
           pht('VERY META'),
           pht(
-            'You are running one copy of Arcanist (at path "%s") against '.
-            'another copy of Arcanist (at path "%s"). Code in the current '.
+            'You are running one copy of %s (at path "%s") against '.
+            'another copy of %s (at path "%s"). Code in the current '.
             'working directory will not be loaded or executed.',
+            PlatformSymbols::getPlatformClientName(),
             $executing_directory,
+            PlatformSymbols::getPlatformClientName(),
             $working_directory)));
     }
   }
 }
diff --git a/src/conduit/ArcanistConduitEngine.php b/src/conduit/ArcanistConduitEngine.php
index cd2b411e..8e7a1de4 100644
--- a/src/conduit/ArcanistConduitEngine.php
+++ b/src/conduit/ArcanistConduitEngine.php
@@ -1,107 +1,107 @@
 <?php
 
 final class ArcanistConduitEngine
   extends Phobject {
 
   private $conduitURI;
   private $conduitToken;
   private $conduitTimeout;
   private $client;
 
   public function isCallable() {
     return ($this->conduitURI !== null);
   }
 
   public function setConduitURI($conduit_uri) {
     $this->conduitURI = $conduit_uri;
     return $this;
   }
 
   public function getConduitURI() {
     return $this->conduitURI;
   }
 
   public function setConduitToken($conduit_token) {
     $this->conduitToken = $conduit_token;
     return $this;
   }
 
   public function getConduitToken() {
     return $this->conduitToken;
   }
 
   public function setConduitTimeout($conduit_timeout) {
     $this->conduitTimeout = $conduit_timeout;
     return $this;
   }
 
   public function getConduitTimeout() {
     return $this->conduitTimeout;
   }
 
   public function newFuture($method, array $parameters) {
     if ($this->conduitURI == null && $this->client === null) {
       $this->raiseURIException();
     }
 
     $future = $this->getClient()->callMethod($method, $parameters);
 
     $call_future = id(new ArcanistConduitCallFuture($future))
       ->setEngine($this);
 
     return $call_future;
   }
 
   private function getClient() {
     if (!$this->client) {
       $conduit_uri = $this->getConduitURI();
 
       $client = new ConduitClient($conduit_uri);
 
       $timeout = $this->getConduitTimeout();
       if ($timeout) {
         $client->setTimeout($timeout);
       }
 
       $token = $this->getConduitToken();
       if ($token) {
         $client->setConduitToken($this->getConduitToken());
       }
 
       $this->client = $client;
     }
 
     return $this->client;
   }
 
   private function raiseURIException() {
     $list = id(new PhutilConsoleList())
       ->addItem(
         pht(
           'Run in a working copy with "phabricator.uri" set in ".arcconfig".'))
       ->addItem(
         pht(
           'Set a default URI with `arc set-config phabricator.uri <uri>`.'))
       ->addItem(
         pht(
           'Specify a URI explicitly with `--config phabricator.uri=<uri>`.'));
 
     $block = id(new PhutilConsoleBlock())
       ->addParagraph(
         pht(
-          'This command needs to communicate with Phabricator, but no '.
-          'Phabricator URI is configured.'))
+          'This command needs to communicate with a server, but no '.
+          'server URI is configured.'))
       ->addList($list);
 
     throw new ArcanistUsageException($block->drawConsoleString());
   }
 
   public static function newConduitEngineFromConduitClient(
     ConduitClient $client) {
 
     $engine = new self();
     $engine->client = $client;
 
     return $engine;
   }
 }
diff --git a/src/config/arc/ArcanistArcConfigurationEngineExtension.php b/src/config/arc/ArcanistArcConfigurationEngineExtension.php
index d40159d5..3fdff3ff 100644
--- a/src/config/arc/ArcanistArcConfigurationEngineExtension.php
+++ b/src/config/arc/ArcanistArcConfigurationEngineExtension.php
@@ -1,164 +1,165 @@
 <?php
 
 final class ArcanistArcConfigurationEngineExtension
   extends ArcanistConfigurationEngineExtension {
 
   const EXTENSIONKEY = 'arc';
 
   const KEY_ALIASES = 'aliases';
   const KEY_PROMPTS = 'prompts';
 
   public function newConfigurationOptions() {
     // TOOLSETS: Restore "load", and maybe this other stuff.
 
 /*
       'load' => array(
         'type' => 'list',
         'legacy' => 'phutil_libraries',
         'help' => pht(
           'A list of paths to phutil libraries that should be loaded at '.
           'startup. This can be used to make classes available, like lint '.
           'or unit test engines.'),
         'default' => array(),
         'example' => '["/var/arc/customlib/src"]',
       ),
       'editor' => array(
         'type' => 'string',
         'help' => pht(
           'Command to use to invoke an interactive editor, like `%s` or `%s`. '.
           'This setting overrides the %s environmental variable.',
           'nano',
           'vim',
           'EDITOR'),
         'example' => '"nano"',
       ),
       'https.cabundle' => array(
         'type' => 'string',
         'help' => pht(
           "Path to a custom CA bundle file to be used for arcanist's cURL ".
           "calls. This is used primarily when your conduit endpoint is ".
           "behind HTTPS signed by your organization's internal CA."),
         'example' => 'support/yourca.pem',
       ),
       'browser' => array(
         'type' => 'string',
         'help' => pht('Command to use to invoke a web browser.'),
         'example' => '"gnome-www-browser"',
       ),
 */
 
 
 
     return array(
       id(new ArcanistStringConfigOption())
         ->setKey('base')
         ->setSummary(pht('Ruleset for selecting commit ranges.'))
         ->setHelp(
           pht(
             'Base commit ruleset to invoke when determining the start of a '.
             'commit range. See "Arcanist User Guide: Commit Ranges" for '.
             'details.'))
         ->setExamples(
           array(
             'arc:amended, arc:prompt',
           )),
       id(new ArcanistStringConfigOption())
         ->setKey('repository')
         ->setAliases(
           array(
             'repository.callsign',
           ))
         ->setSummary(pht('Repository for the current working copy.'))
         ->setHelp(
           pht(
-            'Associate the working copy with a specific Phabricator '.
-            'repository. Normally, Arcanist can figure this association '.
-            'out on its own, but if your setup is unusual you can use '.
-            'this option to tell it what the desired value is.'))
+            'Associate the working copy with a specific repository. Normally, '.
+            'this association can be determined automatically, but if your '.
+            'setup is unusual you can use this option to tell it what the '.
+            'desired value is.'))
         ->setExamples(
           array(
             'libexample',
             'XYZ',
             'R123',
             '123',
           )),
       id(new ArcanistStringConfigOption())
         ->setKey('phabricator.uri')
         ->setAliases(
           array(
             'conduit_uri',
             'default',
           ))
-        ->setSummary(pht('Phabricator install to connect to.'))
+        ->setSummary(pht('Server to connect to.'))
         ->setHelp(
           pht(
             'Associates this working copy with a specific installation of '.
-            'Phabricator.'))
+            '%s (or compatible software).',
+            PlatformSymbols::getPlatformServerName()))
         ->setExamples(
           array(
-            'https://phabricator.mycompany.com/',
+            'https://devtools.example.com/',
           )),
       id(new ArcanistAliasesConfigOption())
         ->setKey(self::KEY_ALIASES)
         ->setDefaultValue(array())
         ->setSummary(pht('List of command aliases.'))
         ->setHelp(
           pht(
             'Configured command aliases. Use the "alias" workflow to define '.
             'aliases.')),
       id(new ArcanistPromptsConfigOption())
         ->setKey(self::KEY_PROMPTS)
         ->setDefaultValue(array())
         ->setSummary(pht('List of prompt responses.'))
         ->setHelp(
           pht(
             'Configured prompt aliases. Use the "prompts" workflow to '.
             'show prompts and responses.')),
       id(new ArcanistStringListConfigOption())
         ->setKey('arc.land.onto')
         ->setDefaultValue(array())
         ->setSummary(pht('Default list of "onto" refs for "arc land".'))
         ->setHelp(
           pht(
             'Specifies the default behavior when "arc land" is run with '.
             'no "--onto" flag.'))
         ->setExamples(
           array(
             '["master"]',
           )),
       id(new ArcanistStringListConfigOption())
         ->setKey('pager')
         ->setDefaultValue(array())
         ->setSummary(pht('Default pager command.'))
         ->setHelp(
           pht(
             'Specify the pager command to use when displaying '.
             'documentation.'))
         ->setExamples(
           array(
             '["less", "-R", "--"]',
           )),
       id(new ArcanistStringConfigOption())
         ->setKey('arc.land.onto-remote')
         ->setSummary(pht('Default list of "onto" remote for "arc land".'))
         ->setHelp(
           pht(
             'Specifies the default behavior when "arc land" is run with '.
             'no "--onto-remote" flag.'))
         ->setExamples(
           array(
             'origin',
           )),
       id(new ArcanistStringConfigOption())
         ->setKey('arc.land.strategy')
         ->setSummary(
           pht(
             'Configure a default merge strategy for "arc land".'))
         ->setHelp(
           pht(
             'Specifies the default behavior when "arc land" is run with '.
             'no "--strategy" flag.')),
     );
   }
 
 }
diff --git a/src/configuration/ArcanistBlindlyTrustHTTPEngineExtension.php b/src/configuration/ArcanistBlindlyTrustHTTPEngineExtension.php
index 098d04a2..fd381969 100644
--- a/src/configuration/ArcanistBlindlyTrustHTTPEngineExtension.php
+++ b/src/configuration/ArcanistBlindlyTrustHTTPEngineExtension.php
@@ -1,27 +1,27 @@
 <?php
 
 final class ArcanistBlindlyTrustHTTPEngineExtension
   extends PhutilHTTPEngineExtension {
 
   const EXTENSIONKEY = 'arc.https.blind';
 
   private $domains = array();
 
   public function setDomains(array $domains) {
     foreach ($domains as $domain) {
       $this->domains[phutil_utf8_strtolower($domain)] = true;
     }
     return $this;
   }
 
   public function getExtensionName() {
-    return pht('Arcanist HTTPS Trusted Domains');
+    return pht('HTTPS Trusted Domains');
   }
 
   public function shouldTrustAnySSLAuthorityForURI(PhutilURI $uri) {
     $domain = $uri->getDomain();
     $domain = phutil_utf8_strtolower($domain);
     return isset($this->domains[$domain]);
   }
 
 }
diff --git a/src/parser/PhutilEmailAddress.php b/src/parser/PhutilEmailAddress.php
index d02c4bce..76ea287c 100644
--- a/src/parser/PhutilEmailAddress.php
+++ b/src/parser/PhutilEmailAddress.php
@@ -1,115 +1,116 @@
 <?php
 
 /**
  * Basic email address parser. This parser is very liberal and does not attempt
  * to be fully RFC-compliant, because trying to do so is a crazy mess. However,
  * it should parse all reasonable addresses which are actually in use on the
  * internet today.
  */
 final class PhutilEmailAddress extends Phobject {
 
   private $displayName;
   private $localPart;
   private $domainName;
 
   public function __construct($email_address = null) {
     $email_address = phutil_string_cast($email_address);
     $email_address = trim($email_address);
 
     $matches = null;
     if (preg_match('/^(.*)<(.*?)>$/', $email_address, $matches)) {
       $display_name = trim($matches[1], '\'" ');
       if (strpos($matches[2], '@') !== false) {
         list($local_part, $domain_name) = explode('@', $matches[2], 2);
       } else {
         $local_part = $matches[2];
         $domain_name = null;
       }
     } else if (preg_match('/^(.*)@(.*)$/', $email_address, $matches)) {
       $display_name = null;
       $local_part = $matches[1];
       $domain_name = $matches[2];
     } else {
       $display_name = null;
       $local_part = $email_address;
       $domain_name = null;
     }
 
     $this->displayName = $display_name;
     $this->localPart = $local_part;
     $this->domainName = $domain_name;
   }
 
   public function __toString() {
     $address = $this->getAddress();
-    if (strlen($this->displayName)) {
+
+    if (phutil_nonempty_string($this->displayName)) {
       $display_name = $this->encodeDisplayName($this->displayName);
       return $display_name.' <'.$address.'>';
-    } else {
-      return $address;
     }
+
+    return $address;
   }
 
   public function setDisplayName($display_name) {
     $this->displayName = $display_name;
     return $this;
   }
 
   public function getDisplayName() {
     return $this->displayName;
   }
 
   public function setLocalPart($local_part) {
     $this->localPart = $local_part;
     return $this;
   }
 
   public function getLocalPart() {
     return $this->localPart;
   }
 
   public function setDomainName($domain_name) {
     $this->domainName = $domain_name;
     return $this;
   }
 
   public function getDomainName() {
     return $this->domainName;
   }
 
   public function setAddress($address) {
     $parts = explode('@', $address, 2);
 
     $this->localPart = $parts[0];
     if (isset($parts[1])) {
       $this->domainName = $parts[1];
     }
 
     return $this;
   }
 
   public function getAddress() {
     $address = $this->localPart;
     if ($this->domainName !== null && strlen($this->domainName)) {
       $address .= '@'.$this->domainName;
     }
     return $address;
   }
 
   private function encodeDisplayName($name) {
     // NOTE: This is a reasonable effort based on a cursory reading of
     // RFC2822, but may be significantly misguided.
 
     // Newlines are not permitted, even when escaped. Discard them.
     $name = preg_replace("/\s*[\r\n]+\s*/", ' ', $name);
 
     // Escape double quotes and backslashes.
     $name = addcslashes($name, '\\"');
 
     // Quote the string.
     $name = '"'.$name.'"';
 
     return $name;
   }
 
 }
diff --git a/src/toolset/ArcanistArcToolset.php b/src/toolset/ArcanistArcToolset.php
index 5c1cb377..1778372e 100644
--- a/src/toolset/ArcanistArcToolset.php
+++ b/src/toolset/ArcanistArcToolset.php
@@ -1,22 +1,22 @@
 <?php
 
 final class ArcanistArcToolset extends ArcanistToolset {
 
   const TOOLSETKEY = 'arc';
 
   public function getToolsetArguments() {
     return array(
       array(
         'name' => 'conduit-uri',
         'param' => 'uri',
-        'help' => pht('Connect to Phabricator install specified by __uri__.'),
+        'help' => pht('Connect to server specified by __uri__.'),
       ),
       array(
         'name' => 'conduit-token',
         'param' => 'token',
         'help' => pht('Use a specific authentication token.'),
       ),
     );
   }
 
 }
diff --git a/src/toolset/workflow/ArcanistShellCompleteWorkflow.php b/src/toolset/workflow/ArcanistShellCompleteWorkflow.php
index f68d04a5..9c2fcf9a 100644
--- a/src/toolset/workflow/ArcanistShellCompleteWorkflow.php
+++ b/src/toolset/workflow/ArcanistShellCompleteWorkflow.php
@@ -1,666 +1,666 @@
 <?php
 
 final class ArcanistShellCompleteWorkflow
   extends ArcanistWorkflow {
 
   public function supportsToolset(ArcanistToolset $toolset) {
     return true;
   }
 
   public function getWorkflowName() {
     return 'shell-complete';
   }
 
   public function getWorkflowInformation() {
     $help = pht(<<<EOTEXT
 Install shell completion so you can use the "tab" key to autocomplete
-commands and flags in your shell for Arcanist toolsets and workflows.
+commands and flags in your shell for toolsets and workflows.
 
 The **bash** shell is supported.
 
 **Installing Completion**
 
 To install shell completion, run the command:
 
   $ arc shell-complete
 
 This will install shell completion into your current shell. After installing,
 you may need to start a new shell (or open a new terminal window) to pick up
 the updated configuration.
 
-Once installed, completion should work across all Arcanist toolsets.
+Once installed, completion should work across all toolsets.
 
 **Using Completion**
 
 After completion is installed, use the "tab" key to automatically complete
 workflows and flags. For example, if you type:
 
   $ arc diff --draf<tab>
 
 ...your shell should automatically expand the flag to:
 
   $ arc diff --draft
 
 **Updating Completion**
 
 To update shell completion, run the same command:
 
   $ arc shell-complete
 
 You can update shell completion without reinstalling it by running:
 
   $ arc shell-complete --generate
 
 You may need to update shell completion if:
 
-  - you install new Arcanist toolsets; or
-  - you move the Arcanist directory; or
-  - you upgrade Arcanist and the new version fixes shell completion bugs.
+  - you install new toolsets; or
+  - you move this software on disk; or
+  - you upgrade this software and the new version fixes shell completion bugs.
 EOTEXT
 );
 
     return $this->newWorkflowInformation()
       ->setSynopsis(pht('Install shell completion.'))
       ->setHelp($help);
   }
 
   public function getWorkflowArguments() {
     return array(
       $this->newWorkflowArgument('current')
         ->setParameter('cursor-position')
         ->setHelp(
           pht(
             'Internal. Current term in the argument list being completed.')),
       $this->newWorkflowArgument('generate')
         ->setHelp(
           pht(
             'Regenerate shell completion rules, without installing any '.
             'configuration.')),
       $this->newWorkflowArgument('shell')
         ->setParameter('shell-name')
         ->setHelp(
           pht(
             'Install completion support for a particular shell.')),
       $this->newWorkflowArgument('argv')
         ->setWildcard(true),
     );
   }
 
   public function runWorkflow() {
     $log = $this->getLogEngine();
 
     $argv = $this->getArgument('argv');
 
     $is_generate = $this->getArgument('generate');
     $is_shell = (bool)strlen($this->getArgument('shell'));
     $is_current = $this->getArgument('current');
 
     if ($argv) {
       $should_install = false;
       $should_generate = false;
 
       if ($is_generate) {
         throw new PhutilArgumentUsageException(
           pht(
             'You can not use "--generate" when completing arguments.'));
       }
 
       if ($is_shell) {
         throw new PhutilArgumentUsageException(
           pht(
             'You can not use "--shell" when completing arguments.'));
       }
 
     } else if ($is_generate) {
       $should_install = false;
       $should_generate = true;
 
       if ($is_current) {
         throw new PhutilArgumentUsageException(
           pht(
             'You can not use "--current" when generating rules.'));
       }
 
       if ($is_shell) {
         throw new PhutilArgumentUsageException(
           pht(
             'The flags "--generate" and "--shell" are mutually exclusive. '.
             'The "--shell" flag selects which shell to install support for, '.
             'but the "--generate" suppresses installation.'));
       }
 
     } else {
       $should_install = true;
       $should_generate = true;
 
       if ($is_current) {
         throw new PhutilArgumentUsageException(
           pht(
             'You can not use "--current" when installing support.'));
       }
     }
 
     if ($should_install) {
       $this->runInstall();
     }
 
     if ($should_generate) {
       $this->runGenerate();
     }
 
     if ($should_install || $should_generate) {
       $log->writeHint(
         pht('NOTE'),
         pht(
           'You may need to open a new terminal window or launch a new shell '.
           'before the changes take effect.'));
       return 0;
     }
 
     $this->runAutocomplete();
   }
 
   protected function newPrompts() {
     return array(
       $this->newPrompt('arc.shell-complete.install')
         ->setDescription(
           pht(
             'Confirms writing to to "~/.profile" (or another similar file) '.
             'to install shell completion.')),
     );
   }
 
   private function runInstall() {
     $log = $this->getLogEngine();
 
     $shells = array(
       array(
         'key' => 'bash',
         'path' => '/bin/bash',
         'file' => '.profile',
         'source' => 'hooks/bash-completion.sh',
       ),
     );
     $shells = ipull($shells, null, 'key');
 
     $shell = $this->getArgument('shell');
     if (!$shell) {
       $shell = $this->detectShell($shells);
     } else {
       $shell = $this->selectShell($shells, $shell);
     }
 
     $spec = $shells[$shell];
     $file = $spec['file'];
     $home = getenv('HOME');
 
     if (!strlen($home)) {
       throw new PhutilArgumentUsageException(
         pht(
           'The "HOME" environment variable is not defined, so this workflow '.
           'can not identify where to install shell completion.'));
     }
 
     $file_path = getenv('HOME').'/'.$file;
     $file_display = '~/'.$file;
 
     if (Filesystem::pathExists($file_path)) {
       $file_path = Filesystem::resolvePath($file_path);
       $data = Filesystem::readFile($file_path);
       $is_new = false;
     } else {
       $data = '';
       $is_new = true;
     }
 
     $line = csprintf(
       'source %R # arcanist-shell-complete',
       $this->getShellPath($spec['source']));
 
     $matches = null;
     $replace = preg_match(
       '/(\s*\n)?[^\n]+# arcanist-shell-complete\s*(\n\s*)?/',
       $data,
       $matches,
       PREG_OFFSET_CAPTURE);
 
     $log->writeSuccess(
       pht('INSTALL'),
       pht(
         'Installing shell completion support for "%s" into "%s".',
         $shell,
         $file_display));
 
     if ($replace) {
       $replace_pos = $matches[0][1];
       $replace_line = $matches[0][0];
       $replace_len = strlen($replace_line);
       $replace_display = trim($replace_line);
 
       if ($replace_pos === 0) {
         $new_line = $line."\n";
       } else {
         $new_line = "\n\n".$line."\n";
       }
 
       $new_data = substr_replace($data, $new_line, $replace_pos, $replace_len);
 
       if ($new_data === $data) {
         // If we aren't changing anything in the file, just skip the write
         // completely.
         $needs_write = false;
 
         $log->writeStatus(
           pht('SKIP'),
           pht('Shell completion for "%s" is already installed.', $shell));
 
         return;
       }
 
       echo tsprintf(
         "%s\n\n    %s\n\n%s\n\n    %s\n",
         pht(
           'To update shell completion support for "%s", your existing '.
           '"%s" file will be modified. This line will be removed:',
           $shell,
           $file_display),
         $replace_display,
         pht('This line will be added:'),
         $line);
 
       $prompt = pht('Rewrite this file?');
     } else {
       if ($is_new) {
         $new_data = $line."\n";
 
         echo tsprintf(
           "%s\n\n    %s\n",
           pht(
             'To install shell completion support for "%s", a new "%s" file '.
             'will be created with this content:',
             $shell,
             $file_display),
           $line);
 
         $prompt = pht('Create this file?');
       } else {
         $new_data = rtrim($data)."\n\n".$line."\n";
 
         echo tsprintf(
           "%s\n\n     %s\n",
           pht(
             'To install shell completion support for "%s", this line will be '.
             'added to your existing "%s" file:',
             $shell,
             $file_display),
           $line);
 
         $prompt = pht('Append to this file?');
       }
     }
 
     $this->getPrompt('arc.shell-complete.install')
       ->setQuery($prompt)
       ->execute();
 
     Filesystem::writeFile($file_path, $new_data);
 
     $log->writeSuccess(
       pht('INSTALLED'),
       pht(
         'Installed shell completion support for "%s" to "%s".',
         $shell,
         $file_display));
   }
 
   private function selectShell(array $shells, $shell_arg) {
     foreach ($shells as $shell) {
       if ($shell['key'] === $shell_arg) {
         return $shell_arg;
       }
     }
 
     throw new PhutilArgumentUsageException(
       pht(
         'The shell "%s" is not supported. Supported shells are: %s.',
         $shell_arg,
         implode(', ', ipull($shells, 'key'))));
   }
 
   private function detectShell(array $shells) {
     // NOTE: The "BASH_VERSION" and "ZSH_VERSION" shell variables are not
     // passed to subprocesses, so we can't inspect them to figure out which
     // shell launched us. If we could figure this out in some other way, it
     // would be nice to do so.
 
     // Instead, just look at "SHELL" (the user's startup shell).
 
     $log = $this->getLogEngine();
 
     $detected = array();
     $log->writeStatus(
       pht('DETECT'),
       pht('Detecting current shell...'));
 
     $shell_env = getenv('SHELL');
     if (!strlen($shell_env)) {
       $log->writeWarning(
         pht('SHELL'),
         pht(
           'The "SHELL" environment variable is not defined, so it can '.
           'not be used to detect the shell to install rules for.'));
     } else {
       $found = false;
       foreach ($shells as $shell) {
         if ($shell['path'] !== $shell_env) {
           continue;
         }
 
         $found = true;
         $detected[] = $shell['key'];
 
         $log->writeSuccess(
           pht('SHELL'),
           pht(
             'The "SHELL" environment variable has value "%s", so the '.
             'target shell was detected as "%s".',
             $shell_env,
             $shell['key']));
       }
 
       if (!$found) {
         $log->writeStatus(
           pht('SHELL'),
           pht(
             'The "SHELL" environment variable does not match any recognized '.
             'shell.'));
       }
     }
 
     if (!$detected) {
       throw new PhutilArgumentUsageException(
         pht(
           'Unable to detect any supported shell, so autocompletion rules '.
           'can not be installed. Use "--shell" to select a shell.'));
     } else if (count($detected) > 1) {
       throw new PhutilArgumentUsageException(
         pht(
           'Multiple supported shells were detected. Unable to determine '.
           'which shell to install autocompletion rules for. Use "--shell" '.
           'to select a shell.'));
     }
 
     return head($detected);
   }
 
   private function runGenerate() {
     $log = $this->getLogEngine();
 
     $toolsets = ArcanistToolset::newToolsetMap();
 
     $log->writeStatus(
       pht('GENERATE'),
       pht('Generating shell completion rules...'));
 
     $shells = array('bash');
     foreach ($shells as $shell) {
 
       $rules = array();
       foreach ($toolsets as $toolset) {
         $rules[] = $this->newCompletionRules($toolset, $shell);
       }
       $rules = implode("\n", $rules);
 
       $rules_path = $this->getShellPath('rules/'.$shell.'-rules.sh');
 
       // If a write wouldn't change anything, skip the write. This allows
       // "arc shell-complete" to work if "arcanist/" is on a read-only NFS
       // filesystem or something unusual like that.
 
       $skip_write = false;
       if (Filesystem::pathExists($rules_path)) {
         $current = Filesystem::readFile($rules_path);
         if ($current === $rules) {
           $skip_write = true;
         }
       }
 
       if ($skip_write) {
         $log->writeStatus(
           pht('SKIP'),
           pht(
             'Rules are already up to date for "%s" in: %s',
             $shell,
             Filesystem::readablePath($rules_path)));
       } else {
         Filesystem::writeFile($rules_path, $rules);
         $log->writeStatus(
           pht('RULES'),
           pht(
             'Wrote updated completion rules for "%s" to: %s.',
             $shell,
             Filesystem::readablePath($rules_path)));
       }
     }
   }
 
   private function newCompletionRules(ArcanistToolset $toolset, $shell) {
     $template_path = $this->getShellPath('templates/'.$shell.'-template.sh');
     $template = Filesystem::readFile($template_path);
 
     $variables = array(
       'BIN' => $toolset->getToolsetKey(),
     );
 
     foreach ($variables as $key => $value) {
       $template = str_replace('{{{'.$key.'}}}', $value, $template);
     }
 
     return $template;
   }
 
   private function getShellPath($to_file = null) {
     $arc_root = dirname(phutil_get_library_root('arcanist'));
     return $arc_root.'/support/shell/'.$to_file;
   }
 
   private function runAutocomplete() {
     $argv = $this->getArgument('argv');
     $argc = count($argv);
 
     $pos = $this->getArgument('current');
     if (!$pos) {
       $pos = $argc - 1;
     }
 
     if ($pos >= $argc) {
       throw new ArcanistUsageException(
         pht(
           'Argument position specified with "--current" ("%s") is greater '.
           'than the number of arguments provided ("%s").',
           new PhutilNumber($pos),
           new PhutilNumber($argc)));
     }
 
     $workflows = $this->getRuntime()->getWorkflows();
 
     // NOTE: This isn't quite right. For example, "arc --con<tab>" will
     // try to autocomplete workflows named "--con", but it should actually
     // autocomplete global flags and suggest "--config".
 
     $is_workflow = ($pos <= 1);
 
     if ($is_workflow) {
       // NOTE: There was previously some logic to try to filter impossible
       // workflows out of the completion list based on the VCS in the current
       // working directory: for example, if you're in an SVN working directory,
       // "arc a" is unlikely to complete to "arc amend" because "amend" does
       // not support SVN. It's not clear this logic is valuable, but we could
       // consider restoring it if good use cases arise.
 
       // TOOLSETS: Restore the ability for workflows to opt out of shell
       // completion. It is exceptionally unlikely that users want to shell
       // complete obscure or internal workflows, like "arc shell-complete"
       // itself. Perhaps a good behavior would be to offer these as
       // completions if they are the ONLY available completion, since a user
       // who has typed "arc shell-comp<tab>" likely does want "shell-complete".
 
       $complete = array();
       foreach ($workflows as $workflow) {
         $complete[] = $workflow->getWorkflowName();
       }
 
       foreach ($this->getConfig('aliases') as $alias) {
         if ($alias->getException()) {
           continue;
         }
 
         if ($alias->getToolset() !== $this->getToolsetKey()) {
           continue;
         }
 
         $complete[] = $alias->getTrigger();
       }
 
       $partial = $argv[$pos];
       $complete = $this->getMatches($complete, $partial);
 
       if ($complete) {
         return $this->suggestStrings($complete);
       } else {
         return $this->suggestNothing();
       }
 
     } else {
       // TOOLSETS: We should resolve aliases before picking a workflow, so
       // that if you alias "arc draft" to "arc diff --draft", we can suggest
       // other "diff" flags when you type "arc draft --q<tab>".
 
       // TOOLSETS: It's possible the workflow isn't in position 1. The user
       // may be running "arc --trace diff --dra<tab>", for example.
 
       $workflow = idx($workflows, $argv[1]);
       if (!$workflow) {
         return $this->suggestNothing();
       }
 
       $arguments = $workflow->getWorkflowArguments();
       $arguments = mpull($arguments, null, 'getKey');
       $current = idx($argv, $pos, '');
 
       $argument = null;
       $prev = idx($argv, $pos - 1, null);
       if (!strncmp($prev, '--', 2)) {
         $prev = substr($prev, 2);
         $argument = idx($arguments, $prev);
       }
 
       // If the last argument was a "--thing" argument, test if "--thing" is
       // a parameterized argument. If it is, the next argument should be a
       // parameter.
 
       if ($argument && strlen($argument->getParameter())) {
         if ($argument->getIsPathArgument()) {
           return $this->suggestPaths($current);
         } else {
           return $this->suggestNothing();
         }
 
         // TOOLSETS: We can allow workflows and arguments to provide a specific
         // list of completeable values, like the "--shell" argument for this
         // workflow.
       }
 
       $flags = array();
       $wildcard = null;
       foreach ($arguments as $argument) {
         if ($argument->getWildcard()) {
           $wildcard = $argument;
           continue;
         }
 
         $flags[] = '--'.$argument->getKey();
       }
 
       $matches = $this->getMatches($flags, $current);
 
       // If whatever the user is completing does not match the prefix of any
       // flag (or is entirely empty), try to autcomplete a wildcard argument
       // if it has some kind of meaningful completion. For example, "arc lint
       // READ<tab>" should autocomplete a file, and "arc lint <tab>" should
       // suggest files in the current directory.
 
       if (!strlen($current) || !$matches) {
         $try_paths = true;
       } else {
         $try_paths = false;
       }
 
       if ($try_paths && $wildcard) {
         // TOOLSETS: There was previously some very questionable support for
         // autocompleting branches here. This could be moved into Arguments
         // and Workflows.
 
         if ($wildcard->getIsPathArgument()) {
           return $this->suggestPaths($current);
         }
       }
 
       // TODO: If a command has only one flag, like "--json", don't suggest
       // it if the user hasn't typed anything or has only typed "--".
 
       // TODO: Don't suggest "--flag" arguments which aren't repeatable if
       // they are already present in the argument list.
 
       return $this->suggestStrings($matches);
     }
   }
 
   private function suggestPaths($prefix) {
     // NOTE: We are returning a directive to the bash script to run "compgen"
     // for us rather than running it ourselves. If we run:
     //
     //   compgen -A file -- %s
     //
     // ...from this context, it fails (exits with error code 1 and no output)
     // if the prefix is "foo\ ", on my machine. See T9116 for some dicussion.
     echo '<compgen:file>';
     return 0;
   }
 
   private function suggestNothing() {
     return $this->suggestStrings(array());
   }
 
   private function suggestStrings(array $strings) {
     sort($strings);
     echo implode("\n", $strings);
     return 0;
   }
 
   private function getMatches(array $candidates, $prefix) {
     $matches = array();
 
     if (strlen($prefix)) {
       foreach ($candidates as $possible) {
         if (!strncmp($possible, $prefix, strlen($prefix))) {
           $matches[] = $possible;
         }
       }
 
       // If we matched nothing, try a case-insensitive match.
       if (!$matches) {
         foreach ($candidates as $possible) {
           if (!strncasecmp($possible, $prefix, strlen($prefix))) {
             $matches[] = $possible;
           }
         }
       }
     } else {
       $matches = $candidates;
     }
 
     return $matches;
   }
 
 }
diff --git a/src/utils/viewutils.php b/src/utils/viewutils.php
index ea7f74ed..b660de42 100644
--- a/src/utils/viewutils.php
+++ b/src/utils/viewutils.php
@@ -1,170 +1,170 @@
 <?php
 
 function phutil_date_format($epoch) {
   $now = time();
   $shift = 30 * 24 * 60 * 60;
   if ($epoch < $now + $shift && $epoch > $now - $shift) {
     $format = pht('D, M j');
   } else {
     $format = pht('M j Y');
   }
   return $format;
 }
 
 function phutil_format_relative_time($duration) {
   return phutil_format_units_generic(
     $duration,
     array(60, 60, 24, 7),
     array('s', 'm', 'h', 'd', 'w'),
     $precision = 0);
 }
 
 /**
  * Format a relative time (duration) into weeks, days, hours, minutes,
  * seconds, but unlike phabricator_format_relative_time, does so for more than
  * just the largest unit.
  *
  * @param int Duration in seconds.
  * @param int Levels to render - will render the three highest levels, ie:
  *            5 h, 37 m, 1 s
  * @return string Human-readable description.
  */
 function phutil_format_relative_time_detailed($duration, $levels = 2) {
   if ($duration == 0) {
     return 'now';
   }
   $levels = max(1, min($levels, 5));
   $remainder = 0;
 
   $is_negative = false;
   if ($duration < 0) {
     $is_negative = true;
     $duration = abs($duration);
   }
 
   $this_level = 1;
   $detailed_relative_time = phutil_format_units_generic(
     $duration,
     array(60, 60, 24, 7),
     array('s', 'm', 'h', 'd', 'w'),
     $precision = 0,
     $remainder);
   $duration = $remainder;
 
   while ($remainder > 0 && $this_level < $levels) {
     $detailed_relative_time .= ', '.phutil_format_units_generic(
       $duration,
       array(60, 60, 24, 7),
       array('s', 'm', 'h', 'd', 'w'),
       $precision = 0,
       $remainder);
     $duration = $remainder;
     $this_level++;
   }
 
   if ($is_negative) {
     $detailed_relative_time .= ' ago';
   }
 
   return $detailed_relative_time;
 }
 
 /**
  * Format a byte count for human consumption, e.g. "10MB" instead of
  * "10485760".
  *
  * @param int Number of bytes.
  * @return string Human-readable description.
  */
 function phutil_format_bytes($bytes) {
   return phutil_format_units_generic(
     $bytes,
     array(1024, 1024, 1024, 1024, 1024),
     array('B', 'KB', 'MB', 'GB', 'TB', 'PB'),
     $precision = 0);
 }
 
 
 /**
  * Parse a human-readable byte description (like "6MB") into an integer.
  *
  * @param string  Human-readable description.
  * @return int    Number of represented bytes.
  */
 function phutil_parse_bytes($input) {
   $bytes = trim($input);
   if (!strlen($bytes)) {
     return null;
   }
 
   // NOTE: Assumes US-centric numeral notation.
   $bytes = preg_replace('/[ ,]/', '', $bytes);
 
   $matches = null;
   if (!preg_match('/^(?:\d+(?:[.]\d+)?)([kmgtp]?)b?$/i', $bytes, $matches)) {
     throw new Exception(pht("Unable to parse byte size '%s'!", $input));
   }
 
   $scale = array(
     'k' => 1024,
     'm' => 1024 * 1024,
     'g' => 1024 * 1024 * 1024,
     't' => 1024 * 1024 * 1024 * 1024,
     'p' => 1024 * 1024 * 1024 * 1024 * 1024,
   );
 
   $bytes = (float)$bytes;
   if ($matches[1]) {
     $bytes *= $scale[strtolower($matches[1])];
   }
 
   return (int)$bytes;
 }
 
 
 function phutil_format_units_generic(
   $n,
   array $scales,
   array $labels,
   $precision  = 0,
   &$remainder = null) {
 
   $is_negative = false;
   if ($n < 0) {
     $is_negative = true;
     $n = abs($n);
   }
 
   $remainder = 0;
   $accum = 1;
 
   $scale = array_shift($scales);
   $label = array_shift($labels);
   while ($n >= $scale && count($labels)) {
-    $remainder += ($n % $scale) * $accum;
+    $remainder += ((int)$n % $scale) * $accum;
     $n /= $scale;
     $accum *= $scale;
     $label = array_shift($labels);
     if (!count($scales)) {
       break;
     }
     $scale = array_shift($scales);
   }
 
   if ($is_negative) {
     $n = -$n;
     $remainder = -$remainder;
   }
 
   if ($precision) {
     $num_string = number_format($n, $precision);
   } else {
     $num_string = (int)floor($n);
   }
 
   if ($label) {
     $num_string .= ' '.$label;
   }
 
   return $num_string;
 }
diff --git a/src/workflow/ArcanistCallConduitWorkflow.php b/src/workflow/ArcanistCallConduitWorkflow.php
index 025be3e1..5402ee16 100644
--- a/src/workflow/ArcanistCallConduitWorkflow.php
+++ b/src/workflow/ArcanistCallConduitWorkflow.php
@@ -1,78 +1,77 @@
 <?php
 
 final class ArcanistCallConduitWorkflow
   extends ArcanistArcWorkflow {
 
   public function getWorkflowName() {
     return 'call-conduit';
   }
 
   public function getWorkflowInformation() {
     $help = pht(<<<EOTEXT
 Allows you to make a raw Conduit method call:
 
   - Run this command from a working directory.
   - Call parameters are required, and read as a JSON blob from stdin.
   - Results are written to stdout as a JSON blob.
 
-This workflow is primarily useful for writing scripts which integrate
-with Phabricator. Examples:
+This workflow is primarily useful for writing scripts. Examples:
 
   $ echo '{}' | arc call-conduit -- conduit.ping
   $ echo '{"phid":"PHID-FILE-xxxx"}' | arc call-conduit -- file.download
 EOTEXT
       );
 
     return $this->newWorkflowInformation()
       ->setSynopsis(pht('Call Conduit API methods.'))
       ->addExample('**call-conduit** -- __method__')
       ->setHelp($help);
   }
 
   public function getWorkflowArguments() {
     return array(
       $this->newWorkflowArgument('method')
         ->setWildcard(true),
     );
   }
 
   public function runWorkflow() {
     $method = $this->getArgument('method');
     if (count($method) !== 1) {
       throw new PhutilArgumentUsageException(
         pht('Provide exactly one Conduit method name to call.'));
     }
     $method = head($method);
 
     $params = $this->readStdin();
     try {
       $params = phutil_json_decode($params);
     } catch (PhutilJSONParserException $ex) {
       throw new ArcanistUsageException(
         pht('Provide method parameters on stdin as a JSON blob.'));
     }
 
     $engine = $this->getConduitEngine();
     $conduit_future = $engine->newFuture($method, $params);
 
     $error = null;
     $error_message = null;
     try {
       $result = $conduit_future->resolve();
     } catch (ConduitClientException $ex) {
       $error = $ex->getErrorCode();
       $error_message = $ex->getMessage();
       $result = null;
     }
 
     echo id(new PhutilJSON())->encodeFormatted(
       array(
         'error' => $error,
         'errorMessage' => $error_message,
         'response' => $result,
       ));
 
     return 0;
   }
 
 }
diff --git a/src/workflow/ArcanistDiffWorkflow.php b/src/workflow/ArcanistDiffWorkflow.php
index 7201a003..36117994 100644
--- a/src/workflow/ArcanistDiffWorkflow.php
+++ b/src/workflow/ArcanistDiffWorkflow.php
@@ -1,2899 +1,2897 @@
 <?php
 
 /**
  * Sends changes from your working copy to Differential for code review.
  *
  * @task lintunit   Lint and Unit Tests
  * @task message    Commit and Update Messages
  * @task diffspec   Diff Specification
  * @task diffprop   Diff Properties
  */
 final class ArcanistDiffWorkflow extends ArcanistWorkflow {
 
   private $console;
   private $hasWarnedExternals = false;
   private $unresolvedLint;
   private $testResults;
   private $diffID;
   private $revisionID;
   private $diffPropertyFutures = array();
   private $commitMessageFromRevision;
   private $hitAutotargets;
   private $revisionTransactions;
   private $revisionIsDraft;
 
   const STAGING_PUSHED = 'pushed';
   const STAGING_USER_SKIP = 'user.skip';
   const STAGING_DIFF_RAW = 'diff.raw';
   const STAGING_REPOSITORY_UNKNOWN = 'repository.unknown';
   const STAGING_REPOSITORY_UNAVAILABLE = 'repository.unavailable';
   const STAGING_REPOSITORY_UNSUPPORTED = 'repository.unsupported';
   const STAGING_REPOSITORY_UNCONFIGURED = 'repository.unconfigured';
   const STAGING_CLIENT_UNSUPPORTED = 'client.unsupported';
 
   public function getWorkflowName() {
     return 'diff';
   }
 
   public function getCommandSynopses() {
     return phutil_console_format(<<<EOTEXT
       **diff** [__paths__] (svn)
       **diff** [__commit__] (git, hg)
 EOTEXT
       );
   }
 
   public function getCommandHelp() {
     return phutil_console_format(<<<EOTEXT
           Supports: git, svn, hg
           Generate a Differential diff or revision from local changes.
 
           Under git and mercurial, you can specify a commit (like __HEAD^^^__
           or __master__) and Differential will generate a diff against the
           merge base of that commit and your current working directory parent.
 
           Under svn, you can choose to include only some of the modified files
           in the working copy in the diff by specifying their paths. If you
           omit paths, all changes are included in the diff.
 EOTEXT
       );
   }
 
   public function requiresWorkingCopy() {
     return !$this->isRawDiffSource();
   }
 
   public function requiresConduit() {
     return true;
   }
 
   public function requiresAuthentication() {
     return true;
   }
 
   public function requiresRepositoryAPI() {
     if (!$this->isRawDiffSource()) {
       return true;
     }
 
     return false;
   }
 
   public function getDiffID() {
     return $this->diffID;
   }
 
   public function getArguments() {
     $arguments = array(
       'message' => array(
         'short'       => 'm',
         'param'       => 'message',
         'help' => pht(
           'When updating a revision, use the specified message instead of '.
           'prompting.'),
       ),
       'message-file' => array(
         'short' => 'F',
         'param' => 'file',
         'paramtype' => 'file',
         'help' => pht(
           'When creating a revision, read revision information '.
           'from this file.'),
       ),
       'edit' => array(
         'supports'    => array(
           'git',
           'hg',
         ),
         'nosupport'   => array(
           'svn' => pht('Edit revisions via the web interface when using SVN.'),
         ),
         'help' => pht(
           'When updating a revision under git, edit revision information '.
           'before updating.'),
       ),
       'raw' => array(
         'help' => pht(
           'Read diff from stdin, not from the working copy. This disables '.
-          'many Arcanist/Phabricator features which depend on having access '.
-          'to the working copy.'),
+          'many features which depend on having access to the working copy.'),
         'conflicts' => array(
           'apply-patches'       => pht('%s disables lint.', '--raw'),
           'never-apply-patches' => pht('%s disables lint.', '--raw'),
 
           'create'              => pht(
             '%s and %s both need stdin. Use %s.',
             '--raw',
             '--create',
             '--raw-command'),
           'edit'                => pht(
             '%s and %s both need stdin. Use %s.',
             '--raw',
             '--edit',
             '--raw-command'),
           'raw-command'         => null,
         ),
       ),
       'raw-command' => array(
         'param' => 'command',
         'help' => pht(
           'Generate diff by executing a specified command, not from the '.
-          'working copy. This disables many Arcanist/Phabricator features '.
-          'which depend on having access to the working copy.'),
+          'working copy. This disables many features which depend on having '.
+          'access to the working copy.'),
         'conflicts' => array(
           'apply-patches'       => pht('%s disables lint.', '--raw-command'),
           'never-apply-patches' => pht('%s disables lint.', '--raw-command'),
         ),
       ),
       'create' => array(
         'help' => pht('Always create a new revision.'),
         'conflicts' => array(
           'edit'    => pht(
             '%s can not be used with %s.',
             '--create',
             '--edit'),
           'only' => pht(
             '%s can not be used with %s.',
             '--create',
             '--only'),
           'update'  => pht(
             '%s can not be used with %s.',
             '--create',
             '--update'),
         ),
       ),
       'update' => array(
         'param' => 'revision_id',
         'help'  => pht('Always update a specific revision.'),
       ),
       'draft' => array(
         'help' => pht(
           'Create a draft revision so you can look over your changes before '.
           'involving anyone else. Other users will not be notified about the '.
           'revision until you later use "Request Review" to publish it. You '.
           'can still share the draft by giving someone the link.'),
         'conflicts' => array(
           'edit' => null,
           'only' => null,
           'update' => null,
         ),
       ),
       'nounit' => array(
         'help' => pht('Do not run unit tests.'),
       ),
       'nolint' => array(
         'help' => pht('Do not run lint.'),
         'conflicts' => array(
           'apply-patches' => pht('%s suppresses lint.', '--nolint'),
           'never-apply-patches' => pht('%s suppresses lint.', '--nolint'),
         ),
       ),
       'only' => array(
         'help' => pht(
           'Instead of creating or updating a revision, only create a diff, '.
           'which you may later attach to a revision.'),
         'conflicts' => array(
           'edit'      => pht('%s does affect revisions.', '--only'),
           'message'   => pht('%s does not update any revision.', '--only'),
         ),
       ),
       'allow-untracked' => array(
         'help' => pht('Skip checks for untracked files in the working copy.'),
       ),
       'apply-patches' => array(
         'help' => pht(
           'Apply patches suggested by lint to the working copy without '.
           'prompting.'),
         'conflicts' => array(
           'never-apply-patches' => true,
         ),
         'passthru' => array(
           'lint' => true,
         ),
       ),
       'never-apply-patches' => array(
         'help' => pht('Never apply patches suggested by lint.'),
         'conflicts' => array(
           'apply-patches' => true,
         ),
         'passthru' => array(
           'lint' => true,
         ),
       ),
       'amend-all' => array(
         'help' => pht(
           'When linting git repositories, amend HEAD with all patches '.
           'suggested by lint without prompting.'),
         'passthru' => array(
           'lint' => true,
         ),
       ),
       'amend-autofixes' => array(
         'help' => pht(
           'When linting git repositories, amend HEAD with autofix '.
           'patches suggested by lint without prompting.'),
         'passthru' => array(
           'lint' => true,
         ),
       ),
       'add-all' => array(
         'short' => 'a',
         'help' => pht(
           'Automatically add all unstaged and uncommitted '.
           'files to the commit.'),
       ),
       'json' => array(
         'help' => pht(
           'Emit machine-readable JSON. EXPERIMENTAL! Probably does not work!'),
       ),
       'no-amend' => array(
         'help' => pht(
           'Never amend commits in the working copy with lint patches.'),
       ),
       'uncommitted' => array(
         'help' => pht('Suppress warning about uncommitted changes.'),
         'supports' => array(
           'hg',
         ),
       ),
       'verbatim' => array(
         'help' => pht(
           'When creating a revision, try to use the working copy commit '.
           'message verbatim, without prompting to edit it. When updating a '.
           'revision, update some fields from the local commit message.'),
         'supports' => array(
           'hg',
           'git',
         ),
         'conflicts' => array(
           'update'              => true,
           'only' => true,
           'raw'                 => true,
           'raw-command'         => true,
           'message-file'        => true,
         ),
       ),
       'reviewers' => array(
         'param' => 'usernames',
         'help' => pht('When creating a revision, add reviewers.'),
         'conflicts' => array(
           'only' => true,
           'update'  => true,
         ),
       ),
       'cc' => array(
         'param' => 'usernames',
         'help' => pht('When creating a revision, add CCs.'),
         'conflicts' => array(
           'only' => true,
           'update'  => true,
         ),
       ),
       'skip-binaries' => array(
         'help'  => pht('Do not upload binaries (like images).'),
       ),
       'skip-staging' => array(
         'help' => pht('Do not copy changes to the staging area.'),
       ),
       'base' => array(
         'param' => 'rules',
         'help'  => pht('Additional rules for determining base revision.'),
         'nosupport' => array(
           'svn' => pht('Subversion does not use base commits.'),
         ),
         'supports' => array('git', 'hg'),
       ),
       'coverage' => array(
         'help' => pht('Always enable coverage information.'),
         'conflicts' => array(
           'no-coverage' => null,
         ),
         'passthru' => array(
           'unit' => true,
         ),
       ),
       'no-coverage' => array(
         'help' => pht('Always disable coverage information.'),
         'passthru' => array(
           'unit' => true,
         ),
       ),
       'browse' => array(
         'help' => pht(
           'After creating a diff or revision, open it in a web browser.'),
       ),
       '*' => 'paths',
       'head' => array(
         'param' => 'commit',
         'help' => pht(
-          'Specify the end of the commit range. This disables many '.
-          'Arcanist/Phabricator features which depend on having access to '.
-          'the working copy.'),
+          'Specify the end of the commit range. This disables many features '.
+          'which depend on having access to the working copy.'),
         'supports' => array('git'),
         'nosupport' => array(
           'svn' => pht('Subversion does not support commit ranges.'),
           'hg' => pht('Mercurial does not support %s yet.', '--head'),
         ),
       ),
     );
 
     return $arguments;
   }
 
   public function isRawDiffSource() {
     return $this->getArgument('raw') || $this->getArgument('raw-command');
   }
 
   public function run() {
     $this->console = PhutilConsole::getConsole();
 
     $this->runRepositoryAPISetup();
     $this->runDiffSetupBasics();
 
     $commit_message = $this->buildCommitMessage();
 
     $this->dispatchEvent(
       ArcanistEventType::TYPE_DIFF_DIDBUILDMESSAGE,
       array(
         'message' => $commit_message,
       ));
 
     if (!$this->shouldOnlyCreateDiff()) {
       $revision = $this->buildRevisionFromCommitMessage($commit_message);
     }
 
     $data = $this->runLintUnit();
 
     $lint_result = $data['lintResult'];
     $this->unresolvedLint = $data['unresolvedLint'];
     $unit_result = $data['unitResult'];
     $this->testResults = $data['testResults'];
 
     $changes = $this->generateChanges();
     if (!$changes) {
       throw new ArcanistUsageException(
         pht('There are no changes to generate a diff from!'));
     }
 
     $diff_spec = array(
       'changes' => mpull($changes, 'toDictionary'),
       'lintStatus' => $this->getLintStatus($lint_result),
       'unitStatus' => $this->getUnitStatus($unit_result),
     ) + $this->buildDiffSpecification();
 
     $conduit = $this->getConduit();
     $diff_info = $conduit->callMethodSynchronous(
       'differential.creatediff',
       $diff_spec);
 
     $this->diffID = $diff_info['diffid'];
 
     $event = $this->dispatchEvent(
       ArcanistEventType::TYPE_DIFF_WASCREATED,
       array(
         'diffID' => $diff_info['diffid'],
         'lintResult' => $lint_result,
         'unitResult' => $unit_result,
       ));
 
     $this->submitChangesToStagingArea($this->diffID);
 
     $phid = idx($diff_info, 'phid');
     if ($phid) {
       $this->hitAutotargets = $this->updateAutotargets(
         $phid,
         $unit_result);
     }
 
     $this->updateLintDiffProperty();
     $this->updateUnitDiffProperty();
     $this->updateLocalDiffProperty();
     $this->updateOntoDiffProperty();
     $this->resolveDiffPropertyUpdates();
 
     $output_json = $this->getArgument('json');
 
     if ($this->shouldOnlyCreateDiff()) {
       if (!$output_json) {
         echo phutil_console_format(
           "%s\n        **%s** __%s__\n\n",
           pht('Created a new Differential diff:'),
           pht('Diff URI:'),
           $diff_info['uri']);
       } else {
         $human = ob_get_clean();
         echo json_encode(array(
           'diffURI' => $diff_info['uri'],
           'diffID'  => $this->getDiffID(),
           'human'   => $human,
         ))."\n";
         ob_start();
       }
 
       if ($this->shouldOpenCreatedObjectsInBrowser()) {
         $this->openURIsInBrowser(array($diff_info['uri']));
       }
     } else {
       $is_draft = $this->getArgument('draft');
       $revision['diffid'] = $this->getDiffID();
 
       if ($commit_message->getRevisionID()) {
         if ($is_draft) {
           // TODO: In at least some cases, we could raise this earlier in the
           // workflow to save users some time before the workflow aborts.
           if ($this->revisionIsDraft) {
             $this->writeWarn(
               pht('ALREADY A DRAFT'),
               pht(
                 'You are updating a revision ("%s") with the "--draft" flag, '.
                 'but this revision is already a draft. You only need to '.
                 'provide the "--draft" flag when creating a revision. Draft '.
                 'revisions are not published until you explicitly request '.
                 'review from the web UI.',
                 $commit_message->getRevisionMonogram()));
           } else {
             throw new ArcanistUsageException(
               pht(
                 'You are updating a revision ("%s") with the "--draft" flag, '.
                 'but this revision has already been published for review. '.
                 'You can not turn a revision back into a draft once it has '.
                 'been published.',
                 $commit_message->getRevisionMonogram()));
           }
         }
 
         $result = $conduit->callMethodSynchronous(
           'differential.updaterevision',
           $revision);
 
         foreach (array('edit-messages.json', 'update-messages.json') as $file) {
           $messages = $this->readScratchJSONFile($file);
           unset($messages[$revision['id']]);
           $this->writeScratchJSONFile($file, $messages);
         }
 
         $result_uri = $result['uri'];
         $result_id = $result['revisionid'];
 
         echo pht('Updated an existing Differential revision:')."\n";
       } else {
         // NOTE: We're either using "differential.revision.edit" (preferred)
         // if we can, or falling back to "differential.createrevision"
         // (the older way) if not.
 
         $xactions = $this->revisionTransactions;
         if ($xactions) {
           $xactions[] = array(
             'type' => 'update',
             'value' => $diff_info['phid'],
           );
 
           if ($is_draft) {
             $xactions[] = array(
               'type' => 'draft',
               'value' => true,
             );
           }
 
           $result = $conduit->callMethodSynchronous(
             'differential.revision.edit',
             array(
               'transactions' => $xactions,
             ));
 
           $result_id = idxv($result, array('object', 'id'));
           if (!$result_id) {
             throw new Exception(
               pht(
                 'Expected a revision ID to be returned by '.
                 '"differential.revision.edit".'));
           }
 
           // TODO: This is hacky, but we don't currently receive a URI back
           // from "differential.revision.edit".
           $result_uri = id(new PhutilURI($this->getConduitURI()))
             ->setPath('/D'.$result_id);
         } else {
           if ($is_draft) {
             throw new ArcanistUsageException(
               pht(
-                'You have specified "--draft", but the version of Phabricator '.
+                'You have specified "--draft", but the software version '.
                 'on the server is too old to support draft revisions. Omit '.
                 'the flag or upgrade the server software.'));
           }
 
           $revision = $this->dispatchWillCreateRevisionEvent($revision);
 
           $result = $conduit->callMethodSynchronous(
             'differential.createrevision',
             $revision);
 
           $result_uri = $result['uri'];
           $result_id = $result['revisionid'];
         }
 
         $revised_message = $conduit->callMethodSynchronous(
           'differential.getcommitmessage',
           array(
             'revision_id' => $result_id,
           ));
 
         if ($this->shouldAmend()) {
           $repository_api = $this->getRepositoryAPI();
           if ($repository_api->supportsAmend()) {
             echo pht('Updating commit message...')."\n";
             $repository_api->amendCommit($revised_message);
           } else {
             echo pht(
               'Commit message was not amended. Amending commit message is '.
               'only supported in git and hg (version 2.2 or newer)');
           }
         }
 
         echo pht('Created a new Differential revision:')."\n";
       }
 
       $uri = $result_uri;
       echo phutil_console_format(
         "        **%s** __%s__\n\n",
         pht('Revision URI:'),
         $uri);
 
       if ($this->shouldOpenCreatedObjectsInBrowser()) {
         $this->openURIsInBrowser(array($uri));
       }
     }
 
     echo pht('Included changes:')."\n";
     foreach ($changes as $change) {
       echo '  '.$change->renderTextSummary()."\n";
     }
 
     if ($output_json) {
       ob_get_clean();
     }
 
     $this->removeScratchFile('create-message');
 
     return 0;
   }
 
   private function runRepositoryAPISetup() {
     if (!$this->requiresRepositoryAPI()) {
       return;
     }
 
     $repository_api = $this->getRepositoryAPI();
 
     $repository_api->setBaseCommitArgumentRules(
       $this->getArgument('base', ''));
 
     if ($repository_api->supportsCommitRanges()) {
       $this->parseBaseCommitArgument($this->getArgument('paths'));
     }
 
     $head_commit = $this->getArgument('head');
     if ($head_commit !== null) {
       $repository_api->setHeadCommit($head_commit);
     }
 
   }
 
   private function runDiffSetupBasics() {
     $output_json = $this->getArgument('json');
     if ($output_json) {
       // TODO: We should move this to a higher-level and put an indirection
       // layer between echoing stuff and stdout.
       ob_start();
     }
 
     if ($this->requiresWorkingCopy()) {
       $repository_api = $this->getRepositoryAPI();
       if ($this->getArgument('add-all')) {
         $this->setCommitMode(self::COMMIT_ENABLE);
       } else if ($this->getArgument('uncommitted')) {
         $this->setCommitMode(self::COMMIT_DISABLE);
       } else {
         $this->setCommitMode(self::COMMIT_ALLOW);
       }
       if ($repository_api instanceof ArcanistSubversionAPI) {
         $repository_api->limitStatusToPaths($this->getArgument('paths'));
       }
       if (!$this->getArgument('head')) {
         $this->requireCleanWorkingCopy();
       }
     }
 
     $this->dispatchEvent(
       ArcanistEventType::TYPE_DIFF_DIDCOLLECTCHANGES,
       array());
   }
 
   private function buildRevisionFromCommitMessage(
     ArcanistDifferentialCommitMessage $message) {
 
     $conduit = $this->getConduit();
 
     $revision_id = $message->getRevisionID();
     $revision = array(
       'fields' => $message->getFields(),
     );
     $xactions = $message->getTransactions();
 
     if ($revision_id) {
 
       // With '--verbatim', pass the (possibly modified) local fields. This
       // allows the user to edit some fields (like "title" and "summary")
       // locally without '--edit' and have changes automatically synchronized.
       // Without '--verbatim', we do not update the revision to reflect local
       // commit message changes.
       if ($this->getArgument('verbatim')) {
         $use_fields = $message->getFields();
       } else {
         $use_fields = array();
       }
 
       $should_edit = $this->getArgument('edit');
       $edit_messages = $this->readScratchJSONFile('edit-messages.json');
       $remote_corpus = idx($edit_messages, $revision_id);
 
       if (!$should_edit || !$remote_corpus || $use_fields) {
         if ($this->commitMessageFromRevision) {
           $remote_corpus = $this->commitMessageFromRevision;
         } else {
           $remote_corpus = $conduit->callMethodSynchronous(
             'differential.getcommitmessage',
             array(
               'revision_id' => $revision_id,
               'edit'        => 'edit',
               'fields'      => $use_fields,
             ));
         }
       }
 
       if ($should_edit) {
         $edited = $this->newInteractiveEditor($remote_corpus)
           ->setName('differential-edit-revision-info')
           ->setTaskMessage(pht(
             'Update the details for a revision, then save and exit.'))
           ->editInteractively();
         if ($edited != $remote_corpus) {
           $remote_corpus = $edited;
           $edit_messages[$revision_id] = $remote_corpus;
           $this->writeScratchJSONFile('edit-messages.json', $edit_messages);
         }
       }
 
       if ($this->commitMessageFromRevision == $remote_corpus) {
         $new_message = $message;
       } else {
         $remote_corpus = ArcanistCommentRemover::removeComments(
           $remote_corpus);
         $new_message = ArcanistDifferentialCommitMessage::newFromRawCorpus(
           $remote_corpus);
         $new_message->pullDataFromConduit($conduit);
       }
 
       $revision['fields'] = $new_message->getFields();
       $xactions = $new_message->getTransactions();
 
       $revision['id'] = $revision_id;
       $this->revisionID = $revision_id;
 
       $revision['message'] = $this->getArgument('message');
       if ($revision['message'] === null) {
         $update_messages = $this->readScratchJSONFile('update-messages.json');
 
         $update_messages[$revision_id] = $this->getUpdateMessage(
           $revision['fields'],
           idx($update_messages, $revision_id));
 
         $revision['message'] = ArcanistCommentRemover::removeComments(
           $update_messages[$revision_id]);
         if (!strlen(trim($revision['message']))) {
           throw new ArcanistUserAbortException();
         }
 
         $this->writeScratchJSONFile('update-messages.json', $update_messages);
       }
     }
 
     $this->revisionTransactions = $xactions;
 
     return $revision;
   }
 
   protected function shouldOnlyCreateDiff() {
     if ($this->getArgument('create')) {
       return false;
     }
 
     if ($this->getArgument('update')) {
       return false;
     }
 
     if ($this->isRawDiffSource()) {
       return true;
     }
 
     return $this->getArgument('only');
   }
 
   private function generateAffectedPaths() {
     if ($this->isRawDiffSource()) {
       return array();
     }
 
     $repository_api = $this->getRepositoryAPI();
     if ($repository_api instanceof ArcanistSubversionAPI) {
       $file_list = new FileList($this->getArgument('paths', array()));
       $paths = $repository_api->getSVNStatus($externals = true);
       foreach ($paths as $path => $mask) {
         if (!$file_list->contains($repository_api->getPath($path), true)) {
           unset($paths[$path]);
         }
       }
 
       $warn_externals = array();
       foreach ($paths as $path => $mask) {
         $any_mod = ($mask & ArcanistRepositoryAPI::FLAG_ADDED) ||
                    ($mask & ArcanistRepositoryAPI::FLAG_MODIFIED) ||
                    ($mask & ArcanistRepositoryAPI::FLAG_DELETED);
         if ($mask & ArcanistRepositoryAPI::FLAG_EXTERNALS) {
           unset($paths[$path]);
           if ($any_mod) {
             $warn_externals[] = $path;
           }
         }
       }
 
       if ($warn_externals && !$this->hasWarnedExternals) {
         echo phutil_console_format(
           "%s\n\n%s\n\n",
           pht(
             "The working copy includes changes to '%s' paths. These ".
             "changes will not be included in the diff because SVN can not ".
             "commit 'svn:externals' changes alongside normal changes.",
             'svn:externals'),
           pht(
             "Modified '%s' files:",
             'svn:externals'),
           phutil_console_wrap(implode("\n", $warn_externals), 8));
         $prompt = pht('Generate a diff (with just local changes) anyway?');
         if (!phutil_console_confirm($prompt)) {
           throw new ArcanistUserAbortException();
         } else {
           $this->hasWarnedExternals = true;
         }
       }
 
     } else {
       $paths = $repository_api->getWorkingCopyStatus();
     }
 
     foreach ($paths as $path => $mask) {
       if ($mask & ArcanistRepositoryAPI::FLAG_UNTRACKED) {
         unset($paths[$path]);
       }
     }
 
     return $paths;
   }
 
 
   protected function generateChanges() {
     $parser = $this->newDiffParser();
 
     $is_raw = $this->isRawDiffSource();
     if ($is_raw) {
 
       if ($this->getArgument('raw')) {
         fwrite(STDERR, pht('Reading diff from stdin...')."\n");
         $raw_diff = file_get_contents('php://stdin');
       } else if ($this->getArgument('raw-command')) {
         list($raw_diff) = execx('%C', $this->getArgument('raw-command'));
       } else {
         throw new Exception(pht('Unknown raw diff source.'));
       }
 
       $changes = $parser->parseDiff($raw_diff);
       foreach ($changes as $key => $change) {
         // Remove "message" changes, e.g. from "git show".
         if ($change->getType() == ArcanistDiffChangeType::TYPE_MESSAGE) {
           unset($changes[$key]);
         }
       }
       return $changes;
     }
 
     $repository_api = $this->getRepositoryAPI();
 
     if ($repository_api instanceof ArcanistSubversionAPI) {
       $paths = $this->generateAffectedPaths();
       $this->primeSubversionWorkingCopyData($paths);
 
       // Check to make sure the user is diffing from a consistent base revision.
       // This is mostly just an abuse sanity check because it's silly to do this
       // and makes the code more difficult to effectively review, but it also
       // affects patches and makes them nonportable.
       $bases = $repository_api->getSVNBaseRevisions();
 
       // Remove all files with baserev "0"; these files are new.
       foreach ($bases as $path => $baserev) {
         if ($bases[$path] <= 0) {
           unset($bases[$path]);
         }
       }
 
       if ($bases) {
         $rev = reset($bases);
 
         $revlist = array();
         foreach ($bases as $path => $baserev) {
           $revlist[] = '    '.pht('Revision %s, %s', $baserev, $path);
         }
         $revlist = implode("\n", $revlist);
 
         foreach ($bases as $path => $baserev) {
           if ($baserev !== $rev) {
             throw new ArcanistUsageException(
               pht(
                 "Base revisions of changed paths are mismatched. Update all ".
                 "paths to the same base revision before creating a diff: ".
                 "\n\n%s",
                 $revlist));
           }
         }
 
         // If you have a change which affects several files, all of which are
         // at a consistent base revision, treat that revision as the effective
         // base revision. The use case here is that you made a change to some
         // file, which updates it to HEAD, but want to be able to change it
         // again without updating the entire working copy. This is a little
         // sketchy but it arises in Facebook Ops workflows with config files and
         // doesn't have any real material tradeoffs (e.g., these patches are
         // perfectly applyable).
         $repository_api->overrideSVNBaseRevisionNumber($rev);
       }
 
       $changes = $parser->parseSubversionDiff(
         $repository_api,
         $paths);
     } else if ($repository_api instanceof ArcanistGitAPI) {
       $diff = $repository_api->getFullGitDiff(
         $repository_api->getBaseCommit(),
         $repository_api->getHeadCommit());
       if (!strlen($diff)) {
         throw new ArcanistUsageException(
           pht('No changes found. (Did you specify the wrong commit range?)'));
       }
       $changes = $parser->parseDiff($diff);
     } else if ($repository_api instanceof ArcanistMercurialAPI) {
       $diff = $repository_api->getFullMercurialDiff();
       if (!strlen($diff)) {
         throw new ArcanistUsageException(
           pht('No changes found. (Did you specify the wrong commit range?)'));
       }
       $changes = $parser->parseDiff($diff);
     } else {
       throw new Exception(pht('Repository API is not supported.'));
     }
 
     $limit = 1024 * 1024 * 4;
     foreach ($changes as $change) {
       $size = 0;
       foreach ($change->getHunks() as $hunk) {
         $size += strlen($hunk->getCorpus());
       }
       if ($size > $limit) {
         $byte_warning = pht(
           "Diff for '%s' with context is %s bytes in length. ".
           "Generally, source changes should not be this large.",
           $change->getCurrentPath(),
           new PhutilNumber($size));
         if ($repository_api instanceof ArcanistSubversionAPI) {
           throw new ArcanistUsageException(
             $byte_warning.' '.
             pht(
               "If the file is not a text file, mark it as binary with:".
               "\n\n  $ %s\n",
               'svn propset svn:mime-type application/octet-stream <filename>'));
         } else {
           $confirm = $byte_warning.' '.pht(
             "If the file is not a text file, you can mark it 'binary'. ".
             "Mark this file as 'binary' and continue?");
           if (phutil_console_confirm($confirm)) {
             $change->convertToBinaryChange($repository_api);
           } else {
             throw new ArcanistUsageException(
               pht('Aborted generation of gigantic diff.'));
           }
         }
       }
     }
 
     $utf8_problems = array();
     foreach ($changes as $change) {
       foreach ($change->getHunks() as $hunk) {
         $corpus = $hunk->getCorpus();
         if (!phutil_is_utf8($corpus)) {
 
           // If this corpus is heuristically binary, don't try to convert it.
           // mb_check_encoding() and mb_convert_encoding() are both very very
           // liberal about what they're willing to process.
           $is_binary = ArcanistDiffUtils::isHeuristicBinaryFile($corpus);
           if (!$is_binary) {
 
             try {
               $try_encoding = $this->getRepositoryEncoding();
             } catch (ConduitClientException $e) {
               if ($e->getErrorCode() == 'ERR-BAD-ARCANIST-PROJECT') {
                 echo phutil_console_wrap(
-                  pht('Lookup of encoding in arcanist project failed: %s',
+                  pht('Lookup of encoding in project failed: %s',
                       $e->getMessage())."\n");
               } else {
                 throw $e;
               }
             }
 
             if ($try_encoding) {
               $corpus = phutil_utf8_convert($corpus, 'UTF-8', $try_encoding);
               $name = $change->getCurrentPath();
               if (phutil_is_utf8($corpus)) {
                 $this->writeStatusMessage(
                   pht(
                     "Converted a '%s' hunk from '%s' to UTF-8.\n",
                     $name,
                     $try_encoding));
                 $hunk->setCorpus($corpus);
                 continue;
               }
             }
           }
           $utf8_problems[] = $change;
           break;
         }
       }
     }
 
     // If there are non-binary files which aren't valid UTF-8, warn the user
     // and treat them as binary changes. See D327 for discussion of why Arcanist
     // has this behavior.
     if ($utf8_problems) {
       $utf8_warning =
         sprintf(
           "%s\n\n%s\n\n    %s\n",
           pht(
             'This diff includes %s file(s) which are not valid UTF-8 (they '.
             'contain invalid byte sequences). You can either stop this '.
             'workflow and fix these files, or continue. If you continue, '.
             'these files will be marked as binary.',
             phutil_count($utf8_problems)),
           pht(
-            "You can learn more about how Phabricator handles character ".
+            "You can learn more about how this software handles character ".
             "encodings (and how to configure encoding settings and detect and ".
             "correct encoding problems) by reading 'User Guide: UTF-8 and ".
-            "Character Encoding' in the Phabricator documentation."),
+            "Character Encoding' in the documentation."),
           pht(
             '%s AFFECTED FILE(S)',
             phutil_count($utf8_problems)));
       $confirm = pht(
         'Do you want to mark these %s file(s) as binary and continue?',
         phutil_count($utf8_problems));
 
       echo phutil_console_format(
         "**%s**\n",
         pht('Invalid Content Encoding (Non-UTF8)'));
       echo phutil_console_wrap($utf8_warning);
 
       $file_list = mpull($utf8_problems, 'getCurrentPath');
       $file_list = '    '.implode("\n    ", $file_list);
       echo $file_list;
 
       if (!phutil_console_confirm($confirm, $default_no = false)) {
         throw new ArcanistUsageException(pht('Aborted workflow to fix UTF-8.'));
       } else {
         foreach ($utf8_problems as $change) {
           $change->convertToBinaryChange($repository_api);
         }
       }
     }
 
     $this->uploadFilesForChanges($changes);
 
     return $changes;
   }
 
   private function getGitParentLogInfo() {
     $info = array(
       'parent'        => null,
       'base_revision' => null,
       'base_path'     => null,
       'uuid'          => null,
     );
 
     $repository_api = $this->getRepositoryAPI();
 
     $parser = $this->newDiffParser();
     $history_messages = $repository_api->getGitHistoryLog();
     if (!$history_messages) {
       // This can occur on the initial commit.
       return $info;
     }
     $history_messages = $parser->parseDiff($history_messages);
 
     foreach ($history_messages as $key => $change) {
       try {
         $message = ArcanistDifferentialCommitMessage::newFromRawCorpus(
           $change->getMetadata('message'));
         if ($message->getRevisionID() && $info['parent'] === null) {
           $info['parent'] = $message->getRevisionID();
         }
         if ($message->getGitSVNBaseRevision() &&
             $info['base_revision'] === null) {
           $info['base_revision'] = $message->getGitSVNBaseRevision();
           $info['base_path']     = $message->getGitSVNBasePath();
         }
         if ($message->getGitSVNUUID()) {
           $info['uuid'] = $message->getGitSVNUUID();
         }
         if ($info['parent'] && $info['base_revision']) {
           break;
         }
       } catch (ArcanistDifferentialCommitMessageParserException $ex) {
         // Ignore.
       } catch (ArcanistUsageException $ex) {
         // Ignore an invalid Differential Revision field in the parent commit
       }
     }
 
     return $info;
   }
 
   protected function primeSubversionWorkingCopyData($paths) {
     $repository_api = $this->getRepositoryAPI();
 
     $futures = array();
     $targets = array();
     foreach ($paths as $path => $mask) {
       $futures[] = $repository_api->buildDiffFuture($path);
       $targets[] = array('command' => 'diff', 'path' => $path);
       $futures[] = $repository_api->buildInfoFuture($path);
       $targets[] = array('command' => 'info', 'path' => $path);
     }
 
     $futures = id(new FutureIterator($futures))
       ->limit(8);
     foreach ($futures as $key => $future) {
       $target = $targets[$key];
       if ($target['command'] == 'diff') {
         $repository_api->primeSVNDiffResult(
           $target['path'],
           $future->resolve());
       } else {
         $repository_api->primeSVNInfoResult(
           $target['path'],
           $future->resolve());
       }
     }
   }
 
   private function shouldAmend() {
     if ($this->isRawDiffSource()) {
       return false;
     }
 
     if ($this->getArgument('no-amend')) {
       return false;
     }
 
     if ($this->getArgument('head') !== null) {
       return false;
     }
 
     // Run this last: with --raw or --raw-command, we won't have a repository
     // API.
     if ($this->isHistoryImmutable()) {
       return false;
     }
 
     return true;
   }
 
 
 /* -(  Lint and Unit Tests  )------------------------------------------------ */
 
 
   /**
    * @task lintunit
    */
   private function runLintUnit() {
     $lint_result = $this->runLint();
     $unit_result = $this->runUnit();
     return array(
       'lintResult' => $lint_result,
       'unresolvedLint' => $this->unresolvedLint,
       'unitResult' => $unit_result,
       'testResults' => $this->testResults,
     );
   }
 
 
   /**
    * @task lintunit
    */
   private function runLint() {
     if ($this->getArgument('nolint') ||
         $this->isRawDiffSource() ||
         $this->getArgument('head')) {
       return ArcanistLintWorkflow::RESULT_SKIP;
     }
 
     $repository_api = $this->getRepositoryAPI();
 
     $this->console->writeOut("%s\n", pht('Linting...'));
     try {
       $argv = $this->getPassthruArgumentsAsArgv('lint');
       if ($repository_api->supportsCommitRanges()) {
         $argv[] = '--rev';
         $argv[] = $repository_api->getBaseCommit();
       }
 
       $lint_workflow = $this->buildChildWorkflow('lint', $argv);
 
       if ($this->shouldAmend()) {
         // TODO: We should offer to create a checkpoint commit.
         $lint_workflow->setShouldAmendChanges(true);
       }
 
       $lint_result = $lint_workflow->run();
 
       switch ($lint_result) {
         case ArcanistLintWorkflow::RESULT_OKAY:
           $this->console->writeOut(
             "<bg:green>** %s **</bg> %s\n",
             pht('LINT OKAY'),
             pht('No lint problems.'));
           break;
         case ArcanistLintWorkflow::RESULT_WARNINGS:
           $this->console->writeOut(
             "<bg:yellow>** %s **</bg> %s\n",
             pht('LINT MESSAGES'),
             pht('Lint issued unresolved warnings.'));
           break;
         case ArcanistLintWorkflow::RESULT_ERRORS:
           $this->console->writeOut(
             "<bg:red>** %s **</bg> %s\n",
             pht('LINT ERRORS'),
             pht('Lint raised errors!'));
           break;
       }
 
       $this->unresolvedLint = array();
       foreach ($lint_workflow->getUnresolvedMessages() as $message) {
         $this->unresolvedLint[] = $message->toDictionary();
       }
 
       return $lint_result;
     } catch (ArcanistNoEngineException $ex) {
       $this->console->writeOut(
         "%s\n",
         pht('No lint engine configured for this project.'));
     } catch (ArcanistNoEffectException $ex) {
       $this->console->writeOut("%s\n", $ex->getMessage());
     }
 
     return null;
   }
 
 
   /**
    * @task lintunit
    */
   private function runUnit() {
     if ($this->getArgument('nounit') ||
         $this->isRawDiffSource() ||
         $this->getArgument('head')) {
       return ArcanistUnitWorkflow::RESULT_SKIP;
     }
 
     $repository_api = $this->getRepositoryAPI();
 
     $this->console->writeOut("%s\n", pht('Running unit tests...'));
     try {
       $argv = $this->getPassthruArgumentsAsArgv('unit');
       if ($repository_api->supportsCommitRanges()) {
         $argv[] = '--rev';
         $argv[] = $repository_api->getBaseCommit();
       }
       $unit_workflow = $this->buildChildWorkflow('unit', $argv);
       $unit_result = $unit_workflow->run();
 
       switch ($unit_result) {
         case ArcanistUnitWorkflow::RESULT_OKAY:
           $this->console->writeOut(
             "<bg:green>** %s **</bg> %s\n",
             pht('UNIT OKAY'),
             pht('No unit test failures.'));
           break;
         case ArcanistUnitWorkflow::RESULT_UNSOUND:
           $continue = phutil_console_confirm(
             pht(
               'Unit test results included failures, but all failing tests '.
               'are known to be unsound. Ignore unsound test failures?'));
           if (!$continue) {
             throw new ArcanistUserAbortException();
           }
 
           echo phutil_console_format(
             "<bg:yellow>** %s **</bg> %s\n",
             pht('UNIT UNSOUND'),
             pht(
               'Unit testing raised errors, but all '.
               'failing tests are unsound.'));
           break;
         case ArcanistUnitWorkflow::RESULT_FAIL:
           $this->console->writeOut(
             "<bg:red>** %s **</bg> %s\n",
             pht('UNIT ERRORS'),
             pht('Unit testing raised errors!'));
           break;
       }
 
       $this->testResults = array();
       foreach ($unit_workflow->getTestResults() as $test) {
         $this->testResults[] = $test->toDictionary();
       }
 
       return $unit_result;
     } catch (ArcanistNoEngineException $ex) {
       $this->console->writeOut(
         "%s\n",
         pht('No unit test engine is configured for this project.'));
     } catch (ArcanistNoEffectException $ex) {
       $this->console->writeOut("%s\n", $ex->getMessage());
     }
 
     return null;
   }
 
   public function getTestResults() {
     return $this->testResults;
   }
 
 
 /* -(  Commit and Update Messages  )----------------------------------------- */
 
 
   /**
    * @task message
    */
   private function buildCommitMessage() {
     if ($this->getArgument('only')) {
       return null;
     }
 
     $is_create = $this->getArgument('create');
     $is_update = $this->getArgument('update');
     $is_raw = $this->isRawDiffSource();
     $is_verbatim = $this->getArgument('verbatim');
 
     if ($is_verbatim) {
       return $this->getCommitMessageFromUser();
     }
 
 
     if (!$is_raw && !$is_create && !$is_update) {
       $repository_api = $this->getRepositoryAPI();
       $revisions = $repository_api->loadWorkingCopyDifferentialRevisions(
         $this->getConduit(),
         array(
           'authors' => array($this->getUserPHID()),
           'status'  => 'status-open',
         ));
       if (!$revisions) {
         $is_create = true;
       } else if (count($revisions) == 1) {
         $revision = head($revisions);
         $is_update = $revision['id'];
       } else {
         throw new ArcanistUsageException(
           pht(
             "There are several revisions which match the working copy:\n\n%s\n".
             "Use '%s' to choose one, or '%s' to create a new revision.",
             $this->renderRevisionList($revisions),
             '--update',
             '--create'));
       }
     }
 
     $message = null;
     if ($is_create) {
       $message_file = $this->getArgument('message-file');
       if ($message_file) {
         return $this->getCommitMessageFromFile($message_file);
       } else {
         return $this->getCommitMessageFromUser();
       }
     } else if ($is_update) {
       $revision_id = $this->normalizeRevisionID($is_update);
       if (!is_numeric($revision_id)) {
         throw new ArcanistUsageException(
           pht(
             'Parameter to %s must be a Differential Revision number.',
             '--update'));
       }
       return $this->getCommitMessageFromRevision($revision_id);
     } else {
       // This is --raw without enough info to create a revision, so force just
       // a diff.
       return null;
     }
   }
 
 
   /**
    * @task message
    */
   private function getCommitMessageFromUser() {
     $conduit = $this->getConduit();
 
     $template = null;
 
     if (!$this->getArgument('verbatim')) {
       $saved = $this->readScratchFile('create-message');
       if ($saved) {
         $where = $this->getReadableScratchFilePath('create-message');
 
         $preview = explode("\n", $saved);
         $preview = array_shift($preview);
         $preview = trim($preview);
         $preview = id(new PhutilUTF8StringTruncator())
           ->setMaximumGlyphs(64)
           ->truncateString($preview);
 
         if ($preview) {
           $preview = pht('Message begins:')."\n\n       {$preview}\n\n";
         } else {
           $preview = null;
         }
 
         echo pht(
           "You have a saved revision message in '%s'.\n%s".
           "You can use this message, or discard it.",
           $where,
           $preview);
 
         $use = phutil_console_confirm(
           pht('Do you want to use this message?'),
           $default_no = false);
         if ($use) {
           $template = $saved;
         } else {
           $this->removeScratchFile('create-message');
         }
       }
     }
 
     $template_is_default = false;
     $notes = array();
     $included = array();
 
     list($fields, $notes, $included_commits) = $this->getDefaultCreateFields();
     if ($template) {
       $fields = array();
       $notes = array();
     } else {
       if (!$fields) {
         $template_is_default = true;
       }
 
       if ($notes) {
         $commit = head($this->getRepositoryAPI()->getLocalCommitInformation());
         $template = $commit['message'];
       } else {
         $template = $conduit->callMethodSynchronous(
           'differential.getcommitmessage',
           array(
             'revision_id' => null,
             'edit'        => 'create',
             'fields'      => $fields,
           ));
       }
     }
 
     $old_message = $template;
 
     $included = array();
     if ($included_commits) {
       foreach ($included_commits as $commit) {
         $included[] = '        '.$commit;
       }
 
       if (!$this->isRawDiffSource()) {
         $message = pht(
           'Included commits in branch %s:',
           $this->getRepositoryAPI()->getBranchName());
       } else {
         $message = pht('Included commits:');
       }
       $included = array_merge(
         array(
           '',
           $message,
           '',
         ),
         $included);
     }
 
     $issues = array_merge(
       array(
         pht('NEW DIFFERENTIAL REVISION'),
         pht('Describe the changes in this new revision.'),
       ),
       $included,
       array(
         '',
         pht(
           'arc could not identify any existing revision in your working copy.'),
         pht('If you intended to update an existing revision, use:'),
         '',
         '  $ arc diff --update <revision>',
       ));
     if ($notes) {
       $issues = array_merge($issues, array(''), $notes);
     }
 
     $done = false;
     $first = true;
     while (!$done) {
       $template = rtrim($template, "\r\n")."\n\n";
       foreach ($issues as $issue) {
         $template .= rtrim('# '.$issue)."\n";
       }
       $template .= "\n";
 
       if ($first && $this->getArgument('verbatim') && !$template_is_default) {
         $new_template = $template;
       } else {
         $new_template = $this->newInteractiveEditor($template)
           ->setName('new-commit')
           ->setTaskMessage(pht(
             'Provide the details for a new revision, then save and exit.'))
           ->editInteractively();
       }
       $first = false;
 
       if ($template_is_default && ($new_template == $template)) {
         throw new ArcanistUsageException(pht('Template not edited.'));
       }
 
       $template = ArcanistCommentRemover::removeComments($new_template);
 
       // With --raw-command, we may not have a repository API.
       if ($this->hasRepositoryAPI()) {
         $repository_api = $this->getRepositoryAPI();
         // special check for whether to amend here. optimizes a common git
         // workflow. we can't do this for mercurial because the mq extension
         // is popular and incompatible with hg commit --amend ; see T2011.
         $should_amend = (count($included_commits) == 1 &&
                          $repository_api instanceof ArcanistGitAPI &&
                          $this->shouldAmend());
       } else {
         $should_amend = false;
       }
 
       if ($should_amend) {
         $wrote = (rtrim($old_message) != rtrim($template));
         if ($wrote) {
           $repository_api->amendCommit($template);
           $where = pht('commit message');
         }
       } else {
         $wrote = $this->writeScratchFile('create-message', $template);
         $where = "'".$this->getReadableScratchFilePath('create-message')."'";
       }
 
       try {
         $message = ArcanistDifferentialCommitMessage::newFromRawCorpus(
           $template);
         $message->pullDataFromConduit($conduit);
         $this->validateCommitMessage($message);
         $done = true;
       } catch (ArcanistDifferentialCommitMessageParserException $ex) {
         echo pht('Commit message has errors:')."\n\n";
         $issues = array(pht('Resolve these errors:'));
         foreach ($ex->getParserErrors() as $error) {
           echo phutil_console_wrap("- ".$error."\n", 6);
           $issues[] = '  - '.$error;
         }
         echo "\n";
         echo pht('You must resolve these errors to continue.');
         $again = phutil_console_confirm(
           pht('Do you want to edit the message?'),
           $default_no = false);
         if ($again) {
           // Keep going.
         } else {
           $saved = null;
           if ($wrote) {
             $saved = pht('A copy was saved to %s.', $where);
           }
           throw new ArcanistUsageException(
             pht('Message has unresolved errors.')." {$saved}");
         }
       } catch (Exception $ex) {
         if ($wrote) {
           echo phutil_console_wrap(pht('(Message saved to %s.)', $where)."\n");
         }
         throw $ex;
       }
     }
 
     return $message;
   }
 
 
   /**
    * @task message
    */
   private function getCommitMessageFromFile($file) {
     $conduit = $this->getConduit();
 
     $data = Filesystem::readFile($file);
     $message = ArcanistDifferentialCommitMessage::newFromRawCorpus($data);
     $message->pullDataFromConduit($conduit);
 
     $this->validateCommitMessage($message);
 
     return $message;
   }
 
 
   /**
    * @task message
    */
   private function getCommitMessageFromRevision($revision_id) {
     $id = $revision_id;
 
     $revision = $this->getConduit()->callMethodSynchronous(
       'differential.query',
       array(
         'ids' => array($id),
       ));
     $revision = head($revision);
 
     if (!$revision) {
       throw new ArcanistUsageException(
         pht(
           "Revision '%s' does not exist!",
           $revision_id));
     }
 
     $this->checkRevisionOwnership($revision);
 
     // TODO: Save this status to improve a prompt later. See PHI458. This is
     // extra awful until we move to "differential.revision.search" because
     // the "differential.query" method doesn't return a real draft status for
     // compatibility.
     $this->revisionIsDraft = (idx($revision, 'statusName') === 'Draft');
 
     $message = $this->getConduit()->callMethodSynchronous(
       'differential.getcommitmessage',
       array(
         'revision_id' => $id,
         'edit'        => false,
       ));
     $this->commitMessageFromRevision = $message;
 
     $obj = ArcanistDifferentialCommitMessage::newFromRawCorpus($message);
     $obj->pullDataFromConduit($this->getConduit());
 
     return $obj;
   }
 
 
   /**
    * @task message
    */
   private function validateCommitMessage(
     ArcanistDifferentialCommitMessage $message) {
     $futures = array();
 
     $revision_id = $message->getRevisionID();
     if ($revision_id) {
       $futures['revision'] = $this->getConduit()->callMethod(
         'differential.query',
         array(
           'ids' => array($revision_id),
         ));
     }
 
     $reviewers = $message->getFieldValue('reviewerPHIDs');
     if ($reviewers) {
       $futures['reviewers'] = $this->getConduit()->callMethod(
         'user.query',
         array(
           'phids' => $reviewers,
         ));
     }
 
     foreach (new FutureIterator($futures) as $key => $future) {
       $result = $future->resolve();
       switch ($key) {
         case 'revision':
           if (empty($result)) {
             throw new ArcanistUsageException(
               pht(
                 'There is no revision %s.',
                 "D{$revision_id}"));
           }
           $this->checkRevisionOwnership(head($result));
           break;
         case 'reviewers':
           $away = array();
           foreach ($result as $user) {
             if (idx($user, 'currentStatus') != 'away') {
               continue;
             }
 
             $username = $user['userName'];
             $real_name = $user['realName'];
 
             if (strlen($real_name)) {
               $name = pht('%s (%s)', $username, $real_name);
             } else {
               $name = pht('%s', $username);
             }
 
             $away[] = array(
               'name' => $name,
               'until' => $user['currentStatusUntil'],
             );
           }
 
           if ($away) {
             if (count($away) == count($reviewers)) {
               $earliest_return = min(ipull($away, 'until'));
 
               $message = pht(
                 'All reviewers are away until %s:',
                 date('l, M j Y', $earliest_return));
             } else {
               $message = pht('Some reviewers are currently away:');
             }
 
             echo tsprintf(
               "%s\n\n",
               $message);
 
             $list = id(new PhutilConsoleList());
             foreach ($away as $spec) {
               $list->addItem(
                 pht(
                   '%s (until %s)',
                   $spec['name'],
                   date('l, M j Y', $spec['until'])));
             }
 
             echo tsprintf(
               '%B',
               $list->drawConsoleString());
 
             $confirm = pht('Continue even though reviewers are unavailable?');
             if (!phutil_console_confirm($confirm)) {
               throw new ArcanistUsageException(
                 pht('Specify available reviewers and retry.'));
             }
           }
           break;
       }
     }
 
   }
 
 
   /**
    * @task message
    */
   private function getUpdateMessage(array $fields, $template = '') {
     if ($this->getArgument('raw')) {
       throw new ArcanistUsageException(
         pht(
           "When using '%s' to update a revision, specify an update message ".
           "with '%s'. (Normally, we'd launch an editor to ask you for a ".
           "message, but can not do that because stdin is the diff source.)",
           '--raw',
           '--message'));
     }
 
     // When updating a revision using git without specifying '--message', try
     // to prefill with the message in HEAD if it isn't a template message. The
     // idea is that if you do:
     //
     //  $ git commit -a -m 'fix some junk'
     //  $ arc diff
     //
     // ...you shouldn't have to retype the update message. Similar things apply
     // to Mercurial.
 
     if ($template == '') {
       $comments = $this->getDefaultUpdateMessage();
 
       $comments = phutil_string_cast($comments);
       $comments = rtrim($comments);
 
       $template = sprintf(
         "%s\n\n# %s\n#\n# %s\n# %s\n#\n# %s\n#  $ %s\n\n",
         $comments,
         pht(
           'Updating %s: %s',
           "D{$fields['revisionID']}",
           $fields['title']),
         pht(
           'Enter a brief description of the changes included in this update.'),
         pht('The first line is used as subject, next lines as comment.'),
         pht('If you intended to create a new revision, use:'),
         'arc diff --create');
     }
 
     $comments = $this->newInteractiveEditor($template)
       ->setName('differential-update-comments')
       ->setTaskMessage(pht(
         'Update the revision comments, then save and exit.'))
       ->editInteractively();
 
     return $comments;
   }
 
   private function getDefaultCreateFields() {
     $result = array(array(), array(), array());
 
     if ($this->isRawDiffSource()) {
       return $result;
     }
 
     $repository_api = $this->getRepositoryAPI();
     $local = $repository_api->getLocalCommitInformation();
     if ($local) {
       $result = $this->parseCommitMessagesIntoFields($local);
       if ($this->getArgument('create')) {
         unset($result[0]['revisionID']);
       }
     }
 
     $result[0] = $this->dispatchWillBuildEvent($result[0]);
 
     return $result;
   }
 
   /**
    * Convert a list of commits from `getLocalCommitInformation()` into
    * a format usable by arc to create a new diff. Specifically, we emit:
    *
    *   - A dictionary of commit message fields.
    *   - A list of errors encountered while parsing the messages.
    *   - A human-readable list of the commits themselves.
    *
    * For example, if the user runs "arc diff HEAD^^^" and selects a diff range
    * which includes several diffs, we attempt to merge them somewhat
    * intelligently into a single message, because we can only send one
    * "Summary:", "Reviewers:", etc., field to Differential. We also return
    * errors (e.g., if the user typed a reviewer name incorrectly) and a
    * summary of the commits themselves.
    *
    * @param dict  Local commit information.
    * @return list Complex output, see summary.
    * @task message
    */
   private function parseCommitMessagesIntoFields(array $local) {
     $conduit = $this->getConduit();
     $local = ipull($local, null, 'commit');
 
     // If the user provided "--reviewers" or "--ccs", add a faux message to
     // the list with the implied fields.
 
     $faux_message = array();
     if ($this->getArgument('reviewers')) {
       $faux_message[] = pht('Reviewers: %s', $this->getArgument('reviewers'));
     }
     if ($this->getArgument('cc')) {
       $faux_message[] = pht('CC: %s', $this->getArgument('cc'));
     }
 
     // NOTE: For now, this isn't a real field, so it just ends up as the first
     // part of the summary.
     $depends_ref = $this->getDependsOnRevisionRef();
     if ($depends_ref) {
       $faux_message[] = pht(
         'Depends on %s. ',
         $depends_ref->getMonogram());
     }
 
     // See T12069. After T10312, the first line of a message is always parsed
     // as a title. Add a placeholder so "Reviewers" and "CC" are never the
     // first line.
     $placeholder_title = pht('<placeholder>');
 
     if ($faux_message) {
       array_unshift($faux_message, $placeholder_title);
       $faux_message = implode("\n\n", $faux_message);
       $local = array(
         '(Flags)     ' => array(
           'message' => $faux_message,
           'summary' => pht('Command-Line Flags'),
         ),
       ) + $local;
     }
 
     // Build a human-readable list of the commits, so we can show the user which
     // commits are included in the diff.
     $included = array();
     foreach ($local as $hash => $info) {
       $included[] = substr($hash, 0, 12).' '.$info['summary'];
     }
 
     // Parse all of the messages into fields.
     $messages = array();
     foreach ($local as $hash => $info) {
       $text = $info['message'];
       $obj = ArcanistDifferentialCommitMessage::newFromRawCorpus($text);
       $messages[$hash] = $obj;
     }
 
     $notes = array();
     $fields = array();
     foreach ($messages as $hash => $message) {
       try {
         $message->pullDataFromConduit($conduit, $partial = true);
         $fields[$hash] = $message->getFields();
       } catch (ArcanistDifferentialCommitMessageParserException $ex) {
         if ($this->getArgument('verbatim')) {
           // In verbatim mode, just bail when we hit an error. The user can
           // rerun without --verbatim if they want to fix it manually. Most
           // users will probably `git commit --amend` instead.
           throw $ex;
         }
         $fields[$hash] = $message->getFields();
 
         $frev = substr($hash, 0, 12);
         $notes[] = pht(
           'NOTE: commit %s could not be completely parsed:',
           $frev);
         foreach ($ex->getParserErrors() as $error) {
           $notes[] = "  - {$error}";
         }
       }
     }
 
     // Merge commit message fields. We do this somewhat-intelligently so that
     // multiple "Reviewers" or "CC" fields will merge into the concatenation
     // of all values.
 
     // We have special parsing rules for 'title' because we can't merge
     // multiple titles, and one-line commit messages like "fix stuff" will
     // parse as titles. Instead, pick the first title we encounter. When we
     // encounter subsequent titles, treat them as part of the summary. Then
     // we merge all the summaries together below.
 
     $result = array();
 
     // Process fields in oldest-first order, so earlier commits get to set the
     // title of record and reviewers/ccs are listed in chronological order.
     $fields = array_reverse($fields);
 
     foreach ($fields as $hash => $dict) {
       $title = idx($dict, 'title');
       if (!strlen($title)) {
         continue;
       }
 
       if ($title === $placeholder_title) {
         continue;
       }
 
       if (!isset($result['title'])) {
         // We don't have a title yet, so use this one.
         $result['title'] = $title;
       } else {
         // We already have a title, so merge this new title into the summary.
         $summary = idx($dict, 'summary');
         if ($summary) {
           $summary = $title."\n\n".$summary;
         } else {
           $summary = $title;
         }
         $fields[$hash]['summary'] = $summary;
       }
     }
 
     // Now, merge all the other fields in a general sort of way.
 
     foreach ($fields as $hash => $dict) {
       foreach ($dict as $key => $value) {
         if ($key == 'title') {
           // This has been handled above, and either assigned directly or
           // merged into the summary.
           continue;
         }
 
         if (is_array($value)) {
           // For array values, merge the arrays, appending the new values.
           // Examples are "Reviewers" and "Cc", where this produces a list of
           // all users specified as reviewers.
           $cur = idx($result, $key, array());
           $new = array_merge($cur, $value);
           $result[$key] = $new;
           continue;
         } else {
           if (!strlen(trim($value))) {
             // Ignore empty fields.
             continue;
           }
 
           // For string values, append the new field to the old field with
           // a blank line separating them. Examples are "Test Plan" and
           // "Summary".
           $cur = idx($result, $key, '');
           if (strlen($cur)) {
             $new = $cur."\n\n".$value;
           } else {
             $new = $value;
           }
           $result[$key] = $new;
         }
       }
     }
 
     return array($result, $notes, $included);
   }
 
   private function getDefaultUpdateMessage() {
     if ($this->isRawDiffSource()) {
       return null;
     }
 
     $repository_api = $this->getRepositoryAPI();
     if ($repository_api instanceof ArcanistGitAPI) {
       return $this->getGitUpdateMessage();
     }
 
     if ($repository_api instanceof ArcanistMercurialAPI) {
       return $this->getMercurialUpdateMessage();
     }
 
     return null;
   }
 
   /**
    * Retrieve the git messages between HEAD and the last update.
    *
    * @task message
    */
   private function getGitUpdateMessage() {
     $repository_api = $this->getRepositoryAPI();
 
     $parser = $this->newDiffParser();
     $commit_messages = $repository_api->getGitCommitLog();
     $commit_messages = $parser->parseDiff($commit_messages);
 
     if (count($commit_messages) == 1) {
       // If there's only one message, assume this is an amend-based workflow and
       // that using it to prefill doesn't make sense.
       return null;
     }
 
     // We have more than one message, so figure out which ones are new. We
     // do this by pulling the current diff and comparing commit hashes in the
     // working copy with attached commit hashes. It's not super important that
     // we always get this 100% right, we're just trying to do something
     // reasonable.
 
     $hashes = $this->loadActiveDiffLocalCommitHashes();
     $hashes = array_fuse($hashes);
 
     $usable = array();
     foreach ($commit_messages as $message) {
       $text = $message->getMetadata('message');
 
       $parsed = ArcanistDifferentialCommitMessage::newFromRawCorpus($text);
       if ($parsed->getRevisionID()) {
         // If this is an amended commit message with a revision ID, it's
         // certainly not new. Stop marking commits as usable and break out.
         break;
       }
 
       if (isset($hashes[$message->getCommitHash()])) {
         // If this commit is currently part of the diff, stop using commit
         // messages, since anything older than this isn't new.
         break;
       }
 
       // Otherwise, this looks new, so it's a usable commit message.
       $usable[] = $text;
     }
 
     if (!$usable) {
       // No new commit messages, so we don't have anywhere to start from.
       return null;
     }
 
     return $this->formatUsableLogs($usable);
   }
 
   /**
    * Retrieve the hg messages between tip and the last update.
    *
    * @task message
    */
   private function getMercurialUpdateMessage() {
     $repository_api = $this->getRepositoryAPI();
 
     $messages = $repository_api->getCommitMessageLog();
 
     if (count($messages) == 1) {
       // If there's only one message, assume this is an amend-based workflow and
       // that using it to prefill doesn't make sense.
       return null;
     }
 
     $hashes = $this->loadActiveDiffLocalCommitHashes();
     $hashes = array_fuse($hashes);
 
     $usable = array();
     foreach ($messages as $rev => $message) {
       if (isset($hashes[$rev])) {
         // If this commit is currently part of the active diff on the revision,
         // stop using commit messages, since anything older than this isn't new.
         break;
       }
 
       // Otherwise, this looks new, so it's a usable commit message.
       $usable[] = $message;
     }
 
     if (!$usable) {
       // No new commit messages, so we don't have anywhere to start from.
       return null;
     }
 
     return $this->formatUsableLogs($usable);
   }
 
 
   /**
    * Format log messages to prefill a diff update.
    *
    * @task message
    */
   private function formatUsableLogs(array $usable) {
     // Flip messages so they'll read chronologically (oldest-first) in the
     // template, e.g.:
     //
     //   - Added foobar.
     //   - Fixed foobar bug.
     //   - Documented foobar.
 
     $usable = array_reverse($usable);
     $default = array();
     foreach ($usable as $message) {
       // Pick the first line out of each message.
       $text = trim($message);
       $text = head(explode("\n", $text));
       $default[] = '  - '.$text."\n";
     }
 
     return implode('', $default);
   }
 
   private function loadActiveDiffLocalCommitHashes() {
     // The older "differential.querydiffs" method includes the full diff text,
     // which can be very slow for large diffs. If we can, try to use
     // "differential.diff.search" instead.
 
     // We expect this to fail if the Phabricator version on the server is
     // older than April 2018 (D19386), which introduced the "commits"
     // attachment for "differential.revision.search".
 
     // TODO: This can be optimized if we're able to learn the "revisionPHID"
     // before we get here. See PHI1104.
 
     try {
       $revisions_raw = $this->getConduit()->callMethodSynchronous(
         'differential.revision.search',
         array(
           'constraints' => array(
             'ids' => array(
               $this->revisionID,
             ),
           ),
         ));
 
       $revisions = $revisions_raw['data'];
       $revision = head($revisions);
       if ($revision) {
         $revision_phid = $revision['phid'];
 
         $diffs_raw = $this->getConduit()->callMethodSynchronous(
           'differential.diff.search',
           array(
             'constraints' => array(
               'revisionPHIDs' => array(
                 $revision_phid,
               ),
             ),
             'attachments' => array(
               'commits' => true,
             ),
             'limit' => 1,
           ));
 
         $diffs = $diffs_raw['data'];
         $diff = head($diffs);
 
         if ($diff) {
           $commits = idxv($diff, array('attachments', 'commits', 'commits'));
           if ($commits !== null) {
             $hashes = ipull($commits, 'identifier');
             return array_values($hashes);
           }
         }
       }
     } catch (Exception $ex) {
       // If any of this fails, fall back to the older method below.
     }
 
     $current_diff = $this->getConduit()->callMethodSynchronous(
       'differential.querydiffs',
       array(
         'revisionIDs' => array($this->revisionID),
       ));
     $current_diff = head($current_diff);
 
     $properties = idx($current_diff, 'properties', array());
     $local = idx($properties, 'local:commits', array());
     $hashes = ipull($local, 'commit');
 
     return array_values($hashes);
   }
 
 
 /* -(  Diff Specification  )------------------------------------------------- */
 
 
   /**
    * @task diffspec
    */
   private function getLintStatus($lint_result) {
     $map = array(
       ArcanistLintWorkflow::RESULT_OKAY       => 'okay',
       ArcanistLintWorkflow::RESULT_ERRORS     => 'fail',
       ArcanistLintWorkflow::RESULT_WARNINGS   => 'warn',
       ArcanistLintWorkflow::RESULT_SKIP       => 'skip',
     );
     return idx($map, $lint_result, 'none');
   }
 
 
   /**
    * @task diffspec
    */
   private function getUnitStatus($unit_result) {
     $map = array(
       ArcanistUnitWorkflow::RESULT_OKAY       => 'okay',
       ArcanistUnitWorkflow::RESULT_FAIL       => 'fail',
       ArcanistUnitWorkflow::RESULT_UNSOUND    => 'warn',
       ArcanistUnitWorkflow::RESULT_SKIP       => 'skip',
     );
     return idx($map, $unit_result, 'none');
   }
 
 
   /**
    * @task diffspec
    */
   private function buildDiffSpecification() {
 
     $base_revision  = null;
     $base_path      = null;
     $vcs            = null;
     $repo_uuid      = null;
     $parent         = null;
     $source_path    = null;
     $branch         = null;
     $bookmark       = null;
 
     if (!$this->isRawDiffSource()) {
       $repository_api = $this->getRepositoryAPI();
 
       $base_revision  = $repository_api->getSourceControlBaseRevision();
       $base_path      = $repository_api->getSourceControlPath();
       $vcs            = $repository_api->getSourceControlSystemName();
       $source_path    = $repository_api->getPath();
       $branch         = $repository_api->getBranchName();
       $repo_uuid      = $repository_api->getRepositoryUUID();
 
       if ($repository_api instanceof ArcanistGitAPI) {
         $info = $this->getGitParentLogInfo();
         if ($info['parent']) {
           $parent = $info['parent'];
         }
         if ($info['base_revision']) {
           $base_revision = $info['base_revision'];
         }
         if ($info['base_path']) {
           $base_path = $info['base_path'];
         }
         if ($info['uuid']) {
           $repo_uuid = $info['uuid'];
         }
       } else if ($repository_api instanceof ArcanistMercurialAPI) {
 
         $bookmark = $repository_api->getActiveBookmark();
         $svn_info = $repository_api->getSubversionInfo();
         $repo_uuid = idx($svn_info, 'uuid');
         $base_path = idx($svn_info, 'base_path', $base_path);
         $base_revision = idx($svn_info, 'base_revision', $base_revision);
 
         // TODO: provide parent info
 
       }
     }
 
     $data = array(
       'sourceMachine'             => php_uname('n'),
       'sourcePath'                => $source_path,
       'branch'                    => $branch,
       'bookmark'                  => $bookmark,
       'sourceControlSystem'       => $vcs,
       'sourceControlPath'         => $base_path,
       'sourceControlBaseRevision' => $base_revision,
       'creationMethod'            => 'arc',
     );
 
     if (!$this->isRawDiffSource()) {
       $repository_phid = $this->getRepositoryPHID();
       if ($repository_phid) {
         $data['repositoryPHID'] = $repository_phid;
       }
     }
 
     return $data;
   }
 
 
 /* -(  Diff Properties  )---------------------------------------------------- */
 
 
   /**
    * Update lint information for the diff.
    *
    * @return void
    *
    * @task diffprop
    */
   private function updateLintDiffProperty() {
     if (!$this->hitAutotargets) {
       if ($this->unresolvedLint) {
         $this->updateDiffProperty(
           'arc:lint',
           json_encode($this->unresolvedLint));
       }
     }
   }
 
 
   /**
    * Update unit test information for the diff.
    *
    * @return void
    *
    * @task diffprop
    */
   private function updateUnitDiffProperty() {
     if (!$this->hitAutotargets) {
       if ($this->testResults) {
         $this->updateDiffProperty('arc:unit', json_encode($this->testResults));
       }
     }
   }
 
 
   /**
    * Update local commit information for the diff.
    *
    * @task diffprop
    */
   private function updateLocalDiffProperty() {
     if ($this->isRawDiffSource()) {
       return;
     }
 
     $local_info = $this->getRepositoryAPI()->getLocalCommitInformation();
     if (!$local_info) {
       return;
     }
 
     $this->updateDiffProperty('local:commits', json_encode($local_info));
   }
 
   private function updateOntoDiffProperty() {
     $onto = $this->getDiffOntoTargets();
 
     if (!$onto) {
       return;
     }
 
     $this->updateDiffProperty('arc:onto', json_encode($onto));
   }
 
   private function getDiffOntoTargets() {
     if ($this->isRawDiffSource()) {
       return null;
     }
 
     $api = $this->getRepositoryAPI();
 
     if (!($api instanceof ArcanistGitAPI)) {
       return null;
     }
 
     // If we track an upstream branch either directly or indirectly, use that.
     $branch = $api->getBranchName();
     if (strlen($branch)) {
       $upstream_path = $api->getPathToUpstream($branch);
       $remote_branch = $upstream_path->getRemoteBranchName();
       if ($remote_branch !== null) {
         return array(
           array(
             'type' => 'branch',
             'name' => $remote_branch,
             'kind' => 'upstream',
           ),
         );
       }
     }
 
     // If "arc.land.onto.default" is configured, use that.
     $config_key = 'arc.land.onto.default';
     $onto = $this->getConfigFromAnySource($config_key);
     if ($onto !== null) {
       return array(
         array(
           'type' => 'branch',
           'name' => $onto,
           'kind' => 'arc.land.onto.default',
         ),
       );
     }
 
     return null;
   }
 
   /**
    * Update an arbitrary diff property.
    *
    * @param string Diff property name.
    * @param string Diff property value.
    * @return void
    *
    * @task diffprop
    */
   private function updateDiffProperty($name, $data) {
     $this->diffPropertyFutures[] = $this->getConduit()->callMethod(
       'differential.setdiffproperty',
       array(
         'diff_id' => $this->getDiffID(),
         'name'    => $name,
         'data'    => $data,
       ));
   }
 
   /**
    * Wait for finishing all diff property updates.
    *
    * @return void
    *
    * @task diffprop
    */
   private function resolveDiffPropertyUpdates() {
     id(new FutureIterator($this->diffPropertyFutures))
       ->resolveAll();
     $this->diffPropertyFutures = array();
   }
 
   private function dispatchWillCreateRevisionEvent(array $fields) {
     $event = $this->dispatchEvent(
       ArcanistEventType::TYPE_REVISION_WILLCREATEREVISION,
       array(
         'specification' => $fields,
       ));
 
     return $event->getValue('specification');
   }
 
   private function dispatchWillBuildEvent(array $fields) {
     $event = $this->dispatchEvent(
       ArcanistEventType::TYPE_DIFF_WILLBUILDMESSAGE,
       array(
         'fields' => $fields,
       ));
 
     return $event->getValue('fields');
   }
 
   private function checkRevisionOwnership(array $revision) {
     if ($revision['authorPHID'] == $this->getUserPHID()) {
       return;
     }
 
     $id = $revision['id'];
     $title = $revision['title'];
 
     $prompt = pht(
       "You don't own revision %s: \"%s\". Normally, you should ".
       "only update revisions you own. You can \"Commandeer\" this revision ".
       "from the web interface if you want to become the owner.\n\n".
       "Update this revision anyway?",
       "D{$id}",
       $title);
 
     $ok = phutil_console_confirm($prompt, $default_no = true);
     if (!$ok) {
       throw new ArcanistUsageException(
         pht('Aborted update of revision: You are not the owner.'));
     }
   }
 
 
 /* -(  File Uploads  )------------------------------------------------------- */
 
 
   private function uploadFilesForChanges(array $changes) {
     assert_instances_of($changes, 'ArcanistDiffChange');
 
     // Collect all the files we need to upload.
 
     $need_upload = array();
     foreach ($changes as $key => $change) {
       if ($change->getFileType() != ArcanistDiffChangeType::FILE_BINARY) {
         continue;
       }
 
       if ($this->getArgument('skip-binaries')) {
         continue;
       }
 
       $name = basename($change->getCurrentPath());
 
       $need_upload[] = array(
         'type' => 'old',
         'name' => $name,
         'data' => $change->getOriginalFileData(),
         'change' => $change,
       );
 
       $need_upload[] = array(
         'type' => 'new',
         'name' => $name,
         'data' => $change->getCurrentFileData(),
         'change' => $change,
       );
     }
 
     if (!$need_upload) {
       return;
     }
 
     // Determine mime types and file sizes. Update changes from "binary" to
     // "image" if the file is an image. Set image metadata.
 
     $type_image = ArcanistDiffChangeType::FILE_IMAGE;
     foreach ($need_upload as $key => $spec) {
       $change = $need_upload[$key]['change'];
 
       if ($spec['data'] === null) {
         // This covers the case where a file was added or removed; we don't
         // need to upload the other half of it (e.g., the old file data for
         // a file which was just added). This is distinct from an empty
         // file, which we do upload.
         unset($need_upload[$key]);
         continue;
       }
 
       $type = $spec['type'];
       $size = strlen($spec['data']);
 
       $change->setMetadata("{$type}:file:size", $size);
 
       $mime = $this->getFileMimeType($spec['data']);
       if (preg_match('@^image/@', $mime)) {
         $change->setFileType($type_image);
       }
 
       $change->setMetadata("{$type}:file:mime-type", $mime);
     }
 
     $uploader = id(new ArcanistFileUploader())
       ->setConduitEngine($this->getConduitEngine());
 
     foreach ($need_upload as $key => $spec) {
       $ref = id(new ArcanistFileDataRef())
         ->setName($spec['name'])
         ->setData($spec['data']);
 
       $uploader->addFile($ref, $key);
     }
 
     $files = $uploader->uploadFiles();
 
     $errors = false;
     foreach ($files as $key => $file) {
       if ($file->getErrors()) {
         unset($files[$key]);
         $errors = true;
         echo pht(
           'Failed to upload binary "%s".',
           $file->getName());
       }
     }
 
     if ($errors) {
       $prompt = pht('Continue?');
       $ok = phutil_console_confirm($prompt, $default_no = false);
       if (!$ok) {
         throw new ArcanistUsageException(
           pht(
             'Aborted due to file upload failure. You can use %s '.
             'to skip binary uploads.',
             '--skip-binaries'));
       }
     }
 
     foreach ($files as $key => $file) {
       $spec = $need_upload[$key];
       $phid = $file->getPHID();
 
       $change = $spec['change'];
       $type = $spec['type'];
       $change->setMetadata("{$type}:binary-phid", $phid);
 
       echo pht('Uploaded binary data for "%s".', $file->getName())."\n";
     }
 
     echo pht('Upload complete.')."\n";
   }
 
   private function getFileMimeType($data) {
     $tmp = new TempFile();
     Filesystem::writeFile($tmp, $data);
     return Filesystem::getMimeType($tmp);
   }
 
   private function shouldOpenCreatedObjectsInBrowser() {
     return $this->getArgument('browse');
   }
 
   private function submitChangesToStagingArea($id) {
     $result = $this->pushChangesToStagingArea($id);
 
     // We'll either get a failure constant on error, or a list of pushed
     // refs on success.
     $ok = is_array($result);
 
     if ($ok) {
       $staging = array(
         'status' => self::STAGING_PUSHED,
         'refs' => $result,
       );
     } else {
       $staging = array(
         'status' => $result,
         'refs' => array(),
       );
     }
 
     $this->updateDiffProperty(
       'arc.staging',
       phutil_json_encode($staging));
   }
 
   private function pushChangesToStagingArea($id) {
     if ($this->getArgument('skip-staging')) {
       $this->writeInfo(
         pht('SKIP STAGING'),
         pht('Flag --skip-staging was specified.'));
       return self::STAGING_USER_SKIP;
     }
 
     if ($this->isRawDiffSource()) {
       $this->writeInfo(
         pht('SKIP STAGING'),
         pht('Raw changes can not be pushed to a staging area.'));
       return self::STAGING_DIFF_RAW;
     }
 
     if (!$this->getRepositoryPHID()) {
       $this->writeInfo(
         pht('SKIP STAGING'),
         pht('Unable to determine repository for this change.'));
       return self::STAGING_REPOSITORY_UNKNOWN;
     }
 
     $staging = $this->getRepositoryStagingConfiguration();
     if ($staging === null) {
       $this->writeInfo(
         pht('SKIP STAGING'),
         pht('The server does not support staging areas.'));
       return self::STAGING_REPOSITORY_UNAVAILABLE;
     }
 
     $supported = idx($staging, 'supported');
     if (!$supported) {
       $this->writeInfo(
         pht('SKIP STAGING'),
-        pht('Phabricator does not support staging areas for this repository.'));
+        pht('The server does not support staging areas for this repository.'));
       return self::STAGING_REPOSITORY_UNSUPPORTED;
     }
 
     $staging_uri = idx($staging, 'uri');
     if (!$staging_uri) {
       $this->writeInfo(
         pht('SKIP STAGING'),
         pht('No staging area is configured for this repository.'));
       return self::STAGING_REPOSITORY_UNCONFIGURED;
     }
 
     $api = $this->getRepositoryAPI();
     if (!($api instanceof ArcanistGitAPI)) {
       $this->writeInfo(
         pht('SKIP STAGING'),
         pht('This client version does not support staging this repository.'));
       return self::STAGING_CLIENT_UNSUPPORTED;
     }
 
     $commit = $api->getHeadCommit();
     $prefix = idx($staging, 'prefix', 'phabricator');
 
     $base_tag = "refs/tags/{$prefix}/base/{$id}";
     $diff_tag = "refs/tags/{$prefix}/diff/{$id}";
 
     $this->writeOkay(
       pht('PUSH STAGING'),
       pht('Pushing changes to staging area...'));
 
     $push_flags = array();
     if (version_compare($api->getGitVersion(), '1.8.2', '>=')) {
       $push_flags[] = '--no-verify';
     }
 
     $refs = array();
 
     $remote = array(
       'uri' => $staging_uri,
     );
 
     $is_lfs = $api->isGitLFSWorkingCopy();
 
     // If the base commit is a real commit, we're going to push it. We don't
     // use this, but pushing it to a ref reduces the amount of redundant work
     // that Git does on later pushes by helping it figure out that the remote
     // already has most of the history. See T10509.
 
     // In the future, we could avoid this push if the staging area is the same
     // as the main repository, or if the staging area is a virtual repository.
     // In these cases, the staging area should automatically have up-to-date
     // refs.
     $base_commit = $api->getSourceControlBaseRevision();
     if ($base_commit !== ArcanistGitAPI::GIT_MAGIC_ROOT_COMMIT) {
       $refs[] = array(
         'ref' => $base_tag,
         'type' => 'base',
         'commit' => $base_commit,
         'remote' => $remote,
       );
     }
 
     // We're always going to push the change itself.
     $refs[] = array(
       'ref' => $diff_tag,
       'type' => 'diff',
       'commit' => $is_lfs ? $base_commit : $commit,
       'remote' => $remote,
     );
 
     $ref_list = array();
     foreach ($refs as $ref) {
       $ref_list[] = $ref['commit'].':'.$ref['ref'];
     }
 
     $err = phutil_passthru(
       'git push %Ls -- %s %Ls',
       $push_flags,
       $staging_uri,
       $ref_list);
 
     if ($err) {
       $this->writeWarn(
         pht('STAGING FAILED'),
         pht('Unable to push changes to the staging area.'));
 
       throw new ArcanistUsageException(
         pht(
           'Failed to push changes to staging area. Correct the issue, or '.
           'use --skip-staging to skip this step.'));
     }
 
     if ($is_lfs) {
       $ref = '+'.$commit.':'.$diff_tag;
       $err = phutil_passthru(
         'git push -- %s %s',
         $staging_uri,
         $ref);
 
       if ($err) {
         $this->writeWarn(
           pht('STAGING FAILED'),
           pht('Unable to push lfs changes to the staging area.'));
 
         throw new ArcanistUsageException(
           pht(
             'Failed to push lfs changes to staging area. Correct the issue, '.
             'or use --skip-staging to skip this step.'));
       }
     }
 
     return $refs;
   }
 
 
   /**
    * Try to upload lint and unit test results into modern Harbormaster build
    * targets.
    *
    * @return bool True if everything was uploaded to build targets.
    */
   private function updateAutotargets($diff_phid, $unit_result) {
     $lint_key = 'arcanist.lint';
     $unit_key = 'arcanist.unit';
 
     try {
       $result = $this->getConduit()->callMethodSynchronous(
         'harbormaster.queryautotargets',
         array(
           'objectPHID' => $diff_phid,
           'targetKeys' => array(
             $lint_key,
             $unit_key,
           ),
         ));
       $targets = idx($result, 'targetMap', array());
     } catch (Exception $ex) {
       return false;
     }
 
     $futures = array();
 
     $lint_target = idx($targets, $lint_key);
     if ($lint_target) {
       $lint = nonempty($this->unresolvedLint, array());
       foreach ($lint as $key => $message) {
         $lint[$key] = $this->getModernLintDictionary($message);
       }
 
       // Consider this target to have failed if there are any unresolved
       // errors or warnings.
       $type = 'pass';
       foreach ($lint as $message) {
         switch (idx($message, 'severity')) {
           case ArcanistLintSeverity::SEVERITY_WARNING:
           case ArcanistLintSeverity::SEVERITY_ERROR:
             $type = 'fail';
             break;
         }
       }
 
       $futures[] = $this->getConduit()->callMethod(
         'harbormaster.sendmessage',
         array(
           'buildTargetPHID' => $lint_target,
           'lint' => array_values($lint),
           'type' => $type,
         ));
     }
 
     $unit_target = idx($targets, $unit_key);
     if ($unit_target) {
       $unit = nonempty($this->testResults, array());
       foreach ($unit as $key => $message) {
         $unit[$key] = $this->getModernUnitDictionary($message);
       }
 
       $type = ArcanistUnitWorkflow::getHarbormasterTypeFromResult($unit_result);
 
       $futures[] = $this->getConduit()->callMethod(
         'harbormaster.sendmessage',
         array(
           'buildTargetPHID' => $unit_target,
           'unit' => array_values($unit),
           'type' => $type,
         ));
     }
 
     try {
       foreach (new FutureIterator($futures) as $future) {
         $future->resolve();
       }
       return true;
     } catch (Exception $ex) {
       // TODO: Eventually, we should expect these to succeed if we get this
       // far, but just log errors for now.
       phlog($ex);
       return false;
     }
   }
 
   private function getDependsOnRevisionRef() {
     // TODO: Restore this behavior after updating for toolsets. Loading the
     // required hardpoints currently depends on a "WorkingCopy" existing.
     return null;
 
     $api = $this->getRepositoryAPI();
     $base_ref = $api->getBaseCommitRef();
 
     $state_ref = id(new ArcanistWorkingCopyStateRef())
       ->setCommitRef($base_ref);
 
     $this->loadHardpoints(
       $state_ref,
       ArcanistWorkingCopyStateRef::HARDPOINT_REVISIONREFS);
 
     $revision_refs = $state_ref->getRevisionRefs();
     $viewer_phid = $this->getUserPHID();
 
     foreach ($revision_refs as $key => $revision_ref) {
       // Don't automatically depend on closed revisions.
       if ($revision_ref->isClosed()) {
         unset($revision_refs[$key]);
         continue;
       }
 
       // Don't automatically depend on revisions authored by other users.
       if ($revision_ref->getAuthorPHID() != $viewer_phid) {
         unset($revision_refs[$key]);
         continue;
       }
     }
 
     if (!$revision_refs) {
       return null;
     }
 
     if (count($revision_refs) > 1) {
       return null;
     }
 
     return head($revision_refs);
   }
 
 }
diff --git a/src/workflow/ArcanistInstallCertificateWorkflow.php b/src/workflow/ArcanistInstallCertificateWorkflow.php
index a352b21d..49bb5045 100644
--- a/src/workflow/ArcanistInstallCertificateWorkflow.php
+++ b/src/workflow/ArcanistInstallCertificateWorkflow.php
@@ -1,239 +1,238 @@
 <?php
 
 /**
  * Installs arcanist certificates.
  */
 final class ArcanistInstallCertificateWorkflow extends ArcanistWorkflow {
 
   public function getWorkflowName() {
     return 'install-certificate';
   }
 
   public function getCommandSynopses() {
     return phutil_console_format(<<<EOTEXT
       **install-certificate** [uri]
 EOTEXT
       );
   }
 
   public function getCommandHelp() {
     return phutil_console_format(<<<EOTEXT
           Supports: http, https
-          Installs Conduit credentials into your ~/.arcrc for the given install
-          of Phabricator. You need to do this before you can use 'arc', as it
-          enables 'arc' to link your command-line activity with your account on
-          the web. Run this command from within a project directory to install
-          that project's certificate, or specify an explicit URI (like
-          "https://phabricator.example.com/").
+          Installs Conduit credentials into your ~/.arcrc for the given server.
+          You need to do this before you can use 'arc', as it enables 'arc' to
+          link your command-line activity with your account on the web. Run
+          this command from within a project directory to install that
+          project's certificate, or specify an explicit URI (like
+          "https://devtools.example.com/").
 EOTEXT
       );
   }
 
   public function getArguments() {
     return array(
       '*' => 'uri',
     );
   }
 
   protected function shouldShellComplete() {
     return false;
   }
 
   public function requiresConduit() {
     return false;
   }
 
   public function requiresWorkingCopy() {
     return false;
   }
 
   public function run() {
     $console = PhutilConsole::getConsole();
 
     $uri = $this->determineConduitURI();
     $this->setConduitURI($uri);
     $configuration_manager = $this->getConfigurationManager();
 
     $config = $configuration_manager->readUserConfigurationFile();
 
     $this->writeInfo(
       pht('CONNECT'),
       pht(
         'Connecting to "%s"...',
         $uri));
 
     $conduit = $this->establishConduit()->getConduit();
     try {
       $conduit->callMethodSynchronous('conduit.ping', array());
     } catch (Exception $ex) {
       throw new ArcanistUsageException(
         pht(
           'Failed to connect to server (%s): %s',
           $uri,
           $ex->getMessage()));
     }
 
     $token_uri = new PhutilURI($uri);
     $token_uri->setPath('/conduit/token/');
 
     // Check if this server supports the more modern token-based login.
     $is_token_auth = false;
     try {
       $capabilities = $conduit->callMethodSynchronous(
         'conduit.getcapabilities',
         array());
       $auth = idx($capabilities, 'authentication', array());
       if (in_array('token', $auth)) {
         $token_uri->setPath('/conduit/login/');
         $is_token_auth = true;
       }
     } catch (Exception $ex) {
       // Ignore.
     }
 
-    echo phutil_console_format("**%s**\n", pht('LOGIN TO PHABRICATOR'));
+    echo phutil_console_format("**%s**\n", pht('LOG IN'));
     echo phutil_console_format(
       "%s\n\n%s\n\n%s",
       pht(
-        'Open this page in your browser and login to '.
-        'Phabricator if necessary:'),
+        'Open this page in your browser and log in if necessary:'),
       $token_uri,
       pht('Then paste the API Token on that page below.'));
 
     do {
       $token = phutil_console_prompt(pht('Paste API Token from that page:'));
       $token = trim($token);
       if (strlen($token)) {
         break;
       }
     } while (true);
 
     if ($is_token_auth) {
       if (strlen($token) != 32) {
         throw new ArcanistUsageException(
           pht(
             'The token "%s" is not formatted correctly. API tokens should '.
             'be 32 characters long. Make sure you visited the correct URI '.
             'and copy/pasted the token correctly.',
             $token));
       }
 
       if (strncmp($token, 'api-', 4) == 0) {
         echo pht(
           'You are installing a standard API token, but a CLI API token '.
           'was expected. If you\'re writing a script, consider passing the '.
           'token at runtime with --conduit-token instead of installing it.');
         if (!phutil_console_confirm(pht('Install this token anyway?'))) {
           throw new ArcanistUsageException(pht('Not installing API token.'));
         }
       } else if (strncmp($token, 'cli-', 4) !== 0) {
         throw new ArcanistUsageException(
           pht(
             'The token "%s" is not formatted correctly. Valid API tokens '.
             'should begin "cli-" and be 32 characters long. Make sure you '.
             'visited the correct URI and copy/pasted the token correctly.',
             $token));
       }
 
       $conduit->setConduitToken($token);
       try {
         $conduit->callMethodSynchronous('user.whoami', array());
       } catch (Exception $ex) {
         throw new ArcanistUsageException(
           pht(
             'The token "%s" is not a valid API Token. The server returned '.
             'this response when trying to use it as a token: %s',
             $token,
             $ex->getMessage()));
       }
 
       $config['hosts'][$uri] = array(
         'token' => $token,
       );
     } else {
       echo "\n";
       echo pht('Downloading authentication certificate...')."\n";
       $info = $conduit->callMethodSynchronous(
         'conduit.getcertificate',
         array(
           'token' => $token,
           'host'  => $uri,
         ));
 
       $user = $info['username'];
       echo pht("Installing certificate for '%s'...", $user)."\n";
       $config['hosts'][$uri] = array(
         'user' => $user,
         'cert' => $info['certificate'],
       );
     }
 
     echo pht('Writing %s...', '~/.arcrc')."\n";
     $configuration_manager->writeUserConfigurationFile($config);
 
     if ($is_token_auth) {
       echo phutil_console_format(
         "<bg:green>** %s **</bg> %s\n",
         pht('SUCCESS!'),
         pht('API Token installed.'));
     } else {
       echo phutil_console_format(
         "<bg:green>** %s **</bg> %s\n",
         pht('SUCCESS!'),
         pht('Certificate installed.'));
     }
 
     return 0;
   }
 
   private function determineConduitURI() {
     $uri = $this->getArgument('uri');
     if (count($uri) > 1) {
       throw new ArcanistUsageException(pht('Specify at most one URI.'));
     } else if (count($uri) == 1) {
       $uri = reset($uri);
     } else {
       $conduit_uri = $this->getConduitURI();
       if (!$conduit_uri) {
         throw new ArcanistUsageException(
           pht(
             'Specify an explicit URI or run this command from within a '.
             'project which is configured with a %s.',
             '.arcconfig'));
       }
       $uri = $conduit_uri;
     }
 
-    $example = 'https://phabricator.example.com/';
+    $example = 'https://devtools.example.com/';
 
     $uri_object = new PhutilURI($uri);
     $protocol = $uri_object->getProtocol();
     if (!$protocol || !$uri_object->getDomain()) {
       throw new ArcanistUsageException(
         pht(
           'Server URI "%s" must include a protocol and domain. It should be '.
           'in the form "%s".',
           $uri,
           $example));
     }
 
     $protocol = $uri_object->getProtocol();
     switch ($protocol) {
       case 'http':
       case 'https':
         break;
       default:
         throw new ArcanistUsageException(
           pht(
             'Server URI "%s" must include the "http" or "https" protocol. '.
             'It should be in the form "%s".',
             $uri,
             $example));
     }
 
     $uri_object->setPath('/api/');
 
     return (string)$uri_object;
   }
 
 }
diff --git a/src/workflow/ArcanistLiberateWorkflow.php b/src/workflow/ArcanistLiberateWorkflow.php
index 9d6b476d..f4ed4fd2 100644
--- a/src/workflow/ArcanistLiberateWorkflow.php
+++ b/src/workflow/ArcanistLiberateWorkflow.php
@@ -1,243 +1,243 @@
 <?php
 
 final class ArcanistLiberateWorkflow
   extends ArcanistArcWorkflow {
 
   public function getWorkflowName() {
     return 'liberate';
   }
 
   public function getWorkflowInformation() {
     // TOOLSETS: Expand this help.
 
     $help = pht(<<<EOTEXT
-Create or update an Arcanist library.
+Create or update a library.
 EOTEXT
 );
 
     return $this->newWorkflowInformation()
       ->setSynopsis(
-        pht('Create or update an Arcanist library.'))
+        pht('Create or update a library.'))
       ->addExample(pht('**liberate**'))
       ->addExample(pht('**liberate** [__path__]'))
       ->setHelp($help);
   }
 
   public function getWorkflowArguments() {
     return array(
       $this->newWorkflowArgument('clean')
         ->setHelp(
           pht('Perform a clean rebuild, ignoring caches. Thorough, but slow.')),
       $this->newWorkflowArgument('argv')
         ->setWildcard(true)
         ->setIsPathArgument(true),
     );
   }
 
   protected function newPrompts() {
     return array(
       $this->newPrompt('arc.liberate.create')
         ->setDescription(
           pht(
             'Confirms creation of a new library.')),
     );
   }
 
 
   public function runWorkflow() {
     $log = $this->getLogEngine();
 
     $argv = $this->getArgument('argv');
     if (count($argv) > 1) {
       throw new ArcanistUsageException(
         pht(
           'Provide only one path to "arc liberate". The path should identify '.
           'a directory where you want to create or update a library.'));
     } else if (!$argv) {
       $log->writeStatus(
         pht('SCAN'),
         pht('Searching for libraries in the current working directory...'));
 
       $init_files = id(new FileFinder(getcwd()))
         ->withPath('*/__phutil_library_init__.php')
         ->find();
 
       if (!$init_files) {
         throw new ArcanistUsageException(
           pht(
             'Unable to find any libraries under the current working '.
             'directory. To create a library, provide a path.'));
       }
 
       $paths = array();
       foreach ($init_files as $init) {
         $paths[] = Filesystem::resolvePath(dirname($init));
       }
     } else {
       $paths = array(
         Filesystem::resolvePath(head($argv)),
       );
     }
 
     $any_errors = false;
     foreach ($paths as $path) {
       $log->writeStatus(
         pht('WORK'),
         pht(
           'Updating library: %s',
           Filesystem::readablePath($path).DIRECTORY_SEPARATOR));
       $exit_code = $this->liberatePath($path);
       if ($exit_code !== 0) {
         $any_errors = true;
         $log->writeError(
           pht('ERROR'),
           pht('Failed to update library: %s', $path));
       }
     }
 
     if (!$any_errors) {
       $log->writeSuccess(
         pht('DONE'),
         pht('Updated %s librarie(s).', phutil_count($paths)));
     }
 
     return 0;
   }
 
   /**
    * @return  int The exit code of running the rebuild-map.php script, which
    *              will be 0 to indicate success or non-zero for failure.
    */
   private function liberatePath($path) {
     if (!Filesystem::pathExists($path.'/__phutil_library_init__.php')) {
       echo tsprintf(
         "%s\n",
         pht(
           'No library currently exists at the path "%s"...',
           $path));
       $this->liberateCreateDirectory($path);
       return $this->liberateCreateLibrary($path);
     }
 
     $version = $this->getLibraryFormatVersion($path);
     switch ($version) {
       case 1:
         throw new ArcanistUsageException(
           pht(
             'This very old library is no longer supported.'));
       case 2:
         return $this->liberateVersion2($path);
       default:
         throw new ArcanistUsageException(
           pht("Unknown library version '%s'!", $version));
     }
   }
 
   private function getLibraryFormatVersion($path) {
     $map_file = $path.'/__phutil_library_map__.php';
     if (!Filesystem::pathExists($map_file)) {
       // Default to library v1.
       return 1;
     }
 
     $map = Filesystem::readFile($map_file);
 
     $matches = null;
     if (preg_match('/@phutil-library-version (\d+)/', $map, $matches)) {
       return (int)$matches[1];
     }
 
     return 1;
   }
 
   /**
    * @return  int The exit code of running the rebuild-map.php script, which
    *              will be 0 to indicate success or non-zero for failure.
    */
   private function liberateVersion2($path) {
     $bin = $this->getScriptPath('support/lib/rebuild-map.php');
 
     $argv = array();
     if ($this->getArgument('clean')) {
       $argv[] = '--drop-cache';
     }
 
     return phutil_passthru(
       'php -f %R -- %Ls %R',
       $bin,
       $argv,
       $path);
   }
 
   private function liberateCreateDirectory($path) {
     if (Filesystem::pathExists($path)) {
       if (!is_dir($path)) {
         throw new ArcanistUsageException(
           pht(
             'Provide a directory to create or update a libphutil library in.'));
       }
       return;
     }
 
     echo tsprintf(
       "%!\n%W\n",
       pht('NEW LIBRARY'),
       pht(
         'The directory "%s" does not exist. Do you want to create it?',
         $path));
 
     $query = pht('Create new library?');
 
     $this->getPrompt('arc.liberate.create')
       ->setQuery($query)
       ->execute();
 
     execx('mkdir -p %R', $path);
   }
 
   /**
    * @return  int The exit code of running the rebuild-map.php script, which
    *              will be 0 to indicate success or non-zero for failure.
    */
   private function liberateCreateLibrary($path) {
     $init_path = $path.'/__phutil_library_init__.php';
     if (Filesystem::pathExists($init_path)) {
       return 0;
     }
 
     echo pht("Creating new libphutil library in '%s'.", $path)."\n";
 
     do {
       echo pht('Choose a name for the new library.')."\n";
       $name = phutil_console_prompt(
         pht('What do you want to name this library?'));
 
       if (preg_match('/^[a-z-]+$/', $name)) {
         break;
       } else {
         echo phutil_console_format(
           "%s\n",
           pht(
           'Library name should contain only lowercase letters and hyphens.'));
       }
     } while (true);
 
     $template =
       "<?php\n\n".
       "phutil_register_library('{$name}', __FILE__);\n";
 
     echo pht(
       "Writing '%s' to '%s'...\n",
       '__phutil_library_init__.php',
       $path);
     Filesystem::writeFile($init_path, $template);
     return $this->liberateVersion2($path);
   }
 
 
   private function getScriptPath($script) {
     $root = dirname(phutil_get_library_root('arcanist'));
     return $root.'/'.$script;
   }
 
 }
diff --git a/src/workflow/ArcanistUpgradeWorkflow.php b/src/workflow/ArcanistUpgradeWorkflow.php
index 7759c10a..2013a201 100644
--- a/src/workflow/ArcanistUpgradeWorkflow.php
+++ b/src/workflow/ArcanistUpgradeWorkflow.php
@@ -1,133 +1,133 @@
 <?php
 
 final class ArcanistUpgradeWorkflow
   extends ArcanistArcWorkflow {
 
   public function getWorkflowName() {
     return 'upgrade';
   }
 
   public function getWorkflowInformation() {
     $help = pht(<<<EOTEXT
-Upgrade Arcanist to the latest version.
+Upgrade this program to the latest version.
 EOTEXT
 );
 
     return $this->newWorkflowInformation()
-      ->setSynopsis(pht('Upgrade Arcanist to the latest version.'))
+      ->setSynopsis(pht('Upgrade this program to the latest version.'))
       ->addExample(pht('**upgrade**'))
       ->setHelp($help);
   }
 
   public function getWorkflowArguments() {
     return array();
   }
 
   public function runWorkflow() {
     $log = $this->getLogEngine();
 
     $roots = array(
       'arcanist' => dirname(phutil_get_library_root('arcanist')),
     );
 
     $supported_branches = array(
       'master',
       'stable',
     );
     $supported_branches = array_fuse($supported_branches);
 
     foreach ($roots as $library => $root) {
       $log->writeStatus(
         pht('PREPARING'),
         pht(
           'Preparing to upgrade "%s"...',
           $library));
 
       $working_copy = ArcanistWorkingCopy::newFromWorkingDirectory($root);
 
       $repository_api = $working_copy->getRepositoryAPI();
       $is_git = ($repository_api instanceof ArcanistGitAPI);
 
       if (!$is_git) {
         throw new PhutilArgumentUsageException(
           pht(
-            'The "arc upgrade" workflow uses "git pull" to upgrade '.
-            'Arcanist, but the "arcanist/" directory  (in "%s") is not a Git '.
-            'working copy. You must leave "arcanist/" as a Git '.
-            'working copy to use "arc upgrade".',
+            'The "arc upgrade" workflow uses "git pull" to upgrade, but '.
+            'the "arcanist/" directory  (in "%s") is not a Git working '.
+            'copy. You must leave "arcanist/" as a Git working copy to '.
+            'use "arc upgrade".',
             $root));
       }
 
       // NOTE: Don't use requireCleanWorkingCopy() here because it tries to
       // amend changes and generally move the workflow forward. We just want to
       // abort if there are local changes and make the user sort things out.
       $uncommitted = $repository_api->getUncommittedStatus();
       if ($uncommitted) {
         $message = pht(
           'You have uncommitted changes in the working copy ("%s") for this '.
           'library ("%s"):',
           $root,
           $library);
 
         $list = id(new PhutilConsoleList())
           ->setWrap(false)
           ->addItems(array_keys($uncommitted));
 
         id(new PhutilConsoleBlock())
           ->addParagraph($message)
           ->addList($list)
           ->addParagraph(
             pht(
               'Discard these changes before running "arc upgrade".'))
           ->draw();
 
         throw new PhutilArgumentUsageException(
           pht('"arc upgrade" can only upgrade clean working copies.'));
       }
 
       $branch_name = $repository_api->getBranchName();
       if (!isset($supported_branches[$branch_name])) {
         throw new PhutilArgumentUsageException(
           pht(
             'Library "%s" (in "%s") is on branch "%s", but this branch is '.
             'not supported for automatic upgrades. Supported branches are: '.
             '%s.',
             $library,
             $root,
             $branch_name,
             implode(', ', array_keys($supported_branches))));
       }
 
       $log->writeStatus(
         pht('UPGRADING'),
         pht(
           'Upgrading "%s" (on branch "%s").',
           $library,
           $branch_name));
 
       $command = csprintf(
         'git pull --rebase origin -- %R',
         $branch_name);
 
       $future = (new PhutilExecPassthru($command))
         ->setCWD($root);
 
       try {
         $this->newCommand($future)
           ->execute();
       } catch (Exception $ex) {
         // If we failed, try to go back to the old state, then throw the
         // original exception.
         exec_manual('git rebase --abort');
         throw $ex;
       }
     }
 
     $log->writeSuccess(
       pht('UPGRADED'),
-      pht('Your copy of Arcanist is now up to date.'));
+      pht('This software is now up to date.'));
 
     return 0;
   }
 
 }
diff --git a/src/workflow/ArcanistUploadWorkflow.php b/src/workflow/ArcanistUploadWorkflow.php
index d888c464..fe2ff1bc 100644
--- a/src/workflow/ArcanistUploadWorkflow.php
+++ b/src/workflow/ArcanistUploadWorkflow.php
@@ -1,144 +1,144 @@
 <?php
 
 final class ArcanistUploadWorkflow
   extends ArcanistArcWorkflow {
 
   public function getWorkflowName() {
     return 'upload';
   }
 
   public function getWorkflowInformation() {
     $help = pht(<<<EOTEXT
-Upload one or more files from local disk to Phabricator.
+Upload one or more files from local disk.
 EOTEXT
 );
 
     return $this->newWorkflowInformation()
       ->setSynopsis(pht('Upload files.'))
       ->addExample(pht('**upload** [__options__] -- __file__ [__file__ ...]'))
       ->setHelp($help);
   }
 
   public function getWorkflowArguments() {
     return array(
       $this->newWorkflowArgument('json')
         ->setHelp(pht('Output upload information in JSON format.')),
       $this->newWorkflowArgument('browse')
         ->setHelp(
           pht(
             'After the upload completes, open the files in a web browser.')),
       $this->newWorkflowArgument('temporary')
         ->setHelp(
           pht(
             'Mark the file as temporary. Temporary files will be '.
             'deleted after 24 hours.')),
       $this->newWorkflowArgument('paths')
         ->setWildcard(true)
         ->setIsPathArgument(true),
     );
   }
 
   public function runWorkflow() {
     if (!$this->getArgument('paths')) {
       throw new PhutilArgumentUsageException(
         pht('Specify one or more paths to files you want to upload.'));
     }
 
     $is_temporary = $this->getArgument('temporary');
     $is_json = $this->getArgument('json');
     $is_browse = $this->getArgument('browse');
     $paths = $this->getArgument('paths');
 
     $conduit = $this->getConduitEngine();
     $results = array();
 
     $uploader = id(new ArcanistFileUploader())
       ->setConduitEngine($conduit);
 
     foreach ($paths as $key => $path) {
       $file = id(new ArcanistFileDataRef())
         ->setName(basename($path))
         ->setPath($path);
 
       if ($is_temporary) {
         $expires_at = time() + phutil_units('24 hours in seconds');
         $file->setDeleteAfterEpoch($expires_at);
       }
 
       $uploader->addFile($file);
     }
 
     $files = $uploader->uploadFiles();
 
     $phids = array();
     foreach ($files as $file) {
       // TODO: This could be handled more gracefully.
       if ($file->getErrors()) {
         throw new Exception(implode("\n", $file->getErrors()));
       }
       $phids[] = $file->getPHID();
     }
 
     $symbols = $this->getSymbolEngine();
     $symbol_refs = $symbols->loadFilesForSymbols($phids);
 
     $refs = array();
     foreach ($symbol_refs as $symbol_ref) {
       $ref = $symbol_ref->getObject();
       if ($ref === null) {
         throw new Exception(
           pht(
             'Failed to resolve symbol ref "%s".',
             $symbol_ref->getSymbol()));
       }
       $refs[] = $ref;
     }
 
     if ($is_json) {
       $json = array();
 
       foreach ($refs as $key => $ref) {
         $uri = $ref->getURI();
         $uri = $this->getAbsoluteURI($uri);
 
         $map = array(
           'argument' => $paths[$key],
           'id' => $ref->getID(),
           'phid' => $ref->getPHID(),
           'name' => $ref->getName(),
           'uri' => $uri,
         );
 
         $json[] = $map;
       }
 
       echo id(new PhutilJSON())->encodeAsList($json);
     } else {
       foreach ($refs as $ref) {
         $uri = $ref->getURI();
         $uri = $this->getAbsoluteURI($uri);
         echo tsprintf(
           '%s',
           $ref->newRefView()
             ->setURI($uri));
       }
     }
 
     if ($is_browse) {
       $uris = array();
       foreach ($refs as $ref) {
         $uri = $ref->getURI();
         $uri = $this->getAbsoluteURI($uri);
         $uris[] = $uri;
       }
       $this->openURIsInBrowser($uris);
     }
 
     return 0;
   }
 
   private function writeStatus($line) {
     $this->writeStatusMessage($line."\n");
   }
 
 }
diff --git a/src/workflow/ArcanistWorkWorkflow.php b/src/workflow/ArcanistWorkWorkflow.php
index 3696bb17..b837fbca 100644
--- a/src/workflow/ArcanistWorkWorkflow.php
+++ b/src/workflow/ArcanistWorkWorkflow.php
@@ -1,95 +1,95 @@
 <?php
 
 final class ArcanistWorkWorkflow
   extends ArcanistArcWorkflow {
 
   public function getWorkflowName() {
     return 'work';
   }
 
   public function getWorkflowArguments() {
     return array(
       $this->newWorkflowArgument('start')
         ->setParameter('symbol')
         ->setHelp(
           pht(
             'When creating a new branch or bookmark, use this as the '.
             'branch point.')),
       $this->newWorkflowArgument('symbol')
         ->setWildcard(true),
     );
   }
 
   public function getWorkflowInformation() {
     $help = pht(<<<EOHELP
 Begin or resume work on a branch, bookmark, task, or revision.
 
 The __symbol__ may be a branch or bookmark name, a revision name (like "D123"),
 a task name (like "T123"), or a new symbol.
 
 If you provide a symbol which currently does not identify any ongoing work,
-Arcanist will create a new branch or bookmark with the name you provide.
+a new branch or bookmark will be created with the name you provide.
 
-If you provide the name of an existing branch or bookmark, Arcanist will switch
-to that branch or bookmark.
+If you provide the name of an existing branch or bookmark, the working copy
+will be switched to that branch or bookmark.
 
-If you provide the name of a revision or task, Arcanist will look for a related
-branch or bookmark that exists in the working copy. If it finds one, it will
-switch to it. If it does not find one, it will attempt to create a new branch
-or bookmark.
+If you provide the name of a revision or task, the workflow will look for a
+related branch or bookmark that already exists in the working copy. If one is
+found, it will switch to it. If it does not find one, it will attempt to create
+a new branch or bookmark.
 
 When "arc work" creates a branch or bookmark, it will use **--start** as the
 branchpoint if it is provided. Otherwise, the current working copy state will
 serve as the starting point.
 EOHELP
       );
 
     return $this->newWorkflowInformation()
       ->setSynopsis(pht('Begin or resume work.'))
       ->addExample(pht('**work** [--start __start__] __symbol__'))
       ->setHelp($help);
   }
 
   public function runWorkflow() {
     $api = $this->getRepositoryAPI();
 
     $work_engine = $api->getWorkEngine();
     if (!$work_engine) {
       throw new PhutilArgumentUsageException(
         pht(
           '"arc work" must be run in a Git or Mercurial working copy.'));
     }
 
     $argv = $this->getArgument('symbol');
     if (count($argv) === 0) {
       throw new PhutilArgumentUsageException(
         pht(
           'Provide a branch, bookmark, task, or revision name to begin '.
           'or resume work on.'));
     } else if (count($argv) === 1) {
       $symbol_argument = $argv[0];
       if (!strlen($symbol_argument)) {
         throw new PhutilArgumentUsageException(
           pht(
             'Provide a nonempty symbol to begin or resume work on.'));
       }
     } else {
       throw new PhutilArgumentUsageException(
         pht(
           'Too many arguments: provide exactly one argument.'));
     }
 
     $start_argument = $this->getArgument('start');
 
     $work_engine
       ->setViewer($this->getViewer())
       ->setWorkflow($this)
       ->setLogEngine($this->getLogEngine())
       ->setSymbolArgument($symbol_argument)
       ->setStartArgument($start_argument)
       ->execute();
 
     return 0;
   }
 
 }
diff --git a/src/workflow/ArcanistWorkflow.php b/src/workflow/ArcanistWorkflow.php
index 85b917b7..3630bdb8 100644
--- a/src/workflow/ArcanistWorkflow.php
+++ b/src/workflow/ArcanistWorkflow.php
@@ -1,2470 +1,2468 @@
 <?php
 
 /**
  * Implements a runnable command, like "arc diff" or "arc help".
  *
  * = Managing Conduit =
  *
  * Workflows have the builtin ability to open a Conduit connection to a
  * Phabricator installation, so methods can be invoked over the API. Workflows
  * may either not need this (e.g., "help"), or may need a Conduit but not
  * authentication (e.g., calling only public APIs), or may need a Conduit and
  * authentication (e.g., "arc diff").
  *
  * To specify that you need an //unauthenticated// conduit, override
  * @{method:requiresConduit} to return ##true##. To specify that you need an
  * //authenticated// conduit, override @{method:requiresAuthentication} to
  * return ##true##. You can also manually invoke @{method:establishConduit}
  * and/or @{method:authenticateConduit} later in a workflow to upgrade it.
  * Once a conduit is open, you can access the client by calling
  * @{method:getConduit}, which allows you to invoke methods. You can get
  * verified information about the user identity by calling @{method:getUserPHID}
  * or @{method:getUserName} after authentication occurs.
  *
  * = Scratch Files =
  *
  * Arcanist workflows can read and write 'scratch files', which are temporary
  * files stored in the project that persist across commands. They can be useful
  * if you want to save some state, or keep a copy of a long message the user
  * entered if something goes wrong.
  *
  *
  * @task  conduit   Conduit
  * @task  scratch   Scratch Files
  * @task  phabrep   Phabricator Repositories
  */
 abstract class ArcanistWorkflow extends Phobject {
 
   const COMMIT_DISABLE = 0;
   const COMMIT_ALLOW = 1;
   const COMMIT_ENABLE = 2;
 
   private $commitMode = self::COMMIT_DISABLE;
 
   private $conduit;
   private $conduitURI;
   private $conduitCredentials;
   private $conduitAuthenticated;
   private $conduitTimeout;
 
   private $userPHID;
   private $userName;
   private $repositoryAPI;
   private $configurationManager;
   private $arguments = array();
   private $command;
 
   private $stashed;
   private $shouldAmend;
 
   private $projectInfo;
   private $repositoryInfo;
   private $repositoryReasons;
   private $repositoryRef;
 
   private $arcanistConfiguration;
   private $parentWorkflow;
   private $workingDirectory;
   private $repositoryVersion;
 
   private $changeCache = array();
   private $conduitEngine;
 
   private $toolset;
   private $runtime;
   private $configurationEngine;
   private $configurationSourceList;
 
   private $promptMap;
 
   final public function setToolset(ArcanistToolset $toolset) {
     $this->toolset = $toolset;
     return $this;
   }
 
   final public function getToolset() {
     return $this->toolset;
   }
 
   final public function setRuntime(ArcanistRuntime $runtime) {
     $this->runtime = $runtime;
     return $this;
   }
 
   final public function getRuntime() {
     return $this->runtime;
   }
 
   final public function setConfigurationEngine(
     ArcanistConfigurationEngine $engine) {
     $this->configurationEngine = $engine;
     return $this;
   }
 
   final public function getConfigurationEngine() {
     return $this->configurationEngine;
   }
 
   final public function setConfigurationSourceList(
     ArcanistConfigurationSourceList $list) {
     $this->configurationSourceList = $list;
     return $this;
   }
 
   final public function getConfigurationSourceList() {
     return $this->configurationSourceList;
   }
 
   public function newPhutilWorkflow() {
     $arguments = $this->getWorkflowArguments();
     assert_instances_of($arguments, 'ArcanistWorkflowArgument');
 
     $specs = mpull($arguments, 'getPhutilSpecification');
 
     $phutil_workflow = id(new ArcanistPhutilWorkflow())
       ->setName($this->getWorkflowName())
       ->setWorkflow($this)
       ->setArguments($specs);
 
     $information = $this->getWorkflowInformation();
 
     if ($information !== null) {
       if (!($information instanceof ArcanistWorkflowInformation)) {
         throw new Exception(
           pht(
             'Expected workflow ("%s", of class "%s") to return an '.
             '"ArcanistWorkflowInformation" object from call to '.
             '"getWorkflowInformation()", got %s.',
             $this->getWorkflowName(),
             get_class($this),
             phutil_describe_type($information)));
       }
     }
 
     if ($information) {
       $synopsis = $information->getSynopsis();
       if ($synopsis !== null) {
         $phutil_workflow->setSynopsis($synopsis);
       }
 
       $examples = $information->getExamples();
       if ($examples) {
         $examples = implode("\n", $examples);
         $phutil_workflow->setExamples($examples);
       }
 
       $help = $information->getHelp();
       if ($help !== null) {
         // Unwrap linebreaks in the help text so we don't get weird formatting.
         $help = preg_replace("/(?<=\S)\n(?=\S)/", ' ', $help);
 
         $phutil_workflow->setHelp($help);
       }
     }
 
     return $phutil_workflow;
   }
 
   final public function newLegacyPhutilWorkflow() {
     $phutil_workflow = id(new ArcanistPhutilWorkflow())
       ->setName($this->getWorkflowName());
 
     $arguments = $this->getArguments();
 
     $specs = array();
     foreach ($arguments as $key => $argument) {
       if ($key == '*') {
         $key = $argument;
         $argument = array(
           'wildcard' => true,
         );
       }
 
       unset($argument['paramtype']);
       unset($argument['supports']);
       unset($argument['nosupport']);
       unset($argument['passthru']);
       unset($argument['conflict']);
 
       $spec = array(
         'name' => $key,
       ) + $argument;
 
       $specs[] = $spec;
     }
 
     $phutil_workflow->setArguments($specs);
 
     $synopses = $this->getCommandSynopses();
     $phutil_workflow->setSynopsis($synopses);
 
     $help = $this->getCommandHelp();
     if (strlen($help)) {
       $phutil_workflow->setHelp($help);
     }
 
     return $phutil_workflow;
   }
 
   final protected function newWorkflowArgument($key) {
     return id(new ArcanistWorkflowArgument())
       ->setKey($key);
   }
 
   final protected function newWorkflowInformation() {
     return new ArcanistWorkflowInformation();
   }
 
   final public function executeWorkflow(PhutilArgumentParser $args) {
     $runtime = $this->getRuntime();
 
     $this->arguments = $args;
     $caught = null;
 
     $runtime->pushWorkflow($this);
 
     try {
       $err = $this->runWorkflow($args);
     } catch (Exception $ex) {
       $caught = $ex;
     }
 
     try {
       $this->runWorkflowCleanup();
     } catch (Exception $ex) {
       phlog($ex);
     }
 
     $runtime->popWorkflow();
 
     if ($caught) {
       throw $caught;
     }
 
     return $err;
   }
 
   final public function getLogEngine() {
     return $this->getRuntime()->getLogEngine();
   }
 
   protected function runWorkflowCleanup() {
     // TOOLSETS: Do we need this?
     return;
   }
 
   public function __construct() {}
 
   public function run() {
     throw new PhutilMethodNotImplementedException();
   }
 
   /**
    * Finalizes any cleanup operations that need to occur regardless of
    * whether the command succeeded or failed.
    */
   public function finalize() {
     $this->finalizeWorkingCopy();
   }
 
   /**
    * Return the command used to invoke this workflow from the command like,
    * e.g. "help" for @{class:ArcanistHelpWorkflow}.
    *
    * @return string   The command a user types to invoke this workflow.
    */
   abstract public function getWorkflowName();
 
   /**
    * Return console formatted string with all command synopses.
    *
    * @return string  6-space indented list of available command synopses.
    */
   public function getCommandSynopses() {
     return array();
   }
 
   /**
    * Return console formatted string with command help printed in `arc help`.
    *
    * @return string  10-space indented help to use the command.
    */
   public function getCommandHelp() {
     return null;
   }
 
   public function supportsToolset(ArcanistToolset $toolset) {
     return false;
   }
 
 
 /* -(  Conduit  )------------------------------------------------------------ */
 
 
   /**
    * Set the URI which the workflow will open a conduit connection to when
    * @{method:establishConduit} is called. Arcanist makes an effort to set
    * this by default for all workflows (by reading ##.arcconfig## and/or the
    * value of ##--conduit-uri##) even if they don't need Conduit, so a workflow
    * can generally upgrade into a conduit workflow later by just calling
    * @{method:establishConduit}.
    *
    * You generally should not need to call this method unless you are
    * specifically overriding the default URI. It is normally sufficient to
    * just invoke @{method:establishConduit}.
    *
    * NOTE: You can not call this after a conduit has been established.
    *
    * @param string  The URI to open a conduit to when @{method:establishConduit}
    *                is called.
    * @return this
    * @task conduit
    */
   final public function setConduitURI($conduit_uri) {
     if ($this->conduit) {
       throw new Exception(
         pht(
           'You can not change the Conduit URI after a '.
           'conduit is already open.'));
     }
     $this->conduitURI = $conduit_uri;
     return $this;
   }
 
   /**
    * Returns the URI the conduit connection within the workflow uses.
    *
    * @return string
    * @task conduit
    */
   final public function getConduitURI() {
     return $this->conduitURI;
   }
 
   /**
    * Open a conduit channel to the server which was previously configured by
    * calling @{method:setConduitURI}. Arcanist will do this automatically if
    * the workflow returns ##true## from @{method:requiresConduit}, or you can
    * later upgrade a workflow and build a conduit by invoking it manually.
    *
    * You must establish a conduit before you can make conduit calls.
    *
    * NOTE: You must call @{method:setConduitURI} before you can call this
    * method.
    *
    * @return this
    * @task conduit
    */
   final public function establishConduit() {
     if ($this->conduit) {
       return $this;
     }
 
     if (!$this->conduitURI) {
       throw new Exception(
         pht(
           'You must specify a Conduit URI with %s before you can '.
           'establish a conduit.',
           'setConduitURI()'));
     }
 
     $this->conduit = new ConduitClient($this->conduitURI);
 
     if ($this->conduitTimeout) {
       $this->conduit->setTimeout($this->conduitTimeout);
     }
 
     return $this;
   }
 
   final public function getConfigFromAnySource($key) {
     $source_list = $this->getConfigurationSourceList();
     if ($source_list) {
       $value_list = $source_list->getStorageValueList($key);
       if ($value_list) {
         return last($value_list)->getValue();
       }
 
       return null;
     }
 
     return $this->configurationManager->getConfigFromAnySource($key);
   }
 
 
   /**
    * Set credentials which will be used to authenticate against Conduit. These
    * credentials can then be used to establish an authenticated connection to
    * conduit by calling @{method:authenticateConduit}. Arcanist sets some
    * defaults for all workflows regardless of whether or not they return true
    * from @{method:requireAuthentication}, based on the ##~/.arcrc## and
    * ##.arcconf## files if they are present. Thus, you can generally upgrade a
    * workflow which does not require authentication into an authenticated
    * workflow by later invoking @{method:requireAuthentication}. You should not
    * normally need to call this method unless you are specifically overriding
    * the defaults.
    *
    * NOTE: You can not call this method after calling
    * @{method:authenticateConduit}.
    *
    * @param dict  A credential dictionary, see @{method:authenticateConduit}.
    * @return this
    * @task conduit
    */
   final public function setConduitCredentials(array $credentials) {
     if ($this->isConduitAuthenticated()) {
       throw new Exception(
         pht('You may not set new credentials after authenticating conduit.'));
     }
 
     $this->conduitCredentials = $credentials;
     return $this;
   }
 
 
   /**
    * Get the protocol version the client should identify with.
    *
    * @return int Version the client should claim to be.
    * @task conduit
    */
   final public function getConduitVersion() {
     return 6;
   }
 
 
   /**
    * Open and authenticate a conduit connection to a Phabricator server using
    * provided credentials. Normally, Arcanist does this for you automatically
    * when you return true from @{method:requiresAuthentication}, but you can
    * also upgrade an existing workflow to one with an authenticated conduit
    * by invoking this method manually.
    *
    * You must authenticate the conduit before you can make authenticated conduit
    * calls (almost all calls require authentication).
    *
    * This method uses credentials provided via @{method:setConduitCredentials}
    * to authenticate to the server:
    *
    *    - ##user## (required) The username to authenticate with.
    *    - ##certificate## (required) The Conduit certificate to use.
    *    - ##description## (optional) Description of the invoking command.
    *
    * Successful authentication allows you to call @{method:getUserPHID} and
    * @{method:getUserName}, as well as use the client you access with
    * @{method:getConduit} to make authenticated calls.
    *
    * NOTE: You must call @{method:setConduitURI} and
    * @{method:setConduitCredentials} before you invoke this method.
    *
    * @return this
    * @task conduit
    */
   final public function authenticateConduit() {
     if ($this->isConduitAuthenticated()) {
       return $this;
     }
 
     $this->establishConduit();
     $credentials = $this->conduitCredentials;
 
     try {
       if (!$credentials) {
         throw new Exception(
           pht(
             'Set conduit credentials with %s before authenticating conduit!',
             'setConduitCredentials()'));
       }
 
       // If we have `token`, this server supports the simpler, new-style
       // token-based authentication. Use that instead of all the certificate
       // stuff.
       $token = idx($credentials, 'token');
       if (strlen($token)) {
         $conduit = $this->getConduit();
 
         $conduit->setConduitToken($token);
 
         try {
           $result = $this->getConduit()->callMethodSynchronous(
             'user.whoami',
             array());
 
           $this->userName = $result['userName'];
           $this->userPHID = $result['phid'];
 
           $this->conduitAuthenticated = true;
 
           return $this;
         } catch (Exception $ex) {
           $conduit->setConduitToken(null);
           throw $ex;
         }
       }
 
       if (empty($credentials['user'])) {
         throw new ConduitClientException(
           'ERR-INVALID-USER',
           pht('Empty user in credentials.'));
       }
       if (empty($credentials['certificate'])) {
         throw new ConduitClientException(
           'ERR-NO-CERTIFICATE',
           pht('Empty certificate in credentials.'));
       }
 
       $description = idx($credentials, 'description', '');
       $user        = $credentials['user'];
       $certificate = $credentials['certificate'];
 
       $connection = $this->getConduit()->callMethodSynchronous(
         'conduit.connect',
         array(
           'client'              => 'arc',
           'clientVersion'       => $this->getConduitVersion(),
           'clientDescription'   => php_uname('n').':'.$description,
           'user'                => $user,
           'certificate'         => $certificate,
           'host'                => $this->conduitURI,
         ));
     } catch (ConduitClientException $ex) {
       if ($ex->getErrorCode() == 'ERR-NO-CERTIFICATE' ||
           $ex->getErrorCode() == 'ERR-INVALID-USER' ||
           $ex->getErrorCode() == 'ERR-INVALID-AUTH') {
         $conduit_uri = $this->conduitURI;
         $message = phutil_console_format(
           "\n%s\n\n    %s\n\n%s\n%s",
-          pht('YOU NEED TO __INSTALL A CERTIFICATE__ TO LOGIN TO PHABRICATOR'),
+          pht('YOU NEED TO __INSTALL A CERTIFICATE__ TO LOG IN'),
           pht('To do this, run: **%s**', 'arc install-certificate'),
           pht("The server '%s' rejected your request:", $conduit_uri),
           $ex->getMessage());
         throw new ArcanistUsageException($message);
       } else if ($ex->getErrorCode() == 'NEW-ARC-VERSION') {
 
         // Cleverly disguise this as being AWESOME!!!
 
         echo phutil_console_format("**%s**\n\n", pht('New Version Available!'));
         echo phutil_console_wrap($ex->getMessage());
         echo "\n\n";
         echo pht('In most cases, arc can be upgraded automatically.')."\n";
 
         $ok = phutil_console_confirm(
           pht('Upgrade arc now?'),
           $default_no = false);
         if (!$ok) {
           throw $ex;
         }
 
         $root = dirname(phutil_get_library_root('arcanist'));
 
         chdir($root);
         $err = phutil_passthru('%s upgrade', $root.'/bin/arc');
         if (!$err) {
           echo "\n".pht('Try running your arc command again.')."\n";
         }
         exit(1);
       } else {
         throw $ex;
       }
     }
 
     $this->userName = $user;
     $this->userPHID = $connection['userPHID'];
 
     $this->conduitAuthenticated = true;
 
     return $this;
   }
 
   /**
    * @return bool True if conduit is authenticated, false otherwise.
    * @task conduit
    */
   final protected function isConduitAuthenticated() {
     return (bool)$this->conduitAuthenticated;
   }
 
 
   /**
    * Override this to return true if your workflow requires a conduit channel.
    * Arc will build the channel for you before your workflow executes. This
    * implies that you only need an unauthenticated channel; if you need
    * authentication, override @{method:requiresAuthentication}.
    *
    * @return bool True if arc should build a conduit channel before running
    *              the workflow.
    * @task conduit
    */
   public function requiresConduit() {
     return false;
   }
 
 
   /**
    * Override this to return true if your workflow requires an authenticated
    * conduit channel. This implies that it requires a conduit. Arc will build
    * and authenticate the channel for you before the workflow executes.
    *
    * @return bool True if arc should build an authenticated conduit channel
    *              before running the workflow.
    * @task conduit
    */
   public function requiresAuthentication() {
     return false;
   }
 
 
   /**
    * Returns the PHID for the user once they've authenticated via Conduit.
    *
    * @return phid Authenticated user PHID.
    * @task conduit
    */
   final public function getUserPHID() {
     if (!$this->userPHID) {
       $workflow = get_class($this);
       throw new Exception(
         pht(
           "This workflow ('%s') requires authentication, override ".
           "%s to return true.",
           $workflow,
           'requiresAuthentication()'));
     }
     return $this->userPHID;
   }
 
   /**
    * Return the username for the user once they've authenticated via Conduit.
    *
    * @return string Authenticated username.
    * @task conduit
    */
   final public function getUserName() {
     return $this->userName;
   }
 
 
   /**
    * Get the established @{class@libphutil:ConduitClient} in order to make
    * Conduit method calls. Before the client is available it must be connected,
    * either implicitly by making @{method:requireConduit} or
    * @{method:requireAuthentication} return true, or explicitly by calling
    * @{method:establishConduit} or @{method:authenticateConduit}.
    *
    * @return @{class@libphutil:ConduitClient} Live conduit client.
    * @task conduit
    */
   final public function getConduit() {
     if (!$this->conduit) {
       $workflow = get_class($this);
       throw new Exception(
         pht(
           "This workflow ('%s') requires a Conduit, override ".
           "%s to return true.",
           $workflow,
           'requiresConduit()'));
     }
     return $this->conduit;
   }
 
 
   final public function setArcanistConfiguration(
     ArcanistConfiguration $arcanist_configuration) {
 
     $this->arcanistConfiguration = $arcanist_configuration;
     return $this;
   }
 
   final public function getArcanistConfiguration() {
     return $this->arcanistConfiguration;
   }
 
   final public function setConfigurationManager(
     ArcanistConfigurationManager $arcanist_configuration_manager) {
 
     $this->configurationManager = $arcanist_configuration_manager;
     return $this;
   }
 
   final public function getConfigurationManager() {
     return $this->configurationManager;
   }
 
   public function requiresWorkingCopy() {
     return false;
   }
 
   public function desiresWorkingCopy() {
     return false;
   }
 
   public function requiresRepositoryAPI() {
     return false;
   }
 
   public function desiresRepositoryAPI() {
     return false;
   }
 
   final public function setCommand($command) {
     $this->command = $command;
     return $this;
   }
 
   final public function getCommand() {
     return $this->command;
   }
 
   public function getArguments() {
     return array();
   }
 
   final public function setWorkingDirectory($working_directory) {
     $this->workingDirectory = $working_directory;
     return $this;
   }
 
   final public function getWorkingDirectory() {
     return $this->workingDirectory;
   }
 
   private function setParentWorkflow($parent_workflow) {
     $this->parentWorkflow = $parent_workflow;
     return $this;
   }
 
   final protected function getParentWorkflow() {
     return $this->parentWorkflow;
   }
 
   final public function buildChildWorkflow($command, array $argv) {
     $arc_config = $this->getArcanistConfiguration();
     $workflow = $arc_config->buildWorkflow($command);
     $workflow->setParentWorkflow($this);
     $workflow->setConduitEngine($this->getConduitEngine());
     $workflow->setCommand($command);
     $workflow->setConfigurationManager($this->getConfigurationManager());
 
     if ($this->repositoryAPI) {
       $workflow->setRepositoryAPI($this->repositoryAPI);
     }
 
     if ($this->userPHID) {
       $workflow->userPHID = $this->getUserPHID();
       $workflow->userName = $this->getUserName();
     }
 
     if ($this->conduit) {
       $workflow->conduit = $this->conduit;
       $workflow->setConduitCredentials($this->conduitCredentials);
       $workflow->conduitAuthenticated = $this->conduitAuthenticated;
     }
 
     $workflow->setArcanistConfiguration($arc_config);
 
     $workflow->parseArguments(array_values($argv));
 
     return $workflow;
   }
 
   final public function getArgument($key, $default = null) {
     // TOOLSETS: Remove this legacy code.
     if (is_array($this->arguments)) {
       return idx($this->arguments, $key, $default);
     }
 
     return $this->arguments->getArg($key);
   }
 
   final public function getCompleteArgumentSpecification() {
     $spec = $this->getArguments();
     $arc_config = $this->getArcanistConfiguration();
     $command = $this->getCommand();
     $spec += $arc_config->getCustomArgumentsForCommand($command);
 
     return $spec;
   }
 
   final public function parseArguments(array $args) {
     $spec = $this->getCompleteArgumentSpecification();
 
     $dict = array();
 
     $more_key = null;
     if (!empty($spec['*'])) {
       $more_key = $spec['*'];
       unset($spec['*']);
       $dict[$more_key] = array();
     }
 
     $short_to_long_map = array();
     foreach ($spec as $long => $options) {
       if (!empty($options['short'])) {
         $short_to_long_map[$options['short']] = $long;
       }
     }
 
     foreach ($spec as $long => $options) {
       if (!empty($options['repeat'])) {
         $dict[$long] = array();
       }
     }
 
     $more = array();
     $size = count($args);
     for ($ii = 0; $ii < $size; $ii++) {
       $arg = $args[$ii];
       $arg_name = null;
       $arg_key = null;
       if ($arg == '--') {
         $more = array_merge(
           $more,
           array_slice($args, $ii + 1));
         break;
       } else if (!strncmp($arg, '--', 2)) {
         $arg_key = substr($arg, 2);
         $parts = explode('=', $arg_key, 2);
         if (count($parts) == 2) {
           list($arg_key, $val) = $parts;
 
           array_splice($args, $ii, 1, array('--'.$arg_key, $val));
           $size++;
         }
 
         if (!array_key_exists($arg_key, $spec)) {
           $corrected = PhutilArgumentSpellingCorrector::newFlagCorrector()
             ->correctSpelling($arg_key, array_keys($spec));
           if (count($corrected) == 1) {
             PhutilConsole::getConsole()->writeErr(
               pht(
                 "(Assuming '%s' is the British spelling of '%s'.)",
                 '--'.$arg_key,
                 '--'.head($corrected))."\n");
             $arg_key = head($corrected);
           } else {
             throw new ArcanistUsageException(
               pht(
                 "Unknown argument '%s'. Try '%s'.",
                 $arg_key,
                 'arc help'));
           }
         }
       } else if (!strncmp($arg, '-', 1)) {
         $arg_key = substr($arg, 1);
         if (empty($short_to_long_map[$arg_key])) {
           throw new ArcanistUsageException(
             pht(
               "Unknown argument '%s'. Try '%s'.",
               $arg_key,
               'arc help'));
         }
         $arg_key = $short_to_long_map[$arg_key];
       } else {
         $more[] = $arg;
         continue;
       }
 
       $options = $spec[$arg_key];
       if (empty($options['param'])) {
         $dict[$arg_key] = true;
       } else {
         if ($ii == $size - 1) {
           throw new ArcanistUsageException(
             pht(
               "Option '%s' requires a parameter.",
               $arg));
         }
         if (!empty($options['repeat'])) {
           $dict[$arg_key][] = $args[$ii + 1];
         } else {
           $dict[$arg_key] = $args[$ii + 1];
         }
         $ii++;
       }
     }
 
     if ($more) {
       if ($more_key) {
         $dict[$more_key] = $more;
       } else {
         $example = reset($more);
         throw new ArcanistUsageException(
           pht(
             "Unrecognized argument '%s'. Try '%s'.",
             $example,
             'arc help'));
       }
     }
 
     foreach ($dict as $key => $value) {
       if (empty($spec[$key]['conflicts'])) {
         continue;
       }
       foreach ($spec[$key]['conflicts'] as $conflict => $more) {
         if (isset($dict[$conflict])) {
           if ($more) {
             $more = ': '.$more;
           } else {
             $more = '.';
           }
           // TODO: We'll always display these as long-form, when the user might
           // have typed them as short form.
           throw new ArcanistUsageException(
             pht(
               "Arguments '%s' and '%s' are mutually exclusive",
               "--{$key}",
               "--{$conflict}").$more);
         }
       }
     }
 
     $this->arguments = $dict;
 
     $this->didParseArguments();
 
     return $this;
   }
 
   protected function didParseArguments() {
     // Override this to customize workflow argument behavior.
   }
 
   final public function getWorkingCopy() {
     $configuration_engine = $this->getConfigurationEngine();
 
     // TOOLSETS: Remove this once all workflows are toolset workflows.
     if (!$configuration_engine) {
       throw new Exception(
         pht(
           'This workflow has not yet been updated to Toolsets and can '.
           'not retrieve a modern WorkingCopy object. Use '.
           '"getWorkingCopyIdentity()" to retrieve a previous-generation '.
           'object.'));
     }
 
     return $configuration_engine->getWorkingCopy();
   }
 
 
   final public function getWorkingCopyIdentity() {
     $configuration_engine = $this->getConfigurationEngine();
     if ($configuration_engine) {
       $working_copy = $configuration_engine->getWorkingCopy();
       $working_path = $working_copy->getWorkingDirectory();
 
       return ArcanistWorkingCopyIdentity::newFromPath($working_path);
     }
 
     $working_copy = $this->getConfigurationManager()->getWorkingCopyIdentity();
     if (!$working_copy) {
       $workflow = get_class($this);
       throw new Exception(
         pht(
           "This workflow ('%s') requires a working copy, override ".
           "%s to return true.",
           $workflow,
           'requiresWorkingCopy()'));
     }
     return $working_copy;
   }
 
   final public function setRepositoryAPI($api) {
     $this->repositoryAPI = $api;
     return $this;
   }
 
   final public function hasRepositoryAPI() {
     try {
       return (bool)$this->getRepositoryAPI();
     } catch (Exception $ex) {
       return false;
     }
   }
 
   final public function getRepositoryAPI() {
     $configuration_engine = $this->getConfigurationEngine();
     if ($configuration_engine) {
       $working_copy = $configuration_engine->getWorkingCopy();
       return $working_copy->getRepositoryAPI();
     }
 
     if (!$this->repositoryAPI) {
       $workflow = get_class($this);
       throw new Exception(
         pht(
           "This workflow ('%s') requires a Repository API, override ".
           "%s to return true.",
           $workflow,
           'requiresRepositoryAPI()'));
     }
     return $this->repositoryAPI;
   }
 
   final protected function shouldRequireCleanUntrackedFiles() {
     return empty($this->arguments['allow-untracked']);
   }
 
   final public function setCommitMode($mode) {
     $this->commitMode = $mode;
     return $this;
   }
 
   final public function finalizeWorkingCopy() {
     if ($this->stashed) {
       $api = $this->getRepositoryAPI();
       $api->unstashChanges();
       echo pht('Restored stashed changes to the working directory.')."\n";
     }
   }
 
   final public function requireCleanWorkingCopy() {
     $api = $this->getRepositoryAPI();
 
     $must_commit = array();
 
     $working_copy_desc = phutil_console_format(
       "  %s: __%s__\n\n",
       pht('Working copy'),
       $api->getPath());
 
     // NOTE: this is a subversion-only concept.
     $incomplete = $api->getIncompleteChanges();
     if ($incomplete) {
       throw new ArcanistUsageException(
         sprintf(
           "%s\n\n%s  %s\n    %s\n\n%s",
           pht(
             "You have incompletely checked out directories in this working ".
             "copy. Fix them before proceeding.'"),
           $working_copy_desc,
           pht('Incomplete directories in working copy:'),
           implode("\n    ", $incomplete),
           pht(
             "You can fix these paths by running '%s' on them.",
             'svn update')));
     }
 
     $conflicts = $api->getMergeConflicts();
     if ($conflicts) {
       throw new ArcanistUsageException(
         sprintf(
           "%s\n\n%s  %s\n    %s",
           pht(
             'You have merge conflicts in this working copy. Resolve merge '.
             'conflicts before proceeding.'),
           $working_copy_desc,
           pht('Conflicts in working copy:'),
           implode("\n    ", $conflicts)));
     }
 
     $missing = $api->getMissingChanges();
     if ($missing) {
       throw new ArcanistUsageException(
         sprintf(
           "%s\n\n%s  %s\n    %s\n",
           pht(
             'You have missing files in this working copy. Revert or formally '.
             'remove them (with `%s`) before proceeding.',
             'svn rm'),
           $working_copy_desc,
           pht('Missing files in working copy:'),
           implode("\n    ", $missing)));
     }
 
     $externals = $api->getDirtyExternalChanges();
 
     // TODO: This state can exist in Subversion, but it is currently handled
     // elsewhere. It should probably be handled here, eventually.
     if ($api instanceof ArcanistSubversionAPI) {
       $externals = array();
     }
 
     if ($externals) {
       $message = pht(
         '%s submodule(s) have uncommitted or untracked changes:',
         new PhutilNumber(count($externals)));
 
       $prompt = pht(
         'Ignore the changes to these %s submodule(s) and continue?',
         new PhutilNumber(count($externals)));
 
       $list = id(new PhutilConsoleList())
         ->setWrap(false)
         ->addItems($externals);
 
       id(new PhutilConsoleBlock())
         ->addParagraph($message)
         ->addList($list)
         ->draw();
 
       $ok = phutil_console_confirm($prompt, $default_no = false);
       if (!$ok) {
         throw new ArcanistUserAbortException();
       }
     }
 
     $uncommitted = $api->getUncommittedChanges();
     $unstaged = $api->getUnstagedChanges();
 
     // We already dealt with externals.
     $unstaged = array_diff($unstaged, $externals);
 
     // We only want files which are purely uncommitted.
     $uncommitted = array_diff($uncommitted, $unstaged);
     $uncommitted = array_diff($uncommitted, $externals);
 
     $untracked = $api->getUntrackedChanges();
     if (!$this->shouldRequireCleanUntrackedFiles()) {
       $untracked = array();
     }
 
     if ($untracked) {
       echo sprintf(
         "%s\n\n%s",
         pht('You have untracked files in this working copy.'),
         $working_copy_desc);
 
       if ($api instanceof ArcanistGitAPI) {
         $hint = pht(
           '(To ignore these %s change(s), add them to "%s".)',
           phutil_count($untracked),
           '.git/info/exclude');
       } else if ($api instanceof ArcanistSubversionAPI) {
         $hint = pht(
           '(To ignore these %s change(s), add them to "%s".)',
           phutil_count($untracked),
           'svn:ignore');
       } else if ($api instanceof ArcanistMercurialAPI) {
         $hint = pht(
           '(To ignore these %s change(s), add them to "%s".)',
           phutil_count($untracked),
           '.hgignore');
       }
 
       $untracked_list = "    ".implode("\n    ", $untracked);
       echo sprintf(
         "  %s\n  %s\n%s",
         pht('Untracked changes in working copy:'),
         $hint,
         $untracked_list);
 
       $prompt = pht(
         'Ignore these %s untracked file(s) and continue?',
         phutil_count($untracked));
 
       if (!phutil_console_confirm($prompt)) {
         throw new ArcanistUserAbortException();
       }
     }
 
 
     $should_commit = false;
     if ($unstaged || $uncommitted) {
 
       // NOTE: We're running this because it builds a cache and can take a
       // perceptible amount of time to arrive at an answer, but we don't want
       // to pause in the middle of printing the output below.
       $this->getShouldAmend();
 
       echo sprintf(
         "%s\n\n%s",
         pht('You have uncommitted changes in this working copy.'),
         $working_copy_desc);
 
       $lists = array();
 
       if ($unstaged) {
         $unstaged_list = "    ".implode("\n    ", $unstaged);
         $lists[] = sprintf(
           "  %s\n%s",
           pht('Unstaged changes in working copy:'),
           $unstaged_list);
       }
 
       if ($uncommitted) {
         $uncommitted_list = "    ".implode("\n    ", $uncommitted);
         $lists[] = sprintf(
           "%s\n%s",
           pht('Uncommitted changes in working copy:'),
           $uncommitted_list);
       }
 
       echo implode("\n\n", $lists)."\n";
 
       $all_uncommitted = array_merge($unstaged, $uncommitted);
       if ($this->askForAdd($all_uncommitted)) {
         if ($unstaged) {
           $api->addToCommit($unstaged);
         }
         $should_commit = true;
       } else {
         $permit_autostash = $this->getConfigFromAnySource('arc.autostash');
         if ($permit_autostash && $api->canStashChanges()) {
            echo pht(
             'Stashing uncommitted changes. (You can restore them with `%s`).',
             'git stash pop')."\n";
           $api->stashChanges();
           $this->stashed = true;
         } else {
           throw new ArcanistUsageException(
             pht(
               'You can not continue with uncommitted changes. '.
               'Commit or discard them before proceeding.'));
         }
       }
     }
 
     if ($should_commit) {
       if ($this->getShouldAmend()) {
         $commit = head($api->getLocalCommitInformation());
         $api->amendCommit($commit['message']);
       } else if ($api->supportsLocalCommits()) {
         $template = sprintf(
           "\n\n# %s\n#\n# %s\n#\n",
           pht('Enter a commit message.'),
           pht('Changes:'));
 
         $paths = array_merge($uncommitted, $unstaged);
         $paths = array_unique($paths);
         sort($paths);
 
         foreach ($paths as $path) {
           $template .= "#     ".$path."\n";
         }
 
         $commit_message = $this->newInteractiveEditor($template)
           ->setName(pht('commit-message'))
           ->setTaskMessage(pht(
             'Supply commit message for uncommitted changes, then save and '.
             'exit.'))
           ->editInteractively();
 
         if ($commit_message === $template) {
           throw new ArcanistUsageException(
             pht('You must provide a commit message.'));
         }
 
         $commit_message = ArcanistCommentRemover::removeComments(
           $commit_message);
 
         if (!strlen($commit_message)) {
           throw new ArcanistUsageException(
             pht('You must provide a nonempty commit message.'));
         }
 
         $api->doCommit($commit_message);
       }
     }
   }
 
   private function getShouldAmend() {
     if ($this->shouldAmend === null) {
       $this->shouldAmend = $this->calculateShouldAmend();
     }
     return $this->shouldAmend;
   }
 
   private function calculateShouldAmend() {
     $api = $this->getRepositoryAPI();
 
     if ($this->isHistoryImmutable() || !$api->supportsAmend()) {
       return false;
     }
 
     $commits = $api->getLocalCommitInformation();
     if (!$commits) {
       return false;
     }
 
     $commit = reset($commits);
     $message = ArcanistDifferentialCommitMessage::newFromRawCorpus(
       $commit['message']);
 
     if ($message->getGitSVNBaseRevision()) {
       return false;
     }
 
     if ($api->getAuthor() != $commit['author']) {
       return false;
     }
 
     if ($message->getRevisionID() && $this->getArgument('create')) {
       return false;
     }
 
     // TODO: Check commits since tracking branch. If empty then return false.
 
     // Don't amend the current commit if it has already been published.
     $repository = $this->loadProjectRepository();
     if ($repository) {
       $repo_id = $repository['id'];
       $commit_hash = $commit['commit'];
       $callsign =  idx($repository, 'callsign');
       if ($callsign) {
         // The server might be too old to support the new style commit names,
         // so prefer the old way
         $commit_name = "r{$callsign}{$commit_hash}";
       } else {
         $commit_name = "R{$repo_id}:{$commit_hash}";
       }
 
       $result = $this->getConduit()->callMethodSynchronous(
         'diffusion.querycommits',
         array('names' => array($commit_name)));
       $known_commit = idx($result['identifierMap'], $commit_name);
       if ($known_commit) {
         return false;
       }
     }
 
     if (!$message->getRevisionID()) {
       return true;
     }
 
     $in_working_copy = $api->loadWorkingCopyDifferentialRevisions(
       $this->getConduit(),
       array(
         'authors' => array($this->getUserPHID()),
         'status' => 'status-open',
       ));
     if ($in_working_copy) {
       return true;
     }
 
     return false;
   }
 
   private function askForAdd(array $files) {
     if ($this->commitMode == self::COMMIT_DISABLE) {
       return false;
     }
     if ($this->commitMode == self::COMMIT_ENABLE) {
       return true;
     }
     $prompt = $this->getAskForAddPrompt($files);
     return phutil_console_confirm($prompt);
   }
 
   private function getAskForAddPrompt(array $files) {
     if ($this->getShouldAmend()) {
       $prompt = pht(
         'Do you want to amend these %s change(s) to the current commit?',
         phutil_count($files));
     } else {
       $prompt = pht(
         'Do you want to create a new commit with these %s change(s)?',
         phutil_count($files));
     }
     return $prompt;
   }
 
   final protected function loadDiffBundleFromConduit(
     ConduitClient $conduit,
     $diff_id) {
 
     return $this->loadBundleFromConduit(
       $conduit,
       array(
       'ids' => array($diff_id),
     ));
   }
 
   final protected function loadRevisionBundleFromConduit(
     ConduitClient $conduit,
     $revision_id) {
 
     return $this->loadBundleFromConduit(
       $conduit,
       array(
       'revisionIDs' => array($revision_id),
     ));
   }
 
   private function loadBundleFromConduit(
     ConduitClient $conduit,
     $params) {
 
     $future = $conduit->callMethod('differential.querydiffs', $params);
     $diff = head($future->resolve());
 
     if ($diff == null) {
       throw new Exception(
         phutil_console_wrap(
           pht("The diff or revision you specified is either invalid or you ".
           "don't have permission to view it."))
       );
     }
 
     $changes = array();
     foreach ($diff['changes'] as $changedict) {
       $changes[] = ArcanistDiffChange::newFromDictionary($changedict);
     }
     $bundle = ArcanistBundle::newFromChanges($changes);
     $bundle->setConduit($conduit);
     // since the conduit method has changes, assume that these fields
     // could be unset
     $bundle->setBaseRevision(idx($diff, 'sourceControlBaseRevision'));
     $bundle->setRevisionID(idx($diff, 'revisionID'));
     $bundle->setAuthorName(idx($diff, 'authorName'));
     $bundle->setAuthorEmail(idx($diff, 'authorEmail'));
     return $bundle;
   }
 
   /**
    * Return a list of lines changed by the current diff, or ##null## if the
    * change list is meaningless (for example, because the path is a directory
    * or binary file).
    *
    * @param string      Path within the repository.
    * @param string      Change selection mode (see ArcanistDiffHunk).
    * @return list|null  List of changed line numbers, or null to indicate that
    *                    the path is not a line-oriented text file.
    */
   final protected function getChangedLines($path, $mode) {
     $repository_api = $this->getRepositoryAPI();
     $full_path = $repository_api->getPath($path);
     if (is_dir($full_path)) {
       return null;
     }
 
     if (!file_exists($full_path)) {
       return null;
     }
 
     $change = $this->getChange($path);
 
     if ($change->getFileType() !== ArcanistDiffChangeType::FILE_TEXT) {
       return null;
     }
 
     $lines = $change->getChangedLines($mode);
     return array_keys($lines);
   }
 
   final protected function getChange($path) {
     $repository_api = $this->getRepositoryAPI();
 
     // TODO: Very gross
     $is_git = ($repository_api instanceof ArcanistGitAPI);
     $is_hg = ($repository_api instanceof ArcanistMercurialAPI);
     $is_svn = ($repository_api instanceof ArcanistSubversionAPI);
 
     if ($is_svn) {
       // NOTE: In SVN, we don't currently support a "get all local changes"
       // operation, so special case it.
       if (empty($this->changeCache[$path])) {
         $diff = $repository_api->getRawDiffText($path);
         $parser = $this->newDiffParser();
         $changes = $parser->parseDiff($diff);
         if (count($changes) != 1) {
           throw new Exception(pht('Expected exactly one change.'));
         }
         $this->changeCache[$path] = reset($changes);
       }
     } else if ($is_git || $is_hg) {
       if (empty($this->changeCache)) {
         $changes = $repository_api->getAllLocalChanges();
         foreach ($changes as $change) {
           $this->changeCache[$change->getCurrentPath()] = $change;
         }
       }
     } else {
       throw new Exception(pht('Missing VCS support.'));
     }
 
     if (empty($this->changeCache[$path])) {
       if ($is_git || $is_hg) {
         // This can legitimately occur under git/hg if you make a change,
         // "git/hg commit" it, and then revert the change in the working copy
         // and run "arc lint".
         $change = new ArcanistDiffChange();
         $change->setCurrentPath($path);
         return $change;
       } else {
         throw new Exception(
           pht(
             "Trying to get change for unchanged path '%s'!",
             $path));
       }
     }
 
     return $this->changeCache[$path];
   }
 
   final public function willRunWorkflow() {
     $spec = $this->getCompleteArgumentSpecification();
     foreach ($this->arguments as $arg => $value) {
       if (empty($spec[$arg])) {
         continue;
       }
       $options = $spec[$arg];
       if (!empty($options['supports'])) {
         $system_name = $this->getRepositoryAPI()->getSourceControlSystemName();
         if (!in_array($system_name, $options['supports'])) {
           $extended_info = null;
           if (!empty($options['nosupport'][$system_name])) {
             $extended_info = ' '.$options['nosupport'][$system_name];
           }
           throw new ArcanistUsageException(
             pht(
               "Option '%s' is not supported under %s.",
               "--{$arg}",
               $system_name).
             $extended_info);
         }
       }
     }
   }
 
   final protected function normalizeRevisionID($revision_id) {
     return preg_replace('/^D/i', '', $revision_id);
   }
 
   protected function shouldShellComplete() {
     return true;
   }
 
   protected function getShellCompletions(array $argv) {
     return array();
   }
 
   public function getSupportedRevisionControlSystems() {
     return array('git', 'hg', 'svn');
   }
 
   final protected function getPassthruArgumentsAsMap($command) {
     $map = array();
     foreach ($this->getCompleteArgumentSpecification() as $key => $spec) {
       if (!empty($spec['passthru'][$command])) {
         if (isset($this->arguments[$key])) {
           $map[$key] = $this->arguments[$key];
         }
       }
     }
     return $map;
   }
 
   final protected function getPassthruArgumentsAsArgv($command) {
     $spec = $this->getCompleteArgumentSpecification();
     $map = $this->getPassthruArgumentsAsMap($command);
     $argv = array();
     foreach ($map as $key => $value) {
       $argv[] = '--'.$key;
       if (!empty($spec[$key]['param'])) {
         $argv[] = $value;
       }
     }
     return $argv;
   }
 
   /**
    * Write a message to stderr so that '--json' flags or stdout which is meant
    * to be piped somewhere aren't disrupted.
    *
    * @param string  Message to write to stderr.
    * @return void
    */
   final protected function writeStatusMessage($msg) {
     fwrite(STDERR, $msg);
   }
 
   final public function writeInfo($title, $message) {
     $this->writeStatusMessage(
       phutil_console_format(
         "<bg:blue>** %s **</bg> %s\n",
         $title,
         $message));
   }
 
   final public function writeWarn($title, $message) {
     $this->writeStatusMessage(
       phutil_console_format(
         "<bg:yellow>** %s **</bg> %s\n",
         $title,
         $message));
   }
 
   final public function writeOkay($title, $message) {
     $this->writeStatusMessage(
       phutil_console_format(
         "<bg:green>** %s **</bg> %s\n",
         $title,
         $message));
   }
 
   final protected function isHistoryImmutable() {
     $repository_api = $this->getRepositoryAPI();
 
     $config = $this->getConfigFromAnySource('history.immutable');
     if ($config !== null) {
       return $config;
     }
 
     return $repository_api->isHistoryDefaultImmutable();
   }
 
   /**
    * Workflows like 'lint' and 'unit' operate on a list of working copy paths.
    * The user can either specify the paths explicitly ("a.js b.php"), or by
    * specifying a revision ("--rev a3f10f1f") to select all paths modified
    * since that revision, or by omitting both and letting arc choose the
    * default relative revision.
    *
    * This method takes the user's selections and returns the paths that the
    * workflow should act upon.
    *
    * @param   list          List of explicitly provided paths.
    * @param   string|null   Revision name, if provided.
    * @param   mask          Mask of ArcanistRepositoryAPI flags to exclude.
    *                        Defaults to ArcanistRepositoryAPI::FLAG_UNTRACKED.
    * @return  list          List of paths the workflow should act on.
    */
   final protected function selectPathsForWorkflow(
     array $paths,
     $rev,
     $omit_mask = null) {
 
     if ($omit_mask === null) {
       $omit_mask = ArcanistRepositoryAPI::FLAG_UNTRACKED;
     }
 
     if ($paths) {
       $working_copy = $this->getWorkingCopyIdentity();
       foreach ($paths as $key => $path) {
         $full_path = Filesystem::resolvePath($path);
         if (!Filesystem::pathExists($full_path)) {
           throw new ArcanistUsageException(
             pht(
               "Path '%s' does not exist!",
               $path));
         }
         $relative_path = Filesystem::readablePath(
           $full_path,
           $working_copy->getProjectRoot());
         $paths[$key] = $relative_path;
       }
     } else {
       $repository_api = $this->getRepositoryAPI();
 
       if ($rev) {
         $this->parseBaseCommitArgument(array($rev));
       }
 
       $paths = $repository_api->getWorkingCopyStatus();
       foreach ($paths as $path => $flags) {
         if ($flags & $omit_mask) {
           unset($paths[$path]);
         }
       }
       $paths = array_keys($paths);
     }
 
     return array_values($paths);
   }
 
   final protected function renderRevisionList(array $revisions) {
     $list = array();
     foreach ($revisions as $revision) {
       $list[] = '     - D'.$revision['id'].': '.$revision['title']."\n";
     }
     return implode('', $list);
   }
 
 
 /* -(  Scratch Files  )------------------------------------------------------ */
 
 
   /**
    * Try to read a scratch file, if it exists and is readable.
    *
    * @param string Scratch file name.
    * @return mixed String for file contents, or false for failure.
    * @task scratch
    */
   final protected function readScratchFile($path) {
     if (!$this->repositoryAPI) {
       return false;
     }
     return $this->getRepositoryAPI()->readScratchFile($path);
   }
 
 
   /**
    * Try to read a scratch JSON file, if it exists and is readable.
    *
    * @param string Scratch file name.
    * @return array Empty array for failure.
    * @task scratch
    */
   final protected function readScratchJSONFile($path) {
     $file = $this->readScratchFile($path);
     if (!$file) {
       return array();
     }
     return phutil_json_decode($file);
   }
 
 
   /**
    * Try to write a scratch file, if there's somewhere to put it and we can
    * write there.
    *
    * @param  string Scratch file name to write.
    * @param  string Data to write.
    * @return bool   True on success, false on failure.
    * @task scratch
    */
   final protected function writeScratchFile($path, $data) {
     if (!$this->repositoryAPI) {
       return false;
     }
     return $this->getRepositoryAPI()->writeScratchFile($path, $data);
   }
 
 
   /**
    * Try to write a scratch JSON file, if there's somewhere to put it and we can
    * write there.
    *
    * @param  string Scratch file name to write.
    * @param  array Data to write.
    * @return bool   True on success, false on failure.
    * @task scratch
    */
   final protected function writeScratchJSONFile($path, array $data) {
     return $this->writeScratchFile($path, json_encode($data));
   }
 
 
   /**
    * Try to remove a scratch file.
    *
    * @param   string  Scratch file name to remove.
    * @return  bool    True if the file was removed successfully.
    * @task scratch
    */
   final protected function removeScratchFile($path) {
     if (!$this->repositoryAPI) {
       return false;
     }
     return $this->getRepositoryAPI()->removeScratchFile($path);
   }
 
 
   /**
    * Get a human-readable description of the scratch file location.
    *
    * @param string  Scratch file name.
    * @return mixed  String, or false on failure.
    * @task scratch
    */
   final protected function getReadableScratchFilePath($path) {
     if (!$this->repositoryAPI) {
       return false;
     }
     return $this->getRepositoryAPI()->getReadableScratchFilePath($path);
   }
 
 
   /**
    * Get the path to a scratch file, if possible.
    *
    * @param string  Scratch file name.
    * @return mixed  File path, or false on failure.
    * @task scratch
    */
   final protected function getScratchFilePath($path) {
     if (!$this->repositoryAPI) {
       return false;
     }
     return $this->getRepositoryAPI()->getScratchFilePath($path);
   }
 
   final protected function getRepositoryEncoding() {
     return nonempty(
       idx($this->loadProjectRepository(), 'encoding'),
       'UTF-8');
   }
 
   final protected function loadProjectRepository() {
     list($info, $reasons) = $this->loadRepositoryInformation();
     return coalesce($info, array());
   }
 
   final protected function newInteractiveEditor($text) {
     $editor = new PhutilInteractiveEditor($text);
 
     $preferred = $this->getConfigFromAnySource('editor');
     if ($preferred) {
       $editor->setPreferredEditor($preferred);
     }
 
     return $editor;
   }
 
   final protected function newDiffParser() {
     $parser = new ArcanistDiffParser();
     if ($this->repositoryAPI) {
       $parser->setRepositoryAPI($this->getRepositoryAPI());
     }
     $parser->setWriteDiffOnFailure(true);
     return $parser;
   }
 
   final protected function dispatchEvent($type, array $data) {
     $data += array(
       'workflow' => $this,
     );
 
     $event = new PhutilEvent($type, $data);
     PhutilEventEngine::dispatchEvent($event);
 
     return $event;
   }
 
   final public function parseBaseCommitArgument(array $argv) {
     if (!count($argv)) {
       return;
     }
 
     $api = $this->getRepositoryAPI();
     if (!$api->supportsCommitRanges()) {
       throw new ArcanistUsageException(
         pht('This version control system does not support commit ranges.'));
     }
 
     if (count($argv) > 1) {
       throw new ArcanistUsageException(
         pht(
           'Specify exactly one base commit. The end of the commit range is '.
           'always the working copy state.'));
     }
 
     $api->setBaseCommit(head($argv));
 
     return $this;
   }
 
   final protected function getRepositoryVersion() {
     if (!$this->repositoryVersion) {
       $api = $this->getRepositoryAPI();
       $commit = $api->getSourceControlBaseRevision();
       $versions = array('' => $commit);
       foreach ($api->getChangedFiles($commit) as $path => $mask) {
         $versions[$path] = (Filesystem::pathExists($path)
           ? md5_file($path)
           : '');
       }
       $this->repositoryVersion = md5(json_encode($versions));
     }
     return $this->repositoryVersion;
   }
 
 
 /* -(  Phabricator Repositories  )------------------------------------------- */
 
 
   /**
    * Get the PHID of the Phabricator repository this working copy corresponds
    * to. Returns `null` if no repository can be identified.
    *
    * @return phid|null  Repository PHID, or null if no repository can be
    *                    identified.
    *
    * @task phabrep
    */
   final protected function getRepositoryPHID() {
     return idx($this->getRepositoryInformation(), 'phid');
   }
 
   /**
    * Get the name of the Phabricator repository this working copy
    * corresponds to. Returns `null` if no repository can be identified.
    *
    * @return string|null  Repository name, or null if no repository can be
    *                      identified.
    *
    * @task phabrep
    */
   final protected function getRepositoryName() {
     return idx($this->getRepositoryInformation(), 'name');
   }
 
 
   /**
    * Get the URI of the Phabricator repository this working copy
    * corresponds to. Returns `null` if no repository can be identified.
    *
    * @return string|null  Repository URI, or null if no repository can be
    *                      identified.
    *
    * @task phabrep
    */
   final protected function getRepositoryURI() {
     return idx($this->getRepositoryInformation(), 'uri');
   }
 
 
   final protected function getRepositoryStagingConfiguration() {
     return idx($this->getRepositoryInformation(), 'staging');
   }
 
 
   /**
    * Get human-readable reasoning explaining how `arc` evaluated which
    * Phabricator repository corresponds to this working copy. Used by
    * `arc which` to explain the process to users.
    *
    * @return list<string> Human-readable explanation of the repository
    *                      association process.
    *
    * @task phabrep
    */
   final protected function getRepositoryReasons() {
     $this->getRepositoryInformation();
     return $this->repositoryReasons;
   }
 
 
   /**
    * @task phabrep
    */
   private function getRepositoryInformation() {
     if ($this->repositoryInfo === null) {
       list($info, $reasons) = $this->loadRepositoryInformation();
       $this->repositoryInfo = nonempty($info, array());
       $this->repositoryReasons = $reasons;
     }
 
     return $this->repositoryInfo;
   }
 
 
   /**
    * @task phabrep
    */
   private function loadRepositoryInformation() {
     list($query, $reasons) = $this->getRepositoryQuery();
     if (!$query) {
       return array(null, $reasons);
     }
 
     try {
       $method = 'repository.query';
       $results = $this->getConduitEngine()
         ->newFuture($method, $query)
         ->resolve();
     } catch (ConduitClientException $ex) {
       if ($ex->getErrorCode() == 'ERR-CONDUIT-CALL') {
         $reasons[] = pht(
-          'This version of Arcanist is more recent than the version of '.
-          'Phabricator you are connecting to: the Phabricator install is '.
-          'out of date and does not have support for identifying '.
-          'repositories by callsign or URI. Update Phabricator to enable '.
-          'these features.');
+          'This software version on the server you are connecting to is out '.
+          'of date and does not have support for identifying repositories '.
+          'by callsign or URI. Update the server sofwware to enable these '.
+          'features.');
         return array(null, $reasons);
       }
       throw $ex;
     }
 
     $result = null;
     if (!$results) {
       $reasons[] = pht(
         'No repositories matched the query. Check that your configuration '.
         'is correct, or use "%s" to select a repository explicitly.',
         'repository.callsign');
     } else if (count($results) > 1) {
       $reasons[] = pht(
         'Multiple repostories (%s) matched the query. You can use the '.
         '"%s" configuration to select the one you want.',
         implode(', ', ipull($results, 'callsign')),
         'repository.callsign');
     } else {
       $result = head($results);
       $reasons[] = pht('Found a unique matching repository.');
     }
 
     return array($result, $reasons);
   }
 
 
   /**
    * @task phabrep
    */
   private function getRepositoryQuery() {
     $reasons = array();
 
     $callsign = $this->getConfigFromAnySource('repository.callsign');
     if ($callsign) {
       $query = array(
         'callsigns' => array($callsign),
       );
       $reasons[] = pht(
         'Configuration value "%s" is set to "%s".',
         'repository.callsign',
         $callsign);
       return array($query, $reasons);
     } else {
       $reasons[] = pht(
         'Configuration value "%s" is empty.',
         'repository.callsign');
     }
 
     $uuid = $this->getRepositoryAPI()->getRepositoryUUID();
     if ($uuid !== null) {
       $query = array(
         'uuids' => array($uuid),
       );
       $reasons[] = pht(
         'The UUID for this working copy is "%s".',
         $uuid);
       return array($query, $reasons);
     } else {
       $reasons[] = pht(
         'This repository has no VCS UUID (this is normal for git/hg).');
     }
 
     // TODO: Swap this for a RemoteRefQuery.
 
     $remote_uri = $this->getRepositoryAPI()->getRemoteURI();
     if ($remote_uri !== null) {
       $query = array(
         'remoteURIs' => array($remote_uri),
       );
       $reasons[] = pht(
         'The remote URI for this working copy is "%s".',
         $remote_uri);
       return array($query, $reasons);
     } else {
       $reasons[] = pht(
         'Unable to determine the remote URI for this repository.');
     }
 
     return array(null, $reasons);
   }
 
 
   /**
    * Build a new lint engine for the current working copy.
    *
    * Optionally, you can pass an explicit engine class name to build an engine
    * of a particular class. Normally this is used to implement an `--engine`
    * flag from the CLI.
    *
    * @param string Optional explicit engine class name.
    * @return ArcanistLintEngine Constructed engine.
    */
   protected function newLintEngine($engine_class = null) {
     $working_copy = $this->getWorkingCopyIdentity();
     $config = $this->getConfigurationManager();
 
     if (!$engine_class) {
       $engine_class = $config->getConfigFromAnySource('lint.engine');
     }
 
     if (!$engine_class) {
       if (Filesystem::pathExists($working_copy->getProjectPath('.arclint'))) {
         $engine_class = 'ArcanistConfigurationDrivenLintEngine';
       }
     }
 
     if (!$engine_class) {
       throw new ArcanistNoEngineException(
         pht(
           "No lint engine is configured for this project. Create an '%s' ".
           "file, or configure an advanced engine with '%s' in '%s'.",
           '.arclint',
           'lint.engine',
           '.arcconfig'));
     }
 
     $base_class = 'ArcanistLintEngine';
     if (!class_exists($engine_class) ||
         !is_subclass_of($engine_class, $base_class)) {
       throw new ArcanistUsageException(
         pht(
           'Configured lint engine "%s" is not a subclass of "%s", but must be.',
           $engine_class,
           $base_class));
     }
 
     $engine = newv($engine_class, array())
       ->setWorkingCopy($working_copy)
       ->setConfigurationManager($config);
 
     return $engine;
   }
 
   /**
    * Build a new unit test engine for the current working copy.
    *
    * Optionally, you can pass an explicit engine class name to build an engine
    * of a particular class. Normally this is used to implement an `--engine`
    * flag from the CLI.
    *
    * @param string Optional explicit engine class name.
    * @return ArcanistUnitTestEngine Constructed engine.
    */
   protected function newUnitTestEngine($engine_class = null) {
     $working_copy = $this->getWorkingCopyIdentity();
     $config = $this->getConfigurationManager();
 
     if (!$engine_class) {
       $engine_class = $config->getConfigFromAnySource('unit.engine');
     }
 
     if (!$engine_class) {
       if (Filesystem::pathExists($working_copy->getProjectPath('.arcunit'))) {
         $engine_class = 'ArcanistConfigurationDrivenUnitTestEngine';
       }
     }
 
     if (!$engine_class) {
       throw new ArcanistNoEngineException(
         pht(
           "No unit test engine is configured for this project. Create an ".
           "'%s' file, or configure an advanced engine with '%s' in '%s'.",
           '.arcunit',
           'unit.engine',
           '.arcconfig'));
     }
 
     $base_class = 'ArcanistUnitTestEngine';
     if (!class_exists($engine_class) ||
         !is_subclass_of($engine_class, $base_class)) {
       throw new ArcanistUsageException(
         pht(
           'Configured unit test engine "%s" is not a subclass of "%s", '.
           'but must be.',
           $engine_class,
           $base_class));
     }
 
     $engine = newv($engine_class, array())
       ->setWorkingCopy($working_copy)
       ->setConfigurationManager($config);
 
     return $engine;
   }
 
 
   protected function openURIsInBrowser(array $uris) {
     $browser = $this->getBrowserCommand();
 
     // The "browser" may actually be a list of arguments.
     if (!is_array($browser)) {
       $browser = array($browser);
     }
 
     foreach ($uris as $uri) {
       $err = phutil_passthru('%LR %R', $browser, $uri);
       if ($err) {
         throw new ArcanistUsageException(
           pht(
             'Failed to open URI "%s" in browser ("%s"). '.
             'Check your "browser" config option.',
             $uri,
             implode(' ', $browser)));
       }
     }
   }
 
   private function getBrowserCommand() {
     $config = $this->getConfigFromAnySource('browser');
     if ($config) {
       return $config;
     }
 
     if (phutil_is_windows()) {
       // See T13504. We now use "bypass_shell", so "start" alone is no longer
       // a valid binary to invoke directly.
       return array(
         'cmd',
         '/c',
         'start',
       );
     }
 
     $candidates = array(
       'sensible-browser' => array('sensible-browser'),
       'xdg-open' => array('xdg-open'),
       'open' => array('open', '--'),
     );
 
     // NOTE: The "open" command works well on OS X, but on many Linuxes "open"
     // exists and is not a browser. For now, we're just looking for other
     // commands first, but we might want to be smarter about selecting "open"
     // only on OS X.
 
     foreach ($candidates as $cmd => $argv) {
       if (Filesystem::binaryExists($cmd)) {
         return $argv;
       }
     }
 
     throw new ArcanistUsageException(
       pht(
-        "Unable to find a browser command to run. Set '%s' in your ".
-        "Arcanist config to specify a command to use.",
-        'browser'));
+        'Unable to find a browser command to run. Set "browser" in your '.
+        'configuration to specify a command to use.'));
   }
 
 
   /**
    * Ask Phabricator to update the current repository as soon as possible.
    *
    * Calling this method after pushing commits allows Phabricator to discover
    * the commits more quickly, so the system overall is more responsive.
    *
    * @return void
    */
   protected function askForRepositoryUpdate() {
     // If we know which repository we're in, try to tell Phabricator that we
     // pushed commits to it so it can update. This hint can help pull updates
     // more quickly, especially in rarely-used repositories.
     if ($this->getRepositoryPHID()) {
       try {
         $this->getConduit()->callMethodSynchronous(
           'diffusion.looksoon',
           array(
             'repositories' => array($this->getRepositoryPHID()),
           ));
       } catch (ConduitClientException $ex) {
         // If we hit an exception, just ignore it. Likely, we are running
         // against a Phabricator which is too old to support this method.
         // Since this hint is purely advisory, it doesn't matter if it has
         // no effect.
       }
     }
   }
 
   protected function getModernLintDictionary(array $map) {
     $map = $this->getModernCommonDictionary($map);
     return $map;
   }
 
   protected function getModernUnitDictionary(array $map) {
     $map = $this->getModernCommonDictionary($map);
 
     $details = idx($map, 'userData');
     if (strlen($details)) {
       $map['details'] = (string)$details;
     }
     unset($map['userData']);
 
     return $map;
   }
 
   private function getModernCommonDictionary(array $map) {
     foreach ($map as $key => $value) {
       if ($value === null) {
         unset($map[$key]);
       }
     }
     return $map;
   }
 
   final public function setConduitEngine(
     ArcanistConduitEngine $conduit_engine) {
     $this->conduitEngine = $conduit_engine;
     return $this;
   }
 
   final public function getConduitEngine() {
     return $this->conduitEngine;
   }
 
   final public function getRepositoryRef() {
     $configuration_engine = $this->getConfigurationEngine();
     if ($configuration_engine) {
       // This is a toolset workflow and can always build a repository ref.
     } else {
       if (!$this->getConfigurationManager()->getWorkingCopyIdentity()) {
         return null;
       }
 
       if (!$this->repositoryAPI) {
         return null;
       }
     }
 
     if (!$this->repositoryRef) {
       $ref = id(new ArcanistRepositoryRef())
         ->setPHID($this->getRepositoryPHID())
         ->setBrowseURI($this->getRepositoryURI());
 
       $this->repositoryRef = $ref;
     }
 
     return $this->repositoryRef;
   }
 
   final public function getToolsetKey() {
     return $this->getToolset()->getToolsetKey();
   }
 
   final public function getConfig($key) {
     return $this->getConfigurationSourceList()->getConfig($key);
   }
 
   public function canHandleSignal($signo) {
     return false;
   }
 
   public function handleSignal($signo) {
     return;
   }
 
   final public function newCommand(PhutilExecutableFuture $future) {
     return id(new ArcanistCommand())
       ->setLogEngine($this->getLogEngine())
       ->setExecutableFuture($future);
   }
 
   final public function loadHardpoints(
     $objects,
     $requests) {
     return $this->getRuntime()->loadHardpoints($objects, $requests);
   }
 
   protected function newPrompts() {
     return array();
   }
 
   protected function newPrompt($key) {
     return id(new ArcanistPrompt())
       ->setWorkflow($this)
       ->setKey($key);
   }
 
   public function hasPrompt($key) {
     $map = $this->getPromptMap();
     return isset($map[$key]);
   }
 
   public function getPromptMap() {
     if ($this->promptMap === null) {
       $prompts = $this->newPrompts();
       assert_instances_of($prompts, 'ArcanistPrompt');
 
       // TODO: Move this somewhere modular.
 
       $prompts[] = $this->newPrompt('arc.state.stash')
         ->setDescription(
           pht(
             'Prompts the user to stash changes and continue when the '.
             'working copy has untracked, uncommitted, or unstaged '.
             'changes.'));
 
       // TODO: Swap to ArrayCheck?
 
       $map = array();
       foreach ($prompts as $prompt) {
         $key = $prompt->getKey();
 
         if (isset($map[$key])) {
           throw new Exception(
             pht(
               'Workflow ("%s") generates two prompts with the same '.
               'key ("%s"). Each prompt a workflow generates must have a '.
               'unique key.',
               get_class($this),
               $key));
         }
 
         $map[$key] = $prompt;
       }
 
       $this->promptMap = $map;
     }
 
     return $this->promptMap;
   }
 
   final public function getPrompt($key) {
     $map = $this->getPromptMap();
 
     $prompt = idx($map, $key);
     if (!$prompt) {
       throw new Exception(
         pht(
           'Workflow ("%s") is requesting a prompt ("%s") but it did not '.
           'generate any prompt with that name in "newPrompts()".',
           get_class($this),
           $key));
     }
 
     return clone $prompt;
   }
 
   final protected function getSymbolEngine() {
     return $this->getRuntime()->getSymbolEngine();
   }
 
   final protected function getViewer() {
     return $this->getRuntime()->getViewer();
   }
 
   final protected function readStdin() {
     $log = $this->getLogEngine();
     $log->writeWaitingForInput();
 
     // NOTE: We can't just "file_get_contents()" here because signals don't
     // interrupt it. If the user types "^C", we want to interrupt the read.
 
     $raw_handle = fopen('php://stdin', 'rb');
     $stdin = new PhutilSocketChannel($raw_handle);
 
     while ($stdin->update()) {
       PhutilChannel::waitForAny(array($stdin));
     }
 
     return $stdin->read();
   }
 
   final public function getAbsoluteURI($raw_uri) {
     // TODO: "ArcanistRevisionRef", at least, may return a relative URI.
     // If we get a relative URI, guess the correct absolute URI based on
     // the Conduit URI. This might not be correct for Conduit over SSH.
 
     $raw_uri = new PhutilURI($raw_uri);
     if (!strlen($raw_uri->getDomain())) {
       $base_uri = $this->getConduitEngine()
         ->getConduitURI();
 
       $raw_uri = id(new PhutilURI($base_uri))
         ->setPath($raw_uri->getPath());
     }
 
     $raw_uri = phutil_string_cast($raw_uri);
 
     return $raw_uri;
   }
 
   final public function writeToPager($corpus) {
     $is_tty = (function_exists('posix_isatty') && posix_isatty(STDOUT));
 
     if (!$is_tty) {
       echo $corpus;
     } else {
       $pager = $this->getConfig('pager');
 
       if (!$pager) {
         $pager = array('less', '-R', '--');
       }
 
       // Try to show the content through a pager.
       $err = id(new PhutilExecPassthru('%Ls', $pager))
         ->write($corpus)
         ->resolve();
 
       // If the pager exits with an error, print the content normally.
       if ($err) {
         echo $corpus;
       }
     }
 
     return $this;
   }
 
 }