diff --git a/scripts/arcanist.php b/scripts/arcanist.php
index df2a573d..37441929 100755
--- a/scripts/arcanist.php
+++ b/scripts/arcanist.php
@@ -1,672 +1,698 @@
 #!/usr/bin/env php
 <?php
 
 sanity_check_environment();
 
 require_once dirname(__FILE__).'/__init_script__.php';
 
 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'    => 'skip-arcconfig',
     ),
     array(
       'name'    => 'arcrc-file',
       'param'   => 'filename',
     ),
     array(
       'name'    => 'conduit-uri',
       'param'   => 'uri',
       'help'    => pht('Connect to Phabricator install specified by __uri__.'),
     ),
     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'    => 'conduit-version',
       'param'   => 'version',
       'help'    => pht(
         '(Developers) Mock client version in protocol handshake.'),
     ),
     array(
       'name'    => 'conduit-timeout',
       'param'   => 'timeout',
       'help'    => pht('Set Conduit timeout (in seconds).'),
     ),
     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.'),
     ),
 ));
 
 $config_trace_mode = $base_args->getArg('trace');
 
 $force_conduit = $base_args->getArg('conduit-uri');
 $force_token = $base_args->getArg('conduit-token');
 $force_conduit_version = $base_args->getArg('conduit-version');
 $conduit_timeout = $base_args->getArg('conduit-timeout');
 $skip_arcconfig = $base_args->getArg('skip-arcconfig');
 $custom_arcrc = $base_args->getArg('arcrc-file');
+$is_anonymous = $base_args->getArg('anonymous');
 $load = $base_args->getArg('load-phutil-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);
 
   if ($skip_arcconfig) {
     $working_copy = ArcanistWorkingCopyIdentity::newDummyWorkingCopy();
   } else {
     $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_class = $working_copy->getProjectConfig('arcanist_configuration');
   if ($config_class) {
     $config = new $config_class();
   } else {
     $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);
 
   if ($force_conduit_version) {
     $workflow->forceConduitVersion($force_conduit_version);
   }
   if ($conduit_timeout) {
     $workflow->setConduitTimeout($conduit_timeout);
   }
 
   $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:'),
         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);
 
+  $basic_user = $configuration_manager->getConfigFromAnySource(
+    'http.basicauth.user');
+  $basic_pass = $configuration_manager->getConfigFromAnySource(
+    'http.basicauth.pass');
+
+  $engine = id(new ArcanistConduitEngine())
+    ->setConduitURI($conduit_uri)
+    ->setConduitToken($conduit_token)
+    ->setBasicAuthUser($basic_user)
+    ->setBasicAuthPass($basic_pass);
+
+  if ($conduit_timeout) {
+    $engine->setConduitTimeout($conduit_timeout);
+  }
+
+  $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:'),
-      $ex->getMessage()));
+      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 {
       require_once $location.'/__phutil_library_init__.php';
     } 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 '.
             'working directory will not be loaded or executed.',
             $executing_directory,
             $working_directory)));
     }
   }
 }
diff --git a/src/__phutil_library_map__.php b/src/__phutil_library_map__.php
index ce7297af..2f9a3798 100644
--- a/src/__phutil_library_map__.php
+++ b/src/__phutil_library_map__.php
@@ -1,1644 +1,1700 @@
 <?php
 
 /**
  * This file is automatically generated. Use 'arc liberate' to rebuild it.
  *
  * @generated
  * @phutil-library-version 2
  */
 phutil_register_library_map(array(
   '__library_version__' => 2,
   'class' => array(
     'AASTNode' => 'parser/aast/api/AASTNode.php',
     'AASTNodeList' => 'parser/aast/api/AASTNodeList.php',
     'AASTToken' => 'parser/aast/api/AASTToken.php',
     'AASTTree' => 'parser/aast/api/AASTTree.php',
     'AbstractDirectedGraph' => 'utils/AbstractDirectedGraph.php',
     'AbstractDirectedGraphTestCase' => 'utils/__tests__/AbstractDirectedGraphTestCase.php',
     'ArcanistAbstractMethodBodyXHPASTLinterRule' => 'lint/linter/xhpast/rules/ArcanistAbstractMethodBodyXHPASTLinterRule.php',
     'ArcanistAbstractMethodBodyXHPASTLinterRuleTestCase' => 'lint/linter/xhpast/rules/__tests__/ArcanistAbstractMethodBodyXHPASTLinterRuleTestCase.php',
     'ArcanistAbstractPrivateMethodXHPASTLinterRule' => 'lint/linter/xhpast/rules/ArcanistAbstractPrivateMethodXHPASTLinterRule.php',
     'ArcanistAbstractPrivateMethodXHPASTLinterRuleTestCase' => 'lint/linter/xhpast/rules/__tests__/ArcanistAbstractPrivateMethodXHPASTLinterRuleTestCase.php',
     'ArcanistAliasFunctionXHPASTLinterRule' => 'lint/linter/xhpast/rules/ArcanistAliasFunctionXHPASTLinterRule.php',
     'ArcanistAliasFunctionXHPASTLinterRuleTestCase' => 'lint/linter/xhpast/rules/__tests__/ArcanistAliasFunctionXHPASTLinterRuleTestCase.php',
     'ArcanistAliasWorkflow' => 'workflow/ArcanistAliasWorkflow.php',
     'ArcanistAmendWorkflow' => 'workflow/ArcanistAmendWorkflow.php',
     'ArcanistAnoidWorkflow' => 'workflow/ArcanistAnoidWorkflow.php',
     'ArcanistArrayCombineXHPASTLinterRule' => 'lint/linter/xhpast/rules/ArcanistArrayCombineXHPASTLinterRule.php',
     'ArcanistArrayCombineXHPASTLinterRuleTestCase' => 'lint/linter/xhpast/rules/__tests__/ArcanistArrayCombineXHPASTLinterRuleTestCase.php',
     'ArcanistArrayIndexSpacingXHPASTLinterRule' => 'lint/linter/xhpast/rules/ArcanistArrayIndexSpacingXHPASTLinterRule.php',
     'ArcanistArrayIndexSpacingXHPASTLinterRuleTestCase' => 'lint/linter/xhpast/rules/__tests__/ArcanistArrayIndexSpacingXHPASTLinterRuleTestCase.php',
     'ArcanistArraySeparatorXHPASTLinterRule' => 'lint/linter/xhpast/rules/ArcanistArraySeparatorXHPASTLinterRule.php',
     'ArcanistArraySeparatorXHPASTLinterRuleTestCase' => 'lint/linter/xhpast/rules/__tests__/ArcanistArraySeparatorXHPASTLinterRuleTestCase.php',
     'ArcanistArrayValueXHPASTLinterRule' => 'lint/linter/xhpast/rules/ArcanistArrayValueXHPASTLinterRule.php',
     'ArcanistArrayValueXHPASTLinterRuleTestCase' => 'lint/linter/xhpast/rules/__tests__/ArcanistArrayValueXHPASTLinterRuleTestCase.php',
     'ArcanistBackoutWorkflow' => 'workflow/ArcanistBackoutWorkflow.php',
     'ArcanistBaseCommitParser' => 'parser/ArcanistBaseCommitParser.php',
     'ArcanistBaseCommitParserTestCase' => 'parser/__tests__/ArcanistBaseCommitParserTestCase.php',
     'ArcanistBaseXHPASTLinter' => 'lint/linter/ArcanistBaseXHPASTLinter.php',
     'ArcanistBinaryExpressionSpacingXHPASTLinterRule' => 'lint/linter/xhpast/rules/ArcanistBinaryExpressionSpacingXHPASTLinterRule.php',
     'ArcanistBinaryExpressionSpacingXHPASTLinterRuleTestCase' => 'lint/linter/xhpast/rules/__tests__/ArcanistBinaryExpressionSpacingXHPASTLinterRuleTestCase.php',
     'ArcanistBinaryNumericScalarCasingXHPASTLinterRule' => 'lint/linter/xhpast/rules/ArcanistBinaryNumericScalarCasingXHPASTLinterRule.php',
     'ArcanistBinaryNumericScalarCasingXHPASTLinterRuleTestCase' => 'lint/linter/xhpast/rules/__tests__/ArcanistBinaryNumericScalarCasingXHPASTLinterRuleTestCase.php',
     'ArcanistBlacklistedFunctionXHPASTLinterRule' => 'lint/linter/xhpast/rules/ArcanistBlacklistedFunctionXHPASTLinterRule.php',
     'ArcanistBlacklistedFunctionXHPASTLinterRuleTestCase' => 'lint/linter/xhpast/rules/__tests__/ArcanistBlacklistedFunctionXHPASTLinterRuleTestCase.php',
     'ArcanistBlindlyTrustHTTPEngineExtension' => 'configuration/ArcanistBlindlyTrustHTTPEngineExtension.php',
     'ArcanistBookmarkWorkflow' => 'workflow/ArcanistBookmarkWorkflow.php',
     'ArcanistBraceFormattingXHPASTLinterRule' => 'lint/linter/xhpast/rules/ArcanistBraceFormattingXHPASTLinterRule.php',
     'ArcanistBraceFormattingXHPASTLinterRuleTestCase' => 'lint/linter/xhpast/rules/__tests__/ArcanistBraceFormattingXHPASTLinterRuleTestCase.php',
+    'ArcanistBranchRef' => 'ref/ArcanistBranchRef.php',
     'ArcanistBranchWorkflow' => 'workflow/ArcanistBranchWorkflow.php',
-    'ArcanistBrowseWorkflow' => 'workflow/ArcanistBrowseWorkflow.php',
+    'ArcanistBrowseCommitHardpointLoader' => 'browse/loader/ArcanistBrowseCommitHardpointLoader.php',
+    'ArcanistBrowseCommitURIHardpointLoader' => 'browse/loader/ArcanistBrowseCommitURIHardpointLoader.php',
+    'ArcanistBrowseObjectNameURIHardpointLoader' => 'browse/loader/ArcanistBrowseObjectNameURIHardpointLoader.php',
+    'ArcanistBrowsePathURIHardpointLoader' => 'browse/loader/ArcanistBrowsePathURIHardpointLoader.php',
+    'ArcanistBrowseRef' => 'browse/ref/ArcanistBrowseRef.php',
+    'ArcanistBrowseRevisionURIHardpointLoader' => 'browse/loader/ArcanistBrowseRevisionURIHardpointLoader.php',
+    'ArcanistBrowseURIHardpointLoader' => 'browse/loader/ArcanistBrowseURIHardpointLoader.php',
+    'ArcanistBrowseURIRef' => 'browse/ref/ArcanistBrowseURIRef.php',
+    'ArcanistBrowseWorkflow' => 'browse/workflow/ArcanistBrowseWorkflow.php',
     'ArcanistBuildPlanRef' => 'ref/ArcanistBuildPlanRef.php',
     'ArcanistBuildRef' => 'ref/ArcanistBuildRef.php',
     'ArcanistBundle' => 'parser/ArcanistBundle.php',
     'ArcanistBundleTestCase' => 'parser/__tests__/ArcanistBundleTestCase.php',
     'ArcanistCSSLintLinter' => 'lint/linter/ArcanistCSSLintLinter.php',
     'ArcanistCSSLintLinterTestCase' => 'lint/linter/__tests__/ArcanistCSSLintLinterTestCase.php',
     'ArcanistCSharpLinter' => 'lint/linter/ArcanistCSharpLinter.php',
     'ArcanistCallConduitWorkflow' => 'workflow/ArcanistCallConduitWorkflow.php',
     'ArcanistCallParenthesesXHPASTLinterRule' => 'lint/linter/xhpast/rules/ArcanistCallParenthesesXHPASTLinterRule.php',
     'ArcanistCallParenthesesXHPASTLinterRuleTestCase' => 'lint/linter/xhpast/rules/__tests__/ArcanistCallParenthesesXHPASTLinterRuleTestCase.php',
     'ArcanistCallTimePassByReferenceXHPASTLinterRule' => 'lint/linter/xhpast/rules/ArcanistCallTimePassByReferenceXHPASTLinterRule.php',
     'ArcanistCallTimePassByReferenceXHPASTLinterRuleTestCase' => 'lint/linter/xhpast/rules/__tests__/ArcanistCallTimePassByReferenceXHPASTLinterRuleTestCase.php',
     'ArcanistCapabilityNotSupportedException' => 'workflow/exception/ArcanistCapabilityNotSupportedException.php',
     'ArcanistCastSpacingXHPASTLinterRule' => 'lint/linter/xhpast/rules/ArcanistCastSpacingXHPASTLinterRule.php',
     'ArcanistCastSpacingXHPASTLinterRuleTestCase' => 'lint/linter/xhpast/rules/__tests__/ArcanistCastSpacingXHPASTLinterRuleTestCase.php',
     'ArcanistCheckstyleXMLLintRenderer' => 'lint/renderer/ArcanistCheckstyleXMLLintRenderer.php',
     'ArcanistChmodLinter' => 'lint/linter/ArcanistChmodLinter.php',
     'ArcanistChmodLinterTestCase' => 'lint/linter/__tests__/ArcanistChmodLinterTestCase.php',
     'ArcanistClassExtendsObjectXHPASTLinterRule' => 'lint/linter/xhpast/rules/ArcanistClassExtendsObjectXHPASTLinterRule.php',
     'ArcanistClassExtendsObjectXHPASTLinterRuleTestCase' => 'lint/linter/xhpast/rules/__tests__/ArcanistClassExtendsObjectXHPASTLinterRuleTestCase.php',
     'ArcanistClassFilenameMismatchXHPASTLinterRule' => 'lint/linter/xhpast/rules/ArcanistClassFilenameMismatchXHPASTLinterRule.php',
     'ArcanistClassMustBeDeclaredAbstractXHPASTLinterRule' => 'lint/linter/xhpast/rules/ArcanistClassMustBeDeclaredAbstractXHPASTLinterRule.php',
     'ArcanistClassMustBeDeclaredAbstractXHPASTLinterRuleTestCase' => 'lint/linter/xhpast/rules/__tests__/ArcanistClassMustBeDeclaredAbstractXHPASTLinterRuleTestCase.php',
     'ArcanistClassNameLiteralXHPASTLinterRule' => 'lint/linter/xhpast/rules/ArcanistClassNameLiteralXHPASTLinterRule.php',
     'ArcanistClassNameLiteralXHPASTLinterRuleTestCase' => 'lint/linter/xhpast/rules/__tests__/ArcanistClassNameLiteralXHPASTLinterRuleTestCase.php',
     'ArcanistCloseRevisionWorkflow' => 'workflow/ArcanistCloseRevisionWorkflow.php',
     'ArcanistCloseWorkflow' => 'workflow/ArcanistCloseWorkflow.php',
     'ArcanistClosureLinter' => 'lint/linter/ArcanistClosureLinter.php',
     'ArcanistClosureLinterTestCase' => 'lint/linter/__tests__/ArcanistClosureLinterTestCase.php',
     'ArcanistCoffeeLintLinter' => 'lint/linter/ArcanistCoffeeLintLinter.php',
     'ArcanistCoffeeLintLinterTestCase' => 'lint/linter/__tests__/ArcanistCoffeeLintLinterTestCase.php',
     'ArcanistCommentRemover' => 'parser/ArcanistCommentRemover.php',
     'ArcanistCommentRemoverTestCase' => 'parser/__tests__/ArcanistCommentRemoverTestCase.php',
     'ArcanistCommentSpacingXHPASTLinterRule' => 'lint/linter/xhpast/rules/ArcanistCommentSpacingXHPASTLinterRule.php',
     'ArcanistCommentStyleXHPASTLinterRule' => 'lint/linter/xhpast/rules/ArcanistCommentStyleXHPASTLinterRule.php',
     'ArcanistCommentStyleXHPASTLinterRuleTestCase' => 'lint/linter/xhpast/rules/__tests__/ArcanistCommentStyleXHPASTLinterRuleTestCase.php',
+    'ArcanistCommitRef' => 'ref/ArcanistCommitRef.php',
+    'ArcanistCommitUpstreamHardpointLoader' => 'loader/ArcanistCommitUpstreamHardpointLoader.php',
     'ArcanistCommitWorkflow' => 'workflow/ArcanistCommitWorkflow.php',
     'ArcanistCompilerLintRenderer' => 'lint/renderer/ArcanistCompilerLintRenderer.php',
     'ArcanistComposerLinter' => 'lint/linter/ArcanistComposerLinter.php',
     'ArcanistComprehensiveLintEngine' => 'lint/engine/ArcanistComprehensiveLintEngine.php',
     'ArcanistConcatenationOperatorXHPASTLinterRule' => 'lint/linter/xhpast/rules/ArcanistConcatenationOperatorXHPASTLinterRule.php',
     'ArcanistConcatenationOperatorXHPASTLinterRuleTestCase' => 'lint/linter/xhpast/rules/__tests__/ArcanistConcatenationOperatorXHPASTLinterRuleTestCase.php',
+    'ArcanistConduitCall' => 'conduit/ArcanistConduitCall.php',
+    'ArcanistConduitEngine' => 'conduit/ArcanistConduitEngine.php',
     'ArcanistConfiguration' => 'configuration/ArcanistConfiguration.php',
     'ArcanistConfigurationDrivenLintEngine' => 'lint/engine/ArcanistConfigurationDrivenLintEngine.php',
     'ArcanistConfigurationDrivenUnitTestEngine' => 'unit/engine/ArcanistConfigurationDrivenUnitTestEngine.php',
     'ArcanistConfigurationManager' => 'configuration/ArcanistConfigurationManager.php',
     'ArcanistConsoleLintRenderer' => 'lint/renderer/ArcanistConsoleLintRenderer.php',
     'ArcanistConsoleLintRendererTestCase' => 'lint/renderer/__tests__/ArcanistConsoleLintRendererTestCase.php',
     'ArcanistConstructorParenthesesXHPASTLinterRule' => 'lint/linter/xhpast/rules/ArcanistConstructorParenthesesXHPASTLinterRule.php',
     'ArcanistConstructorParenthesesXHPASTLinterRuleTestCase' => 'lint/linter/xhpast/rules/__tests__/ArcanistConstructorParenthesesXHPASTLinterRuleTestCase.php',
     'ArcanistContinueInsideSwitchXHPASTLinterRule' => 'lint/linter/xhpast/rules/ArcanistContinueInsideSwitchXHPASTLinterRule.php',
     'ArcanistContinueInsideSwitchXHPASTLinterRuleTestCase' => 'lint/linter/xhpast/rules/__tests__/ArcanistContinueInsideSwitchXHPASTLinterRuleTestCase.php',
     'ArcanistControlStatementSpacingXHPASTLinterRule' => 'lint/linter/xhpast/rules/ArcanistControlStatementSpacingXHPASTLinterRule.php',
     'ArcanistControlStatementSpacingXHPASTLinterRuleTestCase' => 'lint/linter/xhpast/rules/__tests__/ArcanistControlStatementSpacingXHPASTLinterRuleTestCase.php',
     'ArcanistCoverWorkflow' => 'workflow/ArcanistCoverWorkflow.php',
     'ArcanistCppcheckLinter' => 'lint/linter/ArcanistCppcheckLinter.php',
     'ArcanistCppcheckLinterTestCase' => 'lint/linter/__tests__/ArcanistCppcheckLinterTestCase.php',
     'ArcanistCpplintLinter' => 'lint/linter/ArcanistCpplintLinter.php',
     'ArcanistCpplintLinterTestCase' => 'lint/linter/__tests__/ArcanistCpplintLinterTestCase.php',
     'ArcanistCurlyBraceArrayIndexXHPASTLinterRule' => 'lint/linter/xhpast/rules/ArcanistCurlyBraceArrayIndexXHPASTLinterRule.php',
     'ArcanistCurlyBraceArrayIndexXHPASTLinterRuleTestCase' => 'lint/linter/xhpast/rules/__tests__/ArcanistCurlyBraceArrayIndexXHPASTLinterRuleTestCase.php',
     'ArcanistDeclarationParenthesesXHPASTLinterRule' => 'lint/linter/xhpast/rules/ArcanistDeclarationParenthesesXHPASTLinterRule.php',
     'ArcanistDeclarationParenthesesXHPASTLinterRuleTestCase' => 'lint/linter/xhpast/rules/__tests__/ArcanistDeclarationParenthesesXHPASTLinterRuleTestCase.php',
     'ArcanistDefaultParametersXHPASTLinterRule' => 'lint/linter/xhpast/rules/ArcanistDefaultParametersXHPASTLinterRule.php',
     'ArcanistDefaultParametersXHPASTLinterRuleTestCase' => 'lint/linter/xhpast/rules/__tests__/ArcanistDefaultParametersXHPASTLinterRuleTestCase.php',
     'ArcanistDeprecationXHPASTLinterRule' => 'lint/linter/xhpast/rules/ArcanistDeprecationXHPASTLinterRule.php',
     'ArcanistDeprecationXHPASTLinterRuleTestCase' => 'lint/linter/xhpast/rules/__tests__/ArcanistDeprecationXHPASTLinterRuleTestCase.php',
     'ArcanistDiffByteSizeException' => 'exception/ArcanistDiffByteSizeException.php',
     'ArcanistDiffChange' => 'parser/diff/ArcanistDiffChange.php',
     'ArcanistDiffChangeType' => 'parser/diff/ArcanistDiffChangeType.php',
     'ArcanistDiffHunk' => 'parser/diff/ArcanistDiffHunk.php',
     'ArcanistDiffParser' => 'parser/ArcanistDiffParser.php',
     'ArcanistDiffParserTestCase' => 'parser/__tests__/ArcanistDiffParserTestCase.php',
     'ArcanistDiffUtils' => 'difference/ArcanistDiffUtils.php',
     'ArcanistDiffUtilsTestCase' => 'difference/__tests__/ArcanistDiffUtilsTestCase.php',
     'ArcanistDiffWorkflow' => 'workflow/ArcanistDiffWorkflow.php',
     'ArcanistDifferentialCommitMessage' => 'differential/ArcanistDifferentialCommitMessage.php',
     'ArcanistDifferentialCommitMessageParserException' => 'differential/ArcanistDifferentialCommitMessageParserException.php',
     'ArcanistDifferentialDependencyGraph' => 'differential/ArcanistDifferentialDependencyGraph.php',
     'ArcanistDifferentialRevisionHash' => 'differential/constants/ArcanistDifferentialRevisionHash.php',
     'ArcanistDifferentialRevisionStatus' => 'differential/constants/ArcanistDifferentialRevisionStatus.php',
     'ArcanistDoubleQuoteXHPASTLinterRule' => 'lint/linter/xhpast/rules/ArcanistDoubleQuoteXHPASTLinterRule.php',
     'ArcanistDoubleQuoteXHPASTLinterRuleTestCase' => 'lint/linter/xhpast/rules/__tests__/ArcanistDoubleQuoteXHPASTLinterRuleTestCase.php',
     'ArcanistDownloadWorkflow' => 'workflow/ArcanistDownloadWorkflow.php',
     'ArcanistDuplicateKeysInArrayXHPASTLinterRule' => 'lint/linter/xhpast/rules/ArcanistDuplicateKeysInArrayXHPASTLinterRule.php',
     'ArcanistDuplicateKeysInArrayXHPASTLinterRuleTestCase' => 'lint/linter/xhpast/rules/__tests__/ArcanistDuplicateKeysInArrayXHPASTLinterRuleTestCase.php',
     'ArcanistDuplicateSwitchCaseXHPASTLinterRule' => 'lint/linter/xhpast/rules/ArcanistDuplicateSwitchCaseXHPASTLinterRule.php',
     'ArcanistDuplicateSwitchCaseXHPASTLinterRuleTestCase' => 'lint/linter/xhpast/rules/__tests__/ArcanistDuplicateSwitchCaseXHPASTLinterRuleTestCase.php',
     'ArcanistDynamicDefineXHPASTLinterRule' => 'lint/linter/xhpast/rules/ArcanistDynamicDefineXHPASTLinterRule.php',
     'ArcanistDynamicDefineXHPASTLinterRuleTestCase' => 'lint/linter/xhpast/rules/__tests__/ArcanistDynamicDefineXHPASTLinterRuleTestCase.php',
     'ArcanistElseIfUsageXHPASTLinterRule' => 'lint/linter/xhpast/rules/ArcanistElseIfUsageXHPASTLinterRule.php',
     'ArcanistElseIfUsageXHPASTLinterRuleTestCase' => 'lint/linter/xhpast/rules/__tests__/ArcanistElseIfUsageXHPASTLinterRuleTestCase.php',
     'ArcanistEmptyFileXHPASTLinterRule' => 'lint/linter/xhpast/rules/ArcanistEmptyFileXHPASTLinterRule.php',
     'ArcanistEmptyStatementXHPASTLinterRule' => 'lint/linter/xhpast/rules/ArcanistEmptyStatementXHPASTLinterRule.php',
     'ArcanistEmptyStatementXHPASTLinterRuleTestCase' => 'lint/linter/xhpast/rules/__tests__/ArcanistEmptyStatementXHPASTLinterRuleTestCase.php',
     'ArcanistEventType' => 'events/constant/ArcanistEventType.php',
     'ArcanistExitExpressionXHPASTLinterRule' => 'lint/linter/xhpast/rules/ArcanistExitExpressionXHPASTLinterRule.php',
     'ArcanistExitExpressionXHPASTLinterRuleTestCase' => 'lint/linter/xhpast/rules/__tests__/ArcanistExitExpressionXHPASTLinterRuleTestCase.php',
     'ArcanistExportWorkflow' => 'workflow/ArcanistExportWorkflow.php',
     'ArcanistExternalLinter' => 'lint/linter/ArcanistExternalLinter.php',
     'ArcanistExternalLinterTestCase' => 'lint/linter/__tests__/ArcanistExternalLinterTestCase.php',
     'ArcanistExtractUseXHPASTLinterRule' => 'lint/linter/xhpast/rules/ArcanistExtractUseXHPASTLinterRule.php',
     'ArcanistExtractUseXHPASTLinterRuleTestCase' => 'lint/linter/xhpast/rules/__tests__/ArcanistExtractUseXHPASTLinterRuleTestCase.php',
     'ArcanistFeatureWorkflow' => 'workflow/ArcanistFeatureWorkflow.php',
     'ArcanistFileDataRef' => 'upload/ArcanistFileDataRef.php',
     'ArcanistFileUploader' => 'upload/ArcanistFileUploader.php',
     'ArcanistFilenameLinter' => 'lint/linter/ArcanistFilenameLinter.php',
     'ArcanistFilenameLinterTestCase' => 'lint/linter/__tests__/ArcanistFilenameLinterTestCase.php',
     'ArcanistFlagWorkflow' => 'workflow/ArcanistFlagWorkflow.php',
     'ArcanistFlake8Linter' => 'lint/linter/ArcanistFlake8Linter.php',
     'ArcanistFlake8LinterTestCase' => 'lint/linter/__tests__/ArcanistFlake8LinterTestCase.php',
     'ArcanistFormattedStringXHPASTLinterRule' => 'lint/linter/xhpast/rules/ArcanistFormattedStringXHPASTLinterRule.php',
     'ArcanistFormattedStringXHPASTLinterRuleTestCase' => 'lint/linter/xhpast/rules/__tests__/ArcanistFormattedStringXHPASTLinterRuleTestCase.php',
     'ArcanistFunctionCallShouldBeTypeCastXHPASTLinterRule' => 'lint/linter/xhpast/rules/ArcanistFunctionCallShouldBeTypeCastXHPASTLinterRule.php',
     'ArcanistFunctionCallShouldBeTypeCastXHPASTLinterRuleTestCase' => 'lint/linter/xhpast/rules/__tests__/ArcanistFunctionCallShouldBeTypeCastXHPASTLinterRuleTestCase.php',
     'ArcanistFutureLinter' => 'lint/linter/ArcanistFutureLinter.php',
     'ArcanistGeneratedLinter' => 'lint/linter/ArcanistGeneratedLinter.php',
     'ArcanistGeneratedLinterTestCase' => 'lint/linter/__tests__/ArcanistGeneratedLinterTestCase.php',
     'ArcanistGetConfigWorkflow' => 'workflow/ArcanistGetConfigWorkflow.php',
     'ArcanistGitAPI' => 'repository/api/ArcanistGitAPI.php',
+    'ArcanistGitCommitMessageHardpointLoader' => 'loader/ArcanistGitCommitMessageHardpointLoader.php',
+    'ArcanistGitHardpointLoader' => 'loader/ArcanistGitHardpointLoader.php',
     'ArcanistGitLandEngine' => 'land/ArcanistGitLandEngine.php',
+    'ArcanistGitRevisionHardpointLoader' => 'loader/ArcanistGitRevisionHardpointLoader.php',
     'ArcanistGitUpstreamPath' => 'repository/api/ArcanistGitUpstreamPath.php',
     'ArcanistGlobalVariableXHPASTLinterRule' => 'lint/linter/xhpast/rules/ArcanistGlobalVariableXHPASTLinterRule.php',
     'ArcanistGlobalVariableXHPASTLinterRuleTestCase' => 'lint/linter/xhpast/rules/__tests__/ArcanistGlobalVariableXHPASTLinterRuleTestCase.php',
     'ArcanistGoLintLinter' => 'lint/linter/ArcanistGoLintLinter.php',
     'ArcanistGoLintLinterTestCase' => 'lint/linter/__tests__/ArcanistGoLintLinterTestCase.php',
     'ArcanistGoTestResultParser' => 'unit/parser/ArcanistGoTestResultParser.php',
     'ArcanistGoTestResultParserTestCase' => 'unit/parser/__tests__/ArcanistGoTestResultParserTestCase.php',
     'ArcanistHLintLinter' => 'lint/linter/ArcanistHLintLinter.php',
     'ArcanistHLintLinterTestCase' => 'lint/linter/__tests__/ArcanistHLintLinterTestCase.php',
+    'ArcanistHardpointLoader' => 'loader/ArcanistHardpointLoader.php',
     'ArcanistHelpWorkflow' => 'workflow/ArcanistHelpWorkflow.php',
     'ArcanistHexadecimalNumericScalarCasingXHPASTLinterRule' => 'lint/linter/xhpast/rules/ArcanistHexadecimalNumericScalarCasingXHPASTLinterRule.php',
     'ArcanistHexadecimalNumericScalarCasingXHPASTLinterRuleTestCase' => 'lint/linter/xhpast/rules/__tests__/ArcanistHexadecimalNumericScalarCasingXHPASTLinterRuleTestCase.php',
     'ArcanistHgClientChannel' => 'hgdaemon/ArcanistHgClientChannel.php',
     'ArcanistHgProxyClient' => 'hgdaemon/ArcanistHgProxyClient.php',
     'ArcanistHgProxyServer' => 'hgdaemon/ArcanistHgProxyServer.php',
     'ArcanistHgServerChannel' => 'hgdaemon/ArcanistHgServerChannel.php',
     'ArcanistImplicitConstructorXHPASTLinterRule' => 'lint/linter/xhpast/rules/ArcanistImplicitConstructorXHPASTLinterRule.php',
     'ArcanistImplicitConstructorXHPASTLinterRuleTestCase' => 'lint/linter/xhpast/rules/__tests__/ArcanistImplicitConstructorXHPASTLinterRuleTestCase.php',
     'ArcanistImplicitFallthroughXHPASTLinterRule' => 'lint/linter/xhpast/rules/ArcanistImplicitFallthroughXHPASTLinterRule.php',
     'ArcanistImplicitFallthroughXHPASTLinterRuleTestCase' => 'lint/linter/xhpast/rules/__tests__/ArcanistImplicitFallthroughXHPASTLinterRuleTestCase.php',
     'ArcanistImplicitVisibilityXHPASTLinterRule' => 'lint/linter/xhpast/rules/ArcanistImplicitVisibilityXHPASTLinterRule.php',
     'ArcanistImplicitVisibilityXHPASTLinterRuleTestCase' => 'lint/linter/xhpast/rules/__tests__/ArcanistImplicitVisibilityXHPASTLinterRuleTestCase.php',
     'ArcanistImplodeArgumentOrderXHPASTLinterRule' => 'lint/linter/xhpast/rules/ArcanistImplodeArgumentOrderXHPASTLinterRule.php',
     'ArcanistImplodeArgumentOrderXHPASTLinterRuleTestCase' => 'lint/linter/xhpast/rules/__tests__/ArcanistImplodeArgumentOrderXHPASTLinterRuleTestCase.php',
     'ArcanistInlineHTMLXHPASTLinterRule' => 'lint/linter/ArcanistInlineHTMLXHPASTLinterRule.php',
     'ArcanistInlineHTMLXHPASTLinterRuleTestCase' => 'lint/linter/xhpast/rules/__tests__/ArcanistInlineHTMLXHPASTLinterRuleTestCase.php',
     'ArcanistInnerFunctionXHPASTLinterRule' => 'lint/linter/xhpast/rules/ArcanistInnerFunctionXHPASTLinterRule.php',
     'ArcanistInnerFunctionXHPASTLinterRuleTestCase' => 'lint/linter/xhpast/rules/__tests__/ArcanistInnerFunctionXHPASTLinterRuleTestCase.php',
     'ArcanistInstallCertificateWorkflow' => 'workflow/ArcanistInstallCertificateWorkflow.php',
     'ArcanistInstanceOfOperatorXHPASTLinterRule' => 'lint/linter/xhpast/rules/ArcanistInstanceOfOperatorXHPASTLinterRule.php',
     'ArcanistInstanceofOperatorXHPASTLinterRuleTestCase' => 'lint/linter/xhpast/rules/__tests__/ArcanistInstanceofOperatorXHPASTLinterRuleTestCase.php',
     'ArcanistInterfaceAbstractMethodXHPASTLinterRule' => 'lint/linter/xhpast/rules/ArcanistInterfaceAbstractMethodXHPASTLinterRule.php',
     'ArcanistInterfaceAbstractMethodXHPASTLinterRuleTestCase' => 'lint/linter/xhpast/rules/__tests__/ArcanistInterfaceAbstractMethodXHPASTLinterRuleTestCase.php',
     'ArcanistInterfaceMethodBodyXHPASTLinterRule' => 'lint/linter/xhpast/rules/ArcanistInterfaceMethodBodyXHPASTLinterRule.php',
     'ArcanistInterfaceMethodBodyXHPASTLinterRuleTestCase' => 'lint/linter/xhpast/rules/__tests__/ArcanistInterfaceMethodBodyXHPASTLinterRuleTestCase.php',
     'ArcanistInvalidDefaultParameterXHPASTLinterRule' => 'lint/linter/xhpast/rules/ArcanistInvalidDefaultParameterXHPASTLinterRule.php',
     'ArcanistInvalidDefaultParameterXHPASTLinterRuleTestCase' => 'lint/linter/xhpast/rules/__tests__/ArcanistInvalidDefaultParameterXHPASTLinterRuleTestCase.php',
     'ArcanistInvalidModifiersXHPASTLinterRule' => 'lint/linter/xhpast/rules/ArcanistInvalidModifiersXHPASTLinterRule.php',
     'ArcanistInvalidModifiersXHPASTLinterRuleTestCase' => 'lint/linter/xhpast/rules/__tests__/ArcanistInvalidModifiersXHPASTLinterRuleTestCase.php',
     'ArcanistInvalidOctalNumericScalarXHPASTLinterRule' => 'lint/linter/xhpast/rules/ArcanistInvalidOctalNumericScalarXHPASTLinterRule.php',
     'ArcanistInvalidOctalNumericScalarXHPASTLinterRuleTestCase' => 'lint/linter/xhpast/rules/__tests__/ArcanistInvalidOctalNumericScalarXHPASTLinterRuleTestCase.php',
     'ArcanistIsAShouldBeInstanceOfXHPASTLinterRule' => 'lint/linter/xhpast/rules/ArcanistIsAShouldBeInstanceOfXHPASTLinterRule.php',
     'ArcanistIsAShouldBeInstanceOfXHPASTLinterRuleTestCase' => 'lint/linter/xhpast/rules/__tests__/ArcanistIsAShouldBeInstanceOfXHPASTLinterRuleTestCase.php',
     'ArcanistJSHintLinter' => 'lint/linter/ArcanistJSHintLinter.php',
     'ArcanistJSHintLinterTestCase' => 'lint/linter/__tests__/ArcanistJSHintLinterTestCase.php',
     'ArcanistJSONLintLinter' => 'lint/linter/ArcanistJSONLintLinter.php',
     'ArcanistJSONLintLinterTestCase' => 'lint/linter/__tests__/ArcanistJSONLintLinterTestCase.php',
     'ArcanistJSONLintRenderer' => 'lint/renderer/ArcanistJSONLintRenderer.php',
     'ArcanistJSONLinter' => 'lint/linter/ArcanistJSONLinter.php',
     'ArcanistJSONLinterTestCase' => 'lint/linter/__tests__/ArcanistJSONLinterTestCase.php',
     'ArcanistJscsLinter' => 'lint/linter/ArcanistJscsLinter.php',
     'ArcanistJscsLinterTestCase' => 'lint/linter/__tests__/ArcanistJscsLinterTestCase.php',
     'ArcanistKeywordCasingXHPASTLinterRule' => 'lint/linter/xhpast/rules/ArcanistKeywordCasingXHPASTLinterRule.php',
     'ArcanistKeywordCasingXHPASTLinterRuleTestCase' => 'lint/linter/xhpast/rules/__tests__/ArcanistKeywordCasingXHPASTLinterRuleTestCase.php',
     'ArcanistLambdaFuncFunctionXHPASTLinterRule' => 'lint/linter/xhpast/rules/ArcanistLambdaFuncFunctionXHPASTLinterRule.php',
     'ArcanistLambdaFuncFunctionXHPASTLinterRuleTestCase' => 'lint/linter/xhpast/rules/__tests__/ArcanistLambdaFuncFunctionXHPASTLinterRuleTestCase.php',
     'ArcanistLandEngine' => 'land/ArcanistLandEngine.php',
     'ArcanistLandWorkflow' => 'workflow/ArcanistLandWorkflow.php',
     'ArcanistLanguageConstructParenthesesXHPASTLinterRule' => 'lint/linter/xhpast/rules/ArcanistLanguageConstructParenthesesXHPASTLinterRule.php',
     'ArcanistLanguageConstructParenthesesXHPASTLinterRuleTestCase' => 'lint/linter/xhpast/rules/__tests__/ArcanistLanguageConstructParenthesesXHPASTLinterRuleTestCase.php',
     'ArcanistLesscLinter' => 'lint/linter/ArcanistLesscLinter.php',
     'ArcanistLesscLinterTestCase' => 'lint/linter/__tests__/ArcanistLesscLinterTestCase.php',
     'ArcanistLiberateWorkflow' => 'workflow/ArcanistLiberateWorkflow.php',
     'ArcanistLibraryTestCase' => '__tests__/ArcanistLibraryTestCase.php',
     'ArcanistLintEngine' => 'lint/engine/ArcanistLintEngine.php',
     'ArcanistLintMessage' => 'lint/ArcanistLintMessage.php',
     'ArcanistLintMessageTestCase' => 'lint/__tests__/ArcanistLintMessageTestCase.php',
     'ArcanistLintPatcher' => 'lint/ArcanistLintPatcher.php',
     'ArcanistLintRenderer' => 'lint/renderer/ArcanistLintRenderer.php',
     'ArcanistLintResult' => 'lint/ArcanistLintResult.php',
     'ArcanistLintSeverity' => 'lint/ArcanistLintSeverity.php',
     'ArcanistLintWorkflow' => 'workflow/ArcanistLintWorkflow.php',
     'ArcanistLinter' => 'lint/linter/ArcanistLinter.php',
     'ArcanistLinterStandard' => 'lint/linter/standards/ArcanistLinterStandard.php',
     'ArcanistLinterStandardTestCase' => 'lint/linter/standards/__tests__/ArcanistLinterStandardTestCase.php',
     'ArcanistLinterTestCase' => 'lint/linter/__tests__/ArcanistLinterTestCase.php',
     'ArcanistLintersWorkflow' => 'workflow/ArcanistLintersWorkflow.php',
     'ArcanistListAssignmentXHPASTLinterRule' => 'lint/linter/xhpast/rules/ArcanistListAssignmentXHPASTLinterRule.php',
     'ArcanistListAssignmentXHPASTLinterRuleTestCase' => 'lint/linter/xhpast/rules/__tests__/ArcanistListAssignmentXHPASTLinterRuleTestCase.php',
     'ArcanistListWorkflow' => 'workflow/ArcanistListWorkflow.php',
     'ArcanistLogicalOperatorsXHPASTLinterRule' => 'lint/linter/xhpast/rules/ArcanistLogicalOperatorsXHPASTLinterRule.php',
     'ArcanistLogicalOperatorsXHPASTLinterRuleTestCase' => 'lint/linter/xhpast/rules/__tests__/ArcanistLogicalOperatorsXHPASTLinterRuleTestCase.php',
     'ArcanistLowercaseFunctionsXHPASTLinterRule' => 'lint/linter/xhpast/rules/ArcanistLowercaseFunctionsXHPASTLinterRule.php',
     'ArcanistLowercaseFunctionsXHPASTLinterRuleTestCase' => 'lint/linter/xhpast/rules/__tests__/ArcanistLowercaseFunctionsXHPASTLinterRuleTestCase.php',
     'ArcanistMercurialAPI' => 'repository/api/ArcanistMercurialAPI.php',
+    'ArcanistMercurialBranchCommitHardpointLoader' => 'loader/ArcanistMercurialBranchCommitHardpointLoader.php',
+    'ArcanistMercurialHardpointLoader' => 'loader/ArcanistMercurialHardpointLoader.php',
     'ArcanistMercurialParser' => 'repository/parser/ArcanistMercurialParser.php',
     'ArcanistMercurialParserTestCase' => 'repository/parser/__tests__/ArcanistMercurialParserTestCase.php',
+    'ArcanistMercurialWorkingCopyCommitHardpointLoader' => 'loader/ArcanistMercurialWorkingCopyCommitHardpointLoader.php',
     'ArcanistMergeConflictLinter' => 'lint/linter/ArcanistMergeConflictLinter.php',
     'ArcanistMergeConflictLinterTestCase' => 'lint/linter/__tests__/ArcanistMergeConflictLinterTestCase.php',
+    'ArcanistMessageRevisionHardpointLoader' => 'loader/ArcanistMessageRevisionHardpointLoader.php',
     'ArcanistMissingLinterException' => 'lint/linter/exception/ArcanistMissingLinterException.php',
     'ArcanistModifierOrderingXHPASTLinterRule' => 'lint/linter/xhpast/rules/ArcanistModifierOrderingXHPASTLinterRule.php',
     'ArcanistModifierOrderingXHPASTLinterRuleTestCase' => 'lint/linter/xhpast/rules/__tests__/ArcanistModifierOrderingXHPASTLinterRuleTestCase.php',
     'ArcanistNamespaceFirstStatementXHPASTLinterRule' => 'lint/linter/xhpast/rules/ArcanistNamespaceFirstStatementXHPASTLinterRule.php',
     'ArcanistNamespaceFirstStatementXHPASTLinterRuleTestCase' => 'lint/linter/xhpast/rules/__tests__/ArcanistNamespaceFirstStatementXHPASTLinterRuleTestCase.php',
     'ArcanistNamingConventionsXHPASTLinterRule' => 'lint/linter/xhpast/rules/ArcanistNamingConventionsXHPASTLinterRule.php',
     'ArcanistNamingConventionsXHPASTLinterRuleTestCase' => 'lint/linter/xhpast/rules/__tests__/ArcanistNamingConventionsXHPASTLinterRuleTestCase.php',
     'ArcanistNestedNamespacesXHPASTLinterRule' => 'lint/linter/xhpast/rules/ArcanistNestedNamespacesXHPASTLinterRule.php',
     'ArcanistNestedNamespacesXHPASTLinterRuleTestCase' => 'lint/linter/xhpast/rules/__tests__/ArcanistNestedNamespacesXHPASTLinterRuleTestCase.php',
     'ArcanistNewlineAfterOpenTagXHPASTLinterRule' => 'lint/linter/xhpast/rules/ArcanistNewlineAfterOpenTagXHPASTLinterRule.php',
     'ArcanistNewlineAfterOpenTagXHPASTLinterRuleTestCase' => 'lint/linter/xhpast/rules/__tests__/ArcanistNewlineAfterOpenTagXHPASTLinterRuleTestCase.php',
     'ArcanistNoEffectException' => 'exception/usage/ArcanistNoEffectException.php',
     'ArcanistNoEngineException' => 'exception/usage/ArcanistNoEngineException.php',
     'ArcanistNoLintLinter' => 'lint/linter/ArcanistNoLintLinter.php',
     'ArcanistNoLintLinterTestCase' => 'lint/linter/__tests__/ArcanistNoLintLinterTestCase.php',
     'ArcanistNoParentScopeXHPASTLinterRule' => 'lint/linter/xhpast/rules/ArcanistNoParentScopeXHPASTLinterRule.php',
     'ArcanistNoParentScopeXHPASTLinterRuleTestCase' => 'lint/linter/xhpast/rules/__tests__/ArcanistNoParentScopeXHPASTLinterRuleTestCase.php',
     'ArcanistNoneLintRenderer' => 'lint/renderer/ArcanistNoneLintRenderer.php',
     'ArcanistObjectOperatorSpacingXHPASTLinterRule' => 'lint/linter/xhpast/rules/ArcanistObjectOperatorSpacingXHPASTLinterRule.php',
     'ArcanistObjectOperatorSpacingXHPASTLinterRuleTestCase' => 'lint/linter/xhpast/rules/__tests__/ArcanistObjectOperatorSpacingXHPASTLinterRuleTestCase.php',
     'ArcanistPEP8Linter' => 'lint/linter/ArcanistPEP8Linter.php',
     'ArcanistPEP8LinterTestCase' => 'lint/linter/__tests__/ArcanistPEP8LinterTestCase.php',
     'ArcanistPHPCloseTagXHPASTLinterRule' => 'lint/linter/xhpast/rules/ArcanistPHPCloseTagXHPASTLinterRule.php',
     'ArcanistPHPCloseTagXHPASTLinterRuleTestCase' => 'lint/linter/xhpast/rules/__tests__/ArcanistPHPCloseTagXHPASTLinterRuleTestCase.php',
     'ArcanistPHPCompatibilityXHPASTLinterRule' => 'lint/linter/xhpast/rules/ArcanistPHPCompatibilityXHPASTLinterRule.php',
     'ArcanistPHPCompatibilityXHPASTLinterRuleTestCase' => 'lint/linter/xhpast/rules/__tests__/ArcanistPHPCompatibilityXHPASTLinterRuleTestCase.php',
     'ArcanistPHPEchoTagXHPASTLinterRule' => 'lint/linter/xhpast/rules/ArcanistPHPEchoTagXHPASTLinterRule.php',
     'ArcanistPHPEchoTagXHPASTLinterRuleTestCase' => 'lint/linter/xhpast/rules/__tests__/ArcanistPHPEchoTagXHPASTLinterRuleTestCase.php',
     'ArcanistPHPOpenTagXHPASTLinterRule' => 'lint/linter/xhpast/rules/ArcanistPHPOpenTagXHPASTLinterRule.php',
     'ArcanistPHPOpenTagXHPASTLinterRuleTestCase' => 'lint/linter/xhpast/rules/__tests__/ArcanistPHPOpenTagXHPASTLinterRuleTestCase.php',
     'ArcanistPHPShortTagXHPASTLinterRule' => 'lint/linter/xhpast/rules/ArcanistPHPShortTagXHPASTLinterRule.php',
     'ArcanistPHPShortTagXHPASTLinterRuleTestCase' => 'lint/linter/xhpast/rules/__tests__/ArcanistPHPShortTagXHPASTLinterRuleTestCase.php',
     'ArcanistPaamayimNekudotayimSpacingXHPASTLinterRule' => 'lint/linter/xhpast/rules/ArcanistPaamayimNekudotayimSpacingXHPASTLinterRule.php',
     'ArcanistPaamayimNekudotayimSpacingXHPASTLinterRuleTestCase' => 'lint/linter/xhpast/rules/__tests__/ArcanistPaamayimNekudotayimSpacingXHPASTLinterRuleTestCase.php',
     'ArcanistParentMemberReferenceXHPASTLinterRule' => 'lint/linter/xhpast/rules/ArcanistParentMemberReferenceXHPASTLinterRule.php',
     'ArcanistParentMemberReferenceXHPASTLinterRuleTestCase' => 'lint/linter/xhpast/rules/__tests__/ArcanistParentMemberReferenceXHPASTLinterRuleTestCase.php',
     'ArcanistParenthesesSpacingXHPASTLinterRule' => 'lint/linter/xhpast/rules/ArcanistParenthesesSpacingXHPASTLinterRule.php',
     'ArcanistParenthesesSpacingXHPASTLinterRuleTestCase' => 'lint/linter/xhpast/rules/__tests__/ArcanistParenthesesSpacingXHPASTLinterRuleTestCase.php',
     'ArcanistParseStrUseXHPASTLinterRule' => 'lint/linter/xhpast/rules/ArcanistParseStrUseXHPASTLinterRule.php',
     'ArcanistParseStrUseXHPASTLinterRuleTestCase' => 'lint/linter/xhpast/rules/__tests__/ArcanistParseStrUseXHPASTLinterRuleTestCase.php',
     'ArcanistPasteWorkflow' => 'workflow/ArcanistPasteWorkflow.php',
     'ArcanistPatchWorkflow' => 'workflow/ArcanistPatchWorkflow.php',
     'ArcanistPhpLinter' => 'lint/linter/ArcanistPhpLinter.php',
     'ArcanistPhpLinterTestCase' => 'lint/linter/__tests__/ArcanistPhpLinterTestCase.php',
     'ArcanistPhpcsLinter' => 'lint/linter/ArcanistPhpcsLinter.php',
     'ArcanistPhpcsLinterTestCase' => 'lint/linter/__tests__/ArcanistPhpcsLinterTestCase.php',
     'ArcanistPhpunitTestResultParser' => 'unit/parser/ArcanistPhpunitTestResultParser.php',
     'ArcanistPhrequentWorkflow' => 'workflow/ArcanistPhrequentWorkflow.php',
     'ArcanistPhutilLibraryLinter' => 'lint/linter/ArcanistPhutilLibraryLinter.php',
     'ArcanistPhutilXHPASTLinterStandard' => 'lint/linter/standards/phutil/ArcanistPhutilXHPASTLinterStandard.php',
     'ArcanistPlusOperatorOnStringsXHPASTLinterRule' => 'lint/linter/xhpast/rules/ArcanistPlusOperatorOnStringsXHPASTLinterRule.php',
     'ArcanistPlusOperatorOnStringsXHPASTLinterRuleTestCase' => 'lint/linter/xhpast/rules/__tests__/ArcanistPlusOperatorOnStringsXHPASTLinterRuleTestCase.php',
     'ArcanistPregQuoteMisuseXHPASTLinterRule' => 'lint/linter/xhpast/rules/ArcanistPregQuoteMisuseXHPASTLinterRule.php',
     'ArcanistPregQuoteMisuseXHPASTLinterRuleTestCase' => 'lint/linter/xhpast/rules/__tests__/ArcanistPregQuoteMisuseXHPASTLinterRuleTestCase.php',
     'ArcanistPublicPropertyXHPASTLinterRule' => 'lint/linter/xhpast/rules/ArcanistPublicPropertyXHPASTLinterRule.php',
     'ArcanistPublicPropertyXHPASTLinterRuleTestCase' => 'lint/linter/xhpast/rules/__tests__/ArcanistPublicPropertyXHPASTLinterRuleTestCase.php',
     'ArcanistPuppetLintLinter' => 'lint/linter/ArcanistPuppetLintLinter.php',
     'ArcanistPuppetLintLinterTestCase' => 'lint/linter/__tests__/ArcanistPuppetLintLinterTestCase.php',
     'ArcanistPyFlakesLinter' => 'lint/linter/ArcanistPyFlakesLinter.php',
     'ArcanistPyFlakesLinterTestCase' => 'lint/linter/__tests__/ArcanistPyFlakesLinterTestCase.php',
     'ArcanistPyLintLinter' => 'lint/linter/ArcanistPyLintLinter.php',
     'ArcanistPyLintLinterTestCase' => 'lint/linter/__tests__/ArcanistPyLintLinterTestCase.php',
     'ArcanistRaggedClassTreeEdgeXHPASTLinterRule' => 'lint/linter/xhpast/rules/ArcanistRaggedClassTreeEdgeXHPASTLinterRule.php',
     'ArcanistRaggedClassTreeEdgeXHPASTLinterRuleTestCase' => 'lint/linter/xhpast/rules/__tests__/ArcanistRaggedClassTreeEdgeXHPASTLinterRuleTestCase.php',
+    'ArcanistRef' => 'ref/ArcanistRef.php',
+    'ArcanistRefQuery' => 'ref/ArcanistRefQuery.php',
     'ArcanistRepositoryAPI' => 'repository/api/ArcanistRepositoryAPI.php',
     'ArcanistRepositoryAPIMiscTestCase' => 'repository/api/__tests__/ArcanistRepositoryAPIMiscTestCase.php',
     'ArcanistRepositoryAPIStateTestCase' => 'repository/api/__tests__/ArcanistRepositoryAPIStateTestCase.php',
+    'ArcanistRepositoryRef' => 'ref/ArcanistRepositoryRef.php',
     'ArcanistReusedAsIteratorXHPASTLinterRule' => 'lint/linter/xhpast/rules/ArcanistReusedAsIteratorXHPASTLinterRule.php',
     'ArcanistReusedAsIteratorXHPASTLinterRuleTestCase' => 'lint/linter/xhpast/rules/__tests__/ArcanistReusedAsIteratorXHPASTLinterRuleTestCase.php',
     'ArcanistReusedIteratorReferenceXHPASTLinterRule' => 'lint/linter/xhpast/rules/ArcanistReusedIteratorReferenceXHPASTLinterRule.php',
     'ArcanistReusedIteratorReferenceXHPASTLinterRuleTestCase' => 'lint/linter/xhpast/rules/__tests__/ArcanistReusedIteratorReferenceXHPASTLinterRuleTestCase.php',
     'ArcanistReusedIteratorXHPASTLinterRule' => 'lint/linter/xhpast/rules/ArcanistReusedIteratorXHPASTLinterRule.php',
     'ArcanistReusedIteratorXHPASTLinterRuleTestCase' => 'lint/linter/xhpast/rules/__tests__/ArcanistReusedIteratorXHPASTLinterRuleTestCase.php',
     'ArcanistRevertWorkflow' => 'workflow/ArcanistRevertWorkflow.php',
+    'ArcanistRevisionRef' => 'ref/ArcanistRevisionRef.php',
+    'ArcanistRevisionRefSource' => 'ref/ArcanistRevisionRefSource.php',
     'ArcanistRuboCopLinter' => 'lint/linter/ArcanistRuboCopLinter.php',
     'ArcanistRuboCopLinterTestCase' => 'lint/linter/__tests__/ArcanistRuboCopLinterTestCase.php',
     'ArcanistRubyLinter' => 'lint/linter/ArcanistRubyLinter.php',
     'ArcanistRubyLinterTestCase' => 'lint/linter/__tests__/ArcanistRubyLinterTestCase.php',
     'ArcanistScriptAndRegexLinter' => 'lint/linter/ArcanistScriptAndRegexLinter.php',
     'ArcanistSelfClassReferenceXHPASTLinterRule' => 'lint/linter/xhpast/rules/ArcanistSelfClassReferenceXHPASTLinterRule.php',
     'ArcanistSelfClassReferenceXHPASTLinterRuleTestCase' => 'lint/linter/xhpast/rules/__tests__/ArcanistSelfClassReferenceXHPASTLinterRuleTestCase.php',
     'ArcanistSelfMemberReferenceXHPASTLinterRule' => 'lint/linter/xhpast/rules/ArcanistSelfMemberReferenceXHPASTLinterRule.php',
     'ArcanistSelfMemberReferenceXHPASTLinterRuleTestCase' => 'lint/linter/xhpast/rules/__tests__/ArcanistSelfMemberReferenceXHPASTLinterRuleTestCase.php',
     'ArcanistSemicolonSpacingXHPASTLinterRule' => 'lint/linter/xhpast/rules/ArcanistSemicolonSpacingXHPASTLinterRule.php',
     'ArcanistSemicolonSpacingXHPASTLinterRuleTestCase' => 'lint/linter/xhpast/rules/__tests__/ArcanistSemicolonSpacingXHPASTLinterRuleTestCase.php',
     'ArcanistSetConfigWorkflow' => 'workflow/ArcanistSetConfigWorkflow.php',
+    'ArcanistSetting' => 'configuration/ArcanistSetting.php',
     'ArcanistSettings' => 'configuration/ArcanistSettings.php',
     'ArcanistShellCompleteWorkflow' => 'workflow/ArcanistShellCompleteWorkflow.php',
     'ArcanistSingleLintEngine' => 'lint/engine/ArcanistSingleLintEngine.php',
     'ArcanistSlownessXHPASTLinterRule' => 'lint/linter/xhpast/rules/ArcanistSlownessXHPASTLinterRule.php',
     'ArcanistSlownessXHPASTLinterRuleTestCase' => 'lint/linter/xhpast/rules/__tests__/ArcanistSlownessXHPASTLinterRuleTestCase.php',
     'ArcanistSpellingLinter' => 'lint/linter/ArcanistSpellingLinter.php',
     'ArcanistSpellingLinterTestCase' => 'lint/linter/__tests__/ArcanistSpellingLinterTestCase.php',
     'ArcanistStartWorkflow' => 'workflow/ArcanistStartWorkflow.php',
     'ArcanistStaticThisXHPASTLinterRule' => 'lint/linter/xhpast/rules/ArcanistStaticThisXHPASTLinterRule.php',
     'ArcanistStaticThisXHPASTLinterRuleTestCase' => 'lint/linter/xhpast/rules/__tests__/ArcanistStaticThisXHPASTLinterRuleTestCase.php',
     'ArcanistStopWorkflow' => 'workflow/ArcanistStopWorkflow.php',
     'ArcanistSubversionAPI' => 'repository/api/ArcanistSubversionAPI.php',
     'ArcanistSummaryLintRenderer' => 'lint/renderer/ArcanistSummaryLintRenderer.php',
     'ArcanistSyntaxErrorXHPASTLinterRule' => 'lint/linter/xhpast/rules/ArcanistSyntaxErrorXHPASTLinterRule.php',
     'ArcanistTasksWorkflow' => 'workflow/ArcanistTasksWorkflow.php',
     'ArcanistTautologicalExpressionXHPASTLinterRule' => 'lint/linter/xhpast/rules/ArcanistTautologicalExpressionXHPASTLinterRule.php',
     'ArcanistTautologicalExpressionXHPASTLinterRuleTestCase' => 'lint/linter/xhpast/rules/__tests__/ArcanistTautologicalExpressionXHPASTLinterRuleTestCase.php',
     'ArcanistTestResultParser' => 'unit/parser/ArcanistTestResultParser.php',
     'ArcanistTestXHPASTLintSwitchHook' => 'lint/linter/__tests__/ArcanistTestXHPASTLintSwitchHook.php',
     'ArcanistTextLinter' => 'lint/linter/ArcanistTextLinter.php',
     'ArcanistTextLinterTestCase' => 'lint/linter/__tests__/ArcanistTextLinterTestCase.php',
     'ArcanistThisReassignmentXHPASTLinterRule' => 'lint/linter/xhpast/rules/ArcanistThisReassignmentXHPASTLinterRule.php',
     'ArcanistThisReassignmentXHPASTLinterRuleTestCase' => 'lint/linter/xhpast/rules/__tests__/ArcanistThisReassignmentXHPASTLinterRuleTestCase.php',
     'ArcanistTimeWorkflow' => 'workflow/ArcanistTimeWorkflow.php',
     'ArcanistToStringExceptionXHPASTLinterRule' => 'lint/linter/xhpast/rules/ArcanistToStringExceptionXHPASTLinterRule.php',
     'ArcanistToStringExceptionXHPASTLinterRuleTestCase' => 'lint/linter/xhpast/rules/__tests__/ArcanistToStringExceptionXHPASTLinterRuleTestCase.php',
     'ArcanistTodoCommentXHPASTLinterRule' => 'lint/linter/xhpast/rules/ArcanistTodoCommentXHPASTLinterRule.php',
     'ArcanistTodoCommentXHPASTLinterRuleTestCase' => 'lint/linter/xhpast/rules/__tests__/ArcanistTodoCommentXHPASTLinterRuleTestCase.php',
     'ArcanistTodoWorkflow' => 'workflow/ArcanistTodoWorkflow.php',
     'ArcanistUSEnglishTranslation' => 'internationalization/ArcanistUSEnglishTranslation.php',
     'ArcanistUnableToParseXHPASTLinterRule' => 'lint/linter/xhpast/rules/ArcanistUnableToParseXHPASTLinterRule.php',
     'ArcanistUnaryPostfixExpressionSpacingXHPASTLinterRule' => 'lint/linter/xhpast/rules/ArcanistUnaryPostfixExpressionSpacingXHPASTLinterRule.php',
     'ArcanistUnaryPostfixExpressionSpacingXHPASTLinterRuleTestCase' => 'lint/linter/xhpast/rules/__tests__/ArcanistUnaryPostfixExpressionSpacingXHPASTLinterRuleTestCase.php',
     'ArcanistUnaryPrefixExpressionSpacingXHPASTLinterRule' => 'lint/linter/xhpast/rules/ArcanistUnaryPrefixExpressionSpacingXHPASTLinterRule.php',
     'ArcanistUnaryPrefixExpressionSpacingXHPASTLinterRuleTestCase' => 'lint/linter/xhpast/rules/__tests__/ArcanistUnaryPrefixExpressionSpacingXHPASTLinterRuleTestCase.php',
     'ArcanistUndeclaredVariableXHPASTLinterRule' => 'lint/linter/xhpast/rules/ArcanistUndeclaredVariableXHPASTLinterRule.php',
     'ArcanistUndeclaredVariableXHPASTLinterRuleTestCase' => 'lint/linter/xhpast/rules/__tests__/ArcanistUndeclaredVariableXHPASTLinterRuleTestCase.php',
     'ArcanistUnexpectedReturnValueXHPASTLinterRule' => 'lint/linter/xhpast/rules/ArcanistUnexpectedReturnValueXHPASTLinterRule.php',
     'ArcanistUnexpectedReturnValueXHPASTLinterRuleTestCase' => 'lint/linter/xhpast/rules/__tests__/ArcanistUnexpectedReturnValueXHPASTLinterRuleTestCase.php',
     'ArcanistUnitConsoleRenderer' => 'unit/renderer/ArcanistUnitConsoleRenderer.php',
     'ArcanistUnitRenderer' => 'unit/renderer/ArcanistUnitRenderer.php',
     'ArcanistUnitTestEngine' => 'unit/engine/ArcanistUnitTestEngine.php',
     'ArcanistUnitTestResult' => 'unit/ArcanistUnitTestResult.php',
     'ArcanistUnitTestResultTestCase' => 'unit/__tests__/ArcanistUnitTestResultTestCase.php',
     'ArcanistUnitTestableLintEngine' => 'lint/engine/ArcanistUnitTestableLintEngine.php',
     'ArcanistUnitWorkflow' => 'workflow/ArcanistUnitWorkflow.php',
     'ArcanistUnnecessaryFinalModifierXHPASTLinterRule' => 'lint/linter/xhpast/rules/ArcanistUnnecessaryFinalModifierXHPASTLinterRule.php',
     'ArcanistUnnecessaryFinalModifierXHPASTLinterRuleTestCase' => 'lint/linter/xhpast/rules/__tests__/ArcanistUnnecessaryFinalModifierXHPASTLinterRuleTestCase.php',
     'ArcanistUnnecessarySemicolonXHPASTLinterRule' => 'lint/linter/xhpast/rules/ArcanistUnnecessarySemicolonXHPASTLinterRule.php',
     'ArcanistUnnecessarySymbolAliasXHPASTLinterRule' => 'lint/linter/xhpast/rules/ArcanistUnnecessarySymbolAliasXHPASTLinterRule.php',
     'ArcanistUnnecessarySymbolAliasXHPASTLinterRuleTestCase' => 'lint/linter/xhpast/rules/__tests__/ArcanistUnnecessarySymbolAliasXHPASTLinterRuleTestCase.php',
     'ArcanistUnsafeDynamicStringXHPASTLinterRule' => 'lint/linter/xhpast/rules/ArcanistUnsafeDynamicStringXHPASTLinterRule.php',
     'ArcanistUnsafeDynamicStringXHPASTLinterRuleTestCase' => 'lint/linter/xhpast/rules/__tests__/ArcanistUnsafeDynamicStringXHPASTLinterRuleTestCase.php',
     'ArcanistUpgradeWorkflow' => 'workflow/ArcanistUpgradeWorkflow.php',
     'ArcanistUploadWorkflow' => 'workflow/ArcanistUploadWorkflow.php',
     'ArcanistUsageException' => 'exception/ArcanistUsageException.php',
     'ArcanistUseStatementNamespacePrefixXHPASTLinterRule' => 'lint/linter/xhpast/rules/ArcanistUseStatementNamespacePrefixXHPASTLinterRule.php',
     'ArcanistUseStatementNamespacePrefixXHPASTLinterRuleTestCase' => 'lint/linter/xhpast/rules/__tests__/ArcanistUseStatementNamespacePrefixXHPASTLinterRuleTestCase.php',
     'ArcanistUselessOverridingMethodXHPASTLinterRule' => 'lint/linter/xhpast/rules/ArcanistUselessOverridingMethodXHPASTLinterRule.php',
     'ArcanistUselessOverridingMethodXHPASTLinterRuleTestCase' => 'lint/linter/xhpast/rules/__tests__/ArcanistUselessOverridingMethodXHPASTLinterRuleTestCase.php',
     'ArcanistUserAbortException' => 'exception/usage/ArcanistUserAbortException.php',
     'ArcanistVariableReferenceSpacingXHPASTLinterRule' => 'lint/linter/xhpast/rules/ArcanistVariableReferenceSpacingXHPASTLinterRule.php',
     'ArcanistVariableReferenceSpacingXHPASTLinterRuleTestCase' => 'lint/linter/xhpast/rules/__tests__/ArcanistVariableReferenceSpacingXHPASTLinterRuleTestCase.php',
     'ArcanistVariableVariableXHPASTLinterRule' => 'lint/linter/xhpast/rules/ArcanistVariableVariableXHPASTLinterRule.php',
     'ArcanistVariableVariableXHPASTLinterRuleTestCase' => 'lint/linter/xhpast/rules/__tests__/ArcanistVariableVariableXHPASTLinterRuleTestCase.php',
     'ArcanistVersionWorkflow' => 'workflow/ArcanistVersionWorkflow.php',
     'ArcanistWeldWorkflow' => 'workflow/ArcanistWeldWorkflow.php',
     'ArcanistWhichWorkflow' => 'workflow/ArcanistWhichWorkflow.php',
     'ArcanistWorkflow' => 'workflow/ArcanistWorkflow.php',
     'ArcanistWorkingCopyIdentity' => 'workingcopyidentity/ArcanistWorkingCopyIdentity.php',
+    'ArcanistWorkingCopyStateRef' => 'ref/ArcanistWorkingCopyStateRef.php',
     'ArcanistXHPASTLintNamingHook' => 'lint/linter/xhpast/ArcanistXHPASTLintNamingHook.php',
     'ArcanistXHPASTLintNamingHookTestCase' => 'lint/linter/xhpast/__tests__/ArcanistXHPASTLintNamingHookTestCase.php',
     'ArcanistXHPASTLintSwitchHook' => 'lint/linter/xhpast/ArcanistXHPASTLintSwitchHook.php',
     'ArcanistXHPASTLinter' => 'lint/linter/ArcanistXHPASTLinter.php',
     'ArcanistXHPASTLinterRule' => 'lint/linter/xhpast/ArcanistXHPASTLinterRule.php',
     'ArcanistXHPASTLinterRuleTestCase' => 'lint/linter/xhpast/rules/__tests__/ArcanistXHPASTLinterRuleTestCase.php',
     'ArcanistXHPASTLinterTestCase' => 'lint/linter/__tests__/ArcanistXHPASTLinterTestCase.php',
     'ArcanistXMLLinter' => 'lint/linter/ArcanistXMLLinter.php',
     'ArcanistXMLLinterTestCase' => 'lint/linter/__tests__/ArcanistXMLLinterTestCase.php',
     'ArcanistXUnitTestResultParser' => 'unit/parser/ArcanistXUnitTestResultParser.php',
     'BaseHTTPFuture' => 'future/http/BaseHTTPFuture.php',
     'CSharpToolsTestEngine' => 'unit/engine/CSharpToolsTestEngine.php',
     'CaseInsensitiveArray' => 'utils/CaseInsensitiveArray.php',
     'CaseInsensitiveArrayTestCase' => 'utils/__tests__/CaseInsensitiveArrayTestCase.php',
     'CommandException' => 'future/exec/CommandException.php',
     'ConduitClient' => 'conduit/ConduitClient.php',
     'ConduitClientException' => 'conduit/ConduitClientException.php',
     'ConduitClientTestCase' => 'conduit/__tests__/ConduitClientTestCase.php',
     'ConduitFuture' => 'conduit/ConduitFuture.php',
     'ExecFuture' => 'future/exec/ExecFuture.php',
     'ExecFutureTestCase' => 'future/exec/__tests__/ExecFutureTestCase.php',
     'ExecPassthruTestCase' => 'future/exec/__tests__/ExecPassthruTestCase.php',
     'FileFinder' => 'filesystem/FileFinder.php',
     'FileFinderTestCase' => 'filesystem/__tests__/FileFinderTestCase.php',
     'FileList' => 'filesystem/FileList.php',
     'Filesystem' => 'filesystem/Filesystem.php',
     'FilesystemException' => 'filesystem/FilesystemException.php',
     'FilesystemTestCase' => 'filesystem/__tests__/FilesystemTestCase.php',
     'Future' => 'future/Future.php',
     'FutureIterator' => 'future/FutureIterator.php',
     'FutureIteratorTestCase' => 'future/__tests__/FutureIteratorTestCase.php',
     'FutureProxy' => 'future/FutureProxy.php',
     'HTTPFuture' => 'future/http/HTTPFuture.php',
     'HTTPFutureCURLResponseStatus' => 'future/http/status/HTTPFutureCURLResponseStatus.php',
     'HTTPFutureCertificateResponseStatus' => 'future/http/status/HTTPFutureCertificateResponseStatus.php',
     'HTTPFutureHTTPResponseStatus' => 'future/http/status/HTTPFutureHTTPResponseStatus.php',
     'HTTPFutureParseResponseStatus' => 'future/http/status/HTTPFutureParseResponseStatus.php',
     'HTTPFutureResponseStatus' => 'future/http/status/HTTPFutureResponseStatus.php',
     'HTTPFutureTransportResponseStatus' => 'future/http/status/HTTPFutureTransportResponseStatus.php',
     'HTTPSFuture' => 'future/http/HTTPSFuture.php',
     'ImmediateFuture' => 'future/ImmediateFuture.php',
     'LibphutilUSEnglishTranslation' => 'internationalization/translation/LibphutilUSEnglishTranslation.php',
     'LinesOfALarge' => 'filesystem/linesofalarge/LinesOfALarge.php',
     'LinesOfALargeExecFuture' => 'filesystem/linesofalarge/LinesOfALargeExecFuture.php',
     'LinesOfALargeExecFutureTestCase' => 'filesystem/linesofalarge/__tests__/LinesOfALargeExecFutureTestCase.php',
     'LinesOfALargeFile' => 'filesystem/linesofalarge/LinesOfALargeFile.php',
     'LinesOfALargeFileTestCase' => 'filesystem/linesofalarge/__tests__/LinesOfALargeFileTestCase.php',
     'MFilterTestHelper' => 'utils/__tests__/MFilterTestHelper.php',
     'NoseTestEngine' => 'unit/engine/NoseTestEngine.php',
     'PHPASTParserTestCase' => 'parser/xhpast/__tests__/PHPASTParserTestCase.php',
     'PhageAction' => 'phage/action/PhageAction.php',
     'PhageAgentAction' => 'phage/action/PhageAgentAction.php',
     'PhageAgentBootloader' => 'phage/bootloader/PhageAgentBootloader.php',
     'PhageAgentTestCase' => 'phage/__tests__/PhageAgentTestCase.php',
     'PhageExecuteAction' => 'phage/action/PhageExecuteAction.php',
     'PhageLocalAction' => 'phage/action/PhageLocalAction.php',
     'PhagePHPAgent' => 'phage/agent/PhagePHPAgent.php',
     'PhagePHPAgentBootloader' => 'phage/bootloader/PhagePHPAgentBootloader.php',
     'PhagePlanAction' => 'phage/action/PhagePlanAction.php',
     'PhageWorkflow' => 'phage/workflow/PhageWorkflow.php',
     'Phobject' => 'object/Phobject.php',
     'PhobjectTestCase' => 'object/__tests__/PhobjectTestCase.php',
     'PhpunitTestEngine' => 'unit/engine/PhpunitTestEngine.php',
     'PhpunitTestEngineTestCase' => 'unit/engine/__tests__/PhpunitTestEngineTestCase.php',
     'PhutilAWSCloudFormationFuture' => 'future/aws/PhutilAWSCloudFormationFuture.php',
     'PhutilAWSCloudWatchFuture' => 'future/aws/PhutilAWSCloudWatchFuture.php',
     'PhutilAWSEC2Future' => 'future/aws/PhutilAWSEC2Future.php',
     'PhutilAWSException' => 'future/aws/PhutilAWSException.php',
     'PhutilAWSFuture' => 'future/aws/PhutilAWSFuture.php',
     'PhutilAWSManagementWorkflow' => 'future/aws/management/PhutilAWSManagementWorkflow.php',
     'PhutilAWSS3DeleteManagementWorkflow' => 'future/aws/management/PhutilAWSS3DeleteManagementWorkflow.php',
     'PhutilAWSS3Future' => 'future/aws/PhutilAWSS3Future.php',
     'PhutilAWSS3GetManagementWorkflow' => 'future/aws/management/PhutilAWSS3GetManagementWorkflow.php',
     'PhutilAWSS3ManagementWorkflow' => 'future/aws/management/PhutilAWSS3ManagementWorkflow.php',
     'PhutilAWSS3PutManagementWorkflow' => 'future/aws/management/PhutilAWSS3PutManagementWorkflow.php',
     'PhutilAWSv4Signature' => 'future/aws/PhutilAWSv4Signature.php',
     'PhutilAWSv4SignatureTestCase' => 'future/aws/__tests__/PhutilAWSv4SignatureTestCase.php',
     'PhutilAggregateException' => 'error/PhutilAggregateException.php',
     'PhutilAllCapsEnglishLocale' => 'internationalization/locales/PhutilAllCapsEnglishLocale.php',
     'PhutilArgumentParser' => 'parser/argument/PhutilArgumentParser.php',
     'PhutilArgumentParserException' => 'parser/argument/exception/PhutilArgumentParserException.php',
     'PhutilArgumentParserTestCase' => 'parser/argument/__tests__/PhutilArgumentParserTestCase.php',
     'PhutilArgumentSpecification' => 'parser/argument/PhutilArgumentSpecification.php',
     'PhutilArgumentSpecificationException' => 'parser/argument/exception/PhutilArgumentSpecificationException.php',
     'PhutilArgumentSpecificationTestCase' => 'parser/argument/__tests__/PhutilArgumentSpecificationTestCase.php',
     'PhutilArgumentSpellingCorrector' => 'parser/argument/PhutilArgumentSpellingCorrector.php',
     'PhutilArgumentSpellingCorrectorTestCase' => 'parser/argument/__tests__/PhutilArgumentSpellingCorrectorTestCase.php',
     'PhutilArgumentUsageException' => 'parser/argument/exception/PhutilArgumentUsageException.php',
     'PhutilArgumentWorkflow' => 'parser/argument/workflow/PhutilArgumentWorkflow.php',
     'PhutilArray' => 'utils/PhutilArray.php',
     'PhutilArrayTestCase' => 'utils/__tests__/PhutilArrayTestCase.php',
     'PhutilArrayWithDefaultValue' => 'utils/PhutilArrayWithDefaultValue.php',
     'PhutilAsanaFuture' => 'future/asana/PhutilAsanaFuture.php',
     'PhutilBacktraceSignalHandler' => 'future/exec/PhutilBacktraceSignalHandler.php',
     'PhutilBallOfPHP' => 'phage/util/PhutilBallOfPHP.php',
     'PhutilBinaryAnalyzer' => 'filesystem/binary/PhutilBinaryAnalyzer.php',
     'PhutilBinaryAnalyzerTestCase' => 'filesystem/binary/__tests__/PhutilBinaryAnalyzerTestCase.php',
     'PhutilBootloader' => 'init/lib/PhutilBootloader.php',
     'PhutilBootloaderException' => 'init/lib/PhutilBootloaderException.php',
     'PhutilBritishEnglishLocale' => 'internationalization/locales/PhutilBritishEnglishLocale.php',
     'PhutilBufferedIterator' => 'utils/PhutilBufferedIterator.php',
     'PhutilBufferedIteratorTestCase' => 'utils/__tests__/PhutilBufferedIteratorTestCase.php',
     'PhutilBugtraqParser' => 'parser/PhutilBugtraqParser.php',
     'PhutilBugtraqParserTestCase' => 'parser/__tests__/PhutilBugtraqParserTestCase.php',
     'PhutilCIDRBlock' => 'ip/PhutilCIDRBlock.php',
     'PhutilCIDRList' => 'ip/PhutilCIDRList.php',
     'PhutilCallbackFilterIterator' => 'utils/PhutilCallbackFilterIterator.php',
     'PhutilCallbackSignalHandler' => 'future/exec/PhutilCallbackSignalHandler.php',
     'PhutilChannel' => 'channel/PhutilChannel.php',
     'PhutilChannelChannel' => 'channel/PhutilChannelChannel.php',
     'PhutilChannelTestCase' => 'channel/__tests__/PhutilChannelTestCase.php',
     'PhutilChunkedIterator' => 'utils/PhutilChunkedIterator.php',
     'PhutilChunkedIteratorTestCase' => 'utils/__tests__/PhutilChunkedIteratorTestCase.php',
     'PhutilClassMapQuery' => 'symbols/PhutilClassMapQuery.php',
     'PhutilCloudWatchMetric' => 'future/aws/PhutilCloudWatchMetric.php',
     'PhutilCommandString' => 'xsprintf/PhutilCommandString.php',
     'PhutilConsole' => 'console/PhutilConsole.php',
     'PhutilConsoleBlock' => 'console/view/PhutilConsoleBlock.php',
     'PhutilConsoleError' => 'console/view/PhutilConsoleError.php',
     'PhutilConsoleFormatter' => 'console/PhutilConsoleFormatter.php',
     'PhutilConsoleInfo' => 'console/view/PhutilConsoleInfo.php',
     'PhutilConsoleList' => 'console/view/PhutilConsoleList.php',
     'PhutilConsoleLogLine' => 'console/view/PhutilConsoleLogLine.php',
     'PhutilConsoleMessage' => 'console/PhutilConsoleMessage.php',
     'PhutilConsoleMetrics' => 'console/PhutilConsoleMetrics.php',
     'PhutilConsoleMetricsSignalHandler' => 'future/exec/PhutilConsoleMetricsSignalHandler.php',
     'PhutilConsoleProgressBar' => 'console/PhutilConsoleProgressBar.php',
     'PhutilConsoleProgressSink' => 'progress/PhutilConsoleProgressSink.php',
     'PhutilConsoleServer' => 'console/PhutilConsoleServer.php',
     'PhutilConsoleServerChannel' => 'console/PhutilConsoleServerChannel.php',
     'PhutilConsoleSkip' => 'console/view/PhutilConsoleSkip.php',
     'PhutilConsoleStdinNotInteractiveException' => 'console/PhutilConsoleStdinNotInteractiveException.php',
     'PhutilConsoleTable' => 'console/view/PhutilConsoleTable.php',
     'PhutilConsoleView' => 'console/view/PhutilConsoleView.php',
     'PhutilConsoleWarning' => 'console/view/PhutilConsoleWarning.php',
     'PhutilConsoleWrapTestCase' => 'console/__tests__/PhutilConsoleWrapTestCase.php',
     'PhutilCowsay' => 'utils/PhutilCowsay.php',
     'PhutilCowsayTestCase' => 'utils/__tests__/PhutilCowsayTestCase.php',
     'PhutilCsprintfTestCase' => 'xsprintf/__tests__/PhutilCsprintfTestCase.php',
     'PhutilCzechLocale' => 'internationalization/locales/PhutilCzechLocale.php',
     'PhutilDOMNode' => 'parser/html/PhutilDOMNode.php',
     'PhutilDeferredLog' => 'filesystem/PhutilDeferredLog.php',
     'PhutilDeferredLogTestCase' => 'filesystem/__tests__/PhutilDeferredLogTestCase.php',
     'PhutilDiffBinaryAnalyzer' => 'filesystem/binary/PhutilDiffBinaryAnalyzer.php',
     'PhutilDirectedScalarGraph' => 'utils/PhutilDirectedScalarGraph.php',
     'PhutilDirectoryFixture' => 'filesystem/PhutilDirectoryFixture.php',
     'PhutilDocblockParser' => 'parser/PhutilDocblockParser.php',
     'PhutilDocblockParserTestCase' => 'parser/__tests__/PhutilDocblockParserTestCase.php',
     'PhutilEditDistanceMatrix' => 'utils/PhutilEditDistanceMatrix.php',
     'PhutilEditDistanceMatrixTestCase' => 'utils/__tests__/PhutilEditDistanceMatrixTestCase.php',
     'PhutilEditorConfig' => 'parser/PhutilEditorConfig.php',
     'PhutilEditorConfigTestCase' => 'parser/__tests__/PhutilEditorConfigTestCase.php',
     'PhutilEmailAddress' => 'parser/PhutilEmailAddress.php',
     'PhutilEmailAddressTestCase' => 'parser/__tests__/PhutilEmailAddressTestCase.php',
     'PhutilEmojiLocale' => 'internationalization/locales/PhutilEmojiLocale.php',
     'PhutilEnglishCanadaLocale' => 'internationalization/locales/PhutilEnglishCanadaLocale.php',
     'PhutilErrorHandler' => 'error/PhutilErrorHandler.php',
     'PhutilErrorHandlerTestCase' => 'error/__tests__/PhutilErrorHandlerTestCase.php',
     'PhutilErrorTrap' => 'error/PhutilErrorTrap.php',
     'PhutilEvent' => 'events/PhutilEvent.php',
     'PhutilEventConstants' => 'events/constant/PhutilEventConstants.php',
     'PhutilEventEngine' => 'events/PhutilEventEngine.php',
     'PhutilEventListener' => 'events/PhutilEventListener.php',
     'PhutilEventType' => 'events/constant/PhutilEventType.php',
     'PhutilExampleBufferedIterator' => 'utils/PhutilExampleBufferedIterator.php',
     'PhutilExecChannel' => 'channel/PhutilExecChannel.php',
     'PhutilExecPassthru' => 'future/exec/PhutilExecPassthru.php',
     'PhutilExecutableFuture' => 'future/exec/PhutilExecutableFuture.php',
     'PhutilExecutionEnvironment' => 'utils/PhutilExecutionEnvironment.php',
     'PhutilFileLock' => 'filesystem/PhutilFileLock.php',
     'PhutilFileLockTestCase' => 'filesystem/__tests__/PhutilFileLockTestCase.php',
     'PhutilFileTree' => 'filesystem/PhutilFileTree.php',
     'PhutilFrenchLocale' => 'internationalization/locales/PhutilFrenchLocale.php',
     'PhutilGermanLocale' => 'internationalization/locales/PhutilGermanLocale.php',
     'PhutilGitBinaryAnalyzer' => 'filesystem/binary/PhutilGitBinaryAnalyzer.php',
     'PhutilGitHubFuture' => 'future/github/PhutilGitHubFuture.php',
     'PhutilGitHubResponse' => 'future/github/PhutilGitHubResponse.php',
     'PhutilGitURI' => 'parser/PhutilGitURI.php',
     'PhutilGitURITestCase' => 'parser/__tests__/PhutilGitURITestCase.php',
     'PhutilHTMLParser' => 'parser/html/PhutilHTMLParser.php',
     'PhutilHTMLParserTestCase' => 'parser/html/__tests__/PhutilHTMLParserTestCase.php',
     'PhutilHTTPEngineExtension' => 'future/http/PhutilHTTPEngineExtension.php',
     'PhutilHTTPResponse' => 'parser/http/PhutilHTTPResponse.php',
     'PhutilHTTPResponseParser' => 'parser/http/PhutilHTTPResponseParser.php',
     'PhutilHTTPResponseParserTestCase' => 'parser/http/__tests__/PhutilHTTPResponseParserTestCase.php',
     'PhutilHashingIterator' => 'utils/PhutilHashingIterator.php',
     'PhutilHashingIteratorTestCase' => 'utils/__tests__/PhutilHashingIteratorTestCase.php',
     'PhutilHelpArgumentWorkflow' => 'parser/argument/workflow/PhutilHelpArgumentWorkflow.php',
     'PhutilHgsprintfTestCase' => 'xsprintf/__tests__/PhutilHgsprintfTestCase.php',
     'PhutilINIParserException' => 'parser/exception/PhutilINIParserException.php',
     'PhutilIPAddress' => 'ip/PhutilIPAddress.php',
     'PhutilIPAddressTestCase' => 'ip/__tests__/PhutilIPAddressTestCase.php',
     'PhutilIPv4Address' => 'ip/PhutilIPv4Address.php',
     'PhutilIPv6Address' => 'ip/PhutilIPv6Address.php',
     'PhutilInteractiveEditor' => 'console/PhutilInteractiveEditor.php',
     'PhutilInvalidRuleParserGeneratorException' => 'parser/generator/exception/PhutilInvalidRuleParserGeneratorException.php',
     'PhutilInvalidStateException' => 'exception/PhutilInvalidStateException.php',
     'PhutilInvalidStateExceptionTestCase' => 'exception/__tests__/PhutilInvalidStateExceptionTestCase.php',
     'PhutilIrreducibleRuleParserGeneratorException' => 'parser/generator/exception/PhutilIrreducibleRuleParserGeneratorException.php',
     'PhutilJSON' => 'parser/PhutilJSON.php',
     'PhutilJSONFragmentLexer' => 'lexer/PhutilJSONFragmentLexer.php',
     'PhutilJSONParser' => 'parser/PhutilJSONParser.php',
     'PhutilJSONParserException' => 'parser/exception/PhutilJSONParserException.php',
     'PhutilJSONParserTestCase' => 'parser/__tests__/PhutilJSONParserTestCase.php',
     'PhutilJSONProtocolChannel' => 'channel/PhutilJSONProtocolChannel.php',
     'PhutilJSONProtocolChannelTestCase' => 'channel/__tests__/PhutilJSONProtocolChannelTestCase.php',
     'PhutilJSONTestCase' => 'parser/__tests__/PhutilJSONTestCase.php',
     'PhutilJavaFragmentLexer' => 'lexer/PhutilJavaFragmentLexer.php',
     'PhutilKoreanLocale' => 'internationalization/locales/PhutilKoreanLocale.php',
     'PhutilLanguageGuesser' => 'parser/PhutilLanguageGuesser.php',
     'PhutilLanguageGuesserTestCase' => 'parser/__tests__/PhutilLanguageGuesserTestCase.php',
     'PhutilLexer' => 'lexer/PhutilLexer.php',
     'PhutilLibraryConflictException' => 'init/lib/PhutilLibraryConflictException.php',
     'PhutilLibraryMapBuilder' => 'moduleutils/PhutilLibraryMapBuilder.php',
     'PhutilLibraryTestCase' => '__tests__/PhutilLibraryTestCase.php',
     'PhutilLocale' => 'internationalization/PhutilLocale.php',
     'PhutilLocaleTestCase' => 'internationalization/__tests__/PhutilLocaleTestCase.php',
     'PhutilLock' => 'filesystem/PhutilLock.php',
     'PhutilLockException' => 'filesystem/PhutilLockException.php',
     'PhutilLogFileChannel' => 'channel/PhutilLogFileChannel.php',
     'PhutilLunarPhase' => 'utils/PhutilLunarPhase.php',
     'PhutilLunarPhaseTestCase' => 'utils/__tests__/PhutilLunarPhaseTestCase.php',
     'PhutilMercurialBinaryAnalyzer' => 'filesystem/binary/PhutilMercurialBinaryAnalyzer.php',
     'PhutilMethodNotImplementedException' => 'error/PhutilMethodNotImplementedException.php',
     'PhutilMetricsChannel' => 'channel/PhutilMetricsChannel.php',
     'PhutilMissingSymbolException' => 'init/lib/PhutilMissingSymbolException.php',
     'PhutilModuleUtilsTestCase' => 'init/lib/__tests__/PhutilModuleUtilsTestCase.php',
     'PhutilNumber' => 'internationalization/PhutilNumber.php',
     'PhutilOAuth1Future' => 'future/oauth/PhutilOAuth1Future.php',
     'PhutilOAuth1FutureTestCase' => 'future/oauth/__tests__/PhutilOAuth1FutureTestCase.php',
     'PhutilOpaqueEnvelope' => 'error/PhutilOpaqueEnvelope.php',
     'PhutilOpaqueEnvelopeKey' => 'error/PhutilOpaqueEnvelopeKey.php',
     'PhutilOpaqueEnvelopeTestCase' => 'error/__tests__/PhutilOpaqueEnvelopeTestCase.php',
     'PhutilPHPFragmentLexer' => 'lexer/PhutilPHPFragmentLexer.php',
     'PhutilPHPFragmentLexerTestCase' => 'lexer/__tests__/PhutilPHPFragmentLexerTestCase.php',
     'PhutilPHPObjectProtocolChannel' => 'channel/PhutilPHPObjectProtocolChannel.php',
     'PhutilPHPObjectProtocolChannelTestCase' => 'channel/__tests__/PhutilPHPObjectProtocolChannelTestCase.php',
     'PhutilParserGenerator' => 'parser/PhutilParserGenerator.php',
     'PhutilParserGeneratorException' => 'parser/generator/exception/PhutilParserGeneratorException.php',
     'PhutilParserGeneratorTestCase' => 'parser/__tests__/PhutilParserGeneratorTestCase.php',
     'PhutilPayPalAPIFuture' => 'future/paypal/PhutilPayPalAPIFuture.php',
     'PhutilPerson' => 'internationalization/PhutilPerson.php',
     'PhutilPersonTest' => 'internationalization/__tests__/PhutilPersonTest.php',
     'PhutilPhtTestCase' => 'internationalization/__tests__/PhutilPhtTestCase.php',
     'PhutilPirateEnglishLocale' => 'internationalization/locales/PhutilPirateEnglishLocale.php',
     'PhutilPortugueseBrazilLocale' => 'internationalization/locales/PhutilPortugueseBrazilLocale.php',
     'PhutilPortuguesePortugalLocale' => 'internationalization/locales/PhutilPortuguesePortugalLocale.php',
     'PhutilPostmarkFuture' => 'future/postmark/PhutilPostmarkFuture.php',
     'PhutilPregsprintfTestCase' => 'xsprintf/__tests__/PhutilPregsprintfTestCase.php',
     'PhutilProcessQuery' => 'filesystem/PhutilProcessQuery.php',
     'PhutilProcessRef' => 'filesystem/PhutilProcessRef.php',
     'PhutilProcessRefTestCase' => 'filesystem/__tests__/PhutilProcessRefTestCase.php',
     'PhutilProgressSink' => 'progress/PhutilProgressSink.php',
     'PhutilProtocolChannel' => 'channel/PhutilProtocolChannel.php',
     'PhutilProxyException' => 'error/PhutilProxyException.php',
     'PhutilProxyIterator' => 'utils/PhutilProxyIterator.php',
     'PhutilPygmentizeBinaryAnalyzer' => 'filesystem/binary/PhutilPygmentizeBinaryAnalyzer.php',
     'PhutilPythonFragmentLexer' => 'lexer/PhutilPythonFragmentLexer.php',
     'PhutilQueryStringParser' => 'parser/PhutilQueryStringParser.php',
     'PhutilQueryStringParserTestCase' => 'parser/__tests__/PhutilQueryStringParserTestCase.php',
     'PhutilRawEnglishLocale' => 'internationalization/locales/PhutilRawEnglishLocale.php',
     'PhutilReadableSerializer' => 'readableserializer/PhutilReadableSerializer.php',
     'PhutilReadableSerializerTestCase' => 'readableserializer/__tests__/PhutilReadableSerializerTestCase.php',
     'PhutilRope' => 'utils/PhutilRope.php',
     'PhutilRopeTestCase' => 'utils/__tests__/PhutilRopeTestCase.php',
     'PhutilServiceProfiler' => 'serviceprofiler/PhutilServiceProfiler.php',
     'PhutilShellLexer' => 'lexer/PhutilShellLexer.php',
     'PhutilShellLexerTestCase' => 'lexer/__tests__/PhutilShellLexerTestCase.php',
     'PhutilSignalHandler' => 'future/exec/PhutilSignalHandler.php',
     'PhutilSignalRouter' => 'future/exec/PhutilSignalRouter.php',
     'PhutilSimpleOptions' => 'parser/PhutilSimpleOptions.php',
     'PhutilSimpleOptionsLexer' => 'lexer/PhutilSimpleOptionsLexer.php',
     'PhutilSimpleOptionsLexerTestCase' => 'lexer/__tests__/PhutilSimpleOptionsLexerTestCase.php',
     'PhutilSimpleOptionsTestCase' => 'parser/__tests__/PhutilSimpleOptionsTestCase.php',
     'PhutilSimplifiedChineseLocale' => 'internationalization/locales/PhutilSimplifiedChineseLocale.php',
     'PhutilSlackFuture' => 'future/slack/PhutilSlackFuture.php',
     'PhutilSocketChannel' => 'channel/PhutilSocketChannel.php',
     'PhutilSortVector' => 'utils/PhutilSortVector.php',
     'PhutilSpanishSpainLocale' => 'internationalization/locales/PhutilSpanishSpainLocale.php',
     'PhutilStreamIterator' => 'utils/PhutilStreamIterator.php',
     'PhutilSubversionBinaryAnalyzer' => 'filesystem/binary/PhutilSubversionBinaryAnalyzer.php',
     'PhutilSymbolLoader' => 'symbols/PhutilSymbolLoader.php',
     'PhutilSystem' => 'utils/PhutilSystem.php',
     'PhutilSystemTestCase' => 'utils/__tests__/PhutilSystemTestCase.php',
     'PhutilTerminalString' => 'xsprintf/PhutilTerminalString.php',
     'PhutilTestCase' => 'unit/engine/phutil/PhutilTestCase.php',
     'PhutilTestCaseTestCase' => 'unit/engine/phutil/testcase/PhutilTestCaseTestCase.php',
     'PhutilTestPhobject' => 'object/__tests__/PhutilTestPhobject.php',
     'PhutilTestSkippedException' => 'unit/engine/phutil/testcase/PhutilTestSkippedException.php',
     'PhutilTestTerminatedException' => 'unit/engine/phutil/testcase/PhutilTestTerminatedException.php',
     'PhutilTraditionalChineseLocale' => 'internationalization/locales/PhutilTraditionalChineseLocale.php',
     'PhutilTranslation' => 'internationalization/PhutilTranslation.php',
     'PhutilTranslationTestCase' => 'internationalization/__tests__/PhutilTranslationTestCase.php',
     'PhutilTranslator' => 'internationalization/PhutilTranslator.php',
     'PhutilTranslatorTestCase' => 'internationalization/__tests__/PhutilTranslatorTestCase.php',
     'PhutilTsprintfTestCase' => 'xsprintf/__tests__/PhutilTsprintfTestCase.php',
     'PhutilTwitchFuture' => 'future/twitch/PhutilTwitchFuture.php',
     'PhutilTypeCheckException' => 'parser/exception/PhutilTypeCheckException.php',
     'PhutilTypeExtraParametersException' => 'parser/exception/PhutilTypeExtraParametersException.php',
     'PhutilTypeLexer' => 'lexer/PhutilTypeLexer.php',
     'PhutilTypeMissingParametersException' => 'parser/exception/PhutilTypeMissingParametersException.php',
     'PhutilTypeSpec' => 'parser/PhutilTypeSpec.php',
     'PhutilTypeSpecTestCase' => 'parser/__tests__/PhutilTypeSpecTestCase.php',
     'PhutilURI' => 'parser/PhutilURI.php',
     'PhutilURITestCase' => 'parser/__tests__/PhutilURITestCase.php',
     'PhutilUSEnglishLocale' => 'internationalization/locales/PhutilUSEnglishLocale.php',
     'PhutilUTF8StringTruncator' => 'utils/PhutilUTF8StringTruncator.php',
     'PhutilUTF8TestCase' => 'utils/__tests__/PhutilUTF8TestCase.php',
     'PhutilUnitTestEngine' => 'unit/engine/PhutilUnitTestEngine.php',
     'PhutilUnitTestEngineTestCase' => 'unit/engine/__tests__/PhutilUnitTestEngineTestCase.php',
     'PhutilUnknownSymbolParserGeneratorException' => 'parser/generator/exception/PhutilUnknownSymbolParserGeneratorException.php',
     'PhutilUnreachableRuleParserGeneratorException' => 'parser/generator/exception/PhutilUnreachableRuleParserGeneratorException.php',
     'PhutilUnreachableTerminalParserGeneratorException' => 'parser/generator/exception/PhutilUnreachableTerminalParserGeneratorException.php',
     'PhutilUrisprintfTestCase' => 'xsprintf/__tests__/PhutilUrisprintfTestCase.php',
     'PhutilUtilsTestCase' => 'utils/__tests__/PhutilUtilsTestCase.php',
     'PhutilVeryWowEnglishLocale' => 'internationalization/locales/PhutilVeryWowEnglishLocale.php',
     'PhutilWordPressFuture' => 'future/wordpress/PhutilWordPressFuture.php',
     'PhutilXHPASTBinary' => 'parser/xhpast/bin/PhutilXHPASTBinary.php',
     'PytestTestEngine' => 'unit/engine/PytestTestEngine.php',
     'TempFile' => 'filesystem/TempFile.php',
     'TestAbstractDirectedGraph' => 'utils/__tests__/TestAbstractDirectedGraph.php',
     'XHPASTNode' => 'parser/xhpast/api/XHPASTNode.php',
     'XHPASTNodeTestCase' => 'parser/xhpast/api/__tests__/XHPASTNodeTestCase.php',
     'XHPASTSyntaxErrorException' => 'parser/xhpast/api/XHPASTSyntaxErrorException.php',
     'XHPASTToken' => 'parser/xhpast/api/XHPASTToken.php',
     'XHPASTTree' => 'parser/xhpast/api/XHPASTTree.php',
     'XHPASTTreeTestCase' => 'parser/xhpast/api/__tests__/XHPASTTreeTestCase.php',
     'XUnitTestEngine' => 'unit/engine/XUnitTestEngine.php',
     'XUnitTestResultParserTestCase' => 'unit/parser/__tests__/XUnitTestResultParserTestCase.php',
     'XsprintfUnknownConversionException' => 'xsprintf/exception/XsprintfUnknownConversionException.php',
   ),
   'function' => array(
     '__phutil_autoload' => 'init/init-library.php',
     'array_fuse' => 'utils/utils.php',
     'array_interleave' => 'utils/utils.php',
     'array_mergev' => 'utils/utils.php',
     'array_select_keys' => 'utils/utils.php',
     'assert_instances_of' => 'utils/utils.php',
     'assert_same_keys' => 'utils/utils.php',
     'assert_stringlike' => 'utils/utils.php',
     'coalesce' => 'utils/utils.php',
     'csprintf' => 'xsprintf/csprintf.php',
     'exec_manual' => 'future/exec/execx.php',
     'execx' => 'future/exec/execx.php',
     'head' => 'utils/utils.php',
     'head_key' => 'utils/utils.php',
     'hgsprintf' => 'xsprintf/hgsprintf.php',
     'id' => 'utils/utils.php',
     'idx' => 'utils/utils.php',
     'idxv' => 'utils/utils.php',
     'ifilter' => 'utils/utils.php',
     'igroup' => 'utils/utils.php',
     'ipull' => 'utils/utils.php',
     'isort' => 'utils/utils.php',
     'jsprintf' => 'xsprintf/jsprintf.php',
     'last' => 'utils/utils.php',
     'last_key' => 'utils/utils.php',
     'ldap_sprintf' => 'xsprintf/ldapsprintf.php',
     'mfilter' => 'utils/utils.php',
     'mgroup' => 'utils/utils.php',
     'mpull' => 'utils/utils.php',
     'msort' => 'utils/utils.php',
     'msortv' => 'utils/utils.php',
     'newv' => 'utils/utils.php',
     'nonempty' => 'utils/utils.php',
     'phlog' => 'error/phlog.php',
     'pht' => 'internationalization/pht.php',
     'phutil_build_http_querystring' => 'utils/utils.php',
     'phutil_build_http_querystring_from_pairs' => 'utils/utils.php',
     'phutil_censor_credentials' => 'utils/utils.php',
     'phutil_console_confirm' => 'console/format.php',
     'phutil_console_format' => 'console/format.php',
     'phutil_console_get_terminal_width' => 'console/format.php',
     'phutil_console_prompt' => 'console/format.php',
     'phutil_console_require_tty' => 'console/format.php',
     'phutil_console_select' => 'console/format.php',
     'phutil_console_wrap' => 'console/format.php',
     'phutil_count' => 'internationalization/pht.php',
     'phutil_date_format' => 'utils/viewutils.php',
     'phutil_decode_mime_header' => 'utils/utils.php',
     'phutil_deprecated' => 'init/lib/moduleutils.php',
     'phutil_describe_type' => 'utils/utils.php',
     'phutil_error_listener_example' => 'error/phlog.php',
     'phutil_escape_uri' => 'utils/utils.php',
     'phutil_escape_uri_path_component' => 'utils/utils.php',
     'phutil_fnmatch' => 'utils/utils.php',
     'phutil_format_bytes' => 'utils/viewutils.php',
     'phutil_format_relative_time' => 'utils/viewutils.php',
     'phutil_format_relative_time_detailed' => 'utils/viewutils.php',
     'phutil_format_units_generic' => 'utils/viewutils.php',
     'phutil_fwrite_nonblocking_stream' => 'utils/utils.php',
     'phutil_get_current_library_name' => 'init/lib/moduleutils.php',
     'phutil_get_library_name_for_root' => 'init/lib/moduleutils.php',
     'phutil_get_library_root' => 'init/lib/moduleutils.php',
     'phutil_get_library_root_for_path' => 'init/lib/moduleutils.php',
     'phutil_get_signal_name' => 'future/exec/execx.php',
     'phutil_get_system_locale' => 'utils/utf8.php',
     'phutil_hashes_are_identical' => 'utils/utils.php',
     'phutil_http_parameter_pair' => 'utils/utils.php',
     'phutil_ini_decode' => 'utils/utils.php',
     'phutil_is_hiphop_runtime' => 'utils/utils.php',
     'phutil_is_natural_list' => 'utils/utils.php',
     'phutil_is_system_locale_available' => 'utils/utf8.php',
     'phutil_is_utf8' => 'utils/utf8.php',
     'phutil_is_utf8_slowly' => 'utils/utf8.php',
     'phutil_is_utf8_with_only_bmp_characters' => 'utils/utf8.php',
     'phutil_is_windows' => 'utils/utils.php',
     'phutil_json_decode' => 'utils/utils.php',
     'phutil_json_encode' => 'utils/utils.php',
     'phutil_load_library' => 'init/lib/moduleutils.php',
     'phutil_loggable_string' => 'utils/utils.php',
     'phutil_microseconds_since' => 'utils/utils.php',
     'phutil_parse_bytes' => 'utils/viewutils.php',
     'phutil_passthru' => 'future/exec/execx.php',
     'phutil_person' => 'internationalization/pht.php',
     'phutil_register_library' => 'init/lib/core.php',
     'phutil_register_library_map' => 'init/lib/core.php',
     'phutil_set_system_locale' => 'utils/utf8.php',
     'phutil_split_lines' => 'utils/utils.php',
     'phutil_string_cast' => 'utils/utils.php',
     'phutil_unescape_uri_path_component' => 'utils/utils.php',
     'phutil_units' => 'utils/utils.php',
     'phutil_utf8_console_strlen' => 'utils/utf8.php',
     'phutil_utf8_convert' => 'utils/utf8.php',
     'phutil_utf8_encode_codepoint' => 'utils/utf8.php',
     'phutil_utf8_hard_wrap' => 'utils/utf8.php',
     'phutil_utf8_hard_wrap_html' => 'utils/utf8.php',
     'phutil_utf8_is_cjk' => 'utils/utf8.php',
     'phutil_utf8_is_combining_character' => 'utils/utf8.php',
     'phutil_utf8_strlen' => 'utils/utf8.php',
     'phutil_utf8_strtolower' => 'utils/utf8.php',
     'phutil_utf8_strtoupper' => 'utils/utf8.php',
     'phutil_utf8_strtr' => 'utils/utf8.php',
     'phutil_utf8_ucwords' => 'utils/utf8.php',
     'phutil_utf8ize' => 'utils/utf8.php',
     'phutil_utf8v' => 'utils/utf8.php',
     'phutil_utf8v_codepoints' => 'utils/utf8.php',
     'phutil_utf8v_combine_characters' => 'utils/utf8.php',
     'phutil_utf8v_combined' => 'utils/utf8.php',
     'phutil_validate_json' => 'utils/utils.php',
     'phutil_var_export' => 'utils/utils.php',
     'ppull' => 'utils/utils.php',
     'pregsprintf' => 'xsprintf/pregsprintf.php',
     'tsprintf' => 'xsprintf/tsprintf.php',
     'urisprintf' => 'xsprintf/urisprintf.php',
     'vcsprintf' => 'xsprintf/csprintf.php',
     'vjsprintf' => 'xsprintf/jsprintf.php',
     'vurisprintf' => 'xsprintf/urisprintf.php',
     'xhp_parser_node_constants' => 'parser/xhpast/parser_nodes.php',
     'xhpast_parser_token_constants' => 'parser/xhpast/parser_tokens.php',
     'xsprintf' => 'xsprintf/xsprintf.php',
     'xsprintf_callback_example' => 'xsprintf/xsprintf.php',
     'xsprintf_command' => 'xsprintf/csprintf.php',
     'xsprintf_javascript' => 'xsprintf/jsprintf.php',
     'xsprintf_ldap' => 'xsprintf/ldapsprintf.php',
     'xsprintf_mercurial' => 'xsprintf/hgsprintf.php',
     'xsprintf_regex' => 'xsprintf/pregsprintf.php',
     'xsprintf_terminal' => 'xsprintf/tsprintf.php',
     'xsprintf_uri' => 'xsprintf/urisprintf.php',
   ),
   'xmap' => array(
     'AASTNode' => 'Phobject',
     'AASTNodeList' => array(
       'Phobject',
       'Countable',
       'Iterator',
     ),
     'AASTToken' => 'Phobject',
     'AASTTree' => 'Phobject',
     'AbstractDirectedGraph' => 'Phobject',
     'AbstractDirectedGraphTestCase' => 'PhutilTestCase',
     'ArcanistAbstractMethodBodyXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
     'ArcanistAbstractMethodBodyXHPASTLinterRuleTestCase' => 'ArcanistXHPASTLinterRuleTestCase',
     'ArcanistAbstractPrivateMethodXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
     'ArcanistAbstractPrivateMethodXHPASTLinterRuleTestCase' => 'ArcanistXHPASTLinterRuleTestCase',
     'ArcanistAliasFunctionXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
     'ArcanistAliasFunctionXHPASTLinterRuleTestCase' => 'ArcanistXHPASTLinterRuleTestCase',
     'ArcanistAliasWorkflow' => 'ArcanistWorkflow',
     'ArcanistAmendWorkflow' => 'ArcanistWorkflow',
     'ArcanistAnoidWorkflow' => 'ArcanistWorkflow',
     'ArcanistArrayCombineXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
     'ArcanistArrayCombineXHPASTLinterRuleTestCase' => 'ArcanistXHPASTLinterRuleTestCase',
     'ArcanistArrayIndexSpacingXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
     'ArcanistArrayIndexSpacingXHPASTLinterRuleTestCase' => 'ArcanistXHPASTLinterRuleTestCase',
     'ArcanistArraySeparatorXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
     'ArcanistArraySeparatorXHPASTLinterRuleTestCase' => 'ArcanistXHPASTLinterRuleTestCase',
     'ArcanistArrayValueXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
     'ArcanistArrayValueXHPASTLinterRuleTestCase' => 'ArcanistXHPASTLinterRuleTestCase',
     'ArcanistBackoutWorkflow' => 'ArcanistWorkflow',
     'ArcanistBaseCommitParser' => 'Phobject',
     'ArcanistBaseCommitParserTestCase' => 'PhutilTestCase',
     'ArcanistBaseXHPASTLinter' => 'ArcanistFutureLinter',
     'ArcanistBinaryExpressionSpacingXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
     'ArcanistBinaryExpressionSpacingXHPASTLinterRuleTestCase' => 'ArcanistXHPASTLinterRuleTestCase',
     'ArcanistBinaryNumericScalarCasingXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
     'ArcanistBinaryNumericScalarCasingXHPASTLinterRuleTestCase' => 'ArcanistXHPASTLinterRuleTestCase',
     'ArcanistBlacklistedFunctionXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
     'ArcanistBlacklistedFunctionXHPASTLinterRuleTestCase' => 'ArcanistXHPASTLinterRuleTestCase',
     'ArcanistBlindlyTrustHTTPEngineExtension' => 'PhutilHTTPEngineExtension',
     'ArcanistBookmarkWorkflow' => 'ArcanistFeatureWorkflow',
     'ArcanistBraceFormattingXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
     'ArcanistBraceFormattingXHPASTLinterRuleTestCase' => 'ArcanistXHPASTLinterRuleTestCase',
+    'ArcanistBranchRef' => 'ArcanistRef',
     'ArcanistBranchWorkflow' => 'ArcanistFeatureWorkflow',
+    'ArcanistBrowseCommitHardpointLoader' => 'ArcanistHardpointLoader',
+    'ArcanistBrowseCommitURIHardpointLoader' => 'ArcanistBrowseURIHardpointLoader',
+    'ArcanistBrowseObjectNameURIHardpointLoader' => 'ArcanistBrowseURIHardpointLoader',
+    'ArcanistBrowsePathURIHardpointLoader' => 'ArcanistBrowseURIHardpointLoader',
+    'ArcanistBrowseRef' => 'ArcanistRef',
+    'ArcanistBrowseRevisionURIHardpointLoader' => 'ArcanistBrowseURIHardpointLoader',
+    'ArcanistBrowseURIHardpointLoader' => 'ArcanistHardpointLoader',
+    'ArcanistBrowseURIRef' => 'ArcanistRef',
     'ArcanistBrowseWorkflow' => 'ArcanistWorkflow',
     'ArcanistBuildPlanRef' => 'Phobject',
     'ArcanistBuildRef' => 'Phobject',
     'ArcanistBundle' => 'Phobject',
     'ArcanistBundleTestCase' => 'PhutilTestCase',
     'ArcanistCSSLintLinter' => 'ArcanistExternalLinter',
     'ArcanistCSSLintLinterTestCase' => 'ArcanistExternalLinterTestCase',
     'ArcanistCSharpLinter' => 'ArcanistLinter',
     'ArcanistCallConduitWorkflow' => 'ArcanistWorkflow',
     'ArcanistCallParenthesesXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
     'ArcanistCallParenthesesXHPASTLinterRuleTestCase' => 'ArcanistXHPASTLinterRuleTestCase',
     'ArcanistCallTimePassByReferenceXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
     'ArcanistCallTimePassByReferenceXHPASTLinterRuleTestCase' => 'ArcanistXHPASTLinterRuleTestCase',
     'ArcanistCapabilityNotSupportedException' => 'Exception',
     'ArcanistCastSpacingXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
     'ArcanistCastSpacingXHPASTLinterRuleTestCase' => 'ArcanistXHPASTLinterRuleTestCase',
     'ArcanistCheckstyleXMLLintRenderer' => 'ArcanistLintRenderer',
     'ArcanistChmodLinter' => 'ArcanistLinter',
     'ArcanistChmodLinterTestCase' => 'ArcanistLinterTestCase',
     'ArcanistClassExtendsObjectXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
     'ArcanistClassExtendsObjectXHPASTLinterRuleTestCase' => 'ArcanistXHPASTLinterRuleTestCase',
     'ArcanistClassFilenameMismatchXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
     'ArcanistClassMustBeDeclaredAbstractXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
     'ArcanistClassMustBeDeclaredAbstractXHPASTLinterRuleTestCase' => 'ArcanistXHPASTLinterRuleTestCase',
     'ArcanistClassNameLiteralXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
     'ArcanistClassNameLiteralXHPASTLinterRuleTestCase' => 'ArcanistXHPASTLinterRuleTestCase',
     'ArcanistCloseRevisionWorkflow' => 'ArcanistWorkflow',
     'ArcanistCloseWorkflow' => 'ArcanistWorkflow',
     'ArcanistClosureLinter' => 'ArcanistExternalLinter',
     'ArcanistClosureLinterTestCase' => 'ArcanistExternalLinterTestCase',
     'ArcanistCoffeeLintLinter' => 'ArcanistExternalLinter',
     'ArcanistCoffeeLintLinterTestCase' => 'ArcanistExternalLinterTestCase',
     'ArcanistCommentRemover' => 'Phobject',
     'ArcanistCommentRemoverTestCase' => 'PhutilTestCase',
     'ArcanistCommentSpacingXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
     'ArcanistCommentStyleXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
     'ArcanistCommentStyleXHPASTLinterRuleTestCase' => 'ArcanistXHPASTLinterRuleTestCase',
+    'ArcanistCommitRef' => 'ArcanistRef',
+    'ArcanistCommitUpstreamHardpointLoader' => 'ArcanistHardpointLoader',
     'ArcanistCommitWorkflow' => 'ArcanistWorkflow',
     'ArcanistCompilerLintRenderer' => 'ArcanistLintRenderer',
     'ArcanistComposerLinter' => 'ArcanistLinter',
     'ArcanistComprehensiveLintEngine' => 'ArcanistLintEngine',
     'ArcanistConcatenationOperatorXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
     'ArcanistConcatenationOperatorXHPASTLinterRuleTestCase' => 'ArcanistXHPASTLinterRuleTestCase',
+    'ArcanistConduitCall' => 'Phobject',
+    'ArcanistConduitEngine' => 'Phobject',
     'ArcanistConfiguration' => 'Phobject',
     'ArcanistConfigurationDrivenLintEngine' => 'ArcanistLintEngine',
     'ArcanistConfigurationDrivenUnitTestEngine' => 'ArcanistUnitTestEngine',
     'ArcanistConfigurationManager' => 'Phobject',
     'ArcanistConsoleLintRenderer' => 'ArcanistLintRenderer',
     'ArcanistConsoleLintRendererTestCase' => 'PhutilTestCase',
     'ArcanistConstructorParenthesesXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
     'ArcanistConstructorParenthesesXHPASTLinterRuleTestCase' => 'ArcanistXHPASTLinterRuleTestCase',
     'ArcanistContinueInsideSwitchXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
     'ArcanistContinueInsideSwitchXHPASTLinterRuleTestCase' => 'ArcanistXHPASTLinterRuleTestCase',
     'ArcanistControlStatementSpacingXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
     'ArcanistControlStatementSpacingXHPASTLinterRuleTestCase' => 'ArcanistXHPASTLinterRuleTestCase',
     'ArcanistCoverWorkflow' => 'ArcanistWorkflow',
     'ArcanistCppcheckLinter' => 'ArcanistExternalLinter',
     'ArcanistCppcheckLinterTestCase' => 'ArcanistExternalLinterTestCase',
     'ArcanistCpplintLinter' => 'ArcanistExternalLinter',
     'ArcanistCpplintLinterTestCase' => 'ArcanistExternalLinterTestCase',
     'ArcanistCurlyBraceArrayIndexXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
     'ArcanistCurlyBraceArrayIndexXHPASTLinterRuleTestCase' => 'ArcanistXHPASTLinterRuleTestCase',
     'ArcanistDeclarationParenthesesXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
     'ArcanistDeclarationParenthesesXHPASTLinterRuleTestCase' => 'ArcanistXHPASTLinterRuleTestCase',
     'ArcanistDefaultParametersXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
     'ArcanistDefaultParametersXHPASTLinterRuleTestCase' => 'ArcanistXHPASTLinterRuleTestCase',
     'ArcanistDeprecationXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
     'ArcanistDeprecationXHPASTLinterRuleTestCase' => 'ArcanistXHPASTLinterRuleTestCase',
     'ArcanistDiffByteSizeException' => 'Exception',
     'ArcanistDiffChange' => 'Phobject',
     'ArcanistDiffChangeType' => 'Phobject',
     'ArcanistDiffHunk' => 'Phobject',
     'ArcanistDiffParser' => 'Phobject',
     'ArcanistDiffParserTestCase' => 'PhutilTestCase',
     'ArcanistDiffUtils' => 'Phobject',
     'ArcanistDiffUtilsTestCase' => 'PhutilTestCase',
     'ArcanistDiffWorkflow' => 'ArcanistWorkflow',
     'ArcanistDifferentialCommitMessage' => 'Phobject',
     'ArcanistDifferentialCommitMessageParserException' => 'Exception',
     'ArcanistDifferentialDependencyGraph' => 'AbstractDirectedGraph',
     'ArcanistDifferentialRevisionHash' => 'Phobject',
     'ArcanistDifferentialRevisionStatus' => 'Phobject',
     'ArcanistDoubleQuoteXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
     'ArcanistDoubleQuoteXHPASTLinterRuleTestCase' => 'ArcanistXHPASTLinterRuleTestCase',
     'ArcanistDownloadWorkflow' => 'ArcanistWorkflow',
     'ArcanistDuplicateKeysInArrayXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
     'ArcanistDuplicateKeysInArrayXHPASTLinterRuleTestCase' => 'ArcanistXHPASTLinterRuleTestCase',
     'ArcanistDuplicateSwitchCaseXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
     'ArcanistDuplicateSwitchCaseXHPASTLinterRuleTestCase' => 'ArcanistXHPASTLinterRuleTestCase',
     'ArcanistDynamicDefineXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
     'ArcanistDynamicDefineXHPASTLinterRuleTestCase' => 'ArcanistXHPASTLinterRuleTestCase',
     'ArcanistElseIfUsageXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
     'ArcanistElseIfUsageXHPASTLinterRuleTestCase' => 'ArcanistXHPASTLinterRuleTestCase',
     'ArcanistEmptyFileXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
     'ArcanistEmptyStatementXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
     'ArcanistEmptyStatementXHPASTLinterRuleTestCase' => 'ArcanistXHPASTLinterRuleTestCase',
     'ArcanistEventType' => 'PhutilEventType',
     'ArcanistExitExpressionXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
     'ArcanistExitExpressionXHPASTLinterRuleTestCase' => 'ArcanistXHPASTLinterRuleTestCase',
     'ArcanistExportWorkflow' => 'ArcanistWorkflow',
     'ArcanistExternalLinter' => 'ArcanistFutureLinter',
     'ArcanistExternalLinterTestCase' => 'ArcanistLinterTestCase',
     'ArcanistExtractUseXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
     'ArcanistExtractUseXHPASTLinterRuleTestCase' => 'ArcanistXHPASTLinterRuleTestCase',
     'ArcanistFeatureWorkflow' => 'ArcanistWorkflow',
     'ArcanistFileDataRef' => 'Phobject',
     'ArcanistFileUploader' => 'Phobject',
     'ArcanistFilenameLinter' => 'ArcanistLinter',
     'ArcanistFilenameLinterTestCase' => 'ArcanistLinterTestCase',
     'ArcanistFlagWorkflow' => 'ArcanistWorkflow',
     'ArcanistFlake8Linter' => 'ArcanistExternalLinter',
     'ArcanistFlake8LinterTestCase' => 'ArcanistExternalLinterTestCase',
     'ArcanistFormattedStringXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
     'ArcanistFormattedStringXHPASTLinterRuleTestCase' => 'ArcanistXHPASTLinterRuleTestCase',
     'ArcanistFunctionCallShouldBeTypeCastXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
     'ArcanistFunctionCallShouldBeTypeCastXHPASTLinterRuleTestCase' => 'ArcanistXHPASTLinterRuleTestCase',
     'ArcanistFutureLinter' => 'ArcanistLinter',
     'ArcanistGeneratedLinter' => 'ArcanistLinter',
     'ArcanistGeneratedLinterTestCase' => 'ArcanistLinterTestCase',
     'ArcanistGetConfigWorkflow' => 'ArcanistWorkflow',
     'ArcanistGitAPI' => 'ArcanistRepositoryAPI',
+    'ArcanistGitCommitMessageHardpointLoader' => 'ArcanistGitHardpointLoader',
+    'ArcanistGitHardpointLoader' => 'ArcanistHardpointLoader',
     'ArcanistGitLandEngine' => 'ArcanistLandEngine',
+    'ArcanistGitRevisionHardpointLoader' => 'ArcanistGitHardpointLoader',
     'ArcanistGitUpstreamPath' => 'Phobject',
     'ArcanistGlobalVariableXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
     'ArcanistGlobalVariableXHPASTLinterRuleTestCase' => 'ArcanistXHPASTLinterRuleTestCase',
     'ArcanistGoLintLinter' => 'ArcanistExternalLinter',
     'ArcanistGoLintLinterTestCase' => 'ArcanistExternalLinterTestCase',
     'ArcanistGoTestResultParser' => 'ArcanistTestResultParser',
     'ArcanistGoTestResultParserTestCase' => 'PhutilTestCase',
     'ArcanistHLintLinter' => 'ArcanistExternalLinter',
     'ArcanistHLintLinterTestCase' => 'ArcanistExternalLinterTestCase',
+    'ArcanistHardpointLoader' => 'Phobject',
     'ArcanistHelpWorkflow' => 'ArcanistWorkflow',
     'ArcanistHexadecimalNumericScalarCasingXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
     'ArcanistHexadecimalNumericScalarCasingXHPASTLinterRuleTestCase' => 'ArcanistXHPASTLinterRuleTestCase',
     'ArcanistHgClientChannel' => 'PhutilProtocolChannel',
     'ArcanistHgProxyClient' => 'Phobject',
     'ArcanistHgProxyServer' => 'Phobject',
     'ArcanistHgServerChannel' => 'PhutilProtocolChannel',
     'ArcanistImplicitConstructorXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
     'ArcanistImplicitConstructorXHPASTLinterRuleTestCase' => 'ArcanistXHPASTLinterRuleTestCase',
     'ArcanistImplicitFallthroughXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
     'ArcanistImplicitFallthroughXHPASTLinterRuleTestCase' => 'ArcanistXHPASTLinterRuleTestCase',
     'ArcanistImplicitVisibilityXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
     'ArcanistImplicitVisibilityXHPASTLinterRuleTestCase' => 'ArcanistXHPASTLinterRuleTestCase',
     'ArcanistImplodeArgumentOrderXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
     'ArcanistImplodeArgumentOrderXHPASTLinterRuleTestCase' => 'ArcanistXHPASTLinterRuleTestCase',
     'ArcanistInlineHTMLXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
     'ArcanistInlineHTMLXHPASTLinterRuleTestCase' => 'ArcanistXHPASTLinterRuleTestCase',
     'ArcanistInnerFunctionXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
     'ArcanistInnerFunctionXHPASTLinterRuleTestCase' => 'ArcanistXHPASTLinterRuleTestCase',
     'ArcanistInstallCertificateWorkflow' => 'ArcanistWorkflow',
     'ArcanistInstanceOfOperatorXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
     'ArcanistInstanceofOperatorXHPASTLinterRuleTestCase' => 'ArcanistXHPASTLinterRuleTestCase',
     'ArcanistInterfaceAbstractMethodXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
     'ArcanistInterfaceAbstractMethodXHPASTLinterRuleTestCase' => 'ArcanistXHPASTLinterRuleTestCase',
     'ArcanistInterfaceMethodBodyXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
     'ArcanistInterfaceMethodBodyXHPASTLinterRuleTestCase' => 'ArcanistXHPASTLinterRuleTestCase',
     'ArcanistInvalidDefaultParameterXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
     'ArcanistInvalidDefaultParameterXHPASTLinterRuleTestCase' => 'ArcanistXHPASTLinterRuleTestCase',
     'ArcanistInvalidModifiersXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
     'ArcanistInvalidModifiersXHPASTLinterRuleTestCase' => 'ArcanistXHPASTLinterRuleTestCase',
     'ArcanistInvalidOctalNumericScalarXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
     'ArcanistInvalidOctalNumericScalarXHPASTLinterRuleTestCase' => 'ArcanistXHPASTLinterRuleTestCase',
     'ArcanistIsAShouldBeInstanceOfXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
     'ArcanistIsAShouldBeInstanceOfXHPASTLinterRuleTestCase' => 'ArcanistXHPASTLinterRuleTestCase',
     'ArcanistJSHintLinter' => 'ArcanistExternalLinter',
     'ArcanistJSHintLinterTestCase' => 'ArcanistExternalLinterTestCase',
     'ArcanistJSONLintLinter' => 'ArcanistExternalLinter',
     'ArcanistJSONLintLinterTestCase' => 'ArcanistExternalLinterTestCase',
     'ArcanistJSONLintRenderer' => 'ArcanistLintRenderer',
     'ArcanistJSONLinter' => 'ArcanistLinter',
     'ArcanistJSONLinterTestCase' => 'ArcanistLinterTestCase',
     'ArcanistJscsLinter' => 'ArcanistExternalLinter',
     'ArcanistJscsLinterTestCase' => 'ArcanistExternalLinterTestCase',
     'ArcanistKeywordCasingXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
     'ArcanistKeywordCasingXHPASTLinterRuleTestCase' => 'ArcanistXHPASTLinterRuleTestCase',
     'ArcanistLambdaFuncFunctionXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
     'ArcanistLambdaFuncFunctionXHPASTLinterRuleTestCase' => 'ArcanistXHPASTLinterRuleTestCase',
     'ArcanistLandEngine' => 'Phobject',
     'ArcanistLandWorkflow' => 'ArcanistWorkflow',
     'ArcanistLanguageConstructParenthesesXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
     'ArcanistLanguageConstructParenthesesXHPASTLinterRuleTestCase' => 'ArcanistXHPASTLinterRuleTestCase',
     'ArcanistLesscLinter' => 'ArcanistExternalLinter',
     'ArcanistLesscLinterTestCase' => 'ArcanistExternalLinterTestCase',
     'ArcanistLiberateWorkflow' => 'ArcanistWorkflow',
     'ArcanistLibraryTestCase' => 'PhutilLibraryTestCase',
     'ArcanistLintEngine' => 'Phobject',
     'ArcanistLintMessage' => 'Phobject',
     'ArcanistLintMessageTestCase' => 'PhutilTestCase',
     'ArcanistLintPatcher' => 'Phobject',
     'ArcanistLintRenderer' => 'Phobject',
     'ArcanistLintResult' => 'Phobject',
     'ArcanistLintSeverity' => 'Phobject',
     'ArcanistLintWorkflow' => 'ArcanistWorkflow',
     'ArcanistLinter' => 'Phobject',
     'ArcanistLinterStandard' => 'Phobject',
     'ArcanistLinterStandardTestCase' => 'PhutilTestCase',
     'ArcanistLinterTestCase' => 'PhutilTestCase',
     'ArcanistLintersWorkflow' => 'ArcanistWorkflow',
     'ArcanistListAssignmentXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
     'ArcanistListAssignmentXHPASTLinterRuleTestCase' => 'ArcanistXHPASTLinterRuleTestCase',
     'ArcanistListWorkflow' => 'ArcanistWorkflow',
     'ArcanistLogicalOperatorsXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
     'ArcanistLogicalOperatorsXHPASTLinterRuleTestCase' => 'ArcanistXHPASTLinterRuleTestCase',
     'ArcanistLowercaseFunctionsXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
     'ArcanistLowercaseFunctionsXHPASTLinterRuleTestCase' => 'ArcanistXHPASTLinterRuleTestCase',
     'ArcanistMercurialAPI' => 'ArcanistRepositoryAPI',
+    'ArcanistMercurialBranchCommitHardpointLoader' => 'ArcanistMercurialHardpointLoader',
+    'ArcanistMercurialHardpointLoader' => 'ArcanistHardpointLoader',
     'ArcanistMercurialParser' => 'Phobject',
     'ArcanistMercurialParserTestCase' => 'PhutilTestCase',
+    'ArcanistMercurialWorkingCopyCommitHardpointLoader' => 'ArcanistMercurialHardpointLoader',
     'ArcanistMergeConflictLinter' => 'ArcanistLinter',
     'ArcanistMergeConflictLinterTestCase' => 'ArcanistLinterTestCase',
+    'ArcanistMessageRevisionHardpointLoader' => 'ArcanistHardpointLoader',
     'ArcanistMissingLinterException' => 'Exception',
     'ArcanistModifierOrderingXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
     'ArcanistModifierOrderingXHPASTLinterRuleTestCase' => 'ArcanistXHPASTLinterRuleTestCase',
     'ArcanistNamespaceFirstStatementXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
     'ArcanistNamespaceFirstStatementXHPASTLinterRuleTestCase' => 'ArcanistXHPASTLinterRuleTestCase',
     'ArcanistNamingConventionsXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
     'ArcanistNamingConventionsXHPASTLinterRuleTestCase' => 'ArcanistXHPASTLinterRuleTestCase',
     'ArcanistNestedNamespacesXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
     'ArcanistNestedNamespacesXHPASTLinterRuleTestCase' => 'ArcanistXHPASTLinterRuleTestCase',
     'ArcanistNewlineAfterOpenTagXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
     'ArcanistNewlineAfterOpenTagXHPASTLinterRuleTestCase' => 'ArcanistXHPASTLinterRuleTestCase',
     'ArcanistNoEffectException' => 'ArcanistUsageException',
     'ArcanistNoEngineException' => 'ArcanistUsageException',
     'ArcanistNoLintLinter' => 'ArcanistLinter',
     'ArcanistNoLintLinterTestCase' => 'ArcanistLinterTestCase',
     'ArcanistNoParentScopeXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
     'ArcanistNoParentScopeXHPASTLinterRuleTestCase' => 'ArcanistXHPASTLinterRuleTestCase',
     'ArcanistNoneLintRenderer' => 'ArcanistLintRenderer',
     'ArcanistObjectOperatorSpacingXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
     'ArcanistObjectOperatorSpacingXHPASTLinterRuleTestCase' => 'ArcanistXHPASTLinterRuleTestCase',
     'ArcanistPEP8Linter' => 'ArcanistExternalLinter',
     'ArcanistPEP8LinterTestCase' => 'ArcanistExternalLinterTestCase',
     'ArcanistPHPCloseTagXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
     'ArcanistPHPCloseTagXHPASTLinterRuleTestCase' => 'ArcanistXHPASTLinterRuleTestCase',
     'ArcanistPHPCompatibilityXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
     'ArcanistPHPCompatibilityXHPASTLinterRuleTestCase' => 'ArcanistXHPASTLinterRuleTestCase',
     'ArcanistPHPEchoTagXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
     'ArcanistPHPEchoTagXHPASTLinterRuleTestCase' => 'ArcanistXHPASTLinterRuleTestCase',
     'ArcanistPHPOpenTagXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
     'ArcanistPHPOpenTagXHPASTLinterRuleTestCase' => 'ArcanistXHPASTLinterRuleTestCase',
     'ArcanistPHPShortTagXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
     'ArcanistPHPShortTagXHPASTLinterRuleTestCase' => 'ArcanistXHPASTLinterRuleTestCase',
     'ArcanistPaamayimNekudotayimSpacingXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
     'ArcanistPaamayimNekudotayimSpacingXHPASTLinterRuleTestCase' => 'ArcanistXHPASTLinterRuleTestCase',
     'ArcanistParentMemberReferenceXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
     'ArcanistParentMemberReferenceXHPASTLinterRuleTestCase' => 'ArcanistXHPASTLinterRuleTestCase',
     'ArcanistParenthesesSpacingXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
     'ArcanistParenthesesSpacingXHPASTLinterRuleTestCase' => 'ArcanistXHPASTLinterRuleTestCase',
     'ArcanistParseStrUseXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
     'ArcanistParseStrUseXHPASTLinterRuleTestCase' => 'ArcanistXHPASTLinterRuleTestCase',
     'ArcanistPasteWorkflow' => 'ArcanistWorkflow',
     'ArcanistPatchWorkflow' => 'ArcanistWorkflow',
     'ArcanistPhpLinter' => 'ArcanistExternalLinter',
     'ArcanistPhpLinterTestCase' => 'ArcanistExternalLinterTestCase',
     'ArcanistPhpcsLinter' => 'ArcanistExternalLinter',
     'ArcanistPhpcsLinterTestCase' => 'ArcanistExternalLinterTestCase',
     'ArcanistPhpunitTestResultParser' => 'ArcanistTestResultParser',
     'ArcanistPhrequentWorkflow' => 'ArcanistWorkflow',
     'ArcanistPhutilLibraryLinter' => 'ArcanistLinter',
     'ArcanistPhutilXHPASTLinterStandard' => 'ArcanistLinterStandard',
     'ArcanistPlusOperatorOnStringsXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
     'ArcanistPlusOperatorOnStringsXHPASTLinterRuleTestCase' => 'ArcanistXHPASTLinterRuleTestCase',
     'ArcanistPregQuoteMisuseXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
     'ArcanistPregQuoteMisuseXHPASTLinterRuleTestCase' => 'ArcanistXHPASTLinterRuleTestCase',
     'ArcanistPublicPropertyXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
     'ArcanistPublicPropertyXHPASTLinterRuleTestCase' => 'ArcanistXHPASTLinterRuleTestCase',
     'ArcanistPuppetLintLinter' => 'ArcanistExternalLinter',
     'ArcanistPuppetLintLinterTestCase' => 'ArcanistExternalLinterTestCase',
     'ArcanistPyFlakesLinter' => 'ArcanistExternalLinter',
     'ArcanistPyFlakesLinterTestCase' => 'ArcanistExternalLinterTestCase',
     'ArcanistPyLintLinter' => 'ArcanistExternalLinter',
     'ArcanistPyLintLinterTestCase' => 'ArcanistExternalLinterTestCase',
     'ArcanistRaggedClassTreeEdgeXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
     'ArcanistRaggedClassTreeEdgeXHPASTLinterRuleTestCase' => 'ArcanistXHPASTLinterRuleTestCase',
+    'ArcanistRef' => 'Phobject',
+    'ArcanistRefQuery' => 'Phobject',
     'ArcanistRepositoryAPI' => 'Phobject',
     'ArcanistRepositoryAPIMiscTestCase' => 'PhutilTestCase',
     'ArcanistRepositoryAPIStateTestCase' => 'PhutilTestCase',
+    'ArcanistRepositoryRef' => 'ArcanistRef',
     'ArcanistReusedAsIteratorXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
     'ArcanistReusedAsIteratorXHPASTLinterRuleTestCase' => 'ArcanistXHPASTLinterRuleTestCase',
     'ArcanistReusedIteratorReferenceXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
     'ArcanistReusedIteratorReferenceXHPASTLinterRuleTestCase' => 'ArcanistXHPASTLinterRuleTestCase',
     'ArcanistReusedIteratorXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
     'ArcanistReusedIteratorXHPASTLinterRuleTestCase' => 'ArcanistXHPASTLinterRuleTestCase',
     'ArcanistRevertWorkflow' => 'ArcanistWorkflow',
+    'ArcanistRevisionRef' => 'ArcanistRef',
+    'ArcanistRevisionRefSource' => 'Phobject',
     'ArcanistRuboCopLinter' => 'ArcanistExternalLinter',
     'ArcanistRuboCopLinterTestCase' => 'ArcanistExternalLinterTestCase',
     'ArcanistRubyLinter' => 'ArcanistExternalLinter',
     'ArcanistRubyLinterTestCase' => 'ArcanistExternalLinterTestCase',
     'ArcanistScriptAndRegexLinter' => 'ArcanistLinter',
     'ArcanistSelfClassReferenceXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
     'ArcanistSelfClassReferenceXHPASTLinterRuleTestCase' => 'ArcanistXHPASTLinterRuleTestCase',
     'ArcanistSelfMemberReferenceXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
     'ArcanistSelfMemberReferenceXHPASTLinterRuleTestCase' => 'ArcanistXHPASTLinterRuleTestCase',
     'ArcanistSemicolonSpacingXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
     'ArcanistSemicolonSpacingXHPASTLinterRuleTestCase' => 'ArcanistXHPASTLinterRuleTestCase',
     'ArcanistSetConfigWorkflow' => 'ArcanistWorkflow',
+    'ArcanistSetting' => 'Phobject',
     'ArcanistSettings' => 'Phobject',
     'ArcanistShellCompleteWorkflow' => 'ArcanistWorkflow',
     'ArcanistSingleLintEngine' => 'ArcanistLintEngine',
     'ArcanistSlownessXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
     'ArcanistSlownessXHPASTLinterRuleTestCase' => 'ArcanistXHPASTLinterRuleTestCase',
     'ArcanistSpellingLinter' => 'ArcanistLinter',
     'ArcanistSpellingLinterTestCase' => 'ArcanistLinterTestCase',
     'ArcanistStartWorkflow' => 'ArcanistPhrequentWorkflow',
     'ArcanistStaticThisXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
     'ArcanistStaticThisXHPASTLinterRuleTestCase' => 'ArcanistXHPASTLinterRuleTestCase',
     'ArcanistStopWorkflow' => 'ArcanistPhrequentWorkflow',
     'ArcanistSubversionAPI' => 'ArcanistRepositoryAPI',
     'ArcanistSummaryLintRenderer' => 'ArcanistLintRenderer',
     'ArcanistSyntaxErrorXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
     'ArcanistTasksWorkflow' => 'ArcanistWorkflow',
     'ArcanistTautologicalExpressionXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
     'ArcanistTautologicalExpressionXHPASTLinterRuleTestCase' => 'ArcanistXHPASTLinterRuleTestCase',
     'ArcanistTestResultParser' => 'Phobject',
     'ArcanistTestXHPASTLintSwitchHook' => 'ArcanistXHPASTLintSwitchHook',
     'ArcanistTextLinter' => 'ArcanistLinter',
     'ArcanistTextLinterTestCase' => 'ArcanistLinterTestCase',
     'ArcanistThisReassignmentXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
     'ArcanistThisReassignmentXHPASTLinterRuleTestCase' => 'ArcanistXHPASTLinterRuleTestCase',
     'ArcanistTimeWorkflow' => 'ArcanistPhrequentWorkflow',
     'ArcanistToStringExceptionXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
     'ArcanistToStringExceptionXHPASTLinterRuleTestCase' => 'ArcanistXHPASTLinterRuleTestCase',
     'ArcanistTodoCommentXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
     'ArcanistTodoCommentXHPASTLinterRuleTestCase' => 'ArcanistXHPASTLinterRuleTestCase',
     'ArcanistTodoWorkflow' => 'ArcanistWorkflow',
     'ArcanistUSEnglishTranslation' => 'PhutilTranslation',
     'ArcanistUnableToParseXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
     'ArcanistUnaryPostfixExpressionSpacingXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
     'ArcanistUnaryPostfixExpressionSpacingXHPASTLinterRuleTestCase' => 'ArcanistXHPASTLinterRuleTestCase',
     'ArcanistUnaryPrefixExpressionSpacingXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
     'ArcanistUnaryPrefixExpressionSpacingXHPASTLinterRuleTestCase' => 'ArcanistXHPASTLinterRuleTestCase',
     'ArcanistUndeclaredVariableXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
     'ArcanistUndeclaredVariableXHPASTLinterRuleTestCase' => 'ArcanistXHPASTLinterRuleTestCase',
     'ArcanistUnexpectedReturnValueXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
     'ArcanistUnexpectedReturnValueXHPASTLinterRuleTestCase' => 'ArcanistXHPASTLinterRuleTestCase',
     'ArcanistUnitConsoleRenderer' => 'ArcanistUnitRenderer',
     'ArcanistUnitRenderer' => 'Phobject',
     'ArcanistUnitTestEngine' => 'Phobject',
     'ArcanistUnitTestResult' => 'Phobject',
     'ArcanistUnitTestResultTestCase' => 'PhutilTestCase',
     'ArcanistUnitTestableLintEngine' => 'ArcanistLintEngine',
     'ArcanistUnitWorkflow' => 'ArcanistWorkflow',
     'ArcanistUnnecessaryFinalModifierXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
     'ArcanistUnnecessaryFinalModifierXHPASTLinterRuleTestCase' => 'ArcanistXHPASTLinterRuleTestCase',
     'ArcanistUnnecessarySemicolonXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
     'ArcanistUnnecessarySymbolAliasXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
     'ArcanistUnnecessarySymbolAliasXHPASTLinterRuleTestCase' => 'ArcanistXHPASTLinterRuleTestCase',
     'ArcanistUnsafeDynamicStringXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
     'ArcanistUnsafeDynamicStringXHPASTLinterRuleTestCase' => 'ArcanistXHPASTLinterRuleTestCase',
     'ArcanistUpgradeWorkflow' => 'ArcanistWorkflow',
     'ArcanistUploadWorkflow' => 'ArcanistWorkflow',
     'ArcanistUsageException' => 'Exception',
     'ArcanistUseStatementNamespacePrefixXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
     'ArcanistUseStatementNamespacePrefixXHPASTLinterRuleTestCase' => 'ArcanistXHPASTLinterRuleTestCase',
     'ArcanistUselessOverridingMethodXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
     'ArcanistUselessOverridingMethodXHPASTLinterRuleTestCase' => 'ArcanistXHPASTLinterRuleTestCase',
     'ArcanistUserAbortException' => 'ArcanistUsageException',
     'ArcanistVariableReferenceSpacingXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
     'ArcanistVariableReferenceSpacingXHPASTLinterRuleTestCase' => 'ArcanistXHPASTLinterRuleTestCase',
     'ArcanistVariableVariableXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
     'ArcanistVariableVariableXHPASTLinterRuleTestCase' => 'ArcanistXHPASTLinterRuleTestCase',
     'ArcanistVersionWorkflow' => 'ArcanistWorkflow',
     'ArcanistWeldWorkflow' => 'ArcanistWorkflow',
     'ArcanistWhichWorkflow' => 'ArcanistWorkflow',
     'ArcanistWorkflow' => 'Phobject',
     'ArcanistWorkingCopyIdentity' => 'Phobject',
+    'ArcanistWorkingCopyStateRef' => 'ArcanistRef',
     'ArcanistXHPASTLintNamingHook' => 'Phobject',
     'ArcanistXHPASTLintNamingHookTestCase' => 'PhutilTestCase',
     'ArcanistXHPASTLintSwitchHook' => 'Phobject',
     'ArcanistXHPASTLinter' => 'ArcanistBaseXHPASTLinter',
     'ArcanistXHPASTLinterRule' => 'Phobject',
     'ArcanistXHPASTLinterRuleTestCase' => 'ArcanistLinterTestCase',
     'ArcanistXHPASTLinterTestCase' => 'ArcanistLinterTestCase',
     'ArcanistXMLLinter' => 'ArcanistLinter',
     'ArcanistXMLLinterTestCase' => 'ArcanistLinterTestCase',
     'ArcanistXUnitTestResultParser' => 'Phobject',
     'BaseHTTPFuture' => 'Future',
     'CSharpToolsTestEngine' => 'XUnitTestEngine',
     'CaseInsensitiveArray' => 'PhutilArray',
     'CaseInsensitiveArrayTestCase' => 'PhutilTestCase',
     'CommandException' => 'Exception',
     'ConduitClient' => 'Phobject',
     'ConduitClientException' => 'Exception',
     'ConduitClientTestCase' => 'PhutilTestCase',
     'ConduitFuture' => 'FutureProxy',
     'ExecFuture' => 'PhutilExecutableFuture',
     'ExecFutureTestCase' => 'PhutilTestCase',
     'ExecPassthruTestCase' => 'PhutilTestCase',
     'FileFinder' => 'Phobject',
     'FileFinderTestCase' => 'PhutilTestCase',
     'FileList' => 'Phobject',
     'Filesystem' => 'Phobject',
     'FilesystemException' => 'Exception',
     'FilesystemTestCase' => 'PhutilTestCase',
     'Future' => 'Phobject',
     'FutureIterator' => array(
       'Phobject',
       'Iterator',
     ),
     'FutureIteratorTestCase' => 'PhutilTestCase',
     'FutureProxy' => 'Future',
     'HTTPFuture' => 'BaseHTTPFuture',
     'HTTPFutureCURLResponseStatus' => 'HTTPFutureResponseStatus',
     'HTTPFutureCertificateResponseStatus' => 'HTTPFutureResponseStatus',
     'HTTPFutureHTTPResponseStatus' => 'HTTPFutureResponseStatus',
     'HTTPFutureParseResponseStatus' => 'HTTPFutureResponseStatus',
     'HTTPFutureResponseStatus' => 'Exception',
     'HTTPFutureTransportResponseStatus' => 'HTTPFutureResponseStatus',
     'HTTPSFuture' => 'BaseHTTPFuture',
     'ImmediateFuture' => 'Future',
     'LibphutilUSEnglishTranslation' => 'PhutilTranslation',
     'LinesOfALarge' => array(
       'Phobject',
       'Iterator',
     ),
     'LinesOfALargeExecFuture' => 'LinesOfALarge',
     'LinesOfALargeExecFutureTestCase' => 'PhutilTestCase',
     'LinesOfALargeFile' => 'LinesOfALarge',
     'LinesOfALargeFileTestCase' => 'PhutilTestCase',
     'MFilterTestHelper' => 'Phobject',
     'NoseTestEngine' => 'ArcanistUnitTestEngine',
     'PHPASTParserTestCase' => 'PhutilTestCase',
     'PhageAction' => 'Phobject',
     'PhageAgentAction' => 'PhageAction',
     'PhageAgentBootloader' => 'Phobject',
     'PhageAgentTestCase' => 'PhutilTestCase',
     'PhageExecuteAction' => 'PhageAction',
     'PhageLocalAction' => 'PhageAgentAction',
     'PhagePHPAgent' => 'Phobject',
     'PhagePHPAgentBootloader' => 'PhageAgentBootloader',
     'PhagePlanAction' => 'PhageAction',
     'PhageWorkflow' => 'PhutilArgumentWorkflow',
     'Phobject' => 'Iterator',
     'PhobjectTestCase' => 'PhutilTestCase',
     'PhpunitTestEngine' => 'ArcanistUnitTestEngine',
     'PhpunitTestEngineTestCase' => 'PhutilTestCase',
     'PhutilAWSCloudFormationFuture' => 'PhutilAWSFuture',
     'PhutilAWSCloudWatchFuture' => 'PhutilAWSFuture',
     'PhutilAWSEC2Future' => 'PhutilAWSFuture',
     'PhutilAWSException' => 'Exception',
     'PhutilAWSFuture' => 'FutureProxy',
     'PhutilAWSManagementWorkflow' => 'PhutilArgumentWorkflow',
     'PhutilAWSS3DeleteManagementWorkflow' => 'PhutilAWSS3ManagementWorkflow',
     'PhutilAWSS3Future' => 'PhutilAWSFuture',
     'PhutilAWSS3GetManagementWorkflow' => 'PhutilAWSS3ManagementWorkflow',
     'PhutilAWSS3ManagementWorkflow' => 'PhutilAWSManagementWorkflow',
     'PhutilAWSS3PutManagementWorkflow' => 'PhutilAWSS3ManagementWorkflow',
     'PhutilAWSv4Signature' => 'Phobject',
     'PhutilAWSv4SignatureTestCase' => 'PhutilTestCase',
     'PhutilAggregateException' => 'Exception',
     'PhutilAllCapsEnglishLocale' => 'PhutilLocale',
     'PhutilArgumentParser' => 'Phobject',
     'PhutilArgumentParserException' => 'Exception',
     'PhutilArgumentParserTestCase' => 'PhutilTestCase',
     'PhutilArgumentSpecification' => 'Phobject',
     'PhutilArgumentSpecificationException' => 'PhutilArgumentParserException',
     'PhutilArgumentSpecificationTestCase' => 'PhutilTestCase',
     'PhutilArgumentSpellingCorrector' => 'Phobject',
     'PhutilArgumentSpellingCorrectorTestCase' => 'PhutilTestCase',
     'PhutilArgumentUsageException' => 'PhutilArgumentParserException',
     'PhutilArgumentWorkflow' => 'Phobject',
     'PhutilArray' => array(
       'Phobject',
       'Countable',
       'ArrayAccess',
       'Iterator',
     ),
     'PhutilArrayTestCase' => 'PhutilTestCase',
     'PhutilArrayWithDefaultValue' => 'PhutilArray',
     'PhutilAsanaFuture' => 'FutureProxy',
     'PhutilBacktraceSignalHandler' => 'PhutilSignalHandler',
     'PhutilBallOfPHP' => 'Phobject',
     'PhutilBinaryAnalyzer' => 'Phobject',
     'PhutilBinaryAnalyzerTestCase' => 'PhutilTestCase',
     'PhutilBootloaderException' => 'Exception',
     'PhutilBritishEnglishLocale' => 'PhutilLocale',
     'PhutilBufferedIterator' => array(
       'Phobject',
       'Iterator',
     ),
     'PhutilBufferedIteratorTestCase' => 'PhutilTestCase',
     'PhutilBugtraqParser' => 'Phobject',
     'PhutilBugtraqParserTestCase' => 'PhutilTestCase',
     'PhutilCIDRBlock' => 'Phobject',
     'PhutilCIDRList' => 'Phobject',
     'PhutilCallbackFilterIterator' => 'FilterIterator',
     'PhutilCallbackSignalHandler' => 'PhutilSignalHandler',
     'PhutilChannel' => 'Phobject',
     'PhutilChannelChannel' => 'PhutilChannel',
     'PhutilChannelTestCase' => 'PhutilTestCase',
     'PhutilChunkedIterator' => array(
       'Phobject',
       'Iterator',
     ),
     'PhutilChunkedIteratorTestCase' => 'PhutilTestCase',
     'PhutilClassMapQuery' => 'Phobject',
     'PhutilCloudWatchMetric' => 'Phobject',
     'PhutilCommandString' => 'Phobject',
     'PhutilConsole' => 'Phobject',
     'PhutilConsoleBlock' => 'PhutilConsoleView',
     'PhutilConsoleError' => 'PhutilConsoleLogLine',
     'PhutilConsoleFormatter' => 'Phobject',
     'PhutilConsoleInfo' => 'PhutilConsoleLogLine',
     'PhutilConsoleList' => 'PhutilConsoleView',
     'PhutilConsoleLogLine' => 'PhutilConsoleView',
     'PhutilConsoleMessage' => 'Phobject',
     'PhutilConsoleMetrics' => 'Phobject',
     'PhutilConsoleMetricsSignalHandler' => 'PhutilSignalHandler',
     'PhutilConsoleProgressBar' => 'Phobject',
     'PhutilConsoleProgressSink' => 'PhutilProgressSink',
     'PhutilConsoleServer' => 'Phobject',
     'PhutilConsoleServerChannel' => 'PhutilChannelChannel',
     'PhutilConsoleSkip' => 'PhutilConsoleLogLine',
     'PhutilConsoleStdinNotInteractiveException' => 'Exception',
     'PhutilConsoleTable' => 'PhutilConsoleView',
     'PhutilConsoleView' => 'Phobject',
     'PhutilConsoleWarning' => 'PhutilConsoleLogLine',
     'PhutilConsoleWrapTestCase' => 'PhutilTestCase',
     'PhutilCowsay' => 'Phobject',
     'PhutilCowsayTestCase' => 'PhutilTestCase',
     'PhutilCsprintfTestCase' => 'PhutilTestCase',
     'PhutilCzechLocale' => 'PhutilLocale',
     'PhutilDOMNode' => 'Phobject',
     'PhutilDeferredLog' => 'Phobject',
     'PhutilDeferredLogTestCase' => 'PhutilTestCase',
     'PhutilDiffBinaryAnalyzer' => 'PhutilBinaryAnalyzer',
     'PhutilDirectedScalarGraph' => 'AbstractDirectedGraph',
     'PhutilDirectoryFixture' => 'Phobject',
     'PhutilDocblockParser' => 'Phobject',
     'PhutilDocblockParserTestCase' => 'PhutilTestCase',
     'PhutilEditDistanceMatrix' => 'Phobject',
     'PhutilEditDistanceMatrixTestCase' => 'PhutilTestCase',
     'PhutilEditorConfig' => 'Phobject',
     'PhutilEditorConfigTestCase' => 'PhutilTestCase',
     'PhutilEmailAddress' => 'Phobject',
     'PhutilEmailAddressTestCase' => 'PhutilTestCase',
     'PhutilEmojiLocale' => 'PhutilLocale',
     'PhutilEnglishCanadaLocale' => 'PhutilLocale',
     'PhutilErrorHandler' => 'Phobject',
     'PhutilErrorHandlerTestCase' => 'PhutilTestCase',
     'PhutilErrorTrap' => 'Phobject',
     'PhutilEvent' => 'Phobject',
     'PhutilEventConstants' => 'Phobject',
     'PhutilEventEngine' => 'Phobject',
     'PhutilEventListener' => 'Phobject',
     'PhutilEventType' => 'PhutilEventConstants',
     'PhutilExampleBufferedIterator' => 'PhutilBufferedIterator',
     'PhutilExecChannel' => 'PhutilChannel',
     'PhutilExecPassthru' => 'PhutilExecutableFuture',
     'PhutilExecutableFuture' => 'Future',
     'PhutilExecutionEnvironment' => 'Phobject',
     'PhutilFileLock' => 'PhutilLock',
     'PhutilFileLockTestCase' => 'PhutilTestCase',
     'PhutilFileTree' => 'Phobject',
     'PhutilFrenchLocale' => 'PhutilLocale',
     'PhutilGermanLocale' => 'PhutilLocale',
     'PhutilGitBinaryAnalyzer' => 'PhutilBinaryAnalyzer',
     'PhutilGitHubFuture' => 'FutureProxy',
     'PhutilGitHubResponse' => 'Phobject',
     'PhutilGitURI' => 'Phobject',
     'PhutilGitURITestCase' => 'PhutilTestCase',
     'PhutilHTMLParser' => 'Phobject',
     'PhutilHTMLParserTestCase' => 'PhutilTestCase',
     'PhutilHTTPEngineExtension' => 'Phobject',
     'PhutilHTTPResponse' => 'Phobject',
     'PhutilHTTPResponseParser' => 'Phobject',
     'PhutilHTTPResponseParserTestCase' => 'PhutilTestCase',
     'PhutilHashingIterator' => array(
       'PhutilProxyIterator',
       'Iterator',
     ),
     'PhutilHashingIteratorTestCase' => 'PhutilTestCase',
     'PhutilHelpArgumentWorkflow' => 'PhutilArgumentWorkflow',
     'PhutilHgsprintfTestCase' => 'PhutilTestCase',
     'PhutilINIParserException' => 'Exception',
     'PhutilIPAddress' => 'Phobject',
     'PhutilIPAddressTestCase' => 'PhutilTestCase',
     'PhutilIPv4Address' => 'PhutilIPAddress',
     'PhutilIPv6Address' => 'PhutilIPAddress',
     'PhutilInteractiveEditor' => 'Phobject',
     'PhutilInvalidRuleParserGeneratorException' => 'PhutilParserGeneratorException',
     'PhutilInvalidStateException' => 'Exception',
     'PhutilInvalidStateExceptionTestCase' => 'PhutilTestCase',
     'PhutilIrreducibleRuleParserGeneratorException' => 'PhutilParserGeneratorException',
     'PhutilJSON' => 'Phobject',
     'PhutilJSONFragmentLexer' => 'PhutilLexer',
     'PhutilJSONParser' => 'Phobject',
     'PhutilJSONParserException' => 'Exception',
     'PhutilJSONParserTestCase' => 'PhutilTestCase',
     'PhutilJSONProtocolChannel' => 'PhutilProtocolChannel',
     'PhutilJSONProtocolChannelTestCase' => 'PhutilTestCase',
     'PhutilJSONTestCase' => 'PhutilTestCase',
     'PhutilJavaFragmentLexer' => 'PhutilLexer',
     'PhutilKoreanLocale' => 'PhutilLocale',
     'PhutilLanguageGuesser' => 'Phobject',
     'PhutilLanguageGuesserTestCase' => 'PhutilTestCase',
     'PhutilLexer' => 'Phobject',
     'PhutilLibraryConflictException' => 'Exception',
     'PhutilLibraryMapBuilder' => 'Phobject',
     'PhutilLibraryTestCase' => 'PhutilTestCase',
     'PhutilLocale' => 'Phobject',
     'PhutilLocaleTestCase' => 'PhutilTestCase',
     'PhutilLock' => 'Phobject',
     'PhutilLockException' => 'Exception',
     'PhutilLogFileChannel' => 'PhutilChannelChannel',
     'PhutilLunarPhase' => 'Phobject',
     'PhutilLunarPhaseTestCase' => 'PhutilTestCase',
     'PhutilMercurialBinaryAnalyzer' => 'PhutilBinaryAnalyzer',
     'PhutilMethodNotImplementedException' => 'Exception',
     'PhutilMetricsChannel' => 'PhutilChannelChannel',
     'PhutilMissingSymbolException' => 'Exception',
     'PhutilModuleUtilsTestCase' => 'PhutilTestCase',
     'PhutilNumber' => 'Phobject',
     'PhutilOAuth1Future' => 'FutureProxy',
     'PhutilOAuth1FutureTestCase' => 'PhutilTestCase',
     'PhutilOpaqueEnvelope' => 'Phobject',
     'PhutilOpaqueEnvelopeKey' => 'Phobject',
     'PhutilOpaqueEnvelopeTestCase' => 'PhutilTestCase',
     'PhutilPHPFragmentLexer' => 'PhutilLexer',
     'PhutilPHPFragmentLexerTestCase' => 'PhutilTestCase',
     'PhutilPHPObjectProtocolChannel' => 'PhutilProtocolChannel',
     'PhutilPHPObjectProtocolChannelTestCase' => 'PhutilTestCase',
     'PhutilParserGenerator' => 'Phobject',
     'PhutilParserGeneratorException' => 'Exception',
     'PhutilParserGeneratorTestCase' => 'PhutilTestCase',
     'PhutilPayPalAPIFuture' => 'FutureProxy',
     'PhutilPersonTest' => array(
       'Phobject',
       'PhutilPerson',
     ),
     'PhutilPhtTestCase' => 'PhutilTestCase',
     'PhutilPirateEnglishLocale' => 'PhutilLocale',
     'PhutilPortugueseBrazilLocale' => 'PhutilLocale',
     'PhutilPortuguesePortugalLocale' => 'PhutilLocale',
     'PhutilPostmarkFuture' => 'FutureProxy',
     'PhutilPregsprintfTestCase' => 'PhutilTestCase',
     'PhutilProcessQuery' => 'Phobject',
     'PhutilProcessRef' => 'Phobject',
     'PhutilProcessRefTestCase' => 'PhutilTestCase',
     'PhutilProgressSink' => 'Phobject',
     'PhutilProtocolChannel' => 'PhutilChannelChannel',
     'PhutilProxyException' => 'Exception',
     'PhutilProxyIterator' => array(
       'Phobject',
       'Iterator',
     ),
     'PhutilPygmentizeBinaryAnalyzer' => 'PhutilBinaryAnalyzer',
     'PhutilPythonFragmentLexer' => 'PhutilLexer',
     'PhutilQueryStringParser' => 'Phobject',
     'PhutilQueryStringParserTestCase' => 'PhutilTestCase',
     'PhutilRawEnglishLocale' => 'PhutilLocale',
     'PhutilReadableSerializer' => 'Phobject',
     'PhutilReadableSerializerTestCase' => 'PhutilTestCase',
     'PhutilRope' => 'Phobject',
     'PhutilRopeTestCase' => 'PhutilTestCase',
     'PhutilServiceProfiler' => 'Phobject',
     'PhutilShellLexer' => 'PhutilLexer',
     'PhutilShellLexerTestCase' => 'PhutilTestCase',
     'PhutilSignalHandler' => 'Phobject',
     'PhutilSignalRouter' => 'Phobject',
     'PhutilSimpleOptions' => 'Phobject',
     'PhutilSimpleOptionsLexer' => 'PhutilLexer',
     'PhutilSimpleOptionsLexerTestCase' => 'PhutilTestCase',
     'PhutilSimpleOptionsTestCase' => 'PhutilTestCase',
     'PhutilSimplifiedChineseLocale' => 'PhutilLocale',
     'PhutilSlackFuture' => 'FutureProxy',
     'PhutilSocketChannel' => 'PhutilChannel',
     'PhutilSortVector' => 'Phobject',
     'PhutilSpanishSpainLocale' => 'PhutilLocale',
     'PhutilStreamIterator' => array(
       'Phobject',
       'Iterator',
     ),
     'PhutilSubversionBinaryAnalyzer' => 'PhutilBinaryAnalyzer',
     'PhutilSystem' => 'Phobject',
     'PhutilSystemTestCase' => 'PhutilTestCase',
     'PhutilTerminalString' => 'Phobject',
     'PhutilTestCase' => 'Phobject',
     'PhutilTestCaseTestCase' => 'PhutilTestCase',
     'PhutilTestPhobject' => 'Phobject',
     'PhutilTestSkippedException' => 'Exception',
     'PhutilTestTerminatedException' => 'Exception',
     'PhutilTraditionalChineseLocale' => 'PhutilLocale',
     'PhutilTranslation' => 'Phobject',
     'PhutilTranslationTestCase' => 'PhutilTestCase',
     'PhutilTranslator' => 'Phobject',
     'PhutilTranslatorTestCase' => 'PhutilTestCase',
     'PhutilTsprintfTestCase' => 'PhutilTestCase',
     'PhutilTwitchFuture' => 'FutureProxy',
     'PhutilTypeCheckException' => 'Exception',
     'PhutilTypeExtraParametersException' => 'Exception',
     'PhutilTypeLexer' => 'PhutilLexer',
     'PhutilTypeMissingParametersException' => 'Exception',
     'PhutilTypeSpec' => 'Phobject',
     'PhutilTypeSpecTestCase' => 'PhutilTestCase',
     'PhutilURI' => 'Phobject',
     'PhutilURITestCase' => 'PhutilTestCase',
     'PhutilUSEnglishLocale' => 'PhutilLocale',
     'PhutilUTF8StringTruncator' => 'Phobject',
     'PhutilUTF8TestCase' => 'PhutilTestCase',
     'PhutilUnitTestEngine' => 'ArcanistUnitTestEngine',
     'PhutilUnitTestEngineTestCase' => 'PhutilTestCase',
     'PhutilUnknownSymbolParserGeneratorException' => 'PhutilParserGeneratorException',
     'PhutilUnreachableRuleParserGeneratorException' => 'PhutilParserGeneratorException',
     'PhutilUnreachableTerminalParserGeneratorException' => 'PhutilParserGeneratorException',
     'PhutilUrisprintfTestCase' => 'PhutilTestCase',
     'PhutilUtilsTestCase' => 'PhutilTestCase',
     'PhutilVeryWowEnglishLocale' => 'PhutilLocale',
     'PhutilWordPressFuture' => 'FutureProxy',
     'PhutilXHPASTBinary' => 'Phobject',
     'PytestTestEngine' => 'ArcanistUnitTestEngine',
     'TempFile' => 'Phobject',
     'TestAbstractDirectedGraph' => 'AbstractDirectedGraph',
     'XHPASTNode' => 'AASTNode',
     'XHPASTNodeTestCase' => 'PhutilTestCase',
     'XHPASTSyntaxErrorException' => 'Exception',
     'XHPASTToken' => 'AASTToken',
     'XHPASTTree' => 'AASTTree',
     'XHPASTTreeTestCase' => 'PhutilTestCase',
     'XUnitTestEngine' => 'ArcanistUnitTestEngine',
     'XUnitTestResultParserTestCase' => 'PhutilTestCase',
     'XsprintfUnknownConversionException' => 'InvalidArgumentException',
   ),
 ));
diff --git a/src/browse/loader/ArcanistBrowseCommitHardpointLoader.php b/src/browse/loader/ArcanistBrowseCommitHardpointLoader.php
new file mode 100644
index 00000000..9d8a2df1
--- /dev/null
+++ b/src/browse/loader/ArcanistBrowseCommitHardpointLoader.php
@@ -0,0 +1,80 @@
+<?php
+
+final class ArcanistBrowseCommitHardpointLoader
+  extends ArcanistHardpointLoader {
+
+  const LOADERKEY = 'browse.ref.commit';
+
+  public function canLoadRepositoryAPI(ArcanistRepositoryAPI $api) {
+    return true;
+  }
+
+  public function canLoadRef(ArcanistRef $ref) {
+    return ($ref instanceof ArcanistBrowseRef);
+  }
+
+  public function canLoadHardpoint(ArcanistRef $ref, $hardpoint) {
+    return ($hardpoint == 'commitRefs');
+  }
+
+  public function loadHardpoints(array $refs, $hardpoint) {
+    $query = $this->getQuery();
+
+    $api = $query->getRepositoryAPI();
+    if (!$api) {
+      return array();
+    }
+
+    $repository_ref = $query->getRepositoryRef();
+    if (!$repository_ref) {
+      return array();
+    }
+    $repository_phid = $repository_ref->getPHID();
+
+    $commit_map = array();
+    foreach ($refs as $key => $ref) {
+      $token = $ref->getToken();
+
+      if ($token === '.') {
+        // Git resolves "." like HEAD, but we want to treat it as "browse the
+        // current directory" instead in all cases.
+        continue;
+      }
+
+      // Always resolve the empty token; top-level loaders filter out
+      // irrelevant tokens before this stage.
+      if ($token === null) {
+        $token = $api->getHeadCommit();
+      }
+
+      // TODO: We should pull a full commit ref out of the API as soon as it
+      // is able to provide them. In particular, we currently miss Git tree
+      // hashes which reduces the accuracy of lookups.
+
+      try {
+        $commit = $api->getCanonicalRevisionName($token);
+        if ($commit) {
+          $commit_map[$commit][] = $key;
+        }
+      } catch (Exception $ex) {
+        // Ignore anything we can't resolve.
+      }
+    }
+
+    if (!$commit_map) {
+      return array();
+    }
+
+    $results = array();
+    foreach ($commit_map as $commit_identifier => $ref_keys) {
+      foreach ($ref_keys as $key) {
+        $commit_ref = id(new ArcanistCommitRef())
+          ->setCommitHash($commit_identifier);
+        $results[$key][] = $commit_ref;
+      }
+    }
+
+    return $results;
+  }
+
+}
diff --git a/src/browse/loader/ArcanistBrowseCommitURIHardpointLoader.php b/src/browse/loader/ArcanistBrowseCommitURIHardpointLoader.php
new file mode 100644
index 00000000..6eea94d4
--- /dev/null
+++ b/src/browse/loader/ArcanistBrowseCommitURIHardpointLoader.php
@@ -0,0 +1,92 @@
+<?php
+
+final class ArcanistBrowseCommitURIHardpointLoader
+  extends ArcanistBrowseURIHardpointLoader {
+
+  const LOADERKEY = 'browse.uri.commit';
+  const BROWSETYPE = 'commit';
+
+  public function willLoadBrowseURIRefs(array $refs) {
+    $refs = $this->getRefsWithSupportedTypes($refs);
+
+    if (!$refs) {
+      return;
+    }
+
+    $query = $this->getQuery();
+
+    $working_ref = $query->getWorkingCopyRef();
+    if (!$working_ref) {
+      // If we aren't in a working copy, don't warn about this.
+      return;
+    }
+
+    $repository_ref = $this->getQuery()->getRepositoryRef();
+    if (!$repository_ref) {
+      echo pht(
+        'NO REPOSITORY: Unable to determine which repository this working '.
+        'copy belongs to, so arguments can not be resolved as commits. Use '.
+        '"%s" to understand how repositories are resolved.',
+        'arc which');
+      echo "\n";
+      return;
+    }
+  }
+
+  public function loadHardpoints(array $refs, $hardpoint) {
+    $query = $this->getQuery();
+
+    $api = $query->getRepositoryAPI();
+    if (!$api) {
+      return array();
+    }
+
+    $repository_ref = $query->getRepositoryRef();
+    if (!$repository_ref) {
+      return array();
+    }
+
+    $refs = $this->getRefsWithSupportedTypes($refs);
+    if (!$refs) {
+      return array();
+    }
+
+    $this->newQuery($refs)
+      ->needHardpoints(
+        array(
+          'commitRefs',
+        ))
+      ->execute();
+
+    $commit_refs = array();
+    foreach ($refs as $key => $ref) {
+      foreach ($ref->getCommitRefs() as $commit_ref) {
+        $commit_refs[] = $commit_ref;
+      }
+    }
+
+    $this->newQuery($commit_refs)
+      ->needHardpoints(
+        array(
+          'upstream',
+        ))
+      ->execute();
+
+    $results = array();
+    foreach ($refs as $key => $ref) {
+      $commit_refs = $ref->getCommitRefs();
+      foreach ($commit_refs as $commit_ref) {
+        $uri = $commit_ref->getURI();
+        if ($uri !== null) {
+          $results[$key][] = id(new ArcanistBrowseURIRef())
+            ->setURI($uri)
+            ->setType(self::BROWSETYPE);
+        }
+      }
+    }
+
+    return $results;
+  }
+
+
+}
diff --git a/src/browse/loader/ArcanistBrowseObjectNameURIHardpointLoader.php b/src/browse/loader/ArcanistBrowseObjectNameURIHardpointLoader.php
new file mode 100644
index 00000000..964a0542
--- /dev/null
+++ b/src/browse/loader/ArcanistBrowseObjectNameURIHardpointLoader.php
@@ -0,0 +1,54 @@
+<?php
+
+final class ArcanistBrowseObjectNameURIHardpointLoader
+  extends ArcanistBrowseURIHardpointLoader {
+
+  const LOADERKEY = 'browse.uri.name';
+  const BROWSETYPE = 'object';
+
+  public function loadHardpoints(array $refs, $hardpoint) {
+    $refs = $this->getRefsWithSupportedTypes($refs);
+
+    $name_map = array();
+    foreach ($refs as $key => $ref) {
+      $token = $ref->getToken();
+      if (!strlen($token)) {
+        continue;
+      }
+
+      $name_map[$key] = $token;
+    }
+
+    if (!$name_map) {
+      return array();
+    }
+
+    $objects = $this->resolveCall(
+      'phid.lookup',
+      array(
+        'names' => $name_map,
+      ));
+
+    $result = array();
+
+    $reverse_map = array_flip($name_map);
+    foreach ($objects as $name => $object) {
+      $key = idx($reverse_map, $name);
+      if ($key === null) {
+        continue;
+      }
+
+      $uri = idx($object, 'uri');
+      if (!strlen($uri)) {
+        continue;
+      }
+
+      $result[$key][] = id(new ArcanistBrowseURIRef())
+        ->setURI($object['uri'])
+        ->setType('object');
+    }
+
+    return $result;
+  }
+
+}
diff --git a/src/browse/loader/ArcanistBrowsePathURIHardpointLoader.php b/src/browse/loader/ArcanistBrowsePathURIHardpointLoader.php
new file mode 100644
index 00000000..ab2b2db9
--- /dev/null
+++ b/src/browse/loader/ArcanistBrowsePathURIHardpointLoader.php
@@ -0,0 +1,132 @@
+<?php
+
+final class ArcanistBrowsePathURIHardpointLoader
+  extends ArcanistBrowseURIHardpointLoader {
+
+  const LOADERKEY = 'browse.uri.path';
+  const BROWSETYPE = 'path';
+
+  public function willLoadBrowseURIRefs(array $refs) {
+    $refs = $this->getRefsWithSupportedTypes($refs);
+    if (!$refs) {
+      return;
+    }
+
+    $query = $this->getQuery();
+
+    $working_ref = $query->getWorkingCopyRef();
+    if (!$working_ref) {
+      echo pht(
+        'NO WORKING COPY: The current directory is not a repository '.
+        'working copy, so arguments can not be resolved as paths. Run '.
+        'this command inside a working copy to resolve paths.');
+      echo "\n";
+      return;
+    }
+
+    $repository_ref = $query->getRepositoryRef();
+    if (!$repository_ref) {
+      echo pht(
+        'NO REPOSITORY: Unable to determine which repository this working '.
+        'copy belongs to, so arguments can not be resolved as paths. Use '.
+        '"%s" to understand how repositories are resolved.',
+        'arc which');
+      echo "\n";
+      return;
+    }
+  }
+
+  public function didFailToLoadBrowseURIRefs(array $refs) {
+    $refs = $this->getRefsWithSupportedTypes($refs);
+    if (!$refs) {
+      return;
+    }
+
+    $query = $this->getQuery();
+
+    $working_ref = $query->getWorkingCopyRef();
+    if (!$working_ref) {
+      return;
+    }
+
+    $repository_ref = $query->getRepositoryRef();
+    if (!$repository_ref) {
+      return;
+    }
+
+    echo pht(
+      'Use "--types path" to force arguments to be interpreted as paths.');
+    echo "\n";
+  }
+
+
+  public function loadHardpoints(array $refs, $hardpoint) {
+    $query = $this->getQuery();
+
+    $working_ref = $query->getWorkingCopyRef();
+    if (!$working_ref) {
+      return array();
+    }
+
+    $repository_ref = $query->getRepositoryRef();
+    if (!$repository_ref) {
+      return array();
+    }
+
+    $refs = $this->getRefsWithSupportedTypes($refs);
+    $project_root = $working_ref->getRootDirectory();
+
+    $results = array();
+    foreach ($refs as $key => $ref) {
+      $is_path = $ref->hasType(self::BROWSETYPE);
+
+      $path = $ref->getToken();
+      if ($path === null) {
+        // If we're explicitly resolving no arguments as a path, treat it
+        // as the current working directory.
+        if ($is_path) {
+          $path = '.';
+        } else {
+          continue;
+        }
+      }
+
+      $lines = null;
+      $parts = explode(':', $path);
+      if (count($parts) > 1) {
+        $lines = array_pop($parts);
+      }
+      $path = implode(':', $parts);
+
+      $full_path = Filesystem::resolvePath($path);
+
+      if (!Filesystem::pathExists($full_path)) {
+        if (!$is_path) {
+          continue;
+        }
+      }
+
+      if ($full_path == $project_root) {
+        $path = '';
+      } else {
+        $path = Filesystem::readablePath($full_path, $project_root);
+      }
+
+      $params = array(
+        'path' => $path,
+        'lines' => $lines,
+        'branch' => $ref->getBranch(),
+      );
+
+      $uri = $repository_ref->newBrowseURI($params);
+
+      $results[$key][] = id(new ArcanistBrowseURIRef())
+        ->setURI($uri)
+        ->setType(self::BROWSETYPE);
+    }
+
+    return $results;
+  }
+
+
+}
diff --git a/src/browse/loader/ArcanistBrowseRevisionURIHardpointLoader.php b/src/browse/loader/ArcanistBrowseRevisionURIHardpointLoader.php
new file mode 100644
index 00000000..08fda082
--- /dev/null
+++ b/src/browse/loader/ArcanistBrowseRevisionURIHardpointLoader.php
@@ -0,0 +1,78 @@
+<?php
+
+final class ArcanistBrowseRevisionURIHardpointLoader
+  extends ArcanistBrowseURIHardpointLoader {
+
+  const LOADERKEY = 'browse.uri.revision';
+  const BROWSETYPE = 'revision';
+
+  public function loadHardpoints(array $refs, $hardpoint) {
+    $query = $this->getQuery();
+
+    $working_ref = $query->getWorkingCopyRef();
+    if (!$working_ref) {
+      return array();
+    }
+
+    $repository_ref = $query->getRepositoryRef();
+    if (!$repository_ref) {
+      return array();
+    }
+
+    $refs = $this->getRefsWithSupportedTypes($refs);
+    if (!$refs) {
+      return array();
+    }
+
+    $this->newQuery($refs)
+      ->needHardpoints(
+        array(
+          'commitRefs',
+        ))
+      ->execute();
+
+    $states = array();
+    $map = array();
+    foreach ($refs as $key => $ref) {
+      foreach ($ref->getCommitRefs() as $commit_ref) {
+        $hash = $commit_ref->getCommitHash();
+        $states[$hash] = id(clone $working_ref)
+          ->setCommitRef($commit_ref);
+        $map[$hash][] = $key;
+      }
+    }
+
+    if (!$states) {
+      return array();
+    }
+
+    $this->newQuery($states)
+      ->needHardpoints(
+        array(
+          'revisionRefs',
+        ))
+      ->execute();
+
+    $results = array();
+    foreach ($states as $hash => $state) {
+      foreach ($state->getRevisionRefs() as $revision) {
+        if ($revision->isClosed()) {
+          // Don't resolve closed revisions.
+          continue;
+        }
+
+        $uri = $revision->getURI();
+
+        foreach ($map[$hash] as $key) {
+          $results[$key][] = id(new ArcanistBrowseURIRef())
+            ->setURI($uri)
+            ->setType(self::BROWSETYPE);
+        }
+      }
+    }
+
+    return $results;
+  }
+
+
+}
diff --git a/src/browse/loader/ArcanistBrowseURIHardpointLoader.php b/src/browse/loader/ArcanistBrowseURIHardpointLoader.php
new file mode 100644
index 00000000..ab328fa5
--- /dev/null
+++ b/src/browse/loader/ArcanistBrowseURIHardpointLoader.php
@@ -0,0 +1,55 @@
+<?php
+
+abstract class ArcanistBrowseURIHardpointLoader
+  extends ArcanistHardpointLoader {
+
+  public function getSupportedBrowseType() {
+    return $this->getPhobjectClassConstant('BROWSETYPE', 32);
+  }
+
+  public function canLoadRepositoryAPI(ArcanistRepositoryAPI $api) {
+    return true;
+  }
+
+  public function canLoadRef(ArcanistRef $ref) {
+    return ($ref instanceof ArcanistBrowseRef);
+  }
+
+  public function canLoadHardpoint(ArcanistRef $ref, $hardpoint) {
+    return ($hardpoint == 'uris');
+  }
+
+  public function willLoadBrowseURIRefs(array $refs) {
+    return;
+  }
+
+  public function didFailToLoadBrowseURIRefs(array $refs) {
+    return;
+  }
+
+  public function getRefsWithSupportedTypes(array $refs) {
+    $type = $this->getSupportedBrowseType();
+
+    foreach ($refs as $key => $ref) {
+      if ($ref->isUntyped()) {
+        continue;
+      }
+
+      if ($ref->hasType($type)) {
+        continue;
+      }
+
+      unset($refs[$key]);
+    }
+
+    return $refs;
+  }
+
+  public static function getAllBrowseLoaders() {
+    return id(new PhutilClassMapQuery())
+      ->setAncestorClass(__CLASS__)
+      ->setUniqueMethod('getLoaderKey')
+      ->execute();
+  }
+
+}
diff --git a/src/browse/ref/ArcanistBrowseRef.php b/src/browse/ref/ArcanistBrowseRef.php
new file mode 100644
index 00000000..f07c4b2c
--- /dev/null
+++ b/src/browse/ref/ArcanistBrowseRef.php
@@ -0,0 +1,72 @@
+<?php
+
+final class ArcanistBrowseRef
+  extends ArcanistRef {
+
+  private $token;
+  private $types;
+  private $branch;
+
+  public function getRefIdentifier() {
+    return pht('Browse Query "%s"', $this->getToken());
+  }
+
+  public function defineHardpoints() {
+    return array(
+      'commitRefs' => array(
+        'type' => 'ArcanistCommitRef',
+        'vector' => true,
+      ),
+      'uris' => array(
+        'type' => 'ArcanistBrowseURIRef',
+        'vector' => true,
+      ),
+    );
+  }
+
+  public function setToken($token) {
+    $this->token = $token;
+    return $this;
+  }
+
+  public function getToken() {
+    return $this->token;
+  }
+
+  public function setTypes(array $types) {
+    $this->types = $types;
+    return $this;
+  }
+
+  public function getTypes() {
+    return $this->types;
+  }
+
+  public function hasType($type) {
+    $map = $this->getTypes();
+    $map = array_fuse($map);
+    return isset($map[$type]);
+  }
+
+  public function isUntyped() {
+    return !$this->types;
+  }
+
+  public function setBranch($branch) {
+    $this->branch = $branch;
+    return $this;
+  }
+
+  public function getBranch() {
+    return $this->branch;
+  }
+
+  public function getURIs() {
+    return $this->getHardpoint('uris');
+  }
+
+  public function getCommitRefs() {
+    return $this->getHardpoint('commitRefs');
+  }
+
+}
diff --git a/src/browse/ref/ArcanistBrowseURIRef.php b/src/browse/ref/ArcanistBrowseURIRef.php
new file mode 100644
index 00000000..9444d2e0
--- /dev/null
+++ b/src/browse/ref/ArcanistBrowseURIRef.php
@@ -0,0 +1,35 @@
+<?php
+
+final class ArcanistBrowseURIRef
+  extends ArcanistRef {
+
+  private $uri;
+  private $type;
+
+  public function getRefIdentifier() {
+    return pht('Browse URI "%s"', $this->getURI());
+  }
+
+  public function defineHardpoints() {
+    return array();
+  }
+
+  public function setURI($uri) {
+    $this->uri = $uri;
+    return $this;
+  }
+
+  public function getURI() {
+    return $this->uri;
+  }
+
+  public function setType($type) {
+    $this->type = $type;
+    return $this;
+  }
+
+  public function getType() {
+    return $this->type;
+  }
+
+}
diff --git a/src/browse/workflow/ArcanistBrowseWorkflow.php b/src/browse/workflow/ArcanistBrowseWorkflow.php
new file mode 100644
index 00000000..1b0f3221
--- /dev/null
+++ b/src/browse/workflow/ArcanistBrowseWorkflow.php
@@ -0,0 +1,259 @@
+<?php
+
+/**
+ * Browse files or objects in the Phabricator web interface.
+ */
+final class ArcanistBrowseWorkflow extends ArcanistWorkflow {
+
+  public function getWorkflowName() {
+    return 'browse';
+  }
+
+  public function getCommandSynopses() {
+    return phutil_console_format(<<<EOTEXT
+      **browse** [__options__] __path__ ...
+      **browse** [__options__] __object__ ...
+EOTEXT
+      );
+  }
+
+  public function getCommandHelp() {
+    return phutil_console_format(<<<EOTEXT
+          Supports: git, hg, svn
+          Open a file or object (like a task or revision) in your web browser.
+
+            $ arc browse README   # Open a file in Diffusion.
+            $ arc browse T123     # View a task.
+            $ arc browse HEAD     # View a symbolic commit.
+
+          Set the 'browser' value using 'arc set-config' to select a browser. If
+          no browser is set, the command will try to guess which browser to use.
+EOTEXT
+      );
+  }
+
+  public function getArguments() {
+    return array(
+      'branch' => array(
+        'param' => 'branch_name',
+        'help' => pht(
+          'Default branch name to view on server. Defaults to "%s".',
+          'master'),
+      ),
+      'types' => array(
+        'param' => 'types',
+        'aliases' => array('type'),
+        'help' => pht(
+          'Parse arguments with particular types.'),
+      ),
+      'force' => array(
+        'help' => pht(
+          '(DEPRECATED) Obsolete, use "--types path" instead.'),
+      ),
+      '*' => 'targets',
+    );
+  }
+
+  public function desiresWorkingCopy() {
+    return true;
+  }
+
+  public function desiresRepositoryAPI() {
+    return true;
+  }
+
+  public function run() {
+    $conduit = $this->getConduitEngine();
+
+    $console = PhutilConsole::getConsole();
+
+    $targets = $this->getArgument('targets');
+    $targets = array_fuse($targets);
+
+    if (!$targets) {
+      $refs = array(
+        new ArcanistBrowseRef(),
+      );
+    } else {
+      $refs = array();
+      foreach ($targets as $target) {
+        $refs[] = id(new ArcanistBrowseRef())
+          ->setToken($target);
+      }
+    }
+
+    $is_force = $this->getArgument('force');
+    if ($is_force) {
+      // TODO: Remove this completely.
+      $this->writeWarn(
+        pht('DEPRECATED'),
+        pht(
+          'Argument "--force" for "arc browse" is deprecated. Use '.
+          '"--type %s" instead.',
+          ArcanistBrowsePathURIHardpointLoader::BROWSETYPE));
+    }
+
+    $types = $this->getArgument('types');
+    if ($types !== null) {
+      $types = preg_split('/[\s,]+/', $types);
+    } else {
+      if ($is_force) {
+        $types = array(ArcanistBrowsePathURIHardpointLoader::BROWSETYPE);
+      } else {
+        $types = array();
+      }
+    }
+
+    foreach ($refs as $ref) {
+      $ref->setTypes($types);
+    }
+
+    $branch = $this->getArgument('branch');
+    if ($branch) {
+      foreach ($refs as $ref) {
+        $ref->setBranch($branch);
+      }
+    }
+
+    $loaders = ArcanistBrowseURIHardpointLoader::getAllBrowseLoaders();
+    foreach ($loaders as $key => $loader) {
+      $loaders[$key] = clone $loader;
+    }
+
+    $query = $this->newRefQuery($refs)
+      ->needHardpoints(
+        array(
+          'uris',
+        ))
+      ->setLoaders($loaders);
+
+    foreach ($loaders as $loader) {
+      $loader->willLoadBrowseURIRefs($refs);
+    }
+
+    $query->execute();
+
+    $zero_hits = array();
+    $open_uris = array();
+    $many_hits = array();
+    foreach ($refs as $ref) {
+      $uris = $ref->getURIs();
+      if (!$uris) {
+        $zero_hits[] = $ref;
+      } else if (count($uris) == 1) {
+        $open_uris[] = $ref;
+      } else {
+        $many_hits[] = $ref;
+      }
+    }
+
+    $pick_map = array();
+    $pick_selection = null;
+    $pick_id = 0;
+    if ($many_hits) {
+      foreach ($many_hits as $ref) {
+        $token = $ref->getToken();
+        if (strlen($token)) {
+          $message = pht('Argument "%s" is ambiguous.', $token);
+        } else {
+          $message = pht('Default behavior is ambiguous.');
+        }
+
+        $this->writeWarn(pht('AMBIGUOUS'), $message);
+      }
+
+      $is_single_ref = (count($refs) == 1);
+
+      $table = id(new PhutilConsoleTable());
+
+      if ($is_single_ref) {
+        $table->addColumn('pick', array('title' => pht('Pick')));
+      } else {
+        $table->addColumn('argument', array('title' => pht('Argument')));
+      }
+
+      $table
+        ->addColumn('type', array('title' => pht('Type')))
+        ->addColumn('uri', array('title' => pht('URI')));
+
+      foreach ($many_hits as $ref) {
+        $token_display = $ref->getToken();
+        if (!strlen($token)) {
+          $token_display = pht('<default>');
+        }
+
+        foreach ($ref->getURIs() as $uri) {
+          ++$pick_id;
+          $pick_map[$pick_id] = $uri;
+
+          $row = array(
+            'pick' => $pick_id,
+            'argument' => $token_display,
+            'type' => $uri->getType(),
+            'uri' => $uri->getURI(),
+          );
+
+          $table->addRow($row);
+        }
+      }
+
+      $table->draw();
+
+      if ($is_single_ref) {
+        $pick_selection = phutil_console_select(
+          pht('Which URI do you want to open?'),
+          1,
+          $pick_id);
+        $open_uris[] = $ref;
+      } else {
+        $this->writeInfo(
+          pht('CHOOSE'),
+          pht('Use "--types" to select between alternatives.'));
+      }
+    }
+
+    // If anything failed to resolve, this is also an error.
+    if ($zero_hits) {
+      foreach ($zero_hits as $ref) {
+        $token = $ref->getToken();
+        if ($token === null) {
+          echo tsprintf(
+            "%s\n",
+            pht(
+              'Unable to resolve default browse target.'));
+        } else {
+          echo tsprintf(
+            "%s\n",
+            pht(
+              'Unable to resolve argument "%s".',
+              $ref->getToken()));
+        }
+      }
+
+      foreach ($loaders as $loader) {
+        $loader->didFailToLoadBrowseURIRefs($refs);
+      }
+    }
+
+    $uris = array();
+    foreach ($open_uris as $ref) {
+      $ref_uris = $ref->getURIs();
+
+      if (count($ref_uris) > 1) {
+        foreach ($ref_uris as $uri_key => $uri) {
+          if ($pick_map[$pick_selection] !== $uri) {
+            unset($ref_uris[$uri_key]);
+          }
+        }
+      }
+
+      $ref_uri = head($ref_uris);
+      $uris[] = $ref_uri->getURI();
+    }
+
+    $this->openURIsInBrowser($uris);
+
+    return 0;
+  }
+
+}
diff --git a/src/conduit/ArcanistConduitCall.php b/src/conduit/ArcanistConduitCall.php
new file mode 100644
index 00000000..29e67762
--- /dev/null
+++ b/src/conduit/ArcanistConduitCall.php
@@ -0,0 +1,155 @@
+<?php
+
+final class ArcanistConduitCall
+  extends Phobject {
+
+  private $key;
+  private $engine;
+  private $method;
+  private $parameters;
+  private $future;
+
+  public function setKey($key) {
+    $this->key = $key;
+    return $this;
+  }
+
+  public function getKey() {
+    return $this->key;
+  }
+
+  public function setEngine(ArcanistConduitEngine $engine) {
+    $this->engine = $engine;
+    return $this;
+  }
+
+  public function getEngine() {
+    return $this->engine;
+  }
+
+  public function setMethod($method) {
+    $this->method = $method;
+    return $this;
+  }
+
+  public function getMethod() {
+    return $this->method;
+  }
+
+  public function setParameters(array $parameters) {
+    $this->parameters = $parameters;
+    return $this;
+  }
+
+  public function getParameters() {
+    return $this->parameters;
+  }
+
+  private function newFuture() {
+    if ($this->future) {
+      throw new Exception(
+        pht(
+          'Call has previously generated a future. Create a '.
+          'new call object for each API method invocation.'));
+    }
+
+    $method = $this->getMethod();
+    $parameters = $this->getParameters();
+    $future = $this->getEngine()->newFuture($this);
+    $this->future = $future;
+
+    return $this->future;
+  }
+
+  public function resolve() {
+    if (!$this->future) {
+      $this->newFuture();
+    }
+
+    $this->getEngine()->resolveFuture($this->getKey());
+
+    return $this->resolveFuture();
+  }
+
+  private function resolveFuture() {
+    $future = $this->future;
+
+    try {
+      $result = $future->resolve();
+    } catch (ConduitClientException $ex) {
+      switch ($ex->getErrorCode()) {
+        case 'ERR-INVALID-SESSION':
+          if (!$this->getEngine()->getConduitToken()) {
+            $this->raiseLoginRequired();
+          }
+          break;
+        case 'ERR-INVALID-AUTH':
+          $this->raiseInvalidAuth();
+          break;
+      }
+
+      throw $ex;
+    }
+
+    return $result;
+  }
+
+  private function raiseLoginRequired() {
+    $conduit_uri = $this->getEngine()->getConduitURI();
+    $conduit_uri = new PhutilURI($conduit_uri);
+    $conduit_uri->setPath('/');
+
+    $conduit_domain = $conduit_uri->getDomain();
+
+    $block = id(new PhutilConsoleBlock())
+      ->addParagraph(
+        tsprintf(
+          '**<bg:red> %s </bg>**',
+          pht('LOGIN REQUIRED')))
+      ->addParagraph(
+        pht(
+          'You are trying to connect to a server ("%s") that you do not '.
+          'have any stored credentials for, but the command you are '.
+          'running requires authentication.',
+          $conduit_domain))
+      ->addParagraph(
+        pht(
+          'To login and save credentials for this server, run this '.
+          'command:'))
+      ->addParagraph(
+        tsprintf(
+          "    $ arc install-certificate %s\n",
+          $conduit_uri));
+
+    throw new ArcanistUsageException($block->drawConsoleString());
+  }
+
+  private function raiseInvalidAuth() {
+    $conduit_uri = $this->getEngine()->getConduitURI();
+    $conduit_uri = new PhutilURI($conduit_uri);
+    $conduit_uri->setPath('/');
+
+    $conduit_domain = $conduit_uri->getDomain();
+
+    $block = id(new PhutilConsoleBlock())
+      ->addParagraph(
+        tsprintf(
+          '**<bg:red> %s </bg>**',
+          pht('INVALID CREDENTIALS')))
+      ->addParagraph(
+        pht(
+          'Your stored credentials for this server ("%s") are not valid.',
+          $conduit_domain))
+      ->addParagraph(
+        pht(
+          'To login and save valid credentials for this server, run this '.
+          'command:'))
+      ->addParagraph(
+        tsprintf(
+          "    $ arc install-certificate %s\n",
+          $conduit_uri));
+
+    throw new ArcanistUsageException($block->drawConsoleString());
+  }
+
+}
diff --git a/src/conduit/ArcanistConduitEngine.php b/src/conduit/ArcanistConduitEngine.php
new file mode 100644
index 00000000..d05859a2
--- /dev/null
+++ b/src/conduit/ArcanistConduitEngine.php
@@ -0,0 +1,166 @@
+<?php
+
+final class ArcanistConduitEngine
+  extends Phobject {
+
+  private $conduitURI;
+  private $conduitToken;
+
+  private $conduitTimeout;
+  private $basicAuthUser;
+  private $basicAuthPass;
+
+  private $client;
+  private $callKey = 0;
+  private $activeFutures = array();
+  private $resolvedFutures = array();
+
+  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 setBasicAuthUser($basic_auth_user) {
+    $this->basicAuthUser = $basic_auth_user;
+    return $this;
+  }
+
+  public function getBasicAuthUser() {
+    return $this->basicAuthUser;
+  }
+
+  public function setBasicAuthPass($basic_auth_pass) {
+    $this->basicAuthPass = $basic_auth_pass;
+    return $this;
+  }
+
+  public function getBasicAuthPass() {
+    return $this->basicAuthPass;
+  }
+
+  public function newCall($method, array $parameters) {
+    if ($this->conduitURI == null) {
+      $this->raiseURIException();
+    }
+
+    $next_key = ++$this->callKey;
+
+    return id(new ArcanistConduitCall())
+      ->setKey($next_key)
+      ->setEngine($this)
+      ->setMethod($method)
+      ->setParameters($parameters);
+  }
+
+  public function resolveCall($method, array $parameters) {
+    return $this->newCall($method, $parameters)->resolve();
+  }
+
+  public function newFuture(ArcanistConduitCall $call) {
+    $method = $call->getMethod();
+    $parameters = $call->getParameters();
+
+    $future = $this->getClient()->callMethod($method, $parameters);
+    $this->activeFutures[$call->getKey()] = $future;
+    return $future;
+  }
+
+  private function getClient() {
+    if (!$this->client) {
+      $conduit_uri = $this->getConduitURI();
+
+      $client = new ConduitClient($conduit_uri);
+
+      $timeout = $this->getConduitTimeout();
+      if ($timeout) {
+        $client->setTimeout($timeout);
+      }
+
+      $basic_user = $this->getBasicAuthUser();
+      $basic_pass = $this->getBasicAuthPass();
+      if ($basic_user !== null || $basic_pass !== null) {
+        $client->setBasicAuthCredentials($basic_user, $basic_pass);
+      }
+
+      $token = $this->getConduitToken();
+      if ($token) {
+        $client->setConduitToken($this->getConduitToken());
+      }
+    }
+
+    return $client;
+  }
+
+  public function resolveFuture($key) {
+    if (isset($this->resolvedFutures[$key])) {
+      return;
+    }
+
+    if (!isset($this->activeFutures[$key])) {
+      throw new Exception(
+        pht(
+          'No future with key "%s" is present in pool.',
+          $key));
+    }
+
+    $iterator = new FutureIterator($this->activeFutures);
+    foreach ($iterator as $future_key => $future) {
+      $this->resolvedFutures[$future_key] = $future;
+      unset($this->activeFutures[$future_key]);
+      if ($future_key == $key) {
+        break;
+      }
+    }
+
+    return;
+  }
+
+  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 default <uri>`.'))
+      ->addItem(
+        pht(
+          'Specify a URI explicitly with `--conduit-uri=<uri>`.'));
+
+    $block = id(new PhutilConsoleBlock())
+      ->addParagraph(
+        pht(
+          'This command needs to communicate with Phabricator, but no '.
+          'Phabricator URI is configured.'))
+      ->addList($list);
+
+    throw new ArcanistUsageException($block->drawConsoleString());
+  }
+
+}
diff --git a/src/configuration/ArcanistSetting.php b/src/configuration/ArcanistSetting.php
new file mode 100644
index 00000000..ff32239f
--- /dev/null
+++ b/src/configuration/ArcanistSetting.php
@@ -0,0 +1,48 @@
+<?php
+
+abstract class ArcanistSetting
+  extends Phobject {
+
+  final public function getSettingKey() {
+    return $this->getPhobjectClassConstant('SETTINGKEY', 32);
+  }
+
+  public function getAliases() {
+    return array();
+  }
+
+  abstract public function getHelp();
+  abstract public function getType();
+
+  public function getExample() {
+    return null;
+  }
+
+  final public function getLegacyDictionary() {
+    $result = array(
+      'type' => $this->getType(),
+      'help' => $this->getHelp(),
+    );
+
+    $example = $this->getExample();
+    if ($example !== null) {
+      $result['example'] = $example;
+    }
+
+    $aliases = $this->getAliases();
+    if ($aliases) {
+      $result['legacy'] = head($aliases);
+    }
+
+    return $result;
+  }
+
+  final public static function getAllSettings() {
+    return id(new PhutilClassMapQuery())
+      ->setAncestorClass(__CLASS__)
+      ->setUniqueMethod('getSettingKey')
+      ->setSortMethod('getSettingKey')
+      ->execute();
+  }
+
+}
diff --git a/src/configuration/ArcanistSettings.php b/src/configuration/ArcanistSettings.php
index fdf68259..5dc066a5 100644
--- a/src/configuration/ArcanistSettings.php
+++ b/src/configuration/ArcanistSettings.php
@@ -1,343 +1,340 @@
 <?php
 
 final class ArcanistSettings extends Phobject {
 
   private function getOptions() {
-    return array(
+    $legacy_builtins = array(
       'default' => array(
         'type' => 'string',
         'help' => pht(
           'The URI of a Phabricator install to connect to by default, if '.
           '%s is run in a project without a Phabricator URI or run outside '.
           'of a project.',
           'arc'),
         'example' => '"http://phabricator.example.com/"',
       ),
       'base' => array(
         'type' => 'string',
         'help' => pht(
           'Base commit ruleset to invoke when determining the start of a '.
           'commit range. See "Arcanist User Guide: Commit Ranges" for '.
           'details.'),
         'example' => '"arc:amended, arc:prompt"',
       ),
       '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"]',
       ),
       'repository.callsign' => array(
         'type' => 'string',
         'example' => '"X"',
         'help' => pht(
           'Associate the working copy with a specific Phabricator repository. '.
           'Normally, %s 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.',
           'arc'),
       ),
       'phabricator.uri' => array(
         'type' => 'string',
         'legacy' => 'conduit_uri',
         'example' => '"https://phabricator.mycompany.com/"',
         'help' => pht(
           'Associates this working copy with a specific installation of '.
           'Phabricator.'),
       ),
       'lint.engine' => array(
         'type' => 'string',
         'legacy' => 'lint_engine',
         'help' => pht(
           'The name of a default lint engine to use, if no lint engine is '.
           'specified by the current project.'),
         'example' => '"ExampleLintEngine"',
       ),
       'unit.engine' => array(
         'type' => 'string',
         'legacy' => 'unit_engine',
         'help' => pht(
           'The name of a default unit test engine to use, if no unit test '.
           'engine is specified by the current project.'),
         'example' => '"ExampleUnitTestEngine"',
       ),
       'arc.feature.start.default' => array(
         'type' => 'string',
         'help' => pht(
           'The name of the default branch to create the new feature branch '.
           'off of.'),
         'example' => '"develop"',
       ),
       'arc.land.onto.default' => array(
         'type' => 'string',
         'help' => pht(
           'The name of the default branch to land changes onto when '.
           '`%s` is run.',
           'arc land'),
         'example' => '"develop"',
       ),
-      'arc.lint.cache' => array(
-        'type' => 'bool',
-        'help' => pht(
-          'Enable the lint cache by default. When enabled, `%s` attempts to '.
-          'use cached results if possible. Currently, the cache is not always '.
-          'invalidated correctly and may cause `%s` to report incorrect '.
-          'results, particularly while developing linters. This is probably '.
-          'worth enabling only if your linters are very slow.',
-          'arc lint',
-          'arc lint'),
-        'default' => false,
-        'example' => 'false',
-      ),
       'history.immutable' => array(
         'type' => 'bool',
         'legacy' => 'immutable_history',
         'help' => pht(
           'If true, %s will never change repository history (e.g., through '.
           'amending or rebasing). Defaults to true in Mercurial and false in '.
           'Git. This setting has no effect in Subversion.',
           'arc'),
         'example' => 'false',
       ),
       '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',
       ),
       'https.blindly-trust-domains' => array(
         'type' => 'list',
         'help' => pht(
           'List of domains to blindly trust SSL certificates for. '.
           'Disables peer verification.'),
         'default' => array(),
         'example' => '["secure.mycompany.com"]',
       ),
       'browser' => array(
         'type' => 'string',
         'help' => pht('Command to use to invoke a web browser.'),
         'example' => '"gnome-www-browser"',
       ),
       'events.listeners' => array(
         'type' => 'list',
         'help' => pht('List of event listener classes to install at startup.'),
         'default' => array(),
         'example' => '["ExampleEventListener"]',
       ),
       'http.basicauth.user' => array(
         'type' => 'string',
         'help' => pht('Username to use for basic auth over HTTP transports.'),
         'example' => '"bob"',
       ),
       'http.basicauth.pass' => array(
         'type' => 'string',
         'help' => pht('Password to use for basic auth over HTTP transports.'),
         'example' => '"bobhasasecret"',
       ),
       'arc.autostash' => array(
         'type' => 'bool',
         'help' => pht(
           'Whether %s should permit the automatic stashing of changes in the '.
           'working directory when requiring a clean working copy. This option '.
           'should only be used when users understand how to restore their '.
           'working directory from the local stash if an Arcanist operation '.
           'causes an unrecoverable error.',
           'arc'),
         'default' => false,
         'example' => 'false',
       ),
       'aliases' => array(
         'type' => 'aliases',
         'help' => pht(
           'Configured command aliases. Use "arc alias" to define aliases.'),
       ),
     );
+
+    $settings = ArcanistSetting::getAllSettings();
+    foreach ($settings as $key => $setting) {
+      $settings[$key] = $setting->getLegacyDictionary();
+    }
+
+    $results = $settings + $legacy_builtins;
+    ksort($results);
+
+    return $results;
   }
 
   private function getOption($key) {
     return idx($this->getOptions(), $key, array());
   }
 
   public function getAllKeys() {
     return array_keys($this->getOptions());
   }
 
   public function getHelp($key) {
     return idx($this->getOption($key), 'help');
   }
 
   public function getExample($key) {
     return idx($this->getOption($key), 'example');
   }
 
   public function getType($key) {
     return idx($this->getOption($key), 'type', 'wild');
   }
 
   public function getLegacyName($key) {
     return idx($this->getOption($key), 'legacy');
   }
 
   public function getDefaultSettings() {
     $defaults = array();
     foreach ($this->getOptions() as $key => $option) {
       if (array_key_exists('default', $option)) {
         $defaults[$key] = $option['default'];
       }
     }
     return $defaults;
   }
 
   public function willWriteValue($key, $value) {
     $type = $this->getType($key);
     switch ($type) {
       case 'bool':
         if (strtolower($value) === 'false' ||
             strtolower($value) === 'no' ||
             strtolower($value) === 'off' ||
             $value === '' ||
             $value === '0' ||
             $value === 0 ||
             $value === false) {
           $value = false;
         } else if (strtolower($value) === 'true' ||
                    strtolower($value) === 'yes' ||
                    strtolower($value) === 'on' ||
                    $value === '1' ||
                    $value === 1 ||
                    $value === true) {
           $value = true;
         } else {
           throw new ArcanistUsageException(
             pht(
               "Type of setting '%s' must be boolean, like 'true' or 'false'.",
               $key));
         }
         break;
       case 'list':
         if (is_array($value)) {
           break;
         }
 
         if (is_string($value)) {
           $list = json_decode($value, true);
           if (is_array($list)) {
             $value = $list;
             break;
           }
         }
 
         throw new ArcanistUsageException(
           pht(
             "Type of setting '%s' must be list. You can specify a list ".
             "in JSON, like: %s",
             $key,
             '["apple", "banana", "cherry"]'));
 
       case 'string':
         if (!is_scalar($value)) {
           throw new ArcanistUsageException(
             pht(
               "Type of setting '%s' must be string.",
               $key));
         }
         $value = (string)$value;
         break;
       case 'wild':
         break;
       case 'aliases':
         throw new Exception(
           pht(
             'Use "arc alias" to configure aliases, not "arc set-config".'));
         break;
 
     }
 
     return $value;
   }
 
   public function willReadValue($key, $value) {
     $type = $this->getType($key);
     switch ($type) {
       case 'string':
         if (!is_string($value)) {
           throw new ArcanistUsageException(
             pht(
               "Type of setting '%s' must be string.",
               $key));
         }
         break;
       case 'bool':
         if ($value !== true && $value !== false) {
           throw new ArcanistUsageException(
             pht(
               "Type of setting '%s' must be boolean.",
               $key));
         }
         break;
       case 'list':
         if (!is_array($value)) {
           throw new ArcanistUsageException(
             pht(
               "Type of setting '%s' must be list.",
               $key));
         }
         break;
       case 'wild':
       case 'aliases':
         break;
     }
 
     return $value;
   }
 
   public function formatConfigValueForDisplay($key, $value) {
     if ($value === false) {
       return 'false';
     }
 
     if ($value === true) {
       return 'true';
     }
 
     if ($value === null) {
       return 'null';
     }
 
     if (is_string($value)) {
       return '"'.$value.'"';
     }
 
     if (is_array($value)) {
       // TODO: Both json_encode() and PhutilJSON do a bad job with one-liners.
       // PhutilJSON splits them across a bunch of lines, while json_encode()
       // escapes all kinds of stuff like "/". It would be nice if PhutilJSON
       // had a mode for pretty one-liners.
       $value = json_encode($value);
 
       // json_encode() unnecessarily escapes "/" to prevent "</script>" stuff,
       // optimistically unescape it for display to improve readability.
       $value = preg_replace('@(?<!\\\\)\\\\/@', '/', $value);
       return $value;
     }
 
     return $value;
   }
 
 }
diff --git a/src/loader/ArcanistCommitUpstreamHardpointLoader.php b/src/loader/ArcanistCommitUpstreamHardpointLoader.php
new file mode 100644
index 00000000..4f7c251e
--- /dev/null
+++ b/src/loader/ArcanistCommitUpstreamHardpointLoader.php
@@ -0,0 +1,59 @@
+<?php
+
+final class ArcanistCommitUpstreamHardpointLoader
+  extends ArcanistHardpointLoader {
+
+  const LOADERKEY = 'commit.conduit';
+
+  public function canLoadRepositoryAPI(ArcanistRepositoryAPI $api) {
+    return true;
+  }
+
+  public function canLoadRef(ArcanistRef $ref) {
+    return ($ref instanceof ArcanistCommitRef);
+  }
+
+  public function canLoadHardpoint(ArcanistRef $ref, $hardpoint) {
+    return ($hardpoint == 'upstream');
+  }
+
+  public function loadHardpoints(array $refs, $hardpoint) {
+    $query = $this->getQuery();
+
+    $repository_ref = $query->getRepositoryRef();
+    if (!$repository_ref) {
+      return array_fill_keys(array_keys($refs), null);
+    }
+    $repository_phid = $repository_ref->getPHID();
+
+    $commit_map = array();
+    foreach ($refs as $key => $ref) {
+      $hash = $ref->getCommitHash();
+      $commit_map[$hash][] = $key;
+    }
+
+    $commit_info = $this->resolveCall(
+      'diffusion.querycommits',
+      array(
+        'repositoryPHID' => $repository_phid,
+        'names' => array_keys($commit_map),
+      ));
+
+    $results = array();
+    foreach ($commit_map as $hash => $keys) {
+      $commit_phid = idx($commit_info['identifierMap'], $hash);
+      if ($commit_phid) {
+        $commit_data = idx($commit_info['data'], $commit_phid);
+      } else {
+        $commit_data = null;
+      }
+
+      foreach ($keys as $key) {
+        $results[$key] = $commit_data;
+      }
+    }
+
+    return $results;
+  }
+
+}
diff --git a/src/loader/ArcanistGitCommitMessageHardpointLoader.php b/src/loader/ArcanistGitCommitMessageHardpointLoader.php
new file mode 100644
index 00000000..fb39d85e
--- /dev/null
+++ b/src/loader/ArcanistGitCommitMessageHardpointLoader.php
@@ -0,0 +1,41 @@
+<?php
+
+final class ArcanistGitCommitMessageHardpointLoader
+  extends ArcanistGitHardpointLoader {
+
+  const LOADERKEY = 'git.commit.message';
+
+  public function canLoadRef(ArcanistRef $ref) {
+    return ($ref instanceof ArcanistCommitRef);
+  }
+
+  public function canLoadHardpoint(ArcanistRef $ref, $hardpoint) {
+    return ($hardpoint == 'message');
+  }
+
+  public function loadHardpoints(array $refs, $hardpoint) {
+    $api = $this->getQuery()->getRepositoryAPI();
+
+
+    $futures = array();
+    foreach ($refs as $ref_key => $ref) {
+      $hash = $ref->getCommitHash();
+
+      $futures[$ref_key] = $api->execFutureLocal(
+        'log -n1 --format=%C %s --',
+        '%s%n%n%b',
+        $hash);
+    }
+
+    $iterator = $this->newFutureIterator($futures);
+
+    $results = array();
+    foreach ($iterator as $ref_key => $future) {
+      list($stdout) = $future->resolvex();
+      $results[$ref_key] = $stdout;
+    }
+
+    return $results;
+  }
+
+}
diff --git a/src/loader/ArcanistGitHardpointLoader.php b/src/loader/ArcanistGitHardpointLoader.php
new file mode 100644
index 00000000..827f48d4
--- /dev/null
+++ b/src/loader/ArcanistGitHardpointLoader.php
@@ -0,0 +1,10 @@
+<?php
+
+abstract class ArcanistGitHardpointLoader
+  extends ArcanistHardpointLoader {
+
+  public function canLoadRepositoryAPI(ArcanistRepositoryAPI $api) {
+    return ($api instanceof ArcanistGitAPI);
+  }
+
+}
diff --git a/src/loader/ArcanistGitRevisionHardpointLoader.php b/src/loader/ArcanistGitRevisionHardpointLoader.php
new file mode 100644
index 00000000..c609632a
--- /dev/null
+++ b/src/loader/ArcanistGitRevisionHardpointLoader.php
@@ -0,0 +1,82 @@
+<?php
+
+final class ArcanistGitRevisionHardpointLoader
+  extends ArcanistGitHardpointLoader {
+
+  const LOADERKEY = 'git.revision';
+
+  public function canLoadRef(ArcanistRef $ref) {
+    return ($ref instanceof ArcanistWorkingCopyStateRef);
+  }
+
+  public function canLoadHardpoint(ArcanistRef $ref, $hardpoint) {
+    return ($hardpoint == 'revisionRefs');
+  }
+
+  public function loadHardpoints(array $refs, $hardpoint) {
+    $this->newQuery($refs)
+      ->needHardpoints(
+        array(
+          'commitRef',
+        ))
+      ->execute();
+
+    $hashes = array();
+    $map = array();
+    foreach ($refs as $ref_key => $ref) {
+      $commit = $ref->getCommitRef();
+
+      $commit_hashes = array();
+
+      $commit_hashes[] = array(
+        'gtcm',
+        $commit->getCommitHash(),
+      );
+
+      if ($commit->getTreeHash()) {
+        $commit_hashes[] = array(
+          'gttr',
+          $commit->getTreeHash(),
+        );
+      }
+
+      foreach ($commit_hashes as $hash) {
+        $hashes[] = $hash;
+        $hash_key = $this->getHashKey($hash);
+        $map[$hash_key][$ref_key] = $ref;
+      }
+    }
+
+    $results = array();
+    if ($hashes) {
+      $revisions = $this->resolveCall(
+        'differential.query',
+        array(
+          'commitHashes' => $hashes,
+        ));
+
+      foreach ($revisions as $dict) {
+        $revision_hashes = idx($dict, 'hashes');
+        if (!$revision_hashes) {
+          continue;
+        }
+
+        $revision_ref = ArcanistRevisionRef::newFromConduit($dict);
+        foreach ($revision_hashes as $revision_hash) {
+          $hash_key = $this->getHashKey($revision_hash);
+          $state_refs = idx($map, $hash_key, array());
+          foreach ($state_refs as $ref_key => $state_ref) {
+            $results[$ref_key][] = $revision_ref;
+          }
+        }
+      }
+    }
+
+    return $results;
+  }
+
+  private function getHashKey(array $hash) {
+    return $hash[0].':'.$hash[1];
+  }
+
+}
diff --git a/src/loader/ArcanistHardpointLoader.php b/src/loader/ArcanistHardpointLoader.php
new file mode 100644
index 00000000..467fdebf
--- /dev/null
+++ b/src/loader/ArcanistHardpointLoader.php
@@ -0,0 +1,76 @@
+<?php
+
+abstract class ArcanistHardpointLoader
+  extends Phobject {
+
+  private $query;
+  private $conduitEngine;
+
+  abstract public function canLoadRepositoryAPI(ArcanistRepositoryAPI $api);
+  abstract public function canLoadRef(ArcanistRef $ref);
+  abstract public function canLoadHardpoint(ArcanistRef $ref, $hardpoint);
+  abstract public function loadHardpoints(array $refs, $hardpoint);
+
+  final public function setQuery(ArcanistRefQuery $query) {
+    $this->query = $query;
+    return $this;
+  }
+
+  final public function getQuery() {
+    return $this->query;
+  }
+
+  final public function getConduitEngine() {
+    return $this->getQuery()->getConduitEngine();
+  }
+
+  final protected function newQuery(array $refs) {
+    $result = id(new ArcanistRefQuery())
+      ->setConduitEngine($this->getQuery()->getConduitEngine())
+      ->setRefs($refs);
+
+    $query = $this->getQuery();
+
+    $repository_api = $query->getRepositoryAPI();
+    if ($repository_api) {
+      $result->setRepositoryAPI($repository_api);
+    }
+
+    $repository_ref = $query->getRepositoryRef();
+    if ($repository_ref) {
+      $result->setRepositoryRef($repository_ref);
+    }
+
+    $working_ref = $query->getWorkingCopyRef();
+    if ($working_ref) {
+      $result->setWorkingCopyRef($working_ref);
+    }
+
+    return $result;
+  }
+
+  final public function getLoaderKey() {
+    return $this->getPhobjectClassConstant('LOADERKEY', 64);
+  }
+
+  final public static function getAllLoaders() {
+    return id(new PhutilClassMapQuery())
+      ->setAncestorClass(__CLASS__)
+      ->setUniqueMethod('getLoaderKey')
+      ->execute();
+  }
+
+  final public function resolveCall($method, array $parameters) {
+    return $this->newCall($method, $parameters)->resolve();
+  }
+
+  final public function newCall($method, array $parameters) {
+    return $this->getConduitEngine()->newCall($method, $parameters);
+  }
+
+  final protected function newFutureIterator(array $futures) {
+    return id(new FutureIterator($futures))
+      ->limit(16);
+  }
+
+}
diff --git a/src/loader/ArcanistMercurialBranchCommitHardpointLoader.php b/src/loader/ArcanistMercurialBranchCommitHardpointLoader.php
new file mode 100644
index 00000000..a1c69823
--- /dev/null
+++ b/src/loader/ArcanistMercurialBranchCommitHardpointLoader.php
@@ -0,0 +1,49 @@
+<?php
+
+final class ArcanistMercurialBranchCommitHardpointLoader
+  extends ArcanistMercurialHardpointLoader {
+
+  const LOADERKEY = 'hg.branch.commit';
+
+  public function canLoadRef(ArcanistRef $ref) {
+    return ($ref instanceof ArcanistBranchRef);
+  }
+
+  public function canLoadHardpoint(ArcanistRef $ref, $hardpoint) {
+    return ($hardpoint == 'commitRef');
+  }
+
+  public function loadHardpoints(array $refs, $hardpoint) {
+    $api = $this->getQuery()->getRepositoryAPI();
+
+    $futures = array();
+    foreach ($refs as $ref_key => $branch) {
+      $branch_name = $branch->getBranchName();
+
+      $futures[$ref_key] = $api->execFutureLocal(
+        'log -l 1 --template %s -r %s',
+        "{node}\1{date|hgdate}\1{p1node}\1{desc|firstline}\1{desc}",
+        hgsprintf('%s', $branch_name));
+    }
+
+    $results = array();
+
+    $iterator = $this->newFutureIterator($futures);
+    foreach ($iterator as $ref_key => $future) {
+      list($info) = $future->resolvex();
+
+      $fields = explode("\1", trim($info), 5);
+      list($hash, $epoch, $parent, $desc, $text) = $fields;
+
+      $commit_ref = $api->newCommitRef()
+        ->setCommitHash($hash)
+        ->setCommitEpoch((int)$epoch)
+        ->attachMessage($text);
+
+      $results[$ref_key] = $commit_ref;
+    }
+
+    return $results;
+  }
+
+}
diff --git a/src/loader/ArcanistMercurialHardpointLoader.php b/src/loader/ArcanistMercurialHardpointLoader.php
new file mode 100644
index 00000000..dc4badde
--- /dev/null
+++ b/src/loader/ArcanistMercurialHardpointLoader.php
@@ -0,0 +1,10 @@
+<?php
+
+abstract class ArcanistMercurialHardpointLoader
+  extends ArcanistHardpointLoader {
+
+  public function canLoadRepositoryAPI(ArcanistRepositoryAPI $api) {
+    return ($api instanceof ArcanistMercurialAPI);
+  }
+
+}
diff --git a/src/loader/ArcanistMercurialWorkingCopyCommitHardpointLoader.php b/src/loader/ArcanistMercurialWorkingCopyCommitHardpointLoader.php
new file mode 100644
index 00000000..e12c6605
--- /dev/null
+++ b/src/loader/ArcanistMercurialWorkingCopyCommitHardpointLoader.php
@@ -0,0 +1,36 @@
+<?php
+
+final class ArcanistMercurialWorkingCopyCommitHardpointLoader
+  extends ArcanistMercurialHardpointLoader {
+
+  const LOADERKEY = 'hg.state.commit';
+
+  public function canLoadRef(ArcanistRef $ref) {
+    return ($ref instanceof ArcanistWorkingCopyStateRef);
+  }
+
+  public function canLoadHardpoint(ArcanistRef $ref, $hardpoint) {
+    return ($hardpoint == 'commitRef');
+  }
+
+  public function loadHardpoints(array $refs, $hardpoint) {
+    $branch_refs = array();
+    foreach ($refs as $ref_key => $ref) {
+      if ($ref->hasAttachedHardpoint('branchRef')) {
+        $branch_refs[$ref_key] = $ref->getBranchRef();
+      }
+    }
+
+    if ($branch_refs) {
+      $this->newQuery($branch_refs)
+        ->needHardpoints(
+          array(
+            'commitRef',
+          ))
+        ->execute();
+    }
+
+    return mpull($branch_refs, 'getCommitRef');
+  }
+
+}
diff --git a/src/loader/ArcanistMessageRevisionHardpointLoader.php b/src/loader/ArcanistMessageRevisionHardpointLoader.php
new file mode 100644
index 00000000..db01d983
--- /dev/null
+++ b/src/loader/ArcanistMessageRevisionHardpointLoader.php
@@ -0,0 +1,82 @@
+<?php
+
+final class ArcanistMessageRevisionHardpointLoader
+  extends ArcanistHardpointLoader {
+
+  const LOADERKEY = 'message.revision';
+
+  public function canLoadRepositoryAPI(ArcanistRepositoryAPI $api) {
+    return true;
+  }
+
+  public function canLoadRef(ArcanistRef $ref) {
+    return ($ref instanceof ArcanistWorkingCopyStateRef);
+  }
+
+  public function canLoadHardpoint(ArcanistRef $ref, $hardpoint) {
+    return ($hardpoint == 'revisionRefs');
+  }
+
+  public function loadHardpoints(array $refs, $hardpoint) {
+    $this->newQuery($refs)
+      ->needHardpoints(
+        array(
+          'commitRef',
+        ))
+      ->execute();
+
+    $commit_refs = array();
+    foreach ($refs as $ref) {
+      $commit_refs[] = $ref->getCommitRef();
+    }
+
+    $this->newQuery($commit_refs)
+      ->needHardpoints(
+        array(
+          'message',
+        ))
+      ->execute();
+
+    $map = array();
+    foreach ($refs as $ref_key => $ref) {
+      $commit_ref = $ref->getCommitRef();
+      $corpus = $commit_ref->getMessage();
+
+      $id = null;
+      try {
+        $message = ArcanistDifferentialCommitMessage::newFromRawCorpus($corpus);
+        $id = $message->getRevisionID();
+      } catch (ArcanistUsageException $ex) {
+        continue;
+      }
+
+      if (!$id) {
+        continue;
+      }
+
+      $map[$id][$ref_key] = $ref;
+    }
+
+    $results = array();
+    if ($map) {
+      $revisions = $this->resolveCall(
+        'differential.query',
+        array(
+          'ids' => array_keys($map),
+        ));
+
+      foreach ($revisions as $dict) {
+        $revision_ref = ArcanistRevisionRef::newFromConduit($dict);
+        $id = $dict['id'];
+
+        $state_refs = idx($map, $id, array());
+        foreach ($state_refs as $ref_key => $state_ref) {
+          $results[$ref_key][] = $revision_ref;
+        }
+      }
+    }
+
+    return $results;
+  }
+
+}
diff --git a/src/ref/ArcanistBranchRef.php b/src/ref/ArcanistBranchRef.php
new file mode 100644
index 00000000..34a75017
--- /dev/null
+++ b/src/ref/ArcanistBranchRef.php
@@ -0,0 +1,57 @@
+<?php
+
+final class ArcanistBranchRef
+  extends ArcanistRef {
+
+  private $branchName;
+  private $refName;
+  private $isCurrentBranch;
+
+  public function getRefIdentifier() {
+    return pht('Branch %s', $this->getBranchName());
+  }
+
+  public function defineHardpoints() {
+    return array(
+      'commitRef' => array(
+        'type' => 'ArcanistCommitRef',
+      ),
+    );
+  }
+
+  public function setBranchName($branch_name) {
+    $this->branchName = $branch_name;
+    return $this;
+  }
+
+  public function getBranchName() {
+    return $this->branchName;
+  }
+
+  public function setRefName($ref_name) {
+    $this->refName = $ref_name;
+    return $this;
+  }
+
+  public function getRefName() {
+    return $this->refName;
+  }
+
+  public function setIsCurrentBranch($is_current_branch) {
+    $this->isCurrentBranch = $is_current_branch;
+    return $this;
+  }
+
+  public function getIsCurrentBranch() {
+    return $this->isCurrentBranch;
+  }
+
+  public function attachCommitRef(ArcanistCommitRef $ref) {
+    return $this->attachHardpoint('commitRef', $ref);
+  }
+
+  public function getCommitRef() {
+    return $this->getHardpoint('commitRef');
+  }
+
+}
diff --git a/src/ref/ArcanistCommitRef.php b/src/ref/ArcanistCommitRef.php
new file mode 100644
index 00000000..8058c74a
--- /dev/null
+++ b/src/ref/ArcanistCommitRef.php
@@ -0,0 +1,94 @@
+<?php
+
+final class ArcanistCommitRef
+  extends ArcanistRef {
+
+  private $commitHash;
+  private $treeHash;
+  private $commitEpoch;
+  private $authorEpoch;
+  private $upstream;
+
+  public function getRefIdentifier() {
+    return pht('Commit %s', $this->getCommitHash());
+  }
+
+  public function defineHardpoints() {
+    return array(
+      'message' => array(
+        'type' => 'string',
+      ),
+      'upstream' => array(
+        'type' => 'wild',
+      ),
+    );
+  }
+
+  public function setCommitHash($commit_hash) {
+    $this->commitHash = $commit_hash;
+    return $this;
+  }
+
+  public function getCommitHash() {
+    return $this->commitHash;
+  }
+
+  public function setTreeHash($tree_hash) {
+    $this->treeHash = $tree_hash;
+    return $this;
+  }
+
+  public function getTreeHash() {
+    return $this->treeHash;
+  }
+
+  public function setCommitEpoch($commit_epoch) {
+    $this->commitEpoch = $commit_epoch;
+    return $this;
+  }
+
+  public function getCommitEpoch() {
+    return $this->commitEpoch;
+  }
+
+  public function setAuthorEpoch($author_epoch) {
+    $this->authorEpoch = $author_epoch;
+    return $this;
+  }
+
+  public function getAuthorEpoch() {
+    return $this->authorEpoch;
+  }
+
+  public function getSummary() {
+    $message = $this->getMessage();
+
+    $message = trim($message);
+    $lines = phutil_split_lines($message, false);
+
+    return head($lines);
+  }
+
+  public function attachMessage($message) {
+    return $this->attachHardpoint('message', $message);
+  }
+
+  public function getMessage() {
+    return $this->getHardpoint('message');
+  }
+
+  public function getURI() {
+    return $this->getUpstreamProperty('uri');
+  }
+
+  private function getUpstreamProperty($key, $default = null) {
+    $upstream = $this->getHardpoint('upstream');
+
+    if (!$upstream) {
+      return $default;
+    }
+
+    return idx($upstream, $key, $default);
+  }
+
+}
diff --git a/src/ref/ArcanistRef.php b/src/ref/ArcanistRef.php
new file mode 100644
index 00000000..2c1869cf
--- /dev/null
+++ b/src/ref/ArcanistRef.php
@@ -0,0 +1,106 @@
+<?php
+
+abstract class ArcanistRef
+  extends Phobject {
+
+  private $hardpoints = array();
+
+  abstract public function getRefIdentifier();
+  abstract public function defineHardpoints();
+
+  final public function hasHardpoint($hardpoint) {
+    $map = $this->getHardpointMap();
+    return isset($map[$hardpoint]);
+  }
+
+  final public function hasAttachedHardpoint($hardpoint) {
+    if (array_key_exists($hardpoint, $this->hardpoints)) {
+      return true;
+    }
+
+    return $this->canReadHardpoint($hardpoint);
+  }
+
+  final public function attachHardpoint($hardpoint, $value) {
+    if (!$this->hasHardpoint($hardpoint)) {
+      throw new Exception(pht('No hardpoint "%s".', $hardpoint));
+    }
+
+    $this->hardpoints[$hardpoint] = $value;
+
+    return $this;
+  }
+
+  final public function appendHardpoint($hardpoint, array $value) {
+    if (!$this->isVectorHardpoint($hardpoint)) {
+      throw new Exception(
+        pht(
+          'Hardpoint "%s" is not a vector hardpoint.',
+          $hardpoint));
+    }
+
+    if (!isset($this->hardpoints[$hardpoint])) {
+      $this->hardpoints[$hardpoint] = array();
+    }
+
+    $this->hardpoints[$hardpoint] = $this->mergeHardpoint(
+      $hardpoint,
+      $this->hardpoints[$hardpoint],
+      $value);
+
+    return $this;
+  }
+
+  protected function mergeHardpoint($hardpoint, array $src, array $new) {
+    foreach ($new as $value) {
+      $src[] = $value;
+    }
+    return $src;
+  }
+
+  final public function isVectorHardpoint($hardpoint) {
+    if (!$this->hasHardpoint($hardpoint)) {
+      return false;
+    }
+
+    $map = $this->getHardpointMap();
+    $spec = idx($map, $hardpoint, array());
+
+    return (idx($spec, 'vector') === true);
+  }
+
+  final public function getHardpoint($hardpoint) {
+    if (!$this->hasAttachedHardpoint($hardpoint)) {
+      if (!$this->hasHardpoint($hardpoint)) {
+        throw new Exception(
+          pht(
+            'Ref does not have hardpoint "%s"!',
+            $hardpoint));
+      } else {
+        throw new Exception(
+          pht(
+            'Hardpoint "%s" is not attached!',
+            $hardpoint));
+      }
+    }
+
+    if (array_key_exists($hardpoint, $this->hardpoints)) {
+      return $this->hardpoints[$hardpoint];
+    }
+
+    return $this->readHardpoint($hardpoint);
+  }
+
+  private function getHardpointMap() {
+    return $this->defineHardpoints();
+  }
+
+  protected function canReadHardpoint($hardpoint) {
+    return false;
+  }
+
+  protected function readHardpoint($hardpoint) {
+    throw new Exception(pht('Can not read hardpoint "%s".', $hardpoint));
+  }
+
+}
diff --git a/src/ref/ArcanistRefQuery.php b/src/ref/ArcanistRefQuery.php
new file mode 100644
index 00000000..f5d954c8
--- /dev/null
+++ b/src/ref/ArcanistRefQuery.php
@@ -0,0 +1,188 @@
+<?php
+
+final class ArcanistRefQuery extends Phobject {
+
+  private $repositoryAPI;
+  private $conduitEngine;
+  private $repositoryRef;
+  private $workingCopyRef;
+
+  private $refs;
+  private $hardpoints;
+  private $loaders;
+
+  public function setRefs(array $refs) {
+    assert_instances_of($refs, 'ArcanistRef');
+    $this->refs = $refs;
+    return $this;
+  }
+
+  public function getRefs() {
+    return $this->refs;
+  }
+
+  public function setRepositoryAPI(ArcanistRepositoryAPI $repository_api) {
+    $this->repositoryAPI = $repository_api;
+    return $this;
+  }
+
+  public function getRepositoryAPI() {
+    return $this->repositoryAPI;
+  }
+
+  public function setRepositoryRef(ArcanistRepositoryRef $repository_ref) {
+    $this->repositoryRef = $repository_ref;
+    return $this;
+  }
+  public function getRepositoryRef() {
+    return $this->repositoryRef;
+  }
+
+  public function setConduitEngine(ArcanistConduitEngine $conduit_engine) {
+    $this->conduitEngine = $conduit_engine;
+    return $this;
+  }
+
+  public function getConduitEngine() {
+    return $this->conduitEngine;
+  }
+
+  public function setWorkingCopyRef(ArcanistWorkingCopyStateRef $working_ref) {
+    $this->workingCopyRef = $working_ref;
+    return $this;
+  }
+
+  public function getWorkingCopyRef() {
+    return $this->workingCopyRef;
+  }
+
+  public function needHardpoints(array $hardpoints) {
+    $this->hardpoints = $hardpoints;
+    return $this;
+  }
+
+  public function setLoaders(array $loaders) {
+    assert_instances_of($loaders, 'ArcanistHardpointLoader');
+
+    foreach ($loaders as $key => $loader) {
+      $loader->setQuery($this);
+    }
+    $this->loaders = $loaders;
+
+    return $this;
+  }
+
+  public function execute() {
+    $refs = $this->getRefs();
+
+    if ($this->refs === null) {
+      throw new PhutilInvalidStateException('setRefs');
+    }
+
+    if ($this->hardpoints === null) {
+      throw new PhutilInvalidStateException('needHardpoints');
+    }
+
+    if ($this->loaders == null) {
+      $all_loaders = ArcanistHardpointLoader::getAllLoaders();
+      foreach ($all_loaders as $key => $loader) {
+        $all_loaders[$key] = clone $loader;
+      }
+      $this->setLoaders($all_loaders);
+    }
+
+    $all_loaders = $this->loaders;
+
+    $api = $this->getRepositoryAPI();
+    $loaders = array();
+    foreach ($all_loaders as $loader_key => $loader) {
+      if ($api) {
+        if (!$loader->canLoadRepositoryAPI($api)) {
+          continue;
+        }
+      }
+
+      $loaders[$loader_key] = id(clone $loader)
+        ->setQuery($this);
+    }
+
+    foreach ($this->hardpoints as $hardpoint) {
+      $load = array();
+      $need = array();
+      $has_hardpoint = false;
+      foreach ($refs as $ref_key => $ref) {
+        if (!$ref->hasHardpoint($hardpoint)) {
+          continue;
+        }
+
+        $has_hardpoint = true;
+
+        if ($ref->hasAttachedHardpoint($hardpoint)) {
+          continue;
+        }
+
+        foreach ($loaders as $loader_key => $loader) {
+          if (!$loader->canLoadRef($ref)) {
+            continue;
+          }
+
+          if (!$loader->canLoadHardpoint($ref, $hardpoint)) {
+            continue;
+          }
+
+          $load[$loader_key][$ref_key] = $ref;
+        }
+
+        $need[$ref_key] = $ref_key;
+      }
+
+      if ($refs && !$has_hardpoint) {
+        throw new Exception(
+          pht(
+            'No ref in query has hardpoint "%s".',
+            $hardpoint));
+      }
+
+      $vectors = array();
+      foreach ($need as $ref_key) {
+        $ref = $refs[$ref_key];
+        if ($ref->isVectorHardpoint($hardpoint)) {
+          $vectors[$ref_key] = $ref_key;
+          $ref->attachHardpoint($hardpoint, array());
+        }
+      }
+
+      foreach ($load as $loader_key => $loader_refs) {
+        $loader_refs = array_select_keys($loader_refs, $need);
+
+        $loader = $loaders[$loader_key];
+        $data = $loader->loadHardpoints($loader_refs, $hardpoint);
+
+        foreach ($data as $ref_key => $value) {
+          $ref = $refs[$ref_key];
+          if (isset($vectors[$ref_key])) {
+            $ref->appendHardpoint($hardpoint, $value);
+          } else {
+            unset($need[$ref_key]);
+            $ref->attachHardpoint($hardpoint, $value);
+          }
+        }
+      }
+
+      foreach ($vectors as $ref_key) {
+        unset($need[$ref_key]);
+      }
+
+      if ($need) {
+        throw new Exception(
+          pht(
+            'Nothing could attach data to hardpoint "%s" for ref "%s".',
+            $hardpoint,
+            $refs[head($need)]->getRefIdentifier()));
+      }
+    }
+
+    return $refs;
+  }
+
+}
diff --git a/src/ref/ArcanistRepositoryRef.php b/src/ref/ArcanistRepositoryRef.php
new file mode 100644
index 00000000..d381efd2
--- /dev/null
+++ b/src/ref/ArcanistRepositoryRef.php
@@ -0,0 +1,79 @@
+<?php
+
+final class ArcanistRepositoryRef
+  extends ArcanistRef {
+
+  private $phid;
+  private $browseURI;
+
+  public function getRefIdentifier() {
+    return pht('Remote Repository');
+  }
+
+  public function defineHardpoints() {
+    return array();
+  }
+
+  public function setPHID($phid) {
+    $this->phid = $phid;
+    return $this;
+  }
+
+  public function getPHID() {
+    return $this->phid;
+  }
+
+  public function setBrowseURI($browse_uri) {
+    $this->browseURI = $browse_uri;
+    return $this;
+  }
+
+  public function newBrowseURI(array $params) {
+    PhutilTypeSpec::checkMap(
+      $params,
+      array(
+        'path' => 'optional string|null',
+        'branch' => 'optional string|null',
+        'lines' => 'optional string|null',
+      ));
+
+    foreach ($params as $key => $value) {
+      if (!strlen($value)) {
+        unset($params[$key]);
+      }
+    }
+
+    $defaults = array(
+      'path' => '/',
+      'branch' => $this->getDefaultBranch(),
+      'lines' => null,
+    );
+
+    $params = $params + $defaults;
+
+    $uri_base = $this->browseURI;
+    $uri_base = rtrim($uri_base, '/');
+
+    $uri_branch = phutil_escape_uri_path_component($params['branch']);
+
+    $uri_path = ltrim($params['path'], '/');
+    $uri_path = phutil_escape_uri($uri_path);
+
+    $uri_lines = null;
+    if ($params['lines']) {
+      $uri_lines = '$'.phutil_escape_uri($params['lines']);
+    }
+
+    // TODO: This construction, which includes a branch, is probably wrong for
+    // Subversion.
+
+    return "{$uri_base}/browse/{$uri_branch}/{$uri_path}{$uri_lines}";
+  }
+
+  public function getDefaultBranch() {
+    // TODO: This should read from the remote, and is not correct for
+    // Mercurial anyway, as "default" would be a better default branch.
+    return 'master';
+  }
+
+}
diff --git a/src/ref/ArcanistRevisionRef.php b/src/ref/ArcanistRevisionRef.php
new file mode 100644
index 00000000..5e1f2321
--- /dev/null
+++ b/src/ref/ArcanistRevisionRef.php
@@ -0,0 +1,72 @@
+<?php
+
+final class ArcanistRevisionRef
+  extends ArcanistRef {
+
+  private $parameters;
+  private $sources = array();
+
+  public function getRefIdentifier() {
+    return pht('Revision %s', $this->getMonogram());
+  }
+
+  public function defineHardpoints() {
+    return array();
+  }
+
+  public static function newFromConduit(array $dict) {
+    $ref = new self();
+    $ref->parameters = $dict;
+    return $ref;
+  }
+
+  public function getMonogram() {
+    return 'D'.$this->getID();
+  }
+
+  public function getStatusDisplayName() {
+    return idx($this->parameters, 'statusName');
+  }
+
+  public function isClosed() {
+    // TODO: This should use sensible constants, not English language
+    // display text.
+    switch ($this->getStatusDisplayName()) {
+      case 'Abandoned':
+      case 'Closed':
+        return true;
+    }
+
+    return false;
+  }
+
+  public function getURI() {
+    return idx($this->parameters, 'uri');
+  }
+
+  public function getFullName() {
+    return pht('%s: %s', $this->getMonogram(), $this->getName());
+  }
+
+  public function getID() {
+    return idx($this->parameters, 'id');
+  }
+
+  public function getName() {
+    return idx($this->parameters, 'title');
+  }
+
+  public function getAuthorPHID() {
+    return idx($this->parameters, 'authorPHID');
+  }
+
+  public function addSource(ArcanistRevisionRefSource $source) {
+    $this->sources[] = $source;
+    return $this;
+  }
+
+  public function getSources() {
+    return $this->sources;
+  }
+
+}
diff --git a/src/ref/ArcanistRevisionRefSource.php b/src/ref/ArcanistRevisionRefSource.php
new file mode 100644
index 00000000..0f3e5b8d
--- /dev/null
+++ b/src/ref/ArcanistRevisionRefSource.php
@@ -0,0 +1,4 @@
+<?php
+
+abstract class ArcanistRevisionRefSource
+  extends Phobject {}
diff --git a/src/ref/ArcanistWorkingCopyStateRef.php b/src/ref/ArcanistWorkingCopyStateRef.php
new file mode 100644
index 00000000..ad468518
--- /dev/null
+++ b/src/ref/ArcanistWorkingCopyStateRef.php
@@ -0,0 +1,122 @@
+<?php
+
+final class ArcanistWorkingCopyStateRef
+  extends ArcanistRef {
+
+  private $rootDirectory;
+
+  public function getRefIdentifier() {
+    // TODO: This could check attached hardpoints and render something more
+    // insightful.
+    return pht('Working Copy State');
+  }
+
+  public function defineHardpoints() {
+    return array(
+      'commitRef' => array(
+        'type' => 'ArcanistCommitRef',
+      ),
+      'branchRef' => array(
+        'type' => 'ArcanistBranchRef',
+      ),
+      'revisionRefs' => array(
+        'type' => 'ArcanistRevisionRef',
+        'vector' => true,
+      ),
+    );
+  }
+
+  public function setRootDirectory($root_directory) {
+    $this->rootDirectory = $root_directory;
+    return $this;
+  }
+
+  public function getRootDirectory() {
+    return $this->rootDirectory;
+  }
+
+  public function attachBranchRef(ArcanistBranchRef $branch_ref) {
+    return $this->attachHardpoint('branchRef', $branch_ref);
+  }
+
+  public function getBranchRef() {
+    return $this->getHardpoint('branchRef');
+  }
+
+  public function setCommitRef(ArcanistCommitRef $commit_ref) {
+    return $this->attachHardpoint('commitRef', $commit_ref);
+  }
+
+  public function getCommitRef() {
+    return $this->getHardpoint('commitRef');
+  }
+
+  public function getRevisionRefs() {
+    return $this->getHardpoint('revisionRefs');
+  }
+
+  public function getRevisionRef() {
+    if ($this->hasAmbiguousRevisionRefs()) {
+      throw new Exception(
+        pht('State has multiple ambiguous revisions refs.'));
+    }
+
+    $refs = $this->getRevisionRefs();
+    if ($refs) {
+      return head($refs);
+    }
+
+    return null;
+  }
+
+  public function hasAmbiguousRevisionRefs() {
+    return (count($this->getRevisionRefs()) > 1);
+  }
+
+  protected function canReadHardpoint($hardpoint) {
+    switch ($hardpoint) {
+      case 'commitRef':
+        // If we have a branch ref, we can try to read the commit ref from the
+        // branch ref.
+        if ($this->hasAttachedHardpoint('branchRef')) {
+          if ($this->getBranchRef()->hasAttachedHardpoint('commitRef')) {
+            return true;
+          }
+        }
+        break;
+    }
+
+    return false;
+  }
+
+  protected function readHardpoint($hardpoint) {
+    switch ($hardpoint) {
+      case 'commitRef':
+        return $this->getBranchRef()->getCommitRef();
+    }
+
+    return parent::readHardpoint($hardpoint);
+  }
+
+  protected function mergeHardpoint($hardpoint, array $src, array $new) {
+    if ($hardpoint == 'revisionRefs') {
+      $src = mpull($src, null, 'getID');
+      $new = mpull($new, null, 'getID');
+
+      foreach ($new as $id => $ref) {
+        if (isset($src[$id])) {
+          foreach ($ref->getSources() as $source) {
+            $src[$id]->addSource($source);
+          }
+        } else {
+          $src[$id] = $ref;
+        }
+      }
+
+      return array_values($src);
+    }
+
+    return parent::mergeHardpoint($hardpoint, $src, $new);
+  }
+
+}
diff --git a/src/repository/api/ArcanistGitAPI.php b/src/repository/api/ArcanistGitAPI.php
index 6e8dfd0b..99424a80 100644
--- a/src/repository/api/ArcanistGitAPI.php
+++ b/src/repository/api/ArcanistGitAPI.php
@@ -1,1680 +1,1710 @@
 <?php
 
 /**
  * Interfaces with Git working copies.
  */
 final class ArcanistGitAPI extends ArcanistRepositoryAPI {
 
   private $repositoryHasNoCommits = false;
   const SEARCH_LENGTH_FOR_PARENT_REVISIONS = 16;
 
   /**
    * For the repository's initial commit, 'git diff HEAD^' and similar do
    * not work. Using this instead does work; it is the hash of the empty tree.
    */
   const GIT_MAGIC_ROOT_COMMIT = '4b825dc642cb6eb9a060e54bf8d69288fbee4904';
 
   private $symbolicHeadCommit;
   private $resolvedHeadCommit;
 
   protected function buildLocalFuture(array $argv) {
     $argv[0] = 'git '.$argv[0];
 
     $future = newv('ExecFuture', $argv);
     $future->setCWD($this->getPath());
     return $future;
   }
 
   public function execPassthru($pattern /* , ... */) {
     $args = func_get_args();
 
     static $git = null;
     if ($git === null) {
       if (phutil_is_windows()) {
         // NOTE: On Windows, phutil_passthru() uses 'bypass_shell' because
         // everything goes to hell if we don't. We must provide an absolute
         // path to Git for this to work properly.
         $git = Filesystem::resolveBinary('git');
         $git = csprintf('%s', $git);
       } else {
         $git = 'git';
       }
     }
 
     $args[0] = $git.' '.$args[0];
 
     return call_user_func_array('phutil_passthru', $args);
   }
 
 
   public function getSourceControlSystemName() {
     return 'git';
   }
 
   public function getGitVersion() {
     static $version = null;
     if ($version === null) {
       list($stdout) = $this->execxLocal('--version');
       $version = rtrim(str_replace('git version ', '', $stdout));
     }
     return $version;
   }
 
   public function getMetadataPath() {
     static $path = null;
     if ($path === null) {
       list($stdout) = $this->execxLocal('rev-parse --git-dir');
       $path = rtrim($stdout, "\n");
       // the output of git rev-parse --git-dir is an absolute path, unless
       // the cwd is the root of the repository, in which case it uses the
       // relative path of .git. If we get this relative path, turn it into
       // an absolute path.
       if ($path === '.git') {
         $path = $this->getPath('.git');
       }
     }
     return $path;
   }
 
   public function getHasCommits() {
     return !$this->repositoryHasNoCommits;
   }
 
   /**
    * Tests if a child commit is descendant of a parent commit.
    * If child and parent are the same, it returns false.
    * @param Child commit SHA.
    * @param Parent commit SHA.
    * @return bool True if the child is a descendant of the parent.
    */
   private function isDescendant($child, $parent) {
     list($common_ancestor) = $this->execxLocal(
       'merge-base %s %s',
       $child,
       $parent);
     $common_ancestor = trim($common_ancestor);
 
     return ($common_ancestor == $parent) && ($common_ancestor != $child);
   }
 
   public function getLocalCommitInformation() {
     if ($this->repositoryHasNoCommits) {
       // Zero commits.
       throw new Exception(
         pht(
           "You can't get local commit information for a repository with no ".
           "commits."));
     } else if ($this->getBaseCommit() == self::GIT_MAGIC_ROOT_COMMIT) {
       // One commit.
       $against = 'HEAD';
     } else {
 
       // 2..N commits. We include commits reachable from HEAD which are
       // not reachable from the base commit; this is consistent with user
       // expectations even though it is not actually the diff range.
       // Particularly:
       //
       //    |
       //    D <----- master branch
       //    |
       //    C  Y <- feature branch
       //    | /|
       //    B  X
       //    | /
       //    A
       //    |
       //
       // If "A, B, C, D" are master, and the user is at Y, when they run
       // "arc diff B" they want (and get) a diff of B vs Y, but they think about
       // this as being the commits X and Y. If we log "B..Y", we only show
       // Y. With "Y --not B", we show X and Y.
 
 
       if ($this->symbolicHeadCommit !== null) {
         $base_commit = $this->getBaseCommit();
         $resolved_base = $this->resolveCommit($base_commit);
 
         $head_commit = $this->symbolicHeadCommit;
         $resolved_head = $this->getHeadCommit();
 
         if (!$this->isDescendant($resolved_head, $resolved_base)) {
           // NOTE: Since the base commit will have been resolved as the
           // merge-base of the specified base and the specified HEAD, we can't
           // easily tell exactly what's wrong with the range.
 
           // For example, `arc diff HEAD --head HEAD^^^` is invalid because it
           // is reversed, but resolving the commit "HEAD" will compute its
           // merge-base with "HEAD^^^", which is "HEAD^^^", so the range will
           // appear empty.
 
           throw new ArcanistUsageException(
             pht(
               'The specified commit range is empty, backward or invalid: the '.
               'base (%s) is not an ancestor of the head (%s). You can not '.
               'diff an empty or reversed commit range.',
               $base_commit,
               $head_commit));
         }
       }
 
       $against = csprintf(
         '%s --not %s',
         $this->getHeadCommit(),
         $this->getBaseCommit());
     }
 
     // NOTE: Windows escaping of "%" symbols apparently is inherently broken;
     // when passed through escapeshellarg() they are replaced with spaces.
 
     // TODO: Learn how cmd.exe works and find some clever workaround?
 
     // NOTE: If we use "%x00", output is truncated in Windows.
 
     list($info) = $this->execxLocal(
       phutil_is_windows()
         ? 'log %C --format=%C --'
         : 'log %C --format=%s --',
       $against,
       // NOTE: "%B" is somewhat new, use "%s%n%n%b" instead.
       '%H%x01%T%x01%P%x01%at%x01%an%x01%aE%x01%s%x01%s%n%n%b%x02');
 
     $commits = array();
 
     $info = trim($info, " \n\2");
     if (!strlen($info)) {
       return array();
     }
 
     $info = explode("\2", $info);
     foreach ($info as $line) {
       list($commit, $tree, $parents, $time, $author, $author_email,
         $title, $message) = explode("\1", trim($line), 8);
       $message = rtrim($message);
 
       $commits[$commit] = array(
         'commit'  => $commit,
         'tree'    => $tree,
         'parents' => array_filter(explode(' ', $parents)),
         'time'    => $time,
         'author'  => $author,
         'summary' => $title,
         'message' => $message,
         'authorEmail' => $author_email,
       );
     }
 
     return $commits;
   }
 
   protected function buildBaseCommit($symbolic_commit) {
     if ($symbolic_commit !== null) {
       if ($symbolic_commit == self::GIT_MAGIC_ROOT_COMMIT) {
         $this->setBaseCommitExplanation(
           pht('you explicitly specified the empty tree.'));
         return $symbolic_commit;
       }
 
       list($err, $merge_base) = $this->execManualLocal(
         'merge-base %s %s',
         $symbolic_commit,
         $this->getHeadCommit());
       if ($err) {
         throw new ArcanistUsageException(
           pht(
             "Unable to find any git commit named '%s' in this repository.",
             $symbolic_commit));
       }
 
       if ($this->symbolicHeadCommit === null) {
         $this->setBaseCommitExplanation(
           pht(
             "it is the merge-base of the explicitly specified base commit ".
             "'%s' and HEAD.",
             $symbolic_commit));
       } else {
         $this->setBaseCommitExplanation(
           pht(
             "it is the merge-base of the explicitly specified base commit ".
             "'%s' and the explicitly specified head commit '%s'.",
             $symbolic_commit,
             $this->symbolicHeadCommit));
       }
 
       return trim($merge_base);
     }
 
     // Detect zero-commit or one-commit repositories. There is only one
     // relative-commit value that makes any sense in these repositories: the
     // empty tree.
     list($err) = $this->execManualLocal('rev-parse --verify HEAD^');
     if ($err) {
       list($err) = $this->execManualLocal('rev-parse --verify HEAD');
       if ($err) {
         $this->repositoryHasNoCommits = true;
       }
 
       if ($this->repositoryHasNoCommits) {
         $this->setBaseCommitExplanation(pht('the repository has no commits.'));
       } else {
         $this->setBaseCommitExplanation(
           pht('the repository has only one commit.'));
       }
 
       return self::GIT_MAGIC_ROOT_COMMIT;
     }
 
     if ($this->getBaseCommitArgumentRules() ||
         $this->getConfigurationManager()->getConfigFromAnySource('base')) {
       $base = $this->resolveBaseCommit();
       if (!$base) {
         throw new ArcanistUsageException(
           pht(
             "None of the rules in your 'base' configuration matched a valid ".
             "commit. Adjust rules or specify which commit you want to use ".
             "explicitly."));
       }
       return $base;
     }
 
     $do_write = false;
     $default_relative = null;
     $working_copy = $this->getWorkingCopyIdentity();
     if ($working_copy) {
       $default_relative = $working_copy->getProjectConfig(
         'git.default-relative-commit');
       $this->setBaseCommitExplanation(
         pht(
           "it is the merge-base of '%s' and HEAD, as specified in '%s' in ".
           "'%s'. This setting overrides other settings.",
           $default_relative,
           'git.default-relative-commit',
           '.arcconfig'));
     }
 
     if (!$default_relative) {
       list($err, $upstream) = $this->execManualLocal(
         'rev-parse --abbrev-ref --symbolic-full-name %s',
         '@{upstream}');
 
       if (!$err) {
         $default_relative = trim($upstream);
         $this->setBaseCommitExplanation(
           pht(
             "it is the merge-base of '%s' (the Git upstream ".
             "of the current branch) HEAD.",
             $default_relative));
       }
     }
 
     if (!$default_relative) {
       $default_relative = $this->readScratchFile('default-relative-commit');
       $default_relative = trim($default_relative);
       if ($default_relative) {
         $this->setBaseCommitExplanation(
           pht(
             "it is the merge-base of '%s' and HEAD, as specified in '%s'.",
             $default_relative,
             '.git/arc/default-relative-commit'));
       }
     }
 
     if (!$default_relative) {
 
       // TODO: Remove the history lesson soon.
 
       echo phutil_console_format(
         "<bg:green>** %s **</bg>\n\n",
         pht('Select a Default Commit Range'));
       echo phutil_console_wrap(
         pht(
           "You're running a command which operates on a range of revisions ".
           "(usually, from some revision to HEAD) but have not specified the ".
           "revision that should determine the start of the range.\n\n".
           "Previously, arc assumed you meant '%s' when you did not specify ".
           "a start revision, but this behavior does not make much sense in ".
           "most workflows outside of Facebook's historic %s workflow.\n\n".
           "arc no longer assumes '%s'. You must specify a relative commit ".
           "explicitly when you invoke a command (e.g., `%s`, not just `%s`) ".
           "or select a default for this working copy.\n\nIn most cases, the ".
           "best default is '%s'. You can also select '%s' to preserve the ".
           "old behavior, or some other remote or branch. But you almost ".
           "certainly want to select 'origin/master'.\n\n".
           "(Technically: the merge-base of the selected revision and HEAD is ".
           "used to determine the start of the commit range.)",
           'HEAD^',
           'git-svn',
           'HEAD^',
           'arc diff HEAD^',
           'arc diff',
           'origin/master',
           'HEAD^'));
 
       $prompt = pht('What default do you want to use? [origin/master]');
       $default = phutil_console_prompt($prompt);
 
       if (!strlen(trim($default))) {
         $default = 'origin/master';
       }
 
       $default_relative = $default;
       $do_write = true;
     }
 
     list($object_type) = $this->execxLocal(
       'cat-file -t %s',
       $default_relative);
 
     if (trim($object_type) !== 'commit') {
       throw new Exception(
         pht(
           "Relative commit '%s' is not the name of a commit!",
           $default_relative));
     }
 
     if ($do_write) {
       // Don't perform this write until we've verified that the object is a
       // valid commit name.
       $this->writeScratchFile('default-relative-commit', $default_relative);
       $this->setBaseCommitExplanation(
         pht(
           "it is the merge-base of '%s' and HEAD, as you just specified.",
           $default_relative));
     }
 
     list($merge_base) = $this->execxLocal(
       'merge-base %s HEAD',
       $default_relative);
 
     return trim($merge_base);
   }
 
   public function getHeadCommit() {
     if ($this->resolvedHeadCommit === null) {
       $this->resolvedHeadCommit = $this->resolveCommit(
         coalesce($this->symbolicHeadCommit, 'HEAD'));
     }
 
     return $this->resolvedHeadCommit;
   }
 
   public function setHeadCommit($symbolic_commit) {
     $this->symbolicHeadCommit = $symbolic_commit;
     $this->reloadCommitRange();
     return $this;
   }
 
   /**
    * Translates a symbolic commit (like "HEAD^") to a commit identifier.
    * @param string_symbol commit.
    * @return string the commit SHA.
    */
   private function resolveCommit($symbolic_commit) {
     list($err, $commit_hash) = $this->execManualLocal(
       'rev-parse %s',
       $symbolic_commit);
 
     if ($err) {
       throw new ArcanistUsageException(
         pht(
           "Unable to find any git commit named '%s' in this repository.",
           $symbolic_commit));
     }
 
     return trim($commit_hash);
   }
 
   private function getDiffFullOptions($detect_moves_and_renames = true) {
     $options = array(
       self::getDiffBaseOptions(),
       '--no-color',
       '--src-prefix=a/',
       '--dst-prefix=b/',
       '-U'.$this->getDiffLinesOfContext(),
     );
 
     if ($detect_moves_and_renames) {
       $options[] = '-M';
       $options[] = '-C';
     }
 
     return implode(' ', $options);
   }
 
   private function getDiffBaseOptions() {
     $options = array(
       // Disable external diff drivers, like graphical differs, since Arcanist
       // needs to capture the diff text.
       '--no-ext-diff',
       // Disable textconv so we treat binary files as binary, even if they have
       // an alternative textual representation. TODO: Ideally, Differential
       // would ship up the binaries for 'arc patch' but display the textconv
       // output in the visual diff.
       '--no-textconv',
       // Provide a standard view of submodule changes; the 'log' and 'diff'
       // values do not parse by the diff parser.
       '--submodule=short',
     );
     return implode(' ', $options);
   }
 
   /**
    * @param the base revision
    * @param head revision. If this is null, the generated diff will include the
    * working copy
    */
   public function getFullGitDiff($base, $head = null) {
     $options = $this->getDiffFullOptions();
     $config_options = array();
 
     // See T13432. Disable the rare "diff.suppressBlankEmpty" configuration
     // option, which discards the " " (space) change type prefix on unchanged
     // blank lines. At time of writing the parser does not handle these
     // properly, but generating a more-standard diff is generally desirable
     // even if a future parser handles this case more gracefully.
 
     $config_options[] = '-c';
     $config_options[] = 'diff.suppressBlankEmpty=false';
 
     if ($head !== null) {
       list($stdout) = $this->execxLocal(
         "%LR diff {$options} %s %s --",
         $config_options,
         $base,
         $head);
     } else {
       list($stdout) = $this->execxLocal(
         "%LR diff {$options} %s --",
         $config_options,
         $base);
     }
 
     return $stdout;
   }
 
   /**
    * @param string Path to generate a diff for.
    * @param bool   If true, detect moves and renames. Otherwise, ignore
    *               moves/renames; this is useful because it prompts git to
    *               generate real diff text.
    */
   public function getRawDiffText($path, $detect_moves_and_renames = true) {
     $options = $this->getDiffFullOptions($detect_moves_and_renames);
     list($stdout) = $this->execxLocal(
       "diff {$options} %s -- %s",
       $this->getBaseCommit(),
       $path);
     return $stdout;
   }
 
   private function getBranchNameFromRef($ref) {
     $count = 0;
     $branch = preg_replace('/^refs\/heads\//', '', $ref, 1, $count);
     if ($count !== 1) {
       return null;
     }
 
     if (!strlen($branch)) {
       return null;
     }
 
     return $branch;
   }
 
   public function getBranchName() {
     list($err, $stdout, $stderr) = $this->execManualLocal(
       'symbolic-ref --quiet HEAD');
 
     if ($err === 0) {
       // We expect the branch name to come qualified with a refs/heads/ prefix.
       // Verify this, and strip it.
       $ref = rtrim($stdout);
       $branch = $this->getBranchNameFromRef($ref);
       if ($branch === null) {
         throw new Exception(
           pht('Failed to parse %s output!', 'git symbolic-ref'));
       }
       return $branch;
     } else if ($err === 1) {
       // Exit status 1 with --quiet indicates that HEAD is detached.
       return null;
     } else {
       throw new Exception(
         pht('Command %s failed: %s', 'git symbolic-ref', $stderr));
     }
   }
 
   public function getRemoteURI() {
     // Determine which remote to examine; default to 'origin'
     $remote = 'origin';
     $branch = $this->getBranchName();
     if ($branch) {
       $path = $this->getPathToUpstream($branch);
       if ($path->isConnectedToRemote()) {
         $remote = $path->getRemoteRemoteName();
       }
     }
 
     return $this->getGitRemoteFetchURI($remote);
   }
 
   public function getSourceControlPath() {
     // TODO: Try to get something useful here.
     return null;
   }
 
   public function getGitCommitLog() {
     $relative = $this->getBaseCommit();
     if ($this->repositoryHasNoCommits) {
       // No commits yet.
       return '';
     } else if ($relative == self::GIT_MAGIC_ROOT_COMMIT) {
       // First commit.
       list($stdout) = $this->execxLocal(
         'log --format=medium HEAD');
     } else {
       // 2..N commits.
       list($stdout) = $this->execxLocal(
         'log --first-parent --format=medium %s..%s',
         $this->getBaseCommit(),
         $this->getHeadCommit());
     }
     return $stdout;
   }
 
   public function getGitHistoryLog() {
     list($stdout) = $this->execxLocal(
       'log --format=medium -n%d %s',
       self::SEARCH_LENGTH_FOR_PARENT_REVISIONS,
       $this->getBaseCommit());
     return $stdout;
   }
 
   public function getSourceControlBaseRevision() {
     list($stdout) = $this->execxLocal(
       'rev-parse %s',
       $this->getBaseCommit());
     return rtrim($stdout, "\n");
   }
 
   public function getCanonicalRevisionName($string) {
     $match = null;
     if (preg_match('/@([0-9]+)$/', $string, $match)) {
       $stdout = $this->getHashFromFromSVNRevisionNumber($match[1]);
     } else {
       list($stdout) = $this->execxLocal(
         phutil_is_windows()
         ? 'show -s --format=%C %s --'
         : 'show -s --format=%s %s --',
         '%H',
         $string);
     }
     return rtrim($stdout);
   }
 
   private function executeSVNFindRev($input, $vcs) {
     $match = array();
     list($stdout) = $this->execxLocal(
       'svn find-rev %s',
       $input);
     if (!$stdout) {
       throw new ArcanistUsageException(
         pht(
           'Cannot find the %s equivalent of %s.',
           $vcs,
           $input));
     }
     // When git performs a partial-rebuild during svn
     // look-up, we need to parse the final line
     $lines = explode("\n", $stdout);
     $stdout = $lines[count($lines) - 2];
     return rtrim($stdout);
   }
 
   // Convert svn revision number to git hash
   public function getHashFromFromSVNRevisionNumber($revision_id) {
     return $this->executeSVNFindRev('r'.$revision_id, 'Git');
   }
 
 
   // Convert a git hash to svn revision number
   public function getSVNRevisionNumberFromHash($hash) {
     return $this->executeSVNFindRev($hash, 'SVN');
   }
 
   private function buildUncommittedStatusViaStatus() {
     $status = $this->buildLocalFuture(
       array(
         'status --porcelain=2 -z',
       ));
     list($stdout) = $status->resolvex();
 
     $result = new PhutilArrayWithDefaultValue();
     $parts = explode("\0", $stdout);
     while (count($parts) > 1) {
       $entry = array_shift($parts);
       $entry_parts = explode(' ', $entry, 2);
       if ($entry_parts[0] == '1') {
         $entry_parts = explode(' ', $entry, 9);
         $path = $entry_parts[8];
       } else if ($entry_parts[0] == '2') {
         $entry_parts = explode(' ', $entry, 10);
         $path = $entry_parts[9];
       } else if ($entry_parts[0] == 'u') {
         $entry_parts = explode(' ', $entry, 11);
         $path = $entry_parts[10];
       } else if ($entry_parts[0] == '?') {
         $entry_parts = explode(' ', $entry, 2);
         $result[$entry_parts[1]] = self::FLAG_UNTRACKED;
         continue;
       }
 
       $result[$path] |= self::FLAG_UNCOMMITTED;
       $index_state = substr($entry_parts[1], 0, 1);
       $working_state = substr($entry_parts[1], 1, 1);
       if ($index_state == 'A') {
         $result[$path] |= self::FLAG_ADDED;
       } else if ($index_state == 'M') {
         $result[$path] |= self::FLAG_MODIFIED;
       } else if ($index_state == 'D') {
         $result[$path] |= self::FLAG_DELETED;
       }
       if ($working_state != '.') {
         $result[$path] |= self::FLAG_UNSTAGED;
         if ($index_state == '.') {
           if ($working_state == 'A') {
             $result[$path] |= self::FLAG_ADDED;
           } else if ($working_state == 'M') {
             $result[$path] |= self::FLAG_MODIFIED;
           } else if ($working_state == 'D') {
             $result[$path] |= self::FLAG_DELETED;
           }
         }
       }
       $submodule_tracked = substr($entry_parts[2], 2, 1);
       $submodule_untracked = substr($entry_parts[2], 3, 1);
       if ($submodule_tracked == 'M' || $submodule_untracked == 'U') {
         $result[$path] |= self::FLAG_EXTERNALS;
       }
 
       if ($entry_parts[0] == '2') {
         $result[array_shift($parts)] = $result[$path] | self::FLAG_DELETED;
         $result[$path] |= self::FLAG_ADDED;
       }
     }
     return $result->toArray();
   }
 
   protected function buildUncommittedStatus() {
     if (version_compare($this->getGitVersion(), '2.11.0', '>=')) {
       return $this->buildUncommittedStatusViaStatus();
     }
 
     $diff_options = $this->getDiffBaseOptions();
 
     if ($this->repositoryHasNoCommits) {
       $diff_base = self::GIT_MAGIC_ROOT_COMMIT;
     } else {
       $diff_base = 'HEAD';
     }
 
     // Find uncommitted changes.
     $uncommitted_future = $this->buildLocalFuture(
       array(
         'diff %C --raw %s --',
         $diff_options,
         $diff_base,
       ));
 
     $untracked_future = $this->buildLocalFuture(
       array(
         'ls-files --others --exclude-standard',
       ));
 
     // Unstaged changes
     $unstaged_future = $this->buildLocalFuture(
       array(
         'diff-files --name-only',
       ));
 
     $futures = array(
       $uncommitted_future,
       $untracked_future,
       // NOTE: `git diff-files` races with each of these other commands
       // internally, and resolves with inconsistent results if executed
       // in parallel. To work around this, DO NOT run it at the same time.
       // After the other commands exit, we can start the `diff-files` command.
     );
 
     id(new FutureIterator($futures))->resolveAll();
 
     // We're clear to start the `git diff-files` now.
     $unstaged_future->start();
 
     $result = new PhutilArrayWithDefaultValue();
 
     list($stdout) = $uncommitted_future->resolvex();
     $uncommitted_files = $this->parseGitRawDiff($stdout);
     foreach ($uncommitted_files as $path => $mask) {
       $result[$path] |= ($mask | self::FLAG_UNCOMMITTED);
     }
 
     list($stdout) = $untracked_future->resolvex();
     $stdout = rtrim($stdout, "\n");
     if (strlen($stdout)) {
       $stdout = explode("\n", $stdout);
       foreach ($stdout as $path) {
         $result[$path] |= self::FLAG_UNTRACKED;
       }
     }
 
     list($stdout, $stderr) = $unstaged_future->resolvex();
     $stdout = rtrim($stdout, "\n");
     if (strlen($stdout)) {
       $stdout = explode("\n", $stdout);
       foreach ($stdout as $path) {
         $result[$path] |= self::FLAG_UNSTAGED;
       }
     }
 
     return $result->toArray();
   }
 
   protected function buildCommitRangeStatus() {
     list($stdout, $stderr) = $this->execxLocal(
       'diff %C --raw %s HEAD --',
       $this->getDiffBaseOptions(),
       $this->getBaseCommit());
 
     return $this->parseGitRawDiff($stdout);
   }
 
   public function getGitConfig($key, $default = null) {
     list($err, $stdout) = $this->execManualLocal('config %s', $key);
     if ($err) {
       return $default;
     }
     return rtrim($stdout);
   }
 
   public function getAuthor() {
     list($stdout) = $this->execxLocal('var GIT_AUTHOR_IDENT');
     return preg_replace('/\s+<.*/', '', rtrim($stdout, "\n"));
   }
 
   public function addToCommit(array $paths) {
     $this->execxLocal(
       'add -A -- %Ls',
       $paths);
     $this->reloadWorkingCopy();
     return $this;
   }
 
   public function doCommit($message) {
     $tmp_file = new TempFile();
     Filesystem::writeFile($tmp_file, $message);
 
     // NOTE: "--allow-empty-message" was introduced some time after 1.7.0.4,
     // so we do not provide it and thus require a message.
 
     $this->execxLocal(
       'commit -F %s',
       $tmp_file);
 
     $this->reloadWorkingCopy();
 
     return $this;
   }
 
   public function amendCommit($message = null) {
     if ($message === null) {
       $this->execxLocal('commit --amend --allow-empty -C HEAD');
     } else {
       $tmp_file = new TempFile();
       Filesystem::writeFile($tmp_file, $message);
       $this->execxLocal(
         'commit --amend --allow-empty -F %s',
         $tmp_file);
     }
 
     $this->reloadWorkingCopy();
     return $this;
   }
 
   private function parseGitRawDiff($status, $full = false) {
     static $flags = array(
       'A' => self::FLAG_ADDED,
       'M' => self::FLAG_MODIFIED,
       'D' => self::FLAG_DELETED,
     );
 
     $status = trim($status);
     $lines = array();
     foreach (explode("\n", $status) as $line) {
       if ($line) {
         $lines[] = preg_split("/[ \t]/", $line, 6);
       }
     }
 
     $files = array();
     foreach ($lines as $line) {
       $mask = 0;
 
       // "git diff --raw" lines begin with a ":" character.
       $old_mode = ltrim($line[0], ':');
       $new_mode = $line[1];
 
       // The hashes may be padded with "." characters for alignment. Discard
       // them.
       $old_hash = rtrim($line[2], '.');
       $new_hash = rtrim($line[3], '.');
 
       $flag = $line[4];
       $file = $line[5];
 
       $new_value = intval($new_mode, 8);
       $is_submodule = (($new_value & 0160000) === 0160000);
 
       if (($is_submodule) &&
           ($flag == 'M') &&
           ($old_hash === $new_hash) &&
           ($old_mode === $new_mode)) {
         // See T9455. We see this submodule as "modified", but the old and new
         // hashes are the same and the old and new modes are the same, so we
         // don't directly see a modification.
 
         // We can end up here if we have a submodule which has uncommitted
         // changes inside of it (for example, the user has added untracked
         // files or made uncommitted changes to files in the submodule). In
         // this case, we set a different flag because we can't meaningfully
         // give users the same prompt.
 
         // Note that if the submodule has real changes from the parent
         // perspective (the base commit has changed) and also has uncommitted
         // changes, we'll only see the real changes and miss the uncommitted
         // changes. At the time of writing, there is no reasonable porcelain
         // for finding those changes, and the impact of this error seems small.
 
         $mask |= self::FLAG_EXTERNALS;
       } else if (isset($flags[$flag])) {
         $mask |= $flags[$flag];
       } else if ($flag[0] == 'R') {
         $both = explode("\t", $file);
         if ($full) {
           $files[$both[0]] = array(
             'mask' => $mask | self::FLAG_DELETED,
             'ref'  => str_repeat('0', 40),
           );
         } else {
           $files[$both[0]] = $mask | self::FLAG_DELETED;
         }
         $file = $both[1];
         $mask |= self::FLAG_ADDED;
       } else if ($flag[0] == 'C') {
         $both = explode("\t", $file);
         $file = $both[1];
         $mask |= self::FLAG_ADDED;
       }
 
       if ($full) {
         $files[$file] = array(
           'mask' => $mask,
           'ref'  => $new_hash,
         );
       } else {
         $files[$file] = $mask;
       }
     }
 
     return $files;
   }
 
   public function getAllFiles() {
     $future = $this->buildLocalFuture(array('ls-files -z'));
     return id(new LinesOfALargeExecFuture($future))
       ->setDelimiter("\0");
   }
 
   public function getChangedFiles($since_commit) {
     list($stdout) = $this->execxLocal(
       'diff --raw %s',
       $since_commit);
     return $this->parseGitRawDiff($stdout);
   }
 
   public function getBlame($path) {
     list($stdout) = $this->execxLocal(
       'blame --porcelain -w -M %s -- %s',
       $this->getBaseCommit(),
       $path);
 
     // the --porcelain format prints at least one header line per source line,
     // then the source line prefixed by a tab character
     $blame_info = preg_split('/^\t.*\n/m', rtrim($stdout));
 
     // commit info is not repeated in these headers, so cache it
     $revision_data = array();
 
     $blame = array();
     foreach ($blame_info as $line_info) {
       $revision = substr($line_info, 0, 40);
       $data = idx($revision_data, $revision, array());
 
       if (empty($data)) {
         $matches = array();
         if (!preg_match('/^author (.*)$/m', $line_info, $matches)) {
           throw new Exception(
             pht(
               'Unexpected output from %s: no author for commit %s',
               'git blame',
               $revision));
         }
         $data['author'] = $matches[1];
         $data['from_first_commit'] = preg_match('/^boundary$/m', $line_info);
         $revision_data[$revision] = $data;
       }
 
       // Ignore lines predating the git repository (on a boundary commit)
       // rather than blaming them on the oldest diff's unfortunate author
       if (!$data['from_first_commit']) {
         $blame[] = array($data['author'], $revision);
       }
     }
 
     return $blame;
   }
 
   public function getOriginalFileData($path) {
     return $this->getFileDataAtRevision($path, $this->getBaseCommit());
   }
 
   public function getCurrentFileData($path) {
     return $this->getFileDataAtRevision($path, 'HEAD');
   }
 
   private function parseGitTree($stdout) {
     $result = array();
 
     $stdout = trim($stdout);
     if (!strlen($stdout)) {
       return $result;
     }
 
     $lines = explode("\n", $stdout);
     foreach ($lines as $line) {
       $matches = array();
       $ok = preg_match(
         '/^(\d{6}) (blob|tree|commit) ([a-z0-9]{40})[\t](.*)$/',
         $line,
         $matches);
       if (!$ok) {
         throw new Exception(pht('Failed to parse %s output!', 'git ls-tree'));
       }
       $result[$matches[4]] = array(
         'mode' => $matches[1],
         'type' => $matches[2],
         'ref'  => $matches[3],
       );
     }
     return $result;
   }
 
   private function getFileDataAtRevision($path, $revision) {
     // NOTE: We don't want to just "git show {$revision}:{$path}" since if the
     // path was a directory at the given revision we'll get a list of its files
     // and treat it as though it as a file containing a list of other files,
     // which is silly.
 
     if (!strlen($path)) {
       // No filename, so there's no content (Probably new/deleted file).
       return null;
     }
 
     list($stdout) = $this->execxLocal(
       'ls-tree %s -- %s',
       $revision,
       $path);
 
     $info = $this->parseGitTree($stdout);
     if (empty($info[$path])) {
       // No such path, or the path is a directory and we executed 'ls-tree dir/'
       // and got a list of its contents back.
       return null;
     }
 
     if ($info[$path]['type'] != 'blob') {
       // Path is or was a directory, not a file.
       return null;
     }
 
     list($stdout) = $this->execxLocal(
       'cat-file blob %s',
        $info[$path]['ref']);
     return $stdout;
   }
 
   /**
    * Returns names of all the branches in the current repository.
    *
    * @return list<dict<string, string>> Dictionary of branch information.
    */
   public function getAllBranches() {
     $field_list = array(
       '%(refname)',
       '%(objectname)',
       '%(committerdate:raw)',
       '%(tree)',
       '%(subject)',
       '%(subject)%0a%0a%(body)',
       '%02',
     );
 
     list($stdout) = $this->execxLocal(
       'for-each-ref --format=%s -- refs/heads',
       implode('%01', $field_list));
 
     $current = $this->getBranchName();
     $result = array();
 
     $lines = explode("\2", $stdout);
     foreach ($lines as $line) {
       $line = trim($line);
       if (!strlen($line)) {
         continue;
       }
 
       $fields = explode("\1", $line, 6);
       list($ref, $hash, $epoch, $tree, $desc, $text) = $fields;
 
       $branch = $this->getBranchNameFromRef($ref);
       if ($branch !== null) {
         $result[] = array(
           'current' => ($branch === $current),
           'name' => $branch,
+          'ref' => $ref,
           'hash' => $hash,
           'tree' => $tree,
           'epoch' => (int)$epoch,
           'desc' => $desc,
           'text' => $text,
         );
       }
     }
 
     return $result;
   }
 
-  public function getWorkingCopyRevision() {
-    list($stdout) = $this->execxLocal('rev-parse HEAD');
-    return rtrim($stdout, "\n");
+  public function getAllBranchRefs() {
+    $branches = $this->getAllBranches();
+
+    $refs = array();
+    foreach ($branches as $branch) {
+      $commit_ref = $this->newCommitRef()
+        ->setCommitHash($branch['hash'])
+        ->setTreeHash($branch['tree'])
+        ->setCommitEpoch($branch['epoch'])
+        ->attachMessage($branch['text']);
+
+      $refs[] = $this->newBranchRef()
+        ->setBranchName($branch['name'])
+        ->setRefName($branch['ref'])
+        ->setIsCurrentBranch($branch['current'])
+        ->attachCommitRef($commit_ref);
+    }
+
+    return $refs;
   }
 
-  public function getUnderlyingWorkingCopyRevision() {
-    list($err, $stdout) = $this->execManualLocal('svn find-rev HEAD');
-    if (!$err && $stdout) {
-      return rtrim($stdout, "\n");
+  public function getBaseCommitRef() {
+    $base_commit = $this->getBaseCommit();
+
+    if ($base_commit === self::GIT_MAGIC_ROOT_COMMIT) {
+      return null;
     }
-    return $this->getWorkingCopyRevision();
+
+    $base_message = $this->getCommitMessage($base_commit);
+
+    // TODO: We should also pull the tree hash.
+
+    return $this->newCommitRef()
+      ->setCommitHash($base_commit)
+      ->attachMessage($base_message);
+  }
+
+  public function getWorkingCopyRevision() {
+    list($stdout) = $this->execxLocal('rev-parse HEAD');
+    return rtrim($stdout, "\n");
   }
 
   public function isHistoryDefaultImmutable() {
     return false;
   }
 
   public function supportsAmend() {
     return true;
   }
 
   public function supportsCommitRanges() {
     return true;
   }
 
   public function supportsLocalCommits() {
     return true;
   }
 
   public function hasLocalCommit($commit) {
     try {
       if (!$this->getCanonicalRevisionName($commit)) {
         return false;
       }
     } catch (CommandException $exception) {
       return false;
     }
     return true;
   }
 
   public function getAllLocalChanges() {
     $diff = $this->getFullGitDiff($this->getBaseCommit());
     if (!strlen(trim($diff))) {
       return array();
     }
     $parser = new ArcanistDiffParser();
     return $parser->parseDiff($diff);
   }
 
   public function supportsLocalBranchMerge() {
     return true;
   }
 
   public function performLocalBranchMerge($branch, $message) {
     if (!$branch) {
       throw new ArcanistUsageException(
         pht('Under git, you must specify the branch you want to merge.'));
     }
     $err = phutil_passthru(
       '(cd %s && git merge --no-ff -m %s %s)',
       $this->getPath(),
       $message,
       $branch);
 
     if ($err) {
       throw new ArcanistUsageException(pht('Merge failed!'));
     }
   }
 
   public function getFinalizedRevisionMessage() {
     return pht(
       "You may now push this commit upstream, as appropriate (e.g. with ".
       "'%s', or '%s', or by printing and faxing it).",
       'git push',
       'git svn dcommit');
   }
 
   public function getCommitMessage($commit) {
     list($message) = $this->execxLocal(
       'log -n1 --format=%C %s --',
       '%s%n%n%b',
       $commit);
     return $message;
   }
 
   public function loadWorkingCopyDifferentialRevisions(
     ConduitClient $conduit,
     array $query) {
 
     $messages = $this->getGitCommitLog();
     if (!strlen($messages)) {
       return array();
     }
 
     $parser = new ArcanistDiffParser();
     $messages = $parser->parseDiff($messages);
 
     // First, try to find revisions by explicit revision IDs in commit messages.
     $reason_map = array();
     $revision_ids = array();
     foreach ($messages as $message) {
       $object = ArcanistDifferentialCommitMessage::newFromRawCorpus(
         $message->getMetadata('message'));
       if ($object->getRevisionID()) {
         $revision_ids[] = $object->getRevisionID();
         $reason_map[$object->getRevisionID()] = $message->getCommitHash();
       }
     }
 
     if ($revision_ids) {
       $results = $conduit->callMethodSynchronous(
         'differential.query',
         $query + array(
           'ids' => $revision_ids,
         ));
 
       foreach ($results as $key => $result) {
         $hash = substr($reason_map[$result['id']], 0, 16);
         $results[$key]['why'] = pht(
           "Commit message for '%s' has explicit 'Differential Revision'.",
           $hash);
       }
 
       return $results;
     }
 
     // If we didn't succeed, try to find revisions by hash.
     $hashes = array();
     foreach ($this->getLocalCommitInformation() as $commit) {
       $hashes[] = array('gtcm', $commit['commit']);
       $hashes[] = array('gttr', $commit['tree']);
     }
 
     $results = $conduit->callMethodSynchronous(
       'differential.query',
       $query + array(
         'commitHashes' => $hashes,
       ));
 
     foreach ($results as $key => $result) {
       $results[$key]['why'] = pht(
         'A git commit or tree hash in the commit range is already attached '.
         'to the Differential revision.');
     }
 
     return $results;
   }
 
   public function updateWorkingCopy() {
     $this->execxLocal('pull');
     $this->reloadWorkingCopy();
   }
 
   public function getCommitSummary($commit) {
     if ($commit == self::GIT_MAGIC_ROOT_COMMIT) {
       return pht('(The Empty Tree)');
     }
 
     list($summary) = $this->execxLocal(
       'log -n 1 --format=%C %s',
       '%s',
       $commit);
 
     return trim($summary);
   }
 
   public function backoutCommit($commit_hash) {
     $this->execxLocal('revert %s -n --no-edit', $commit_hash);
     $this->reloadWorkingCopy();
     if (!$this->getUncommittedStatus()) {
       throw new ArcanistUsageException(
         pht('%s has already been reverted.', $commit_hash));
     }
   }
 
   public function getBackoutMessage($commit_hash) {
     return pht('This reverts commit %s.', $commit_hash);
   }
 
   public function isGitSubversionRepo() {
     return Filesystem::pathExists($this->getPath('.git/svn'));
   }
 
   public function resolveBaseCommitRule($rule, $source) {
     list($type, $name) = explode(':', $rule, 2);
 
     switch ($type) {
       case 'git':
         $matches = null;
         if (preg_match('/^merge-base\((.+)\)$/', $name, $matches)) {
           list($err, $merge_base) = $this->execManualLocal(
             'merge-base %s HEAD',
             $matches[1]);
           if (!$err) {
             $this->setBaseCommitExplanation(
               pht(
                 "it is the merge-base of '%s' and HEAD, as specified by ".
                 "'%s' in your %s 'base' configuration.",
                 $matches[1],
                 $rule,
                 $source));
             return trim($merge_base);
           }
         } else if (preg_match('/^branch-unique\((.+)\)$/', $name, $matches)) {
           list($err, $merge_base) = $this->execManualLocal(
             'merge-base %s HEAD',
             $matches[1]);
           if ($err) {
             return null;
           }
           $merge_base = trim($merge_base);
 
           list($commits) = $this->execxLocal(
             'log --format=%C %s..HEAD --',
             '%H',
             $merge_base);
           $commits = array_filter(explode("\n", $commits));
 
           if (!$commits) {
             return null;
           }
 
           $commits[] = $merge_base;
 
           $head_branch_count = null;
           $all_branch_names = ipull($this->getAllBranches(), 'name');
           foreach ($commits as $commit) {
             // Ideally, we would use something like "for-each-ref --contains"
             // to get a filtered list of branches ready for script consumption.
             // Instead, try to get predictable output from "branch --contains".
 
             $flags = array();
             $flags[] = '--no-color';
 
             // NOTE: The "--no-column" flag was introduced in Git 1.7.11, so
             // don't pass it if we're running an older version. See T9953.
             $version = $this->getGitVersion();
             if (version_compare($version, '1.7.11', '>=')) {
               $flags[] = '--no-column';
             }
 
             list($branches) = $this->execxLocal(
               'branch %Ls --contains %s',
               $flags,
               $commit);
             $branches = array_filter(explode("\n", $branches));
 
             // Filter the list, removing the "current" marker (*) and ignoring
             // anything other than known branch names (mainly, any possible
             // "detached HEAD" or "no branch" line).
             foreach ($branches as $key => $branch) {
               $branch = trim($branch, ' *');
               if (in_array($branch, $all_branch_names)) {
                 $branches[$key] = $branch;
               } else {
                 unset($branches[$key]);
               }
             }
 
             if ($head_branch_count === null) {
               // If this is the first commit, it's HEAD. Count how many
               // branches it is on; we want to include commits on the same
               // number of branches. This covers a case where this branch
               // has sub-branches and we're running "arc diff" here again
               // for whatever reason.
               $head_branch_count = count($branches);
             } else if (count($branches) > $head_branch_count) {
               $branches = implode(', ', $branches);
               $this->setBaseCommitExplanation(
                 pht(
                   "it is the first commit between '%s' (the merge-base of ".
                   "'%s' and HEAD) which is also contained by another branch ".
                   "(%s).",
                   $merge_base,
                   $matches[1],
                   $branches));
               return $commit;
             }
           }
         } else {
           list($err) = $this->execManualLocal(
             'cat-file -t %s',
             $name);
           if (!$err) {
             $this->setBaseCommitExplanation(
               pht(
                 "it is specified by '%s' in your %s 'base' configuration.",
                 $rule,
                 $source));
             return $name;
           }
         }
         break;
       case 'arc':
         switch ($name) {
           case 'empty':
             $this->setBaseCommitExplanation(
               pht(
                 "you specified '%s' in your %s 'base' configuration.",
                 $rule,
                 $source));
             return self::GIT_MAGIC_ROOT_COMMIT;
           case 'amended':
             $text = $this->getCommitMessage('HEAD');
             $message = ArcanistDifferentialCommitMessage::newFromRawCorpus(
               $text);
             if ($message->getRevisionID()) {
               $this->setBaseCommitExplanation(
                 pht(
                   "HEAD has been amended with 'Differential Revision:', ".
                   "as specified by '%s' in your %s 'base' configuration.",
                   $rule,
                   $source));
               return 'HEAD^';
             }
             break;
           case 'upstream':
             list($err, $upstream) = $this->execManualLocal(
               'rev-parse --abbrev-ref --symbolic-full-name %s',
               '@{upstream}');
             if (!$err) {
               $upstream = rtrim($upstream);
               list($upstream_merge_base) = $this->execxLocal(
                 'merge-base %s HEAD',
                 $upstream);
               $upstream_merge_base = rtrim($upstream_merge_base);
               $this->setBaseCommitExplanation(
                 pht(
                   "it is the merge-base of the upstream of the current branch ".
                   "and HEAD, and matched the rule '%s' in your %s ".
                   "'base' configuration.",
                   $rule,
                   $source));
               return $upstream_merge_base;
             }
             break;
           case 'this':
             $this->setBaseCommitExplanation(
               pht(
                 "you specified '%s' in your %s 'base' configuration.",
                 $rule,
                 $source));
             return 'HEAD^';
         }
       default:
         return null;
     }
 
     return null;
   }
 
   public function canStashChanges() {
     return true;
   }
 
   public function stashChanges() {
     $this->execxLocal('stash');
     $this->reloadWorkingCopy();
   }
 
   public function unstashChanges() {
     $this->execxLocal('stash pop');
   }
 
   protected function didReloadCommitRange() {
     // After an amend, the symbolic head may resolve to a different commit.
     $this->resolvedHeadCommit = null;
   }
 
   /**
    * Follow the chain of tracking branches upstream until we reach a remote
    * or cycle locally.
    *
    * @param string Ref to start from.
    * @return ArcanistGitUpstreamPath Path to an upstream.
    */
   public function getPathToUpstream($start) {
     $cursor = $start;
     $path = new ArcanistGitUpstreamPath();
     while (true) {
       list($err, $upstream) = $this->execManualLocal(
         'rev-parse --symbolic-full-name %s@{upstream}',
         $cursor);
 
       if ($err) {
         // We ended up somewhere with no tracking branch, so we're done.
         break;
       }
 
       $upstream = trim($upstream);
 
       if (preg_match('(^refs/heads/)', $upstream)) {
         $upstream = preg_replace('(^refs/heads/)', '', $upstream);
 
         $is_cycle = $path->getUpstream($upstream);
 
         $path->addUpstream(
           $cursor,
           array(
             'type' => ArcanistGitUpstreamPath::TYPE_LOCAL,
             'name' => $upstream,
             'cycle' => $is_cycle,
           ));
 
         if ($is_cycle) {
           // We ran into a local cycle, so we're done.
           break;
         }
 
         // We found another local branch, so follow that one upriver.
         $cursor = $upstream;
         continue;
       }
 
       if (preg_match('(^refs/remotes/)', $upstream)) {
         $upstream = preg_replace('(^refs/remotes/)', '', $upstream);
         list($remote, $branch) = explode('/', $upstream, 2);
 
         $path->addUpstream(
           $cursor,
           array(
             'type' => ArcanistGitUpstreamPath::TYPE_REMOTE,
             'name' => $branch,
             'remote' => $remote,
           ));
 
         // We found a remote, so we're done.
         break;
       }
 
       throw new Exception(
         pht(
           'Got unrecognized upstream format ("%s") from Git, expected '.
           '"refs/heads/..." or "refs/remotes/...".',
           $upstream));
     }
 
     return $path;
   }
 
   public function isPerforceRemote($remote_name) {
     // See T13434. In Perforce workflows, "git p4 clone" creates "p4" refs
     // under "refs/remotes/", but does not define a real remote named "p4".
 
     // We treat this remote as though it were a real remote during "arc land",
     // but it does not respond to commands like "git remote show p4", so we
     // need to handle it specially.
 
     if ($remote_name !== 'p4') {
       return false;
     }
 
     $remote_dir = $this->getMetadataPath().'/refs/remotes/p4';
     if (!Filesystem::pathExists($remote_dir)) {
       return false;
     }
 
     return true;
   }
 
   public function isPushableRemote($remote_name) {
     $uri = $this->getGitRemotePushURI($remote_name);
     return ($uri !== null);
   }
 
   private function getGitRemoteFetchURI($remote_name) {
     return $this->getGitRemoteURI($remote_name, $for_push = false);
   }
 
   private function getGitRemotePushURI($remote_name) {
     return $this->getGitRemoteURI($remote_name, $for_push = true);
   }
 
   private function getGitRemoteURI($remote_name, $for_push) {
     $remote_uri = $this->loadGitRemoteURI($remote_name, $for_push);
 
     if ($remote_uri !== null) {
       $remote_uri = rtrim($remote_uri);
       if (!strlen($remote_uri)) {
         $remote_uri = null;
       }
     }
 
     return $remote_uri;
   }
 
   private function loadGitRemoteURI($remote_name, $for_push) {
     // Try to identify the best URI for a given remote. This is complicated
     // because remotes may have different "push" and "fetch" URIs, may
     // rewrite URIs with "insteadOf" configuration, and different versions
     // of Git support different URI resolution commands.
 
     // Remotes may also have more than one URI of a given type, but we ignore
     // those cases here.
 
     // Start with "git remote get-url [--push]". This is the simplest and
     // most accurate command, but was introduced most recently in Git's
     // history.
 
     $argv = array();
     if ($for_push) {
       $argv[] = '--push';
     }
 
     list($err, $stdout) = $this->execManualLocal(
       'remote get-url %Ls -- %s',
       $argv,
       $remote_name);
     if (!$err) {
       return $stdout;
     }
 
     // See T13481. If "git remote get-url [--push]" failed, it might be because
     // the remote does not exist, but it might also be because the version of
     // Git is too old to support "git remote get-url", which was introduced
     // in Git 2.7 (circa late 2015).
 
     $git_version = $this->getGitVersion();
     if (version_compare($git_version, '2.7', '>=')) {
       // This version of Git should support "git remote get-url --push", but
       // the command failed, so conclude this is not a valid remote and thus
       // there is no remote URI.
       return null;
     }
 
     // If we arrive here, we're in a version of Git which is too old to
     // support "git remote get-url [--push]". We're going to fall back to
     // older and less accurate mechanisms for figuring out the remote URI.
 
     // The first mechanism we try is "git ls-remote --get-url". This exists
     // in Git 1.7.5 or newer. It only gives us the fetch URI, so this result
     // will be incorrect if a remote has different fetch and push URIs.
     // However, this is very rare, and this result is almost always correct.
 
     // Note that some old versions of Git do not parse "--" in this command
     // properly. We omit it since it doesn't seem like there's anything
     // dangerous an attacker can do even if they can choose a remote name to
     // intentionally cause an argument misparse.
 
     // This will cause the command to behave incorrectly for remotes with
     // names which are also valid flags, like "--quiet".
 
     list($err, $stdout) = $this->execManualLocal(
       'ls-remote --get-url %s',
       $remote_name);
     if (!$err) {
       // The "git ls-remote --get-url" command just echoes the remote name
       // (like "origin") if no remote URI is found. Treat this like a failure.
       $output_is_input = (rtrim($stdout) === $remote_name);
       if (!$output_is_input) {
         return $stdout;
       }
     }
 
     if (version_compare($git_version, '1.7.5', '>=')) {
       // This version of Git should support "git ls-remote --get-url", but
       // the command failed (or echoed the input), so conclude the remote
       // really does not exist.
       return null;
     }
 
     // Fall back to the very old "git config -- remote.origin.url" command.
     // This does not give us push URLs and does not resolve "insteadOf"
     // aliases, but still works in the simplest (and most common) cases.
 
     list($err, $stdout) = $this->execManualLocal(
       'config -- %s',
       sprintf('remote.%s.url', $remote_name));
     if (!$err) {
       return $stdout;
     }
 
     return null;
   }
 
 }
diff --git a/src/repository/api/ArcanistMercurialAPI.php b/src/repository/api/ArcanistMercurialAPI.php
index 7aaa04f7..714058ba 100644
--- a/src/repository/api/ArcanistMercurialAPI.php
+++ b/src/repository/api/ArcanistMercurialAPI.php
@@ -1,1109 +1,1136 @@
 <?php
 
 /**
  * Interfaces with the Mercurial working copies.
  */
 final class ArcanistMercurialAPI extends ArcanistRepositoryAPI {
 
   private $branch;
   private $localCommitInfo;
   private $rawDiffCache = array();
 
   private $supportsRebase;
   private $supportsPhases;
 
   protected function buildLocalFuture(array $argv) {
     // Mercurial has a "defaults" feature which basically breaks automation by
     // allowing the user to add random flags to any command. This feature is
     // "deprecated" and "a bad idea" that you should "forget ... existed"
     // according to project lead Matt Mackall:
     //
     //  http://markmail.org/message/hl3d6eprubmkkqh5
     //
     // There is an HGPLAIN environmental variable which enables "plain mode"
     // and hopefully disables this stuff.
 
     if (phutil_is_windows()) {
       $argv[0] = 'set HGPLAIN=1 & hg '.$argv[0];
     } else {
       $argv[0] = 'HGPLAIN=1 hg '.$argv[0];
     }
 
     $future = newv('ExecFuture', $argv);
     $future->setCWD($this->getPath());
     return $future;
   }
 
   public function execPassthru($pattern /* , ... */) {
     $args = func_get_args();
     if (phutil_is_windows()) {
       $args[0] = 'hg '.$args[0];
     } else {
       $args[0] = 'HGPLAIN=1 hg '.$args[0];
     }
 
     return call_user_func_array('phutil_passthru', $args);
   }
 
   public function getSourceControlSystemName() {
     return 'hg';
   }
 
   public function getMetadataPath() {
     return $this->getPath('.hg');
   }
 
   public function getSourceControlBaseRevision() {
     return $this->getCanonicalRevisionName($this->getBaseCommit());
   }
 
   public function getCanonicalRevisionName($string) {
     $match = null;
     if ($this->isHgSubversionRepo() &&
         preg_match('/@([0-9]+)$/', $string, $match)) {
       $string = hgsprintf('svnrev(%s)', $match[1]);
     }
 
     list($stdout) = $this->execxLocal(
       'log -l 1 --template %s -r %s --',
       '{node}',
       $string);
     return $stdout;
   }
 
   public function getHashFromFromSVNRevisionNumber($revision_id) {
     $matches = array();
     $string = hgsprintf('svnrev(%s)', $revision_id);
     list($stdout) = $this->execxLocal(
       'log -l 1 --template %s -r %s --',
       '{node}',
        $string);
     if (!$stdout) {
       throw new ArcanistUsageException(
         pht('Cannot find the HG equivalent of %s given.', $revision_id));
     }
     return $stdout;
   }
 
 
   public function getSVNRevisionNumberFromHash($hash) {
     $matches = array();
     list($stdout) = $this->execxLocal(
       'log -r %s --template {svnrev}', $hash);
     if (!$stdout) {
       throw new ArcanistUsageException(
         pht('Cannot find the SVN equivalent of %s given.', $hash));
     }
     return $stdout;
   }
 
   public function getSourceControlPath() {
     return '/';
   }
 
   public function getBranchName() {
     if (!$this->branch) {
       list($stdout) = $this->execxLocal('branch');
       $this->branch = trim($stdout);
     }
     return $this->branch;
   }
 
   protected function didReloadCommitRange() {
     $this->localCommitInfo = null;
   }
 
   protected function buildBaseCommit($symbolic_commit) {
     if ($symbolic_commit !== null) {
       try {
         $commit = $this->getCanonicalRevisionName(
           hgsprintf('ancestor(%s,.)', $symbolic_commit));
       } catch (Exception $ex) {
         // Try it as a revset instead of a commit id
         try {
           $commit = $this->getCanonicalRevisionName(
             hgsprintf('ancestor(%R,.)', $symbolic_commit));
         } catch (Exception $ex) {
           throw new ArcanistUsageException(
             pht(
               "Commit '%s' is not a valid Mercurial commit identifier.",
               $symbolic_commit));
         }
       }
 
       $this->setBaseCommitExplanation(
         pht(
           'it is the greatest common ancestor of the working directory '.
           'and the commit you specified explicitly.'));
       return $commit;
     }
 
     if ($this->getBaseCommitArgumentRules() ||
         $this->getConfigurationManager()->getConfigFromAnySource('base')) {
       $base = $this->resolveBaseCommit();
       if (!$base) {
         throw new ArcanistUsageException(
           pht(
             "None of the rules in your 'base' configuration matched a valid ".
             "commit. Adjust rules or specify which commit you want to use ".
             "explicitly."));
       }
       return $base;
     }
 
     // Mercurial 2.1 and up have phases which indicate if something is
     // published or not. To find which revs are outgoing, it's much
     // faster to check the phase instead of actually checking the server.
     if ($this->supportsPhases()) {
       list($err, $stdout) = $this->execManualLocal(
         'log --branch %s -r %s --style default',
         $this->getBranchName(),
         'draft()');
     } else {
       list($err, $stdout) = $this->execManualLocal(
         'outgoing --branch %s --style default',
         $this->getBranchName());
     }
 
     if (!$err) {
       $logs = ArcanistMercurialParser::parseMercurialLog($stdout);
     } else {
       // Mercurial (in some versions?) raises an error when there's nothing
       // outgoing.
       $logs = array();
     }
 
     if (!$logs) {
       $this->setBaseCommitExplanation(
         pht(
           'you have no outgoing commits, so arc assumes you intend to submit '.
           'uncommitted changes in the working copy.'));
       return $this->getWorkingCopyRevision();
     }
 
     $outgoing_revs = ipull($logs, 'rev');
 
     // This is essentially an implementation of a theoretical `hg merge-base`
     // command.
     $against = $this->getWorkingCopyRevision();
     while (true) {
       // NOTE: The "^" and "~" syntaxes were only added in hg 1.9, which is
       // new as of July 2011, so do this in a compatible way. Also, "hg log"
       // and "hg outgoing" don't necessarily show parents (even if given an
       // explicit template consisting of just the parents token) so we need
       // to separately execute "hg parents".
 
       list($stdout) = $this->execxLocal(
         'parents --style default --rev %s',
         $against);
       $parents_logs = ArcanistMercurialParser::parseMercurialLog($stdout);
 
       list($p1, $p2) = array_merge($parents_logs, array(null, null));
 
       if ($p1 && !in_array($p1['rev'], $outgoing_revs)) {
         $against = $p1['rev'];
         break;
       } else if ($p2 && !in_array($p2['rev'], $outgoing_revs)) {
         $against = $p2['rev'];
         break;
       } else if ($p1) {
         $against = $p1['rev'];
       } else {
         // This is the case where you have a new repository and the entire
         // thing is outgoing; Mercurial literally accepts "--rev null" as
         // meaning "diff against the empty state".
         $against = 'null';
         break;
       }
     }
 
     if ($against == 'null') {
       $this->setBaseCommitExplanation(
         pht('this is a new repository (all changes are outgoing).'));
     } else {
       $this->setBaseCommitExplanation(
         pht(
           'it is the first commit reachable from the working copy state '.
           'which is not outgoing.'));
     }
 
     return $against;
   }
 
   public function getLocalCommitInformation() {
     if ($this->localCommitInfo === null) {
       $base_commit = $this->getBaseCommit();
       list($info) = $this->execxLocal(
         'log --template %s --rev %s --branch %s --',
         "{node}\1{rev}\1{author}\1".
           "{date|rfc822date}\1{branch}\1{tag}\1{parents}\1{desc}\2",
         hgsprintf('(%s::. - %s)', $base_commit, $base_commit),
         $this->getBranchName());
       $logs = array_filter(explode("\2", $info));
 
       $last_node = null;
 
       $futures = array();
 
       $commits = array();
       foreach ($logs as $log) {
         list($node, $rev, $full_author, $date, $branch, $tag,
           $parents, $desc) = explode("\1", $log, 9);
 
         list($author, $author_email) = $this->parseFullAuthor($full_author);
 
         // NOTE: If a commit has only one parent, {parents} returns empty.
         // If it has two parents, {parents} returns revs and short hashes, not
         // full hashes. Try to avoid making calls to "hg parents" because it's
         // relatively expensive.
         $commit_parents = null;
         if (!$parents) {
           if ($last_node) {
             $commit_parents = array($last_node);
           }
         }
 
         if (!$commit_parents) {
           // We didn't get a cheap hit on previous commit, so do the full-cost
           // "hg parents" call. We can run these in parallel, at least.
           $futures[$node] = $this->execFutureLocal(
             'parents --template %s --rev %s',
             '{node}\n',
             $node);
         }
 
         $commits[$node] = array(
           'author'  => $author,
           'time'    => strtotime($date),
           'branch'  => $branch,
           'tag'     => $tag,
           'commit'  => $node,
           'rev'     => $node, // TODO: Remove eventually.
           'local'   => $rev,
           'parents' => $commit_parents,
           'summary' => head(explode("\n", $desc)),
           'message' => $desc,
           'authorEmail' => $author_email,
         );
 
         $last_node = $node;
       }
 
       $futures = id(new FutureIterator($futures))
         ->limit(4);
       foreach ($futures as $node => $future) {
         list($parents) = $future->resolvex();
         $parents = array_filter(explode("\n", $parents));
         $commits[$node]['parents'] = $parents;
       }
 
       // Put commits in newest-first order, to be consistent with Git and the
       // expected order of "hg log" and "git log" under normal circumstances.
       // The order of ancestors() is oldest-first.
       $commits = array_reverse($commits);
 
       $this->localCommitInfo = $commits;
     }
 
     return $this->localCommitInfo;
   }
 
   public function getAllFiles() {
     // TODO: Handle paths with newlines.
     $future = $this->buildLocalFuture(array('manifest'));
     return new LinesOfALargeExecFuture($future);
   }
 
   public function getChangedFiles($since_commit) {
     list($stdout) = $this->execxLocal(
       'status --rev %s',
       $since_commit);
     return ArcanistMercurialParser::parseMercurialStatus($stdout);
   }
 
   public function getBlame($path) {
     list($stdout) = $this->execxLocal(
       'annotate -u -v -c --rev %s -- %s',
       $this->getBaseCommit(),
       $path);
 
     $lines = phutil_split_lines($stdout, $retain_line_endings = true);
 
     $blame = array();
     foreach ($lines as $line) {
       if (!strlen($line)) {
         continue;
       }
 
       $matches = null;
       $ok = preg_match('/^\s*([^:]+?) ([a-f0-9]{12}):/', $line, $matches);
 
       if (!$ok) {
         throw new Exception(
           pht(
             'Unable to parse Mercurial blame line: %s',
             $line));
       }
 
       $revision = $matches[2];
       $author = trim($matches[1]);
       $blame[] = array($author, $revision);
     }
 
     return $blame;
   }
 
   protected function buildUncommittedStatus() {
     list($stdout) = $this->execxLocal('status');
 
     $results = new PhutilArrayWithDefaultValue();
 
     $working_status = ArcanistMercurialParser::parseMercurialStatus($stdout);
     foreach ($working_status as $path => $mask) {
       if (!($mask & parent::FLAG_UNTRACKED)) {
         // Mark tracked files as uncommitted.
         $mask |= self::FLAG_UNCOMMITTED;
       }
 
       $results[$path] |= $mask;
     }
 
     return $results->toArray();
   }
 
   protected function buildCommitRangeStatus() {
     list($stdout) = $this->execxLocal(
       'status --rev %s --rev tip',
       $this->getBaseCommit());
 
     $results = new PhutilArrayWithDefaultValue();
 
     $working_status = ArcanistMercurialParser::parseMercurialStatus($stdout);
     foreach ($working_status as $path => $mask) {
       $results[$path] |= $mask;
     }
 
     return $results->toArray();
   }
 
   protected function didReloadWorkingCopy() {
     // Diffs are against ".", so we need to drop the cache if we change the
     // working copy.
     $this->rawDiffCache = array();
     $this->branch = null;
   }
 
   private function getDiffOptions() {
     $options = array(
       '--git',
       '-U'.$this->getDiffLinesOfContext(),
     );
     return implode(' ', $options);
   }
 
   public function getRawDiffText($path) {
     $options = $this->getDiffOptions();
 
     $range = $this->getBaseCommit();
 
     $raw_diff_cache_key = $options.' '.$range.' '.$path;
     if (idx($this->rawDiffCache, $raw_diff_cache_key)) {
       return idx($this->rawDiffCache, $raw_diff_cache_key);
     }
 
     list($stdout) = $this->execxLocal(
       'diff %C --rev %s -- %s',
       $options,
       $range,
       $path);
 
     $this->rawDiffCache[$raw_diff_cache_key] = $stdout;
 
     return $stdout;
   }
 
   public function getFullMercurialDiff() {
     return $this->getRawDiffText('');
   }
 
   public function getOriginalFileData($path) {
     return $this->getFileDataAtRevision($path, $this->getBaseCommit());
   }
 
   public function getCurrentFileData($path) {
     return $this->getFileDataAtRevision(
       $path,
       $this->getWorkingCopyRevision());
   }
 
   public function getBulkOriginalFileData($paths) {
     return $this->getBulkFileDataAtRevision($paths, $this->getBaseCommit());
   }
 
   public function getBulkCurrentFileData($paths) {
     return $this->getBulkFileDataAtRevision(
       $paths,
       $this->getWorkingCopyRevision());
   }
 
   private function getBulkFileDataAtRevision($paths, $revision) {
     // Calling 'hg cat' on each file individually is slow (1 second per file
     // on a large repo) because mercurial has to decompress and parse the
     // entire manifest every time. Do it in one large batch instead.
 
     // hg cat will write the file data to files in a temp directory
     $tmpdir = Filesystem::createTemporaryDirectory();
 
     // Mercurial doesn't create the directories for us :(
     foreach ($paths as $path) {
       $tmppath = $tmpdir.'/'.$path;
       Filesystem::createDirectory(dirname($tmppath), 0755, true);
     }
 
     // NOTE: The "%s%%p" construction passes a literal "%p" to Mercurial,
     // which is a formatting directive for a repo-relative filepath. The
     // particulars of the construction avoid Windows escaping issues. See
     // PHI904.
 
     list($err, $stdout) = $this->execManualLocal(
       'cat --rev %s --output %s%%p -- %Ls',
       $revision,
       $tmpdir.DIRECTORY_SEPARATOR,
       $paths);
 
     $filedata = array();
     foreach ($paths as $path) {
       $tmppath = $tmpdir.'/'.$path;
       if (Filesystem::pathExists($tmppath)) {
         $filedata[$path] = Filesystem::readFile($tmppath);
       }
     }
 
     Filesystem::remove($tmpdir);
 
     return $filedata;
   }
 
   private function getFileDataAtRevision($path, $revision) {
     list($err, $stdout) = $this->execManualLocal(
       'cat --rev %s -- %s',
       $revision,
       $path);
     if ($err) {
       // Assume this is "no file at revision", i.e. a deleted or added file.
       return null;
     } else {
       return $stdout;
     }
   }
 
   public function getWorkingCopyRevision() {
     return '.';
   }
 
   public function isHistoryDefaultImmutable() {
     return true;
   }
 
   public function supportsAmend() {
     list($err, $stdout) = $this->execManualLocal('help commit');
     if ($err) {
       return false;
     } else {
       return (strpos($stdout, 'amend') !== false);
     }
   }
 
   public function supportsRebase() {
     if ($this->supportsRebase === null) {
       list($err) = $this->execManualLocal('help rebase');
       $this->supportsRebase = $err === 0;
     }
 
     return $this->supportsRebase;
   }
 
   public function supportsPhases() {
     if ($this->supportsPhases === null) {
       list($err) = $this->execManualLocal('help phase');
       $this->supportsPhases = $err === 0;
     }
 
     return $this->supportsPhases;
   }
 
   public function supportsCommitRanges() {
     return true;
   }
 
   public function supportsLocalCommits() {
     return true;
   }
 
   public function getAllBranches() {
     list($branch_info) = $this->execxLocal('bookmarks');
     if (trim($branch_info) == 'no bookmarks set') {
       return array();
     }
 
     $matches = null;
     preg_match_all(
       '/^\s*(\*?)\s*(.+)\s(\S+)$/m',
       $branch_info,
       $matches,
       PREG_SET_ORDER);
 
     $return = array();
     foreach ($matches as $match) {
       list(, $current, $name) = $match;
       $return[] = array(
         'current' => (bool)$current,
         'name'    => rtrim($name),
       );
     }
     return $return;
   }
 
+  public function getAllBranchRefs() {
+    $branches = $this->getAllBranches();
+
+    $refs = array();
+    foreach ($branches as $branch) {
+      $refs[] = $this->newBranchRef()
+        ->setBranchName($branch['name'])
+        ->setIsCurrentBranch($branch['current']);
+    }
+
+    return $refs;
+  }
+
+  public function getBaseCommitRef() {
+    $base_commit = $this->getBaseCommit();
+
+    if ($base_commit === 'null') {
+      return null;
+    }
+
+    $base_message = $this->getCommitMessage($base_commit);
+
+    return $this->newCommitRef()
+      ->setCommitHash($base_commit)
+      ->attachMessage($base_message);
+  }
+
   public function hasLocalCommit($commit) {
     try {
       $this->getCanonicalRevisionName($commit);
       return true;
     } catch (Exception $ex) {
       return false;
     }
   }
 
   public function getCommitMessage($commit) {
     list($message) = $this->execxLocal(
       'log --template={desc} --rev %s',
       $commit);
     return $message;
   }
 
   public function getAllLocalChanges() {
     $diff = $this->getFullMercurialDiff();
     if (!strlen(trim($diff))) {
       return array();
     }
     $parser = new ArcanistDiffParser();
     return $parser->parseDiff($diff);
   }
 
   public function supportsLocalBranchMerge() {
     return true;
   }
 
   public function performLocalBranchMerge($branch, $message) {
     if ($branch) {
       $err = phutil_passthru(
         '(cd %s && HGPLAIN=1 hg merge --rev %s && hg commit -m %s)',
         $this->getPath(),
         $branch,
         $message);
     } else {
       $err = phutil_passthru(
         '(cd %s && HGPLAIN=1 hg merge && hg commit -m %s)',
         $this->getPath(),
         $message);
     }
 
     if ($err) {
       throw new ArcanistUsageException(pht('Merge failed!'));
     }
   }
 
   public function getFinalizedRevisionMessage() {
     return pht(
       "You may now push this commit upstream, as appropriate (e.g. with ".
       "'%s' or by printing and faxing it).",
       'hg push');
   }
 
   public function getCommitMessageLog() {
     $base_commit = $this->getBaseCommit();
     list($stdout) = $this->execxLocal(
       'log --template %s --rev %s --branch %s --',
       "{node}\1{desc}\2",
       hgsprintf('(%s::. - %s)', $base_commit, $base_commit),
       $this->getBranchName());
 
     $map = array();
 
     $logs = explode("\2", trim($stdout));
     foreach (array_filter($logs) as $log) {
       list($node, $desc) = explode("\1", $log);
       $map[$node] = $desc;
     }
 
     return array_reverse($map);
   }
 
   public function loadWorkingCopyDifferentialRevisions(
     ConduitClient $conduit,
     array $query) {
 
     $messages = $this->getCommitMessageLog();
     $parser = new ArcanistDiffParser();
 
     // First, try to find revisions by explicit revision IDs in commit messages.
     $reason_map = array();
     $revision_ids = array();
     foreach ($messages as $node_id => $message) {
       $object = ArcanistDifferentialCommitMessage::newFromRawCorpus($message);
 
       if ($object->getRevisionID()) {
         $revision_ids[] = $object->getRevisionID();
         $reason_map[$object->getRevisionID()] = $node_id;
       }
     }
 
     if ($revision_ids) {
       $results = $conduit->callMethodSynchronous(
         'differential.query',
         $query + array(
           'ids' => $revision_ids,
         ));
 
       foreach ($results as $key => $result) {
         $hash = substr($reason_map[$result['id']], 0, 16);
         $results[$key]['why'] =
           pht(
             "Commit message for '%s' has explicit 'Differential Revision'.",
             $hash);
       }
 
       return $results;
     }
 
     // Try to find revisions by hash.
     $hashes = array();
     foreach ($this->getLocalCommitInformation() as $commit) {
       $hashes[] = array('hgcm', $commit['commit']);
     }
 
     if ($hashes) {
 
       // NOTE: In the case of "arc diff . --uncommitted" in a Mercurial working
       // copy with dirty changes, there may be no local commits.
 
       $results = $conduit->callMethodSynchronous(
         'differential.query',
         $query + array(
           'commitHashes' => $hashes,
         ));
 
       foreach ($results as $key => $hash) {
         $results[$key]['why'] = pht(
           'A mercurial commit hash in the commit range is already attached '.
           'to the Differential revision.');
       }
 
       return $results;
     }
 
     return array();
   }
 
   public function updateWorkingCopy() {
     $this->execxLocal('up');
     $this->reloadWorkingCopy();
   }
 
   private function getMercurialConfig($key, $default = null) {
     list($stdout) = $this->execxLocal('showconfig %s', $key);
     if ($stdout == '') {
       return $default;
     }
     return rtrim($stdout);
   }
 
   public function getAuthor() {
     $full_author = $this->getMercurialConfig('ui.username');
     list($author, $author_email) = $this->parseFullAuthor($full_author);
     return $author;
   }
 
   /**
    * Parse the Mercurial author field.
    *
    * Not everyone enters their email address as a part of the username
    * field. Try to make it work when it's obvious.
    *
    * @param string $full_author
    * @return array
    */
   protected function parseFullAuthor($full_author) {
     if (strpos($full_author, '@') === false) {
       $author = $full_author;
       $author_email = null;
     } else {
       $email = new PhutilEmailAddress($full_author);
       $author = $email->getDisplayName();
       $author_email = $email->getAddress();
     }
 
     return array($author, $author_email);
   }
 
   public function addToCommit(array $paths) {
     $this->execxLocal(
       'addremove -- %Ls',
       $paths);
     $this->reloadWorkingCopy();
   }
 
   public function doCommit($message) {
     $tmp_file = new TempFile();
     Filesystem::writeFile($tmp_file, $message);
     $this->execxLocal('commit -l %s', $tmp_file);
     $this->reloadWorkingCopy();
   }
 
   public function amendCommit($message = null) {
     if ($message === null) {
       $message = $this->getCommitMessage('.');
     }
 
     $tmp_file = new TempFile();
     Filesystem::writeFile($tmp_file, $message);
 
     try {
       $this->execxLocal(
         'commit --amend -l %s',
         $tmp_file);
     } catch (CommandException $ex) {
       if (preg_match('/nothing changed/', $ex->getStdout())) {
         // NOTE: Mercurial considers it an error to make a no-op amend. Although
         // we generally defer to the underlying VCS to dictate behavior, this
         // one seems a little goofy, and we use amend as part of various
         // workflows under the assumption that no-op amends are fine. If this
         // amend failed because it's a no-op, just continue.
       } else {
         throw $ex;
       }
     }
 
     $this->reloadWorkingCopy();
   }
 
   public function getCommitSummary($commit) {
     if ($commit == 'null') {
       return pht('(The Empty Void)');
     }
 
     list($summary) = $this->execxLocal(
       'log --template {desc} --limit 1 --rev %s',
       $commit);
 
     $summary = head(explode("\n", $summary));
 
     return trim($summary);
   }
 
   public function backoutCommit($commit_hash) {
     $this->execxLocal('backout -r %s', $commit_hash);
     $this->reloadWorkingCopy();
     if (!$this->getUncommittedStatus()) {
       throw new ArcanistUsageException(
         pht('%s has already been reverted.', $commit_hash));
     }
   }
 
   public function getBackoutMessage($commit_hash) {
     return pht('Backed out changeset %s,', $commit_hash);
   }
 
   public function resolveBaseCommitRule($rule, $source) {
     list($type, $name) = explode(':', $rule, 2);
 
     // NOTE: This function MUST return node hashes or symbolic commits (like
     // branch names or the word "tip"), not revsets. This includes ".^" and
     // similar, which a revset, not a symbolic commit identifier. If you return
     // a revset it will be escaped later and looked up literally.
 
     switch ($type) {
       case 'hg':
         $matches = null;
         if (preg_match('/^gca\((.+)\)$/', $name, $matches)) {
           list($err, $merge_base) = $this->execManualLocal(
             'log --template={node} --rev %s',
             sprintf('ancestor(., %s)', $matches[1]));
           if (!$err) {
             $this->setBaseCommitExplanation(
               pht(
                 "it is the greatest common ancestor of '%s' and %s, as ".
                 "specified by '%s' in your %s 'base' configuration.",
                 $matches[1],
                 '.',
                 $rule,
                 $source));
             return trim($merge_base);
           }
         } else {
           list($err, $commit) = $this->execManualLocal(
             'log --template {node} --rev %s',
             hgsprintf('%s', $name));
 
           if ($err) {
             list($err, $commit) = $this->execManualLocal(
               'log --template {node} --rev %s',
               $name);
           }
           if (!$err) {
             $this->setBaseCommitExplanation(
               pht(
                 "it is specified by '%s' in your %s 'base' configuration.",
                 $rule,
                 $source));
             return trim($commit);
           }
         }
         break;
       case 'arc':
         switch ($name) {
           case 'empty':
             $this->setBaseCommitExplanation(
               pht(
                 "you specified '%s' in your %s 'base' configuration.",
                 $rule,
                 $source));
             return 'null';
           case 'outgoing':
             list($err, $outgoing_base) = $this->execManualLocal(
               'log --template={node} --rev %s',
               'limit(reverse(ancestors(.) - outgoing()), 1)');
             if (!$err) {
               $this->setBaseCommitExplanation(
                 pht(
                   "it is the first ancestor of the working copy that is not ".
                   "outgoing, and it matched the rule %s in your %s ".
                   "'base' configuration.",
                   $rule,
                   $source));
               return trim($outgoing_base);
             }
           case 'amended':
             $text = $this->getCommitMessage('.');
             $message = ArcanistDifferentialCommitMessage::newFromRawCorpus(
               $text);
             if ($message->getRevisionID()) {
               $this->setBaseCommitExplanation(
                 pht(
                   "'%s' has been amended with 'Differential Revision:', ".
                   "as specified by '%s' in your %s 'base' configuration.",
                   '.'.
                   $rule,
                   $source));
               // NOTE: This should be safe because Mercurial doesn't support
               // amend until 2.2.
               return $this->getCanonicalRevisionName('.^');
             }
             break;
           case 'bookmark':
             $revset =
               'limit('.
               '  sort('.
               '    (ancestors(.) and bookmark() - .) or'.
               '    (ancestors(.) - outgoing()), '.
               '  -rev),'.
               '1)';
             list($err, $bookmark_base) = $this->execManualLocal(
               'log --template={node} --rev %s',
               $revset);
             if (!$err) {
               $this->setBaseCommitExplanation(
                 pht(
                   "it is the first ancestor of %s that either has a bookmark, ".
                   "or is already in the remote and it matched the rule %s in ".
                   "your %s 'base' configuration",
                   '.',
                   $rule,
                   $source));
               return trim($bookmark_base);
             }
             break;
           case 'this':
             $this->setBaseCommitExplanation(
               pht(
                 "you specified '%s' in your %s 'base' configuration.",
                 $rule,
                 $source));
             return $this->getCanonicalRevisionName('.^');
           default:
             if (preg_match('/^nodiff\((.+)\)$/', $name, $matches)) {
               list($results) = $this->execxLocal(
                 'log --template %s --rev %s',
                 "{node}\1{desc}\2",
                 sprintf('ancestor(.,%s)::.^', $matches[1]));
               $results = array_reverse(explode("\2", trim($results)));
 
               foreach ($results as $result) {
                 if (empty($result)) {
                   continue;
                 }
 
                 list($node, $desc) = explode("\1", $result, 2);
 
                 $message = ArcanistDifferentialCommitMessage::newFromRawCorpus(
                   $desc);
                 if ($message->getRevisionID()) {
                   $this->setBaseCommitExplanation(
                     pht(
                       "it is the first ancestor of %s that has a diff and is ".
                       "the gca or a descendant of the gca with '%s', ".
                       "specified by '%s' in your %s 'base' configuration.",
                       '.',
                       $matches[1],
                       $rule,
                       $source));
                   return $node;
                 }
               }
             }
             break;
           }
         break;
       default:
         return null;
     }
 
     return null;
 
   }
 
   public function isHgSubversionRepo() {
     return file_exists($this->getPath('.hg/svn/rev_map'));
   }
 
   public function getSubversionInfo() {
     $info = array();
     $base_path = null;
     $revision = null;
     list($err, $raw_info) = $this->execManualLocal('svn info');
     if (!$err) {
       foreach (explode("\n", trim($raw_info)) as $line) {
         list($key, $value) = explode(': ', $line, 2);
         switch ($key) {
           case 'URL':
             $info['base_path'] = $value;
             $base_path = $value;
             break;
           case 'Repository UUID':
             $info['uuid'] = $value;
             break;
           case 'Revision':
             $revision = $value;
             break;
           default:
             break;
         }
       }
       if ($base_path && $revision) {
         $info['base_revision'] = $base_path.'@'.$revision;
       }
     }
     return $info;
   }
 
   public function getActiveBookmark() {
     $bookmarks = $this->getBookmarks();
     foreach ($bookmarks as $bookmark) {
       if ($bookmark['is_active']) {
         return $bookmark['name'];
       }
     }
 
     return null;
   }
 
   public function isBookmark($name) {
     $bookmarks = $this->getBookmarks();
     foreach ($bookmarks as $bookmark) {
       if ($bookmark['name'] === $name) {
         return true;
       }
     }
 
     return false;
   }
 
   public function isBranch($name) {
     $branches = $this->getBranches();
     foreach ($branches as $branch) {
       if ($branch['name'] === $name) {
         return true;
       }
     }
 
     return false;
   }
 
   public function getBranches() {
     list($stdout) = $this->execxLocal('--debug branches');
     $lines = ArcanistMercurialParser::parseMercurialBranches($stdout);
 
     $branches = array();
     foreach ($lines as $name => $spec) {
       $branches[] = array(
         'name' => $name,
         'revision' => $spec['rev'],
       );
     }
 
     return $branches;
   }
 
   public function getBookmarks() {
     $bookmarks = array();
 
     list($raw_output) = $this->execxLocal('bookmarks');
     $raw_output = trim($raw_output);
     if ($raw_output !== 'no bookmarks set') {
       foreach (explode("\n", $raw_output) as $line) {
         // example line:  * mybook               2:6b274d49be97
         list($name, $revision) = $this->splitBranchOrBookmarkLine($line);
 
         $is_active = false;
         if ('*' === $name[0]) {
           $is_active = true;
           $name = substr($name, 2);
         }
 
         $bookmarks[] = array(
           'is_active' => $is_active,
           'name' => $name,
           'revision' => $revision,
         );
       }
     }
 
     return $bookmarks;
   }
 
   private function splitBranchOrBookmarkLine($line) {
     // branches and bookmarks are printed in the format:
     // default                 0:a5ead76cdf85 (inactive)
     // * mybook               2:6b274d49be97
     // this code divides the name half from the revision half
     // it does not parse the * and (inactive) bits
     $colon_index = strrpos($line, ':');
     $before_colon = substr($line, 0, $colon_index);
     $start_rev_index = strrpos($before_colon, ' ');
     $name = substr($line, 0, $start_rev_index);
     $rev = substr($line, $start_rev_index);
 
     return array(trim($name), trim($rev));
   }
 
   public function getRemoteURI() {
     list($stdout) = $this->execxLocal('paths default');
 
     $stdout = trim($stdout);
     if (strlen($stdout)) {
       return $stdout;
     }
 
     return null;
   }
 
 }
diff --git a/src/repository/api/ArcanistRepositoryAPI.php b/src/repository/api/ArcanistRepositoryAPI.php
index f95742c1..41b7840f 100644
--- a/src/repository/api/ArcanistRepositoryAPI.php
+++ b/src/repository/api/ArcanistRepositoryAPI.php
@@ -1,671 +1,682 @@
 <?php
 
 /**
  * Interfaces with the VCS in the working copy.
  *
  * @task  status      Path Status
  */
 abstract class ArcanistRepositoryAPI extends Phobject {
 
   const FLAG_MODIFIED     = 1;
   const FLAG_ADDED        = 2;
   const FLAG_DELETED      = 4;
   const FLAG_UNTRACKED    = 8;
   const FLAG_CONFLICT     = 16;
   const FLAG_MISSING      = 32;
   const FLAG_UNSTAGED     = 64;
   const FLAG_UNCOMMITTED  = 128;
 
   // Occurs in SVN when you have uncommitted changes to a modified external,
   // or in Git when you have uncommitted or untracked changes in a submodule.
   const FLAG_EXTERNALS    = 256;
 
   // Occurs in SVN when you replace a file with a directory without telling
   // SVN about it.
   const FLAG_OBSTRUCTED   = 512;
 
   // Occurs in SVN when an update was interrupted or failed, e.g. you ^C'd it.
   const FLAG_INCOMPLETE   = 1024;
 
   protected $path;
   protected $diffLinesOfContext = 0x7FFF;
   private $baseCommitExplanation = '???';
   private $configurationManager;
   private $baseCommitArgumentRules;
 
   private $uncommittedStatusCache;
   private $commitRangeStatusCache;
 
   private $symbolicBaseCommit;
   private $resolvedBaseCommit;
 
   abstract public function getSourceControlSystemName();
 
   public function getDiffLinesOfContext() {
     return $this->diffLinesOfContext;
   }
 
   public function setDiffLinesOfContext($lines) {
     $this->diffLinesOfContext = $lines;
     return $this;
   }
 
   public function getWorkingCopyIdentity() {
     return $this->configurationManager->getWorkingCopyIdentity();
   }
 
   public function getConfigurationManager() {
     return $this->configurationManager;
   }
 
   public static function newAPIFromConfigurationManager(
     ArcanistConfigurationManager $configuration_manager) {
 
     $working_copy = $configuration_manager->getWorkingCopyIdentity();
 
     if (!$working_copy) {
       throw new Exception(
         pht(
           'Trying to create a %s without a working copy!',
           __CLASS__));
     }
 
     $root = $working_copy->getProjectRoot();
     switch ($working_copy->getVCSType()) {
       case 'svn':
         $api = new ArcanistSubversionAPI($root);
         break;
       case 'hg':
         $api = new ArcanistMercurialAPI($root);
         break;
       case 'git':
         $api = new ArcanistGitAPI($root);
         break;
       default:
         throw new Exception(
           pht(
             'The current working directory is not part of a working copy for '.
             'a supported version control system (Git, Subversion or '.
             'Mercurial).'));
     }
 
     $api->configurationManager = $configuration_manager;
     return $api;
   }
 
   public function __construct($path) {
     $this->path = $path;
   }
 
   public function getPath($to_file = null) {
     if ($to_file !== null) {
       return $this->path.DIRECTORY_SEPARATOR.
              ltrim($to_file, DIRECTORY_SEPARATOR);
     } else {
       return $this->path.DIRECTORY_SEPARATOR;
     }
   }
 
 
 /* -(  Path Status  )-------------------------------------------------------- */
 
 
   abstract protected function buildUncommittedStatus();
   abstract protected function buildCommitRangeStatus();
 
 
   /**
    * Get a list of uncommitted paths in the working copy that have been changed
    * or are affected by other status effects, like conflicts or untracked
    * files.
    *
    * Convenience methods @{method:getUntrackedChanges},
    * @{method:getUnstagedChanges}, @{method:getUncommittedChanges},
    * @{method:getMergeConflicts}, and @{method:getIncompleteChanges} allow
    * simpler selection of paths in a specific state.
    *
    * This method returns a map of paths to bitmasks with status, using
    * `FLAG_` constants. For example:
    *
    *   array(
    *     'some/uncommitted/file.txt' => ArcanistRepositoryAPI::FLAG_UNSTAGED,
    *   );
    *
    * A file may be in several states. Not all states are possible with all
    * version control systems.
    *
    * @return map<string, bitmask> Map of paths, see above.
    * @task status
    */
   final public function getUncommittedStatus() {
     if ($this->uncommittedStatusCache === null) {
       $status = $this->buildUncommittedStatus();
       ksort($status);
       $this->uncommittedStatusCache = $status;
     }
     return $this->uncommittedStatusCache;
   }
 
 
   /**
    * @task status
    */
   final public function getUntrackedChanges() {
     return $this->getUncommittedPathsWithMask(self::FLAG_UNTRACKED);
   }
 
 
   /**
    * @task status
    */
   final public function getUnstagedChanges() {
     return $this->getUncommittedPathsWithMask(self::FLAG_UNSTAGED);
   }
 
 
   /**
    * @task status
    */
   final public function getUncommittedChanges() {
     return $this->getUncommittedPathsWithMask(self::FLAG_UNCOMMITTED);
   }
 
 
   /**
    * @task status
    */
   final public function getMergeConflicts() {
     return $this->getUncommittedPathsWithMask(self::FLAG_CONFLICT);
   }
 
 
   /**
    * @task status
    */
   final public function getIncompleteChanges() {
     return $this->getUncommittedPathsWithMask(self::FLAG_INCOMPLETE);
   }
 
 
   /**
    * @task status
    */
   final public function getMissingChanges() {
     return $this->getUncommittedPathsWithMask(self::FLAG_MISSING);
   }
 
 
   /**
    * @task status
    */
   final public function getDirtyExternalChanges() {
     return $this->getUncommittedPathsWithMask(self::FLAG_EXTERNALS);
   }
 
 
   /**
    * @task status
    */
   private function getUncommittedPathsWithMask($mask) {
     $match = array();
     foreach ($this->getUncommittedStatus() as $path => $flags) {
       if ($flags & $mask) {
         $match[] = $path;
       }
     }
     return $match;
   }
 
 
   /**
    * Get a list of paths affected by the commits in the current commit range.
    *
    * See @{method:getUncommittedStatus} for a description of the return value.
    *
    * @return map<string, bitmask> Map from paths to status.
    * @task status
    */
   final public function getCommitRangeStatus() {
     if ($this->commitRangeStatusCache === null) {
       $status = $this->buildCommitRangeStatus();
       ksort($status);
       $this->commitRangeStatusCache = $status;
     }
     return $this->commitRangeStatusCache;
   }
 
 
   /**
    * Get a list of paths affected by commits in the current commit range, or
    * uncommitted changes in the working copy. See @{method:getUncommittedStatus}
    * or @{method:getCommitRangeStatus} to retrieve smaller parts of the status.
    *
    * See @{method:getUncommittedStatus} for a description of the return value.
    *
    * @return map<string, bitmask> Map from paths to status.
    * @task status
    */
   final public function getWorkingCopyStatus() {
     $range_status = $this->getCommitRangeStatus();
     $uncommitted_status = $this->getUncommittedStatus();
 
     $result = new PhutilArrayWithDefaultValue($range_status);
     foreach ($uncommitted_status as $path => $mask) {
       $result[$path] |= $mask;
     }
 
     $result = $result->toArray();
     ksort($result);
     return $result;
   }
 
 
   /**
    * Drops caches after changes to the working copy. By default, some queries
    * against the working copy are cached. They
    *
    * @return this
    * @task status
    */
   final public function reloadWorkingCopy() {
     $this->uncommittedStatusCache = null;
     $this->commitRangeStatusCache = null;
 
     $this->didReloadWorkingCopy();
     $this->reloadCommitRange();
 
     return $this;
   }
 
 
   /**
    * Hook for implementations to dirty working copy caches after the working
    * copy has been updated.
    *
    * @return void
    * @task status
    */
   protected function didReloadWorkingCopy() {
     return;
   }
 
 
   /**
    * Fetches the original file data for each path provided.
    *
    * @return map<string, string> Map from path to file data.
    */
   public function getBulkOriginalFileData($paths) {
     $filedata = array();
     foreach ($paths as $path) {
       $filedata[$path] = $this->getOriginalFileData($path);
     }
 
     return $filedata;
   }
 
   /**
    * Fetches the current file data for each path provided.
    *
    * @return map<string, string> Map from path to file data.
    */
   public function getBulkCurrentFileData($paths) {
     $filedata = array();
     foreach ($paths as $path) {
       $filedata[$path] = $this->getCurrentFileData($path);
     }
 
     return $filedata;
   }
 
   /**
    * @return Traversable
    */
   abstract public function getAllFiles();
 
   abstract public function getBlame($path);
 
   abstract public function getRawDiffText($path);
   abstract public function getOriginalFileData($path);
   abstract public function getCurrentFileData($path);
   abstract public function getLocalCommitInformation();
   abstract public function getSourceControlBaseRevision();
   abstract public function getCanonicalRevisionName($string);
   abstract public function getBranchName();
   abstract public function getSourceControlPath();
   abstract public function isHistoryDefaultImmutable();
   abstract public function supportsAmend();
   abstract public function getWorkingCopyRevision();
   abstract public function updateWorkingCopy();
   abstract public function getMetadataPath();
   abstract public function loadWorkingCopyDifferentialRevisions(
     ConduitClient $conduit,
     array $query);
   abstract public function getRemoteURI();
 
-
-  public function getUnderlyingWorkingCopyRevision() {
-    return $this->getWorkingCopyRevision();
-  }
-
   public function getChangedFiles($since_commit) {
     throw new ArcanistCapabilityNotSupportedException($this);
   }
 
   public function getAuthor() {
     throw new ArcanistCapabilityNotSupportedException($this);
   }
 
   public function addToCommit(array $paths) {
     throw new ArcanistCapabilityNotSupportedException($this);
   }
 
   abstract public function supportsLocalCommits();
 
   public function doCommit($message) {
     throw new ArcanistCapabilityNotSupportedException($this);
   }
 
   public function amendCommit($message = null) {
     throw new ArcanistCapabilityNotSupportedException($this);
   }
 
   public function getAllBranches() {
     // TODO: Implement for Mercurial/SVN and make abstract.
     return array();
   }
 
+  public function getAllBranchRefs() {
+    throw new ArcanistCapabilityNotSupportedException($this);
+  }
+
+  public function getBaseCommitRef() {
+    throw new ArcanistCapabilityNotSupportedException($this);
+  }
+
   public function hasLocalCommit($commit) {
     throw new ArcanistCapabilityNotSupportedException($this);
   }
 
   public function getCommitMessage($commit) {
     throw new ArcanistCapabilityNotSupportedException($this);
   }
 
   public function getCommitSummary($commit) {
     throw new ArcanistCapabilityNotSupportedException($this);
   }
 
   public function getAllLocalChanges() {
     throw new ArcanistCapabilityNotSupportedException($this);
   }
 
   abstract public function supportsLocalBranchMerge();
 
   public function performLocalBranchMerge($branch, $message) {
     throw new ArcanistCapabilityNotSupportedException($this);
   }
 
   public function getFinalizedRevisionMessage() {
     throw new ArcanistCapabilityNotSupportedException($this);
   }
 
   public function execxLocal($pattern /* , ... */) {
     $args = func_get_args();
     return $this->buildLocalFuture($args)->resolvex();
   }
 
   public function execManualLocal($pattern /* , ... */) {
     $args = func_get_args();
     return $this->buildLocalFuture($args)->resolve();
   }
 
   public function execFutureLocal($pattern /* , ... */) {
     $args = func_get_args();
     return $this->buildLocalFuture($args);
   }
 
   abstract protected function buildLocalFuture(array $argv);
 
   public function canStashChanges() {
     return false;
   }
 
   public function stashChanges() {
     throw new ArcanistCapabilityNotSupportedException($this);
   }
 
   public function unstashChanges() {
     throw new ArcanistCapabilityNotSupportedException($this);
   }
 
 /* -(  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
    */
   public function readScratchFile($path) {
     $full_path = $this->getScratchFilePath($path);
     if (!$full_path) {
       return false;
     }
 
     if (!Filesystem::pathExists($full_path)) {
       return false;
     }
 
     try {
       $result = Filesystem::readFile($full_path);
     } catch (FilesystemException $ex) {
       return false;
     }
 
     return $result;
   }
 
 
   /**
    * 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
    */
   public function writeScratchFile($path, $data) {
     $dir = $this->getScratchFilePath('');
     if (!$dir) {
       return false;
     }
 
     if (!Filesystem::pathExists($dir)) {
       try {
         Filesystem::createDirectory($dir);
       } catch (Exception $ex) {
         return false;
       }
     }
 
     try {
       Filesystem::writeFile($this->getScratchFilePath($path), $data);
     } catch (FilesystemException $ex) {
       return false;
     }
 
     return true;
   }
 
 
   /**
    * Try to remove a scratch file.
    *
    * @param   string  Scratch file name to remove.
    * @return  bool    True if the file was removed successfully.
    * @task scratch
    */
   public function removeScratchFile($path) {
     $full_path = $this->getScratchFilePath($path);
     if (!$full_path) {
       return false;
     }
 
     try {
       Filesystem::remove($full_path);
     } catch (FilesystemException $ex) {
       return false;
     }
 
     return true;
   }
 
 
   /**
    * Get a human-readable description of the scratch file location.
    *
    * @param string  Scratch file name.
    * @return mixed  String, or false on failure.
    * @task scratch
    */
   public function getReadableScratchFilePath($path) {
     $full_path = $this->getScratchFilePath($path);
     if ($full_path) {
       return Filesystem::readablePath(
         $full_path,
         $this->getPath());
     } else {
       return false;
     }
   }
 
 
   /**
    * Get the path to a scratch file, if possible.
    *
    * @param string  Scratch file name.
    * @return mixed  File path, or false on failure.
    * @task scratch
    */
   public function getScratchFilePath($path) {
     $new_scratch_path  = Filesystem::resolvePath(
       'arc',
       $this->getMetadataPath());
 
     static $checked = false;
     if (!$checked) {
       $checked = true;
       $old_scratch_path = $this->getPath('.arc');
       // we only want to do the migration once
       // unfortunately, people have checked in .arc directories which
       // means that the old one may get recreated after we delete it
       if (Filesystem::pathExists($old_scratch_path) &&
           !Filesystem::pathExists($new_scratch_path)) {
         Filesystem::createDirectory($new_scratch_path);
         $existing_files = Filesystem::listDirectory($old_scratch_path, true);
         foreach ($existing_files as $file) {
           $new_path = Filesystem::resolvePath($file, $new_scratch_path);
           $old_path = Filesystem::resolvePath($file, $old_scratch_path);
           Filesystem::writeFile(
             $new_path,
             Filesystem::readFile($old_path));
         }
         Filesystem::remove($old_scratch_path);
       }
     }
     return Filesystem::resolvePath($path, $new_scratch_path);
   }
 
 
 /* -(  Base Commits  )------------------------------------------------------- */
 
   abstract public function supportsCommitRanges();
 
   final public function setBaseCommit($symbolic_commit) {
     if (!$this->supportsCommitRanges()) {
       throw new ArcanistCapabilityNotSupportedException($this);
     }
 
     $this->symbolicBaseCommit = $symbolic_commit;
     $this->reloadCommitRange();
     return $this;
   }
 
   public function setHeadCommit($symbolic_commit) {
     throw new ArcanistCapabilityNotSupportedException($this);
   }
 
   final public function getBaseCommit() {
     if (!$this->supportsCommitRanges()) {
       throw new ArcanistCapabilityNotSupportedException($this);
     }
 
     if ($this->resolvedBaseCommit === null) {
       $commit = $this->buildBaseCommit($this->symbolicBaseCommit);
       $this->resolvedBaseCommit = $commit;
     }
 
     return $this->resolvedBaseCommit;
   }
 
   public function getHeadCommit() {
     throw new ArcanistCapabilityNotSupportedException($this);
   }
 
   final public function reloadCommitRange() {
     $this->resolvedBaseCommit = null;
     $this->baseCommitExplanation = null;
 
     $this->didReloadCommitRange();
 
     return $this;
   }
 
   protected function didReloadCommitRange() {
     return;
   }
 
   protected function buildBaseCommit($symbolic_commit) {
     throw new ArcanistCapabilityNotSupportedException($this);
   }
 
   public function getBaseCommitExplanation() {
     return $this->baseCommitExplanation;
   }
 
   public function setBaseCommitExplanation($explanation) {
     $this->baseCommitExplanation = $explanation;
     return $this;
   }
 
   public function resolveBaseCommitRule($rule, $source) {
     return null;
   }
 
   public function setBaseCommitArgumentRules($base_commit_argument_rules) {
     $this->baseCommitArgumentRules = $base_commit_argument_rules;
     return $this;
   }
 
   public function getBaseCommitArgumentRules() {
     return $this->baseCommitArgumentRules;
   }
 
   public function resolveBaseCommit() {
     $base_commit_rules = array(
       'runtime' => $this->getBaseCommitArgumentRules(),
       'local'   => '',
       'project' => '',
       'user'    => '',
       'system'  => '',
     );
     $all_sources = $this->configurationManager->getConfigFromAllSources('base');
 
     $base_commit_rules = $all_sources + $base_commit_rules;
 
     $parser = new ArcanistBaseCommitParser($this);
     $commit = $parser->resolveBaseCommit($base_commit_rules);
 
     return $commit;
   }
 
   public function getRepositoryUUID() {
     return null;
   }
 
+  final public function newCommitRef() {
+    return new ArcanistCommitRef();
+  }
+
+  final public function newBranchRef() {
+    return new ArcanistBranchRef();
+  }
+
 }
diff --git a/src/workflow/ArcanistBrowseWorkflow.php b/src/workflow/ArcanistBrowseWorkflow.php
deleted file mode 100644
index 64d8f84a..00000000
--- a/src/workflow/ArcanistBrowseWorkflow.php
+++ /dev/null
@@ -1,233 +0,0 @@
-<?php
-
-/**
- * Browse files or objects in the Phabricator web interface.
- */
-final class ArcanistBrowseWorkflow extends ArcanistWorkflow {
-
-  public function getWorkflowName() {
-    return 'browse';
-  }
-
-  public function getCommandSynopses() {
-    return phutil_console_format(<<<EOTEXT
-      **browse** [__options__] __path__ ...
-      **browse** [__options__] __object__ ...
-EOTEXT
-      );
-  }
-
-  public function getCommandHelp() {
-    return phutil_console_format(<<<EOTEXT
-          Supports: git, hg, svn
-          Open a file or object (like a task or revision) in your web browser.
-
-            $ arc browse README   # Open a file in Diffusion.
-            $ arc browse T123     # View a task.
-            $ arc browse HEAD     # View a symbolic commit.
-
-          Set the 'browser' value using 'arc set-config' to select a browser. If
-          no browser is set, the command will try to guess which browser to use.
-EOTEXT
-      );
-  }
-
-  public function getArguments() {
-    return array(
-      'branch' => array(
-        'param' => 'branch_name',
-        'help' => pht(
-          'Default branch name to view on server. Defaults to "%s".',
-          'master'),
-      ),
-      'force' => array(
-        'help' => pht(
-          'Open arguments as paths, even if they do not exist in the '.
-          'working copy.'),
-      ),
-      '*' => 'paths',
-    );
-  }
-
-  public function desiresWorkingCopy() {
-    return true;
-  }
-
-  public function requiresConduit() {
-    return true;
-  }
-
-  public function requiresAuthentication() {
-    return true;
-  }
-
-  public function desiresRepositoryAPI() {
-    return true;
-  }
-
-  public function run() {
-    $console = PhutilConsole::getConsole();
-
-    $is_force = $this->getArgument('force');
-
-    $things = $this->getArgument('paths');
-    if (!$things) {
-      throw new ArcanistUsageException(
-        pht(
-          'Specify one or more paths or objects to browse. Use the command '.
-          '"%s" if you want to browse this directory.',
-          'arc browse .'));
-    }
-    $things = array_fuse($things);
-
-    $objects = $this->getConduit()->callMethodSynchronous(
-      'phid.lookup',
-      array(
-        'names' => array_keys($things),
-      ));
-
-    $uris = array();
-    foreach ($objects as $name => $object) {
-      $uris[] = $object['uri'];
-
-      $console->writeOut(
-        pht(
-          'Opening **%s** as an object.',
-          $name)."\n");
-
-      unset($things[$name]);
-    }
-
-    if ($this->hasRepositoryAPI()) {
-      $repository_api = $this->getRepositoryAPI();
-      $project_root = $this->getWorkingCopy()->getProjectRoot();
-
-      // First, try to resolve arguments as symbolic commits.
-
-      $commits = array();
-      foreach ($things as $key => $thing) {
-        if ($thing == '.') {
-          // Git resolves '.' like HEAD, but it should be interpreted to mean
-          // "the current directory". Just skip resolution and fall through.
-          continue;
-        }
-
-        try {
-          $commit = $repository_api->getCanonicalRevisionName($thing);
-          if ($commit) {
-            $commits[$commit] = $key;
-          }
-        } catch (Exception $ex) {
-          // Ignore.
-        }
-      }
-
-      if ($commits) {
-        $commit_info = $this->getConduit()->callMethodSynchronous(
-          'diffusion.querycommits',
-          array(
-            'repositoryPHID' => $this->getRepositoryPHID(),
-            'names' => array_keys($commits),
-          ));
-
-        foreach ($commit_info['identifierMap'] as $ckey => $cphid) {
-          $thing = $commits[$ckey];
-          unset($things[$thing]);
-
-          $uris[] = $commit_info['data'][$cphid]['uri'];
-
-          $console->writeOut(
-            pht(
-              'Opening **%s** as a commit.',
-              $thing)."\n");
-        }
-      }
-
-      // If we fail, try to resolve them as paths.
-
-      foreach ($things as $key => $path) {
-        $lines = null;
-        $parts = explode(':', $path);
-        if (count($parts) > 1) {
-          $lines = array_pop($parts);
-        }
-        $path = implode(':', $parts);
-
-        $full_path = Filesystem::resolvePath($path);
-
-        if (!$is_force && !Filesystem::pathExists($full_path)) {
-          continue;
-        }
-
-        $console->writeOut(
-          pht(
-            'Opening **%s** as a repository path.',
-            $key)."\n");
-
-        unset($things[$key]);
-
-        if ($full_path == $project_root) {
-          $path = '';
-        } else {
-          $path = Filesystem::readablePath($full_path, $project_root);
-        }
-
-        $base_uri = $this->getBaseURI();
-        $uri = $base_uri.$path;
-
-        if ($lines) {
-          $uri = $uri.'$'.$lines;
-        }
-
-        $uris[] = $uri;
-      }
-    } else {
-      if ($things) {
-        $console->writeOut(
-          "%s\n",
-          pht(
-            "The current working directory is not a repository working ".
-            "copy, so remaining arguments can not be resolved as paths or ".
-            "commits. To browse paths or symbolic commits in Diffusion, run ".
-            "'%s' from inside a working copy.",
-            'arc browse'));
-      }
-    }
-
-    foreach ($things as $thing) {
-      $console->writeOut(
-        "%s\n",
-        pht(
-          'Unable to find an object named **%s**, no such commit exists in '.
-          'the remote, and no such path exists in the working copy. Use '.
-          '__%s__ to treat this as a path anyway.',
-          $thing,
-          '--force'));
-    }
-
-    if ($uris) {
-      $this->openURIsInBrowser($uris);
-    }
-
-    return 0;
-  }
-
-  private function getBaseURI() {
-    $repo_uri = $this->getRepositoryURI();
-    if ($repo_uri === null) {
-      throw new ArcanistUsageException(
-        pht(
-          'arc is unable to determine which repository in Diffusion '.
-          'this working copy belongs to. Use "%s" to understand how '.
-          '%s looks for a repository.',
-          'arc which',
-          'arc'));
-    }
-
-    $branch = $this->getArgument('branch', 'master');
-    $branch = phutil_escape_uri_path_component($branch);
-
-    return $repo_uri.'browse/'.$branch.'/';
-  }
-
-}
diff --git a/src/workflow/ArcanistDiffWorkflow.php b/src/workflow/ArcanistDiffWorkflow.php
index bb46fd0a..7f117ca8 100644
--- a/src/workflow/ArcanistDiffWorkflow.php
+++ b/src/workflow/ArcanistDiffWorkflow.php
@@ -1,3033 +1,3084 @@
 <?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 $excuses = array('lint' => null, 'unit' => null);
   private $testResults;
   private $diffID;
   private $revisionID;
   private $haveUncommittedChanges = false;
   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;
     }
 
     if ($this->getArgument('use-commit-message')) {
       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.'),
       ),
       'use-commit-message' => array(
         'supports' => array(
           'git',
           // TODO: Support mercurial.
         ),
         'short' => 'C',
         'param' => 'commit',
         'help' => pht('Read revision information from a specific commit.'),
         'conflicts' => array(
           'only' => null,
           'update'  => null,
         ),
       ),
       '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.'),
         'conflicts' => array(
           'less-context'        => null,
           'apply-patches'       => pht('%s disables lint.', '--raw'),
           'never-apply-patches' => pht('%s disables lint.', '--raw'),
           'advice'              => pht('%s disables lint.', '--raw'),
           'lintall'             => 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.'),
         'conflicts' => array(
           'less-context'        => null,
           'apply-patches'       => pht('%s disables lint.', '--raw-command'),
           'never-apply-patches' => pht('%s disables lint.', '--raw-command'),
           'advice'              => pht('%s disables lint.', '--raw-command'),
           'lintall'             => 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(
           'lintall'   => pht('%s suppresses lint.', '--nolint'),
           'advice'    => pht('%s suppresses lint.', '--nolint'),
           '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'),
         ),
       ),
       'encoding' => array(
         'param' => 'encoding',
         'help' => pht(
           'Attempt to convert non UTF-8 hunks into specified encoding.'),
       ),
       'allow-untracked' => array(
         'help' => pht('Skip checks for untracked files in the working copy.'),
       ),
       'excuse' => array(
         'param' => 'excuse',
         'help' => pht(
           'Provide a prepared in advance excuse for any lints/tests '.
           'shall they fail.'),
       ),
       'less-context' => array(
         'help' => pht(
           "Normally, files are diffed with full context: the entire file is ".
           "sent to Differential so reviewers can 'show more' and see it. If ".
           "you are making changes to very large files with tens of thousands ".
           "of lines, this may not work well. With this flag, a diff will ".
           "be created that has only a few lines of context."),
       ),
       'lintall' => array(
         'help' => pht(
           'Raise all lint warnings, not just those on lines you changed.'),
         'passthru' => array(
           'lint' => true,
         ),
       ),
       'advice' => array(
         'help' => pht(
           'Require excuse for lint advice in addition to lint warnings and '.
           'errors.'),
       ),
       'only-new' => array(
         'param' => 'bool',
         'help' => pht(
           'Display only lint messages not present in the original code.'),
         'passthru' => array(
           'lint' => true,
         ),
       ),
       '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(
           'use-commit-message'  => true,
           '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.'),
       ),
       'ignore-unsound-tests' => array(
         'help'  => pht('Ignore unsound test failures without prompting.'),
       ),
       '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.'),
         'supports' => array('git'),
         'nosupport' => array(
           'svn' => pht('Subversion does not support commit ranges.'),
           'hg' => pht('Mercurial does not support %s yet.', '--head'),
         ),
         'conflicts' => array(
           'lintall'   => pht('%s suppresses lint.', '--head'),
           'advice'    => pht('%s suppresses lint.', '--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);
     }
 
     $server = $this->console->getServer();
     $server->setHandler(array($this, 'handleServerMessage'));
     $data = $this->runLintUnit();
 
     $lint_result = $data['lintResult'];
     $this->unresolvedLint = $data['unresolvedLint'];
     $unit_result = $data['unitResult'];
     $this->testResults = $data['testResults'];
 
     if ($this->getArgument('nolint')) {
       $this->excuses['lint'] = $this->getSkipExcuse(
         pht('Provide explanation for skipping lint or press Enter to abort:'),
         'lint-excuses');
     }
 
     if ($this->getArgument('nounit')) {
       $this->excuses['unit'] = $this->getSkipExcuse(
         pht(
           'Provide explanation for skipping unit tests '.
           'or press Enter to abort:'),
         'unit-excuses');
     }
 
     $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 '.
                 '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();
     if ($this->getArgument('less-context')) {
       $repository_api->setDiffLinesOfContext(3);
     }
 
     $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')
           ->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 (!strlen($revision['message'])) {
         $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->getArgument('use-commit-message')) {
       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 (!$this->getArgument('less-context')) {
           $byte_warning .= ' '.pht(
             "If this file is a huge text file, try using the '%s' flag.",
             '--less-context');
         }
         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.'));
           }
         }
       }
     }
 
     $try_encoding = nonempty($this->getArgument('encoding'), null);
 
     $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) {
 
             if (!$try_encoding) {
               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',
                         $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 ".
             "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."),
           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->haveUncommittedChanges) {
       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:
           if ($this->getArgument('advice') &&
               $lint_workflow->getUnresolvedMessages()) {
             $this->getErrorExcuse(
               'lint',
               pht('Lint issued unresolved advice.'),
               'lint-excuses');
           } else {
             $this->console->writeOut(
               "<bg:green>** %s **</bg> %s\n",
               pht('LINT OKAY'),
               pht('No lint problems.'));
           }
           break;
         case ArcanistLintWorkflow::RESULT_WARNINGS:
           $this->getErrorExcuse(
             'lint',
             pht('Lint issued unresolved warnings.'),
             'lint-excuses');
           break;
         case ArcanistLintWorkflow::RESULT_ERRORS:
           $this->console->writeOut(
             "<bg:red>** %s **</bg> %s\n",
             pht('LINT ERRORS'),
             pht('Lint raised errors!'));
           $this->getErrorExcuse(
             'lint',
             pht('Lint issued unresolved errors!'),
             'lint-excuses');
           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:
           if ($this->getArgument('ignore-unsound-tests')) {
             echo phutil_console_format(
               "<bg:yellow>** %s **</bg> %s\n",
               pht('UNIT UNSOUND'),
               pht(
                 'Unit testing raised errors, but all '.
                 'failing tests are unsound.'));
           } else {
             $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();
             }
           }
           break;
         case ArcanistUnitWorkflow::RESULT_FAIL:
           $this->console->writeOut(
             "<bg:red>** %s **</bg> %s\n",
             pht('UNIT ERRORS'),
             pht('Unit testing raised errors!'));
           $this->getErrorExcuse(
             'unit',
             pht('Unit test results include failures!'),
             'unit-excuses');
           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;
   }
 
   private function getSkipExcuse($prompt, $history) {
     $excuse = $this->getArgument('excuse');
 
     if ($excuse === null) {
       $history = $this->getRepositoryAPI()->getScratchFilePath($history);
       $excuse = phutil_console_prompt($prompt, $history);
       if ($excuse == '') {
         throw new ArcanistUserAbortException();
       }
     }
 
     return $excuse;
   }
 
   private function getErrorExcuse($type, $prompt, $history) {
     if ($this->getArgument('excuse')) {
       $this->console->sendMessage(array(
         'type'    => $type,
         'confirm'  => $prompt.' '.pht('Ignore them?'),
       ));
       return;
     }
 
     $history = $this->getRepositoryAPI()->getScratchFilePath($history);
 
     $prompt .= ' '.
       pht('Provide explanation to continue or press Enter to abort.');
     $this->console->writeOut("\n\n%s", phutil_console_wrap($prompt));
     $this->console->sendMessage(array(
       'type'    => $type,
       'prompt'  => pht('Explanation:'),
       'history' => $history,
     ));
   }
 
   public function handleServerMessage(PhutilConsoleMessage $message) {
     $data = $message->getData();
 
     if ($this->getArgument('excuse')) {
       try {
         phutil_console_require_tty();
       } catch (PhutilConsoleStdinNotInteractiveException $ex) {
         $this->excuses[$data['type']] = $this->getArgument('excuse');
         return null;
       }
     }
 
     $response = '';
     if (isset($data['prompt'])) {
       $response = phutil_console_prompt($data['prompt'], idx($data, 'history'));
     } else if (phutil_console_confirm($data['confirm'])) {
       $response = $this->getArgument('excuse');
     }
     if ($response == '') {
       throw new ArcanistUserAbortException();
     }
     $this->excuses[$data['type']] = $response;
     return null;
   }
 
 
 /* -(  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_message = $this->getArgument('use-commit-message');
     $is_verbatim = $this->getArgument('verbatim');
 
     if ($is_message) {
       return $this->getCommitMessageFromCommit($is_message);
     }
 
     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 getCommitMessageFromCommit($commit) {
     $text = $this->getRepositoryAPI()->getCommitMessage($commit);
     $message = ArcanistDifferentialCommitMessage::newFromRawCorpus($text);
     $message->pullDataFromConduit($this->getConduit());
     $this->validateCommitMessage($message);
     return $message;
   }
 
 
   /**
    * @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')
           ->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();
 
       $template = sprintf(
         "%s\n\n# %s\n#\n# %s\n# %s\n#\n# %s\n#  $ %s\n\n",
         rtrim($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')
       ->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 (strlen($this->excuses['lint'])) {
       $this->updateDiffProperty(
         'arc:lint-excuse',
         json_encode($this->excuses['lint']));
     }
 
     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 (strlen($this->excuses['unit'])) {
       $this->updateDiffProperty('arc:unit-excuse',
         json_encode($this->excuses['unit']));
     }
 
     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 (strlen($remote_branch)) {
         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 (strlen($onto)) {
       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())
       ->setConduitClient($this->getConduit());
 
     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.'));
       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,
     );
 
     // 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' => $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.'));
     }
 
     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() {
+    $api = $this->getRepositoryAPI();
+    $base_ref = $api->getBaseCommitRef();
+
+    $state_ref = $this->newWorkingCopyStateRef()
+      ->setCommitRef($base_ref);
+
+    $this->newRefQuery(array($state_ref))
+      ->needHardpoints(
+        array(
+          'revisionRefs',
+        ))
+      ->execute();
+
+    $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/ArcanistFeatureWorkflow.php b/src/workflow/ArcanistFeatureWorkflow.php
index a1cbe108..53d5772f 100644
--- a/src/workflow/ArcanistFeatureWorkflow.php
+++ b/src/workflow/ArcanistFeatureWorkflow.php
@@ -1,374 +1,283 @@
 <?php
 
 /**
  * Displays user's Git branches or Mercurial bookmarks.
  *
  * @concrete-extensible
  */
 class ArcanistFeatureWorkflow extends ArcanistWorkflow {
 
   private $branches;
 
   public function getWorkflowName() {
     return 'feature';
   }
 
   public function getCommandSynopses() {
     return phutil_console_format(<<<EOTEXT
       **feature** [__options__]
       **feature** __name__ [__start__]
 EOTEXT
       );
   }
 
   public function getCommandHelp() {
     return phutil_console_format(<<<EOTEXT
           Supports: git, hg
           A wrapper on 'git branch' or 'hg bookmark'.
 
           Without __name__, it lists the available branches and their revision
           status.
 
           With __name__, it creates or checks out a branch. If the branch
           __name__ doesn't exist and is in format D123 then the branch of
           revision D123 is checked out. Use __start__ to specify where the new
           branch will start. Use 'arc.feature.start.default' to set the default
           feature start location.
 EOTEXT
       );
   }
 
-  public function requiresConduit() {
-    return true;
-  }
-
   public function requiresRepositoryAPI() {
     return true;
   }
 
-  public function requiresAuthentication() {
-    return !$this->getArgument('branch');
-  }
-
   public function getArguments() {
     return array(
       'view-all' => array(
         'help' => pht('Include closed and abandoned revisions.'),
       ),
       'by-status' => array(
         'help' => pht('Sort branches by status instead of time.'),
       ),
       'output' => array(
         'param' => 'format',
         'support' => array(
           'json',
         ),
         'help' => pht(
           "With '%s', show features in machine-readable JSON format.",
           'json'),
       ),
       '*' => 'branch',
     );
   }
 
   public function getSupportedRevisionControlSystems() {
     return array('git', 'hg');
   }
 
   public function run() {
     $repository_api = $this->getRepositoryAPI();
 
     $names = $this->getArgument('branch');
     if ($names) {
       if (count($names) > 2) {
         throw new ArcanistUsageException(pht('Specify only one branch.'));
       }
       return $this->checkoutBranch($names);
     }
 
-    $branches = $repository_api->getAllBranches();
+    // TODO: Everything in this whole workflow that says "branch" means
+    // "bookmark" in Mercurial.
+
+    $branches = $repository_api->getAllBranchRefs();
     if (!$branches) {
       throw new ArcanistUsageException(
         pht('No branches in this working copy.'));
     }
 
-    $branches = $this->loadCommitInfo($branches);
-    $revisions = $this->loadRevisions($branches);
-    $this->printBranches($branches, $revisions);
+    $states = array();
+    foreach ($branches as $branch) {
+      $states[] = $this->newWorkingCopyStateRef()
+        ->attachBranchRef($branch);
+    }
+
+    $this->newRefQuery($states)
+      ->needHardpoints(
+        array(
+          'revisionRefs',
+        ))
+      ->execute();
+
+    $this->printBranches($states);
 
     return 0;
   }
 
   private function checkoutBranch(array $names) {
     $api = $this->getRepositoryAPI();
 
     if ($api instanceof ArcanistMercurialAPI) {
       $command = 'update %s';
     } else {
       $command = 'checkout %s';
     }
 
     $err = 1;
 
     $name = $names[0];
     if (isset($names[1])) {
       $start = $names[1];
     } else {
       $start = $this->getConfigFromAnySource('arc.feature.start.default');
     }
 
     $branches = $api->getAllBranches();
     if (in_array($name, ipull($branches, 'name'))) {
       list($err, $stdout, $stderr) = $api->execManualLocal($command, $name);
     }
 
     if ($err) {
       $match = null;
       if (preg_match('/^D(\d+)$/', $name, $match)) {
-        try {
-          $diff = $this->getConduit()->callMethodSynchronous(
-            'differential.querydiffs',
-            array(
-              'revisionIDs' => array($match[1]),
-            ));
-          $diff = head($diff);
-
-          if ($diff['branch'] != '') {
-            $name = $diff['branch'];
-            list($err, $stdout, $stderr) = $api->execManualLocal(
-              $command,
-              $name);
-          }
-        } catch (ConduitClientException $ex) {}
+        $diff = $this->getConduitEngine()->resolveCall(
+          'differential.querydiffs',
+          array(
+            'revisionIDs' => array($match[1]),
+          ));
+        $diff = head($diff);
+
+        if ($diff['branch'] != '') {
+          $name = $diff['branch'];
+          list($err, $stdout, $stderr) = $api->execManualLocal(
+            $command,
+            $name);
+        }
       }
     }
 
     if ($err) {
       if ($api instanceof ArcanistMercurialAPI) {
         $rev = '';
         if ($start) {
           $rev = csprintf('-r %s', $start);
         }
 
         $exec = $api->execManualLocal('bookmark %C %s', $rev, $name);
 
         if (!$exec[0] && $start) {
           $api->execxLocal('update %s', $name);
         }
       } else {
         $startarg = $start ? csprintf('%s', $start) : '';
         $exec = $api->execManualLocal(
           'checkout --track -b %s %C',
           $name,
           $startarg);
       }
 
       list($err, $stdout, $stderr) = $exec;
     }
 
     echo $stdout;
     fprintf(STDERR, '%s', $stderr);
     return $err;
   }
 
-  private function loadCommitInfo(array $branches) {
-    $repository_api = $this->getRepositoryAPI();
-
-    $branches = ipull($branches, null, 'name');
-
-    if ($repository_api instanceof ArcanistMercurialAPI) {
-      $futures = array();
-      foreach ($branches as $branch) {
-        $futures[$branch['name']] = $repository_api->execFutureLocal(
-          'log -l 1 --template %s -r %s',
-          "{node}\1{date|hgdate}\1{p1node}\1{desc|firstline}\1{desc}",
-          hgsprintf('%s', $branch['name']));
-      }
-
-      $futures = id(new FutureIterator($futures))
-        ->limit(16);
-      foreach ($futures as $name => $future) {
-        list($info) = $future->resolvex();
-
-        $fields = explode("\1", trim($info), 5);
-        list($hash, $epoch, $tree, $desc, $text) = $fields;
-
-        $branches[$name] += array(
-          'hash' => $hash,
-          'desc' => $desc,
-          'tree' => $tree,
-          'epoch' => (int)$epoch,
-          'text' => $text,
-        );
-      }
-    }
-
-    foreach ($branches as $name => $branch) {
-      $text = $branch['text'];
-
-      try {
-        $message = ArcanistDifferentialCommitMessage::newFromRawCorpus($text);
-        $id = $message->getRevisionID();
-
-        $branch['revisionID'] = $id;
-      } catch (ArcanistUsageException $ex) {
-        // In case of invalid commit message which fails the parsing,
-        // do nothing.
-        $branch['revisionID'] = null;
-      }
-
-      $branches[$name] = $branch;
-    }
-
-    return $branches;
-  }
-
-  private function loadRevisions(array $branches) {
-    $ids = array();
-    $hashes = array();
-
-    foreach ($branches as $branch) {
-      if ($branch['revisionID']) {
-        $ids[] = $branch['revisionID'];
-      }
-      $hashes[] = array('gtcm', $branch['hash']);
-      $hashes[] = array('gttr', $branch['tree']);
-    }
-
-    $calls = array();
-
-    if ($ids) {
-      $calls[] = $this->getConduit()->callMethod(
-        'differential.query',
-        array(
-          'ids' => $ids,
-        ));
-    }
-
-    if ($hashes) {
-      $calls[] = $this->getConduit()->callMethod(
-        'differential.query',
-        array(
-          'commitHashes' => $hashes,
-        ));
-    }
-
-    $results = array();
-    foreach (new FutureIterator($calls) as $call) {
-      $results[] = $call->resolve();
-    }
-
-    return array_mergev($results);
-  }
-
-  private function printBranches(array $branches, array $revisions) {
-    $revisions = ipull($revisions, null, 'id');
-
+  private function printBranches(array $states) {
     static $color_map = array(
       'Closed'          => 'cyan',
       'Needs Review'    => 'magenta',
       'Needs Revision'  => 'red',
       'Accepted'        => 'green',
       'No Revision'     => 'blue',
       'Abandoned'       => 'default',
     );
 
     static $ssort_map = array(
       'Closed'          => 1,
       'No Revision'     => 2,
       'Needs Review'    => 3,
       'Needs Revision'  => 4,
       'Accepted'        => 5,
     );
 
     $out = array();
-    foreach ($branches as $branch) {
-      $revision = idx($revisions, idx($branch, 'revisionID'));
-
-      // If we haven't identified a revision by ID, try to identify it by hash.
-      if (!$revision) {
-        foreach ($revisions as $rev) {
-          $hashes = idx($rev, 'hashes', array());
-          foreach ($hashes as $hash) {
-            if (($hash[0] == 'gtcm' && $hash[1] == $branch['hash']) ||
-                ($hash[0] == 'gttr' && $hash[1] == $branch['tree'])) {
-              $revision = $rev;
-              break;
-            }
-          }
-        }
-      }
+    foreach ($states as $state) {
+      $branch = $state->getBranchRef();
 
-      if ($revision) {
-        $desc = 'D'.$revision['id'].': '.$revision['title'];
-        $status = $revision['statusName'];
+      $revision = null;
+      if ($state->hasAmbiguousRevisionRefs()) {
+        $status = pht('Ambiguous Revision');
       } else {
-        $desc = $branch['desc'];
-        $status = pht('No Revision');
+        $revision = $state->getRevisionRef();
+        if ($revision) {
+          $status = $revision->getStatusDisplayName();
+        } else {
+          $status = pht('No Revision');
+        }
       }
 
-      if (!$this->getArgument('view-all') && !$branch['current']) {
+      if (!$this->getArgument('view-all') && !$branch->getIsCurrentBranch()) {
         if ($status == 'Closed' || $status == 'Abandoned') {
           continue;
         }
       }
 
-      $epoch = $branch['epoch'];
+      $commit = $branch->getCommitRef();
+      $epoch = $commit->getCommitEpoch();
 
       $color = idx($color_map, $status, 'default');
       $ssort = sprintf('%d%012d', idx($ssort_map, $status, 0), $epoch);
 
+      if ($revision) {
+        $desc = $revision->getFullName();
+      } else {
+        $desc = $commit->getSummary();
+      }
+
       $out[] = array(
-        'name'      => $branch['name'],
-        'current'   => $branch['current'],
+        'name'      => $branch->getBranchName(),
+        'current'   => $branch->getIsCurrentBranch(),
         'status'    => $status,
         'desc'      => $desc,
-        'revision'  => $revision ? $revision['id'] : null,
+        'revision'  => $revision ? $revision->getID() : null,
         'color'     => $color,
         'esort'     => $epoch,
         'epoch'     => $epoch,
         'ssort'     => $ssort,
       );
     }
 
     if (!$out) {
       // All of the revisions are closed or abandoned.
       return;
     }
 
     $len_name = max(array_map('strlen', ipull($out, 'name'))) + 2;
     $len_status = max(array_map('strlen', ipull($out, 'status'))) + 2;
 
     if ($this->getArgument('by-status')) {
       $out = isort($out, 'ssort');
     } else {
       $out = isort($out, 'esort');
     }
     if ($this->getArgument('output') == 'json') {
       foreach ($out as &$feature) {
         unset($feature['color'], $feature['ssort'], $feature['esort']);
       }
       echo json_encode(ipull($out, null, 'name'))."\n";
     } else {
       $table = id(new PhutilConsoleTable())
         ->setShowHeader(false)
         ->addColumn('current', array('title' => ''))
         ->addColumn('name',    array('title' => pht('Name')))
         ->addColumn('status',  array('title' => pht('Status')))
         ->addColumn('descr',   array('title' => pht('Description')));
 
       foreach ($out as $line) {
         $table->addRow(array(
           'current' => $line['current'] ? '*' : '',
           'name'    => tsprintf('**%s**', $line['name']),
           'status'  => tsprintf(
             "<fg:{$line['color']}>%s</fg>", $line['status']),
           'descr'   => $line['desc'],
         ));
       }
 
       $table->draw();
     }
   }
 
 }
diff --git a/src/workflow/ArcanistUpgradeWorkflow.php b/src/workflow/ArcanistUpgradeWorkflow.php
index 5b7019d1..a46d255c 100644
--- a/src/workflow/ArcanistUpgradeWorkflow.php
+++ b/src/workflow/ArcanistUpgradeWorkflow.php
@@ -1,111 +1,116 @@
 <?php
 
 /**
  * Upgrade arcanist itself.
  */
 final class ArcanistUpgradeWorkflow extends ArcanistWorkflow {
 
   public function getWorkflowName() {
     return 'upgrade';
   }
 
   public function getCommandSynopses() {
     return phutil_console_format(<<<EOTEXT
       **upgrade**
 EOTEXT
       );
   }
 
   public function getCommandHelp() {
     return phutil_console_format(<<<EOTEXT
           Supports: cli
           Upgrade arcanist and libphutil to the latest versions.
 EOTEXT
       );
   }
 
   public function run() {
     $roots = array(
       'arcanist' => dirname(phutil_get_library_root('arcanist')),
     );
 
+    $supported_branches = array(
+      'master',
+      'stable',
+      'experimental',
+    );
+    $supported_branches = array_fuse($supported_branches);
+
     foreach ($roots as $lib => $root) {
       echo phutil_console_format(
         "%s\n",
         pht('Upgrading %s...', $lib));
 
       $working_copy = ArcanistWorkingCopyIdentity::newFromPath($root);
       $configuration_manager = clone $this->getConfigurationManager();
       $configuration_manager->setWorkingCopyIdentity($working_copy);
       $repository = ArcanistRepositoryAPI::newAPIFromConfigurationManager(
         $configuration_manager);
 
       if (!Filesystem::pathExists($repository->getMetadataPath())) {
         throw new ArcanistUsageException(
           pht(
             "%s must be in its git working copy to be automatically upgraded. ".
             "This copy of %s (in '%s') is not in a git working copy.",
             $lib,
             $lib,
             $root));
       }
 
       $this->setRepositoryAPI($repository);
 
       // 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->getUncommittedStatus();
       if ($uncommitted) {
         $message = pht(
           'You have uncommitted changes in the working copy for this '.
           'library:');
 
         $list = id(new PhutilConsoleList())
           ->setWrap(false)
           ->addItems(array_keys($uncommitted));
 
         id(new PhutilConsoleBlock())
           ->addParagraph($message)
           ->addList($list)
           ->draw();
 
         throw new ArcanistUsageException(
           pht('`arc upgrade` can only upgrade clean working copies.'));
       }
 
       $branch_name = $repository->getBranchName();
-      if ($branch_name != 'master' && $branch_name != 'stable') {
+      if (!isset($supported_branches[$branch_name])) {
         throw new ArcanistUsageException(
           pht(
-            "%s must be on either branch '%s' or '%s' to be automatically ".
-            "upgraded. ".
-            "This copy of %s (in '%s') is on branch '%s'.",
-            $lib,
-            'master',
-            'stable',
+            'Library "%s" (in "%s") is on branch "%s", but this branch is '.
+            'not supported for automatic upgrades. Supported branches are: '.
+            '%s.',
             $lib,
             $root,
-            $branch_name));
+            $branch_name,
+            implode(', ', array_keys($supported_branches))));
       }
 
       chdir($root);
 
       try {
         execx('git pull --rebase');
       } 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;
       }
     }
 
     echo phutil_console_format(
       "**%s** %s\n",
       pht('Updated!'),
       pht('Your copy of arc is now up to date.'));
     return 0;
   }
 
 }
diff --git a/src/workflow/ArcanistWorkflow.php b/src/workflow/ArcanistWorkflow.php
index ad78b243..d7afc47e 100644
--- a/src/workflow/ArcanistWorkflow.php
+++ b/src/workflow/ArcanistWorkflow.php
@@ -1,2072 +1,2138 @@
 <?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 $forcedConduitVersion;
   private $conduitTimeout;
 
   private $userPHID;
   private $userName;
   private $repositoryAPI;
   private $configurationManager;
   private $arguments = array();
   private $passedArguments = 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;
 
 
   public function __construct() {}
 
 
   abstract public function run();
 
   /**
    * 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.
    */
   abstract public function getCommandSynopses();
 
   /**
    * Return console formatted string with command help printed in `arc help`.
    *
    * @return string  10-space indented help to use the command.
    */
   abstract public function getCommandHelp();
 
 
 /* -(  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);
     }
 
     $user = $this->getConfigFromAnySource('http.basicauth.user');
     $pass = $this->getConfigFromAnySource('http.basicauth.pass');
     if ($user !== null && $pass !== null) {
       $this->conduit->setBasicAuthCredentials($user, $pass);
     }
 
     return $this;
   }
 
   final public function getConfigFromAnySource($key) {
     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;
   }
 
 
   /**
    * Force arc to identify with a specific Conduit version during the
    * protocol handshake. This is primarily useful for development (especially
    * for sending diffs which bump the client Conduit version), since the client
    * still actually speaks the builtin version of the protocol.
    *
    * Controlled by the --conduit-version flag.
    *
    * @param int Version the client should pretend to be.
    * @return this
    * @task conduit
    */
   final public function forceConduitVersion($version) {
     $this->forcedConduitVersion = $version;
     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 nonempty($this->forcedConduitVersion, 6);
   }
 
 
   /**
    * Override the default timeout for Conduit.
    *
    * Controlled by the --conduit-timeout flag.
    *
    * @param float Timeout, in seconds.
    * @return this
    * @task conduit
    */
   final public function setConduitTimeout($timeout) {
     $this->conduitTimeout = $timeout;
     if ($this->conduit) {
       $this->conduit->setConduitTimeout($timeout);
     }
     return $this;
   }
 
 
   /**
    * 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('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;
   }
 
   final 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) {
     return idx($this->arguments, $key, $default);
   }
 
   final public function getPassedArguments() {
     return $this->passedArguments;
   }
 
   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) {
     $this->passedArguments = $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() {
     $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() {
     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'))
           ->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),
     ));
   }
 
   final 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->getWorkingCopy();
       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 resolveCall(ConduitFuture $method, $timeout = null) {
     try {
       return $method->resolve($timeout);
     } catch (ConduitClientException $ex) {
       if ($ex->getErrorCode() == 'ERR-CONDUIT-CALL') {
         echo phutil_console_wrap(
           pht(
             'This feature requires a newer version of Phabricator. Please '.
             'update it using these instructions: %s',
             'https://secure.phabricator.com/book/phabricator/article/'.
               'upgrading/')."\n\n");
       }
       throw $ex;
     }
   }
 
   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 {
-      $results = $this->getConduit()->callMethodSynchronous(
-        'repository.query',
-        $query);
+      $method = 'repository.query';
+      $results = $this->getConduitEngine()->newCall($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.');
         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).');
     }
 
     $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->getWorkingCopy();
     $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->getWorkingCopy();
     $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();
     foreach ($uris as $uri) {
       $err = phutil_passthru('%s %s', $browser, $uri);
       if ($err) {
         throw new ArcanistUsageException(
           pht(
             "Failed to open '%s' in browser ('%s'). ".
             "Check your 'browser' config option.",
             $uri,
             $browser));
       }
     }
   }
 
   private function getBrowserCommand() {
     $config = $this->getConfigFromAnySource('browser');
     if ($config) {
       return $config;
     }
 
     if (phutil_is_windows()) {
       return 'start';
     }
 
     $candidates = array('sensible-browser', 'xdg-open', '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) {
       if (Filesystem::binaryExists($cmd)) {
         return $cmd;
       }
     }
 
     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'));
   }
 
 
   /**
    * 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 protected function newWorkingCopyStateRef() {
+    $ref = new ArcanistWorkingCopyStateRef();
+
+    $working_copy = $this->getWorkingCopy();
+    $ref->setRootDirectory($working_copy->getProjectRoot());
+
+    return $ref;
+  }
+
+  final protected function newRefQuery(array $refs) {
+    assert_instances_of($refs, 'ArcanistRef');
+
+    $query = id(new ArcanistRefQuery())
+      ->setConduitEngine($this->getConduitEngine())
+      ->setRefs($refs);
+
+    if ($this->hasRepositoryAPI()) {
+      $query->setRepositoryAPI($this->getRepositoryAPI());
+    }
+
+    $repository_ref = $this->getRepositoryRef();
+    if ($repository_ref) {
+      $query->setRepositoryRef($repository_ref);
+    }
+
+    $working_copy = $this->getConfigurationManager()->getWorkingCopyIdentity();
+    if ($working_copy) {
+      $working_ref = $this->newWorkingCopyStateRef();
+      $query->setWorkingCopyRef($working_ref);
+    }
+
+    return $query;
+  }
+
+  final public function getRepositoryRef() {
+    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;
+  }
 
 }