diff --git a/src/__phutil_library_map__.php b/src/__phutil_library_map__.php
index 7c45ea87..f0e69db7 100644
--- a/src/__phutil_library_map__.php
+++ b/src/__phutil_library_map__.php
@@ -1,1867 +1,1867 @@
 <?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',
     'ArcanistAlias' => 'toolset/ArcanistAlias.php',
     'ArcanistAliasEffect' => 'toolset/ArcanistAliasEffect.php',
     'ArcanistAliasEngine' => 'toolset/ArcanistAliasEngine.php',
     'ArcanistAliasFunctionXHPASTLinterRule' => 'lint/linter/xhpast/rules/ArcanistAliasFunctionXHPASTLinterRule.php',
     'ArcanistAliasFunctionXHPASTLinterRuleTestCase' => 'lint/linter/xhpast/rules/__tests__/ArcanistAliasFunctionXHPASTLinterRuleTestCase.php',
     'ArcanistAliasWorkflow' => 'toolset/workflow/ArcanistAliasWorkflow.php',
     'ArcanistAliasesConfigOption' => 'config/option/ArcanistAliasesConfigOption.php',
     'ArcanistAmendWorkflow' => 'workflow/ArcanistAmendWorkflow.php',
     'ArcanistAnoidWorkflow' => 'workflow/ArcanistAnoidWorkflow.php',
     'ArcanistArcConfigurationEngineExtension' => 'config/arc/ArcanistArcConfigurationEngineExtension.php',
     'ArcanistArcToolset' => 'toolset/ArcanistArcToolset.php',
     'ArcanistArcWorkflow' => 'toolset/workflow/ArcanistArcWorkflow.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',
     'ArcanistBrowseCommitHardpointQuery' => 'browse/query/ArcanistBrowseCommitHardpointQuery.php',
     'ArcanistBrowseCommitURIHardpointQuery' => 'browse/query/ArcanistBrowseCommitURIHardpointQuery.php',
     'ArcanistBrowseObjectNameURIHardpointQuery' => 'browse/query/ArcanistBrowseObjectNameURIHardpointQuery.php',
     'ArcanistBrowsePathURIHardpointQuery' => 'browse/query/ArcanistBrowsePathURIHardpointQuery.php',
     'ArcanistBrowseRef' => 'browse/ref/ArcanistBrowseRef.php',
     'ArcanistBrowseRefInspector' => 'inspector/ArcanistBrowseRefInspector.php',
     'ArcanistBrowseRevisionURIHardpointQuery' => 'browse/query/ArcanistBrowseRevisionURIHardpointQuery.php',
     'ArcanistBrowseURIHardpointQuery' => 'browse/query/ArcanistBrowseURIHardpointQuery.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',
     'ArcanistCommand' => 'toolset/command/ArcanistCommand.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/commit/ArcanistCommitRef.php',
     'ArcanistCommitSymbolRef' => 'ref/commit/ArcanistCommitSymbolRef.php',
     'ArcanistCommitSymbolRefInspector' => 'ref/commit/ArcanistCommitSymbolRefInspector.php',
     'ArcanistCommitUpstreamHardpointQuery' => 'query/ArcanistCommitUpstreamHardpointQuery.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',
     'ArcanistConduitException' => 'conduit/ArcanistConduitException.php',
     'ArcanistConfigOption' => 'config/option/ArcanistConfigOption.php',
     'ArcanistConfiguration' => 'configuration/ArcanistConfiguration.php',
     'ArcanistConfigurationDrivenLintEngine' => 'lint/engine/ArcanistConfigurationDrivenLintEngine.php',
     'ArcanistConfigurationDrivenUnitTestEngine' => 'unit/engine/ArcanistConfigurationDrivenUnitTestEngine.php',
     'ArcanistConfigurationEngine' => 'config/ArcanistConfigurationEngine.php',
     'ArcanistConfigurationEngineExtension' => 'config/ArcanistConfigurationEngineExtension.php',
     'ArcanistConfigurationManager' => 'configuration/ArcanistConfigurationManager.php',
     'ArcanistConfigurationSource' => 'config/source/ArcanistConfigurationSource.php',
     'ArcanistConfigurationSourceList' => 'config/ArcanistConfigurationSourceList.php',
     'ArcanistConfigurationSourceValue' => 'config/ArcanistConfigurationSourceValue.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',
     'ArcanistDefaultsConfigurationSource' => 'config/source/ArcanistDefaultsConfigurationSource.php',
     'ArcanistDeprecationXHPASTLinterRule' => 'lint/linter/xhpast/rules/ArcanistDeprecationXHPASTLinterRule.php',
     'ArcanistDeprecationXHPASTLinterRuleTestCase' => 'lint/linter/xhpast/rules/__tests__/ArcanistDeprecationXHPASTLinterRuleTestCase.php',
     'ArcanistDictionaryConfigurationSource' => 'config/source/ArcanistDictionaryConfigurationSource.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',
     'ArcanistDisplayRef' => 'ref/ArcanistDisplayRef.php',
     'ArcanistDisplayRefInterface' => 'ref/ArcanistDisplayRefInterface.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',
     'ArcanistFeatureBaseWorkflow' => 'workflow/ArcanistFeatureBaseWorkflow.php',
     'ArcanistFeatureWorkflow' => 'workflow/ArcanistFeatureWorkflow.php',
     'ArcanistFileConfigurationSource' => 'config/source/ArcanistFileConfigurationSource.php',
     'ArcanistFileDataRef' => 'upload/ArcanistFileDataRef.php',
     'ArcanistFileUploader' => 'upload/ArcanistFileUploader.php',
     'ArcanistFilenameLinter' => 'lint/linter/ArcanistFilenameLinter.php',
     'ArcanistFilenameLinterTestCase' => 'lint/linter/__tests__/ArcanistFilenameLinterTestCase.php',
     'ArcanistFilesystemAPI' => 'repository/api/ArcanistFilesystemAPI.php',
     'ArcanistFilesystemConfigurationSource' => 'config/source/ArcanistFilesystemConfigurationSource.php',
     'ArcanistFilesystemWorkingCopy' => 'workingcopy/ArcanistFilesystemWorkingCopy.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',
     'ArcanistGitCommitMessageHardpointQuery' => 'query/ArcanistGitCommitMessageHardpointQuery.php',
     'ArcanistGitCommitSymbolCommitHardpointQuery' => 'ref/commit/ArcanistGitCommitSymbolCommitHardpointQuery.php',
     'ArcanistGitLandEngine' => 'land/ArcanistGitLandEngine.php',
     'ArcanistGitUpstreamPath' => 'repository/api/ArcanistGitUpstreamPath.php',
     'ArcanistGitWorkingCopy' => 'workingcopy/ArcanistGitWorkingCopy.php',
     'ArcanistGitWorkingCopyRevisionHardpointQuery' => 'query/ArcanistGitWorkingCopyRevisionHardpointQuery.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',
     'ArcanistHardpoint' => 'hardpoint/ArcanistHardpoint.php',
     'ArcanistHardpointEngine' => 'hardpoint/ArcanistHardpointEngine.php',
     'ArcanistHardpointFutureList' => 'hardpoint/ArcanistHardpointFutureList.php',
     'ArcanistHardpointList' => 'hardpoint/ArcanistHardpointList.php',
     'ArcanistHardpointObject' => 'hardpoint/ArcanistHardpointObject.php',
     'ArcanistHardpointQuery' => 'hardpoint/ArcanistHardpointQuery.php',
     'ArcanistHardpointRequest' => 'hardpoint/ArcanistHardpointRequest.php',
     'ArcanistHardpointRequestList' => 'hardpoint/ArcanistHardpointRequestList.php',
     'ArcanistHardpointTask' => 'hardpoint/ArcanistHardpointTask.php',
     'ArcanistHardpointTaskResult' => 'hardpoint/ArcanistHardpointTaskResult.php',
     'ArcanistHelpWorkflow' => 'toolset/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',
     'ArcanistInspectWorkflow' => 'workflow/ArcanistInspectWorkflow.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',
     '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',
     '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',
     'ArcanistListConfigOption' => 'config/option/ArcanistListConfigOption.php',
     'ArcanistListWorkflow' => 'workflow/ArcanistListWorkflow.php',
     'ArcanistLocalConfigurationSource' => 'config/source/ArcanistLocalConfigurationSource.php',
     'ArcanistLogEngine' => 'log/ArcanistLogEngine.php',
     'ArcanistLogMessage' => 'log/ArcanistLogMessage.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',
     'ArcanistMercurialParser' => 'repository/parser/ArcanistMercurialParser.php',
     'ArcanistMercurialParserTestCase' => 'repository/parser/__tests__/ArcanistMercurialParserTestCase.php',
     'ArcanistMercurialWorkingCopy' => 'workingcopy/ArcanistMercurialWorkingCopy.php',
     'ArcanistMergeConflictLinter' => 'lint/linter/ArcanistMergeConflictLinter.php',
     'ArcanistMergeConflictLinterTestCase' => 'lint/linter/__tests__/ArcanistMergeConflictLinterTestCase.php',
     'ArcanistMessageRevisionHardpointQuery' => 'query/ArcanistMessageRevisionHardpointQuery.php',
     'ArcanistMissingArgumentTerminatorException' => 'exception/ArcanistMissingArgumentTerminatorException.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',
     'ArcanistNoURIConduitException' => 'conduit/ArcanistNoURIConduitException.php',
     'ArcanistNoneLintRenderer' => 'lint/renderer/ArcanistNoneLintRenderer.php',
     'ArcanistObjectListHardpoint' => 'hardpoint/ArcanistObjectListHardpoint.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',
     'ArcanistPhutilWorkflow' => 'toolset/ArcanistPhutilWorkflow.php',
     'ArcanistPhutilXHPASTLinterStandard' => 'lint/linter/standards/phutil/ArcanistPhutilXHPASTLinterStandard.php',
     'ArcanistPlusOperatorOnStringsXHPASTLinterRule' => 'lint/linter/xhpast/rules/ArcanistPlusOperatorOnStringsXHPASTLinterRule.php',
     'ArcanistPlusOperatorOnStringsXHPASTLinterRuleTestCase' => 'lint/linter/xhpast/rules/__tests__/ArcanistPlusOperatorOnStringsXHPASTLinterRuleTestCase.php',
     'ArcanistProjectConfigurationSource' => 'config/source/ArcanistProjectConfigurationSource.php',
     'ArcanistPrompt' => 'toolset/ArcanistPrompt.php',
     'ArcanistPromptsWorkflow' => 'toolset/workflow/ArcanistPromptsWorkflow.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',
     'ArcanistRefInspector' => 'inspector/ArcanistRefInspector.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',
     'ArcanistRevisionCommitMessageHardpointQuery' => 'ref/revision/ArcanistRevisionCommitMessageHardpointQuery.php',
     'ArcanistRevisionRef' => 'ref/revision/ArcanistRevisionRef.php',
     'ArcanistRevisionRefSource' => 'ref/ArcanistRevisionRefSource.php',
     'ArcanistRevisionSymbolHardpointQuery' => 'ref/revision/ArcanistRevisionSymbolHardpointQuery.php',
     'ArcanistRevisionSymbolRef' => 'ref/revision/ArcanistRevisionSymbolRef.php',
     'ArcanistRevisionSymbolRefInspector' => 'ref/revision/ArcanistRevisionSymbolRefInspector.php',
     'ArcanistRuboCopLinter' => 'lint/linter/ArcanistRuboCopLinter.php',
     'ArcanistRuboCopLinterTestCase' => 'lint/linter/__tests__/ArcanistRuboCopLinterTestCase.php',
     'ArcanistRubyLinter' => 'lint/linter/ArcanistRubyLinter.php',
     'ArcanistRubyLinterTestCase' => 'lint/linter/__tests__/ArcanistRubyLinterTestCase.php',
     'ArcanistRuntime' => 'runtime/ArcanistRuntime.php',
     'ArcanistRuntimeConfigurationSource' => 'config/source/ArcanistRuntimeConfigurationSource.php',
+    'ArcanistRuntimeHardpointQuery' => 'toolset/query/ArcanistRuntimeHardpointQuery.php',
     'ArcanistScalarConfigOption' => 'config/option/ArcanistScalarConfigOption.php',
     'ArcanistScalarHardpoint' => 'hardpoint/ArcanistScalarHardpoint.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' => 'toolset/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',
     'ArcanistStringConfigOption' => 'config/option/ArcanistStringConfigOption.php',
     'ArcanistSubversionAPI' => 'repository/api/ArcanistSubversionAPI.php',
     'ArcanistSubversionWorkingCopy' => 'workingcopy/ArcanistSubversionWorkingCopy.php',
     'ArcanistSummaryLintRenderer' => 'lint/renderer/ArcanistSummaryLintRenderer.php',
     'ArcanistSymbolEngine' => 'ref/symbol/ArcanistSymbolEngine.php',
     'ArcanistSymbolRef' => 'ref/symbol/ArcanistSymbolRef.php',
     'ArcanistSyntaxErrorXHPASTLinterRule' => 'lint/linter/xhpast/rules/ArcanistSyntaxErrorXHPASTLinterRule.php',
     'ArcanistSystemConfigurationSource' => 'config/source/ArcanistSystemConfigurationSource.php',
     'ArcanistTasksWorkflow' => 'workflow/ArcanistTasksWorkflow.php',
     'ArcanistTautologicalExpressionXHPASTLinterRule' => 'lint/linter/xhpast/rules/ArcanistTautologicalExpressionXHPASTLinterRule.php',
     'ArcanistTautologicalExpressionXHPASTLinterRuleTestCase' => 'lint/linter/xhpast/rules/__tests__/ArcanistTautologicalExpressionXHPASTLinterRuleTestCase.php',
     'ArcanistTerminalStringInterface' => 'xsprintf/ArcanistTerminalStringInterface.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',
     'ArcanistToolset' => 'toolset/ArcanistToolset.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',
     'ArcanistUserConfigurationSource' => 'config/source/ArcanistUserConfigurationSource.php',
     'ArcanistUserRef' => 'ref/user/ArcanistUserRef.php',
     'ArcanistUserSymbolHardpointQuery' => 'ref/user/ArcanistUserSymbolHardpointQuery.php',
     'ArcanistUserSymbolRef' => 'ref/user/ArcanistUserSymbolRef.php',
     'ArcanistUserSymbolRefInspector' => 'ref/user/ArcanistUserSymbolRefInspector.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',
     'ArcanistVectorHardpoint' => 'hardpoint/ArcanistVectorHardpoint.php',
     'ArcanistVersionWorkflow' => 'toolset/workflow/ArcanistVersionWorkflow.php',
     'ArcanistWeldWorkflow' => 'workflow/ArcanistWeldWorkflow.php',
     'ArcanistWhichWorkflow' => 'workflow/ArcanistWhichWorkflow.php',
     'ArcanistWildConfigOption' => 'config/option/ArcanistWildConfigOption.php',
     'ArcanistWorkflow' => 'workflow/ArcanistWorkflow.php',
     'ArcanistWorkflowArgument' => 'toolset/ArcanistWorkflowArgument.php',
     'ArcanistWorkflowGitHardpointQuery' => 'query/ArcanistWorkflowGitHardpointQuery.php',
-    'ArcanistWorkflowHardpointQuery' => 'toolset/query/ArcanistWorkflowHardpointQuery.php',
     'ArcanistWorkflowInformation' => 'toolset/ArcanistWorkflowInformation.php',
     'ArcanistWorkingCopy' => 'workingcopy/ArcanistWorkingCopy.php',
     'ArcanistWorkingCopyCommitHardpointQuery' => 'query/ArcanistWorkingCopyCommitHardpointQuery.php',
     'ArcanistWorkingCopyConfigurationSource' => 'config/source/ArcanistWorkingCopyConfigurationSource.php',
     'ArcanistWorkingCopyIdentity' => 'workingcopyidentity/ArcanistWorkingCopyIdentity.php',
     'ArcanistWorkingCopyPath' => 'workingcopy/ArcanistWorkingCopyPath.php',
     'ArcanistWorkingCopyStateRef' => 'ref/ArcanistWorkingCopyStateRef.php',
     'ArcanistWorkingCopyStateRefInspector' => 'inspector/ArcanistWorkingCopyStateRefInspector.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',
     'ConduitSearchFuture' => 'conduit/ConduitSearchFuture.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',
     'FutureAgent' => 'conduit/FutureAgent.php',
     'FutureIterator' => 'future/FutureIterator.php',
     'FutureIteratorTestCase' => 'future/__tests__/FutureIteratorTestCase.php',
     'FuturePool' => 'future/FuturePool.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',
     'PhageExecWorkflow' => 'phage/workflow/PhageExecWorkflow.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',
     'PhageToolset' => 'phage/toolset/PhageToolset.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_encode_log' => '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_glue' => 'utils/utils.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_noninteractive' => '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',
     'ArcanistAlias' => 'Phobject',
     'ArcanistAliasEffect' => 'Phobject',
     'ArcanistAliasEngine' => 'Phobject',
     'ArcanistAliasFunctionXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
     'ArcanistAliasFunctionXHPASTLinterRuleTestCase' => 'ArcanistXHPASTLinterRuleTestCase',
     'ArcanistAliasWorkflow' => 'ArcanistWorkflow',
     'ArcanistAliasesConfigOption' => 'ArcanistListConfigOption',
-    'ArcanistAmendWorkflow' => 'ArcanistWorkflow',
+    'ArcanistAmendWorkflow' => 'ArcanistArcWorkflow',
     'ArcanistAnoidWorkflow' => 'ArcanistArcWorkflow',
     'ArcanistArcConfigurationEngineExtension' => 'ArcanistConfigurationEngineExtension',
     'ArcanistArcToolset' => 'ArcanistToolset',
     'ArcanistArcWorkflow' => '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' => 'ArcanistFeatureBaseWorkflow',
     'ArcanistBraceFormattingXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
     'ArcanistBraceFormattingXHPASTLinterRuleTestCase' => 'ArcanistXHPASTLinterRuleTestCase',
     'ArcanistBranchRef' => 'ArcanistRef',
     'ArcanistBranchWorkflow' => 'ArcanistFeatureBaseWorkflow',
-    'ArcanistBrowseCommitHardpointQuery' => 'ArcanistWorkflowHardpointQuery',
+    'ArcanistBrowseCommitHardpointQuery' => 'ArcanistRuntimeHardpointQuery',
     'ArcanistBrowseCommitURIHardpointQuery' => 'ArcanistBrowseURIHardpointQuery',
     'ArcanistBrowseObjectNameURIHardpointQuery' => 'ArcanistBrowseURIHardpointQuery',
     'ArcanistBrowsePathURIHardpointQuery' => 'ArcanistBrowseURIHardpointQuery',
     'ArcanistBrowseRef' => 'ArcanistRef',
     'ArcanistBrowseRefInspector' => 'ArcanistRefInspector',
     'ArcanistBrowseRevisionURIHardpointQuery' => 'ArcanistBrowseURIHardpointQuery',
-    'ArcanistBrowseURIHardpointQuery' => 'ArcanistWorkflowHardpointQuery',
+    'ArcanistBrowseURIHardpointQuery' => 'ArcanistRuntimeHardpointQuery',
     'ArcanistBrowseURIRef' => 'ArcanistRef',
     'ArcanistBrowseWorkflow' => 'ArcanistArcWorkflow',
     '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',
     'ArcanistCommand' => 'Phobject',
     'ArcanistCommentRemover' => 'Phobject',
     'ArcanistCommentRemoverTestCase' => 'PhutilTestCase',
     'ArcanistCommentSpacingXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
     'ArcanistCommentStyleXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
     'ArcanistCommentStyleXHPASTLinterRuleTestCase' => 'ArcanistXHPASTLinterRuleTestCase',
     'ArcanistCommitRef' => 'ArcanistRef',
     'ArcanistCommitSymbolRef' => 'ArcanistSymbolRef',
     'ArcanistCommitSymbolRefInspector' => 'ArcanistRefInspector',
-    'ArcanistCommitUpstreamHardpointQuery' => 'ArcanistWorkflowHardpointQuery',
+    'ArcanistCommitUpstreamHardpointQuery' => 'ArcanistRuntimeHardpointQuery',
     'ArcanistCommitWorkflow' => 'ArcanistWorkflow',
     'ArcanistCompilerLintRenderer' => 'ArcanistLintRenderer',
     'ArcanistComposerLinter' => 'ArcanistLinter',
     'ArcanistComprehensiveLintEngine' => 'ArcanistLintEngine',
     'ArcanistConcatenationOperatorXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
     'ArcanistConcatenationOperatorXHPASTLinterRuleTestCase' => 'ArcanistXHPASTLinterRuleTestCase',
     'ArcanistConduitCall' => 'Phobject',
     'ArcanistConduitEngine' => 'Phobject',
     'ArcanistConduitException' => 'Exception',
     'ArcanistConfigOption' => 'Phobject',
     'ArcanistConfiguration' => 'Phobject',
     'ArcanistConfigurationDrivenLintEngine' => 'ArcanistLintEngine',
     'ArcanistConfigurationDrivenUnitTestEngine' => 'ArcanistUnitTestEngine',
     'ArcanistConfigurationEngine' => 'Phobject',
     'ArcanistConfigurationEngineExtension' => 'Phobject',
     'ArcanistConfigurationManager' => 'Phobject',
     'ArcanistConfigurationSource' => 'Phobject',
     'ArcanistConfigurationSourceList' => 'Phobject',
     'ArcanistConfigurationSourceValue' => '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',
     'ArcanistDefaultsConfigurationSource' => 'ArcanistDictionaryConfigurationSource',
     'ArcanistDeprecationXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
     'ArcanistDeprecationXHPASTLinterRuleTestCase' => 'ArcanistXHPASTLinterRuleTestCase',
     'ArcanistDictionaryConfigurationSource' => 'ArcanistConfigurationSource',
     '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',
     'ArcanistDisplayRef' => array(
       'Phobject',
       'ArcanistTerminalStringInterface',
     ),
     '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',
     'ArcanistFeatureBaseWorkflow' => 'ArcanistArcWorkflow',
     'ArcanistFeatureWorkflow' => 'ArcanistFeatureBaseWorkflow',
     'ArcanistFileConfigurationSource' => 'ArcanistFilesystemConfigurationSource',
     'ArcanistFileDataRef' => 'Phobject',
     'ArcanistFileUploader' => 'Phobject',
     'ArcanistFilenameLinter' => 'ArcanistLinter',
     'ArcanistFilenameLinterTestCase' => 'ArcanistLinterTestCase',
     'ArcanistFilesystemAPI' => 'ArcanistRepositoryAPI',
     'ArcanistFilesystemConfigurationSource' => 'ArcanistDictionaryConfigurationSource',
     'ArcanistFilesystemWorkingCopy' => 'ArcanistWorkingCopy',
     'ArcanistFlagWorkflow' => 'ArcanistWorkflow',
     'ArcanistFlake8Linter' => 'ArcanistExternalLinter',
     'ArcanistFlake8LinterTestCase' => 'ArcanistExternalLinterTestCase',
     'ArcanistFormattedStringXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
     'ArcanistFormattedStringXHPASTLinterRuleTestCase' => 'ArcanistXHPASTLinterRuleTestCase',
     'ArcanistFunctionCallShouldBeTypeCastXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
     'ArcanistFunctionCallShouldBeTypeCastXHPASTLinterRuleTestCase' => 'ArcanistXHPASTLinterRuleTestCase',
     'ArcanistFutureLinter' => 'ArcanistLinter',
     'ArcanistGeneratedLinter' => 'ArcanistLinter',
     'ArcanistGeneratedLinterTestCase' => 'ArcanistLinterTestCase',
     'ArcanistGetConfigWorkflow' => 'ArcanistWorkflow',
     'ArcanistGitAPI' => 'ArcanistRepositoryAPI',
     'ArcanistGitCommitMessageHardpointQuery' => 'ArcanistWorkflowGitHardpointQuery',
     'ArcanistGitCommitSymbolCommitHardpointQuery' => 'ArcanistWorkflowGitHardpointQuery',
     'ArcanistGitLandEngine' => 'ArcanistLandEngine',
     'ArcanistGitUpstreamPath' => 'Phobject',
     'ArcanistGitWorkingCopy' => 'ArcanistWorkingCopy',
     'ArcanistGitWorkingCopyRevisionHardpointQuery' => 'ArcanistWorkflowGitHardpointQuery',
     'ArcanistGlobalVariableXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
     'ArcanistGlobalVariableXHPASTLinterRuleTestCase' => 'ArcanistXHPASTLinterRuleTestCase',
     'ArcanistGoLintLinter' => 'ArcanistExternalLinter',
     'ArcanistGoLintLinterTestCase' => 'ArcanistExternalLinterTestCase',
     'ArcanistGoTestResultParser' => 'ArcanistTestResultParser',
     'ArcanistGoTestResultParserTestCase' => 'PhutilTestCase',
     'ArcanistHLintLinter' => 'ArcanistExternalLinter',
     'ArcanistHLintLinterTestCase' => 'ArcanistExternalLinterTestCase',
     'ArcanistHardpoint' => 'Phobject',
     'ArcanistHardpointEngine' => 'Phobject',
     'ArcanistHardpointFutureList' => 'Phobject',
     'ArcanistHardpointList' => 'Phobject',
     'ArcanistHardpointObject' => 'Phobject',
     'ArcanistHardpointQuery' => 'Phobject',
     'ArcanistHardpointRequest' => 'Phobject',
     'ArcanistHardpointRequestList' => 'Phobject',
     'ArcanistHardpointTask' => 'Phobject',
     'ArcanistHardpointTaskResult' => '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',
     'ArcanistInspectWorkflow' => 'ArcanistArcWorkflow',
     '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',
     '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' => 'ArcanistArcWorkflow',
     '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',
     'ArcanistListConfigOption' => 'ArcanistConfigOption',
     'ArcanistListWorkflow' => 'ArcanistWorkflow',
     'ArcanistLocalConfigurationSource' => 'ArcanistWorkingCopyConfigurationSource',
     'ArcanistLogEngine' => 'Phobject',
     'ArcanistLogMessage' => 'Phobject',
     'ArcanistLogicalOperatorsXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
     'ArcanistLogicalOperatorsXHPASTLinterRuleTestCase' => 'ArcanistXHPASTLinterRuleTestCase',
     'ArcanistLowercaseFunctionsXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
     'ArcanistLowercaseFunctionsXHPASTLinterRuleTestCase' => 'ArcanistXHPASTLinterRuleTestCase',
     'ArcanistMercurialAPI' => 'ArcanistRepositoryAPI',
     'ArcanistMercurialParser' => 'Phobject',
     'ArcanistMercurialParserTestCase' => 'PhutilTestCase',
     'ArcanistMercurialWorkingCopy' => 'ArcanistWorkingCopy',
     'ArcanistMergeConflictLinter' => 'ArcanistLinter',
     'ArcanistMergeConflictLinterTestCase' => 'ArcanistLinterTestCase',
-    'ArcanistMessageRevisionHardpointQuery' => 'ArcanistWorkflowHardpointQuery',
+    'ArcanistMessageRevisionHardpointQuery' => 'ArcanistRuntimeHardpointQuery',
     'ArcanistMissingArgumentTerminatorException' => 'Exception',
     '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',
     'ArcanistNoURIConduitException' => 'ArcanistConduitException',
     'ArcanistNoneLintRenderer' => 'ArcanistLintRenderer',
     'ArcanistObjectListHardpoint' => 'ArcanistHardpoint',
     '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',
     'ArcanistPhutilWorkflow' => 'PhutilArgumentWorkflow',
     'ArcanistPhutilXHPASTLinterStandard' => 'ArcanistLinterStandard',
     'ArcanistPlusOperatorOnStringsXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
     'ArcanistPlusOperatorOnStringsXHPASTLinterRuleTestCase' => 'ArcanistXHPASTLinterRuleTestCase',
     'ArcanistProjectConfigurationSource' => 'ArcanistWorkingCopyConfigurationSource',
     'ArcanistPrompt' => 'Phobject',
     'ArcanistPromptsWorkflow' => 'ArcanistWorkflow',
     'ArcanistPublicPropertyXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
     'ArcanistPublicPropertyXHPASTLinterRuleTestCase' => 'ArcanistXHPASTLinterRuleTestCase',
     'ArcanistPuppetLintLinter' => 'ArcanistExternalLinter',
     'ArcanistPuppetLintLinterTestCase' => 'ArcanistExternalLinterTestCase',
     'ArcanistPyFlakesLinter' => 'ArcanistExternalLinter',
     'ArcanistPyFlakesLinterTestCase' => 'ArcanistExternalLinterTestCase',
     'ArcanistPyLintLinter' => 'ArcanistExternalLinter',
     'ArcanistPyLintLinterTestCase' => 'ArcanistExternalLinterTestCase',
     'ArcanistRaggedClassTreeEdgeXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
     'ArcanistRaggedClassTreeEdgeXHPASTLinterRuleTestCase' => 'ArcanistXHPASTLinterRuleTestCase',
     'ArcanistRef' => 'ArcanistHardpointObject',
     'ArcanistRefInspector' => 'Phobject',
     'ArcanistRepositoryAPI' => 'Phobject',
     'ArcanistRepositoryAPIMiscTestCase' => 'PhutilTestCase',
     'ArcanistRepositoryAPIStateTestCase' => 'PhutilTestCase',
     'ArcanistRepositoryRef' => 'ArcanistRef',
     'ArcanistReusedAsIteratorXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
     'ArcanistReusedAsIteratorXHPASTLinterRuleTestCase' => 'ArcanistXHPASTLinterRuleTestCase',
     'ArcanistReusedIteratorReferenceXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
     'ArcanistReusedIteratorReferenceXHPASTLinterRuleTestCase' => 'ArcanistXHPASTLinterRuleTestCase',
     'ArcanistReusedIteratorXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
     'ArcanistReusedIteratorXHPASTLinterRuleTestCase' => 'ArcanistXHPASTLinterRuleTestCase',
     'ArcanistRevertWorkflow' => 'ArcanistWorkflow',
-    'ArcanistRevisionCommitMessageHardpointQuery' => 'ArcanistWorkflowHardpointQuery',
+    'ArcanistRevisionCommitMessageHardpointQuery' => 'ArcanistRuntimeHardpointQuery',
     'ArcanistRevisionRef' => array(
       'ArcanistRef',
       'ArcanistDisplayRefInterface',
     ),
     'ArcanistRevisionRefSource' => 'Phobject',
-    'ArcanistRevisionSymbolHardpointQuery' => 'ArcanistWorkflowHardpointQuery',
+    'ArcanistRevisionSymbolHardpointQuery' => 'ArcanistRuntimeHardpointQuery',
     'ArcanistRevisionSymbolRef' => 'ArcanistSymbolRef',
     'ArcanistRevisionSymbolRefInspector' => 'ArcanistRefInspector',
     'ArcanistRuboCopLinter' => 'ArcanistExternalLinter',
     'ArcanistRuboCopLinterTestCase' => 'ArcanistExternalLinterTestCase',
     'ArcanistRubyLinter' => 'ArcanistExternalLinter',
     'ArcanistRubyLinterTestCase' => 'ArcanistExternalLinterTestCase',
     'ArcanistRuntimeConfigurationSource' => 'ArcanistDictionaryConfigurationSource',
+    'ArcanistRuntimeHardpointQuery' => 'ArcanistHardpointQuery',
     'ArcanistScalarConfigOption' => 'ArcanistConfigOption',
     'ArcanistScalarHardpoint' => 'ArcanistHardpoint',
     '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',
     'ArcanistStringConfigOption' => 'ArcanistScalarConfigOption',
     'ArcanistSubversionAPI' => 'ArcanistRepositoryAPI',
     'ArcanistSubversionWorkingCopy' => 'ArcanistWorkingCopy',
     'ArcanistSummaryLintRenderer' => 'ArcanistLintRenderer',
     'ArcanistSymbolEngine' => 'Phobject',
     'ArcanistSymbolRef' => 'ArcanistRef',
     'ArcanistSyntaxErrorXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
     'ArcanistSystemConfigurationSource' => 'ArcanistFilesystemConfigurationSource',
     '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',
     'ArcanistToolset' => 'Phobject',
     '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' => 'ArcanistArcWorkflow',
     'ArcanistUploadWorkflow' => 'ArcanistArcWorkflow',
     'ArcanistUsageException' => 'Exception',
     'ArcanistUseStatementNamespacePrefixXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
     'ArcanistUseStatementNamespacePrefixXHPASTLinterRuleTestCase' => 'ArcanistXHPASTLinterRuleTestCase',
     'ArcanistUselessOverridingMethodXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
     'ArcanistUselessOverridingMethodXHPASTLinterRuleTestCase' => 'ArcanistXHPASTLinterRuleTestCase',
     'ArcanistUserAbortException' => 'ArcanistUsageException',
     'ArcanistUserConfigurationSource' => 'ArcanistFilesystemConfigurationSource',
     'ArcanistUserRef' => array(
       'ArcanistRef',
       'ArcanistDisplayRefInterface',
     ),
-    'ArcanistUserSymbolHardpointQuery' => 'ArcanistWorkflowHardpointQuery',
+    'ArcanistUserSymbolHardpointQuery' => 'ArcanistRuntimeHardpointQuery',
     'ArcanistUserSymbolRef' => 'ArcanistSymbolRef',
     'ArcanistUserSymbolRefInspector' => 'ArcanistRefInspector',
     'ArcanistVariableReferenceSpacingXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
     'ArcanistVariableReferenceSpacingXHPASTLinterRuleTestCase' => 'ArcanistXHPASTLinterRuleTestCase',
     'ArcanistVariableVariableXHPASTLinterRule' => 'ArcanistXHPASTLinterRule',
     'ArcanistVariableVariableXHPASTLinterRuleTestCase' => 'ArcanistXHPASTLinterRuleTestCase',
     'ArcanistVectorHardpoint' => 'ArcanistHardpoint',
     'ArcanistVersionWorkflow' => 'ArcanistWorkflow',
     'ArcanistWeldWorkflow' => 'ArcanistArcWorkflow',
     'ArcanistWhichWorkflow' => 'ArcanistWorkflow',
     'ArcanistWildConfigOption' => 'ArcanistConfigOption',
     'ArcanistWorkflow' => 'Phobject',
     'ArcanistWorkflowArgument' => 'Phobject',
-    'ArcanistWorkflowGitHardpointQuery' => 'ArcanistWorkflowHardpointQuery',
-    'ArcanistWorkflowHardpointQuery' => 'ArcanistHardpointQuery',
+    'ArcanistWorkflowGitHardpointQuery' => 'ArcanistRuntimeHardpointQuery',
     'ArcanistWorkflowInformation' => 'Phobject',
     'ArcanistWorkingCopy' => 'Phobject',
-    'ArcanistWorkingCopyCommitHardpointQuery' => 'ArcanistWorkflowHardpointQuery',
+    'ArcanistWorkingCopyCommitHardpointQuery' => 'ArcanistRuntimeHardpointQuery',
     'ArcanistWorkingCopyConfigurationSource' => 'ArcanistFilesystemConfigurationSource',
     'ArcanistWorkingCopyIdentity' => 'Phobject',
     'ArcanistWorkingCopyPath' => 'Phobject',
     'ArcanistWorkingCopyStateRef' => 'ArcanistRef',
     'ArcanistWorkingCopyStateRefInspector' => 'ArcanistRefInspector',
     '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',
     'ConduitSearchFuture' => 'FutureAgent',
     'ExecFuture' => 'PhutilExecutableFuture',
     'ExecFutureTestCase' => 'PhutilTestCase',
     'ExecPassthruTestCase' => 'PhutilTestCase',
     'FileFinder' => 'Phobject',
     'FileFinderTestCase' => 'PhutilTestCase',
     'FileList' => 'Phobject',
     'Filesystem' => 'Phobject',
     'FilesystemException' => 'Exception',
     'FilesystemTestCase' => 'PhutilTestCase',
     'Future' => 'Phobject',
     'FutureAgent' => 'Future',
     'FutureIterator' => array(
       'Phobject',
       'Iterator',
     ),
     'FutureIteratorTestCase' => 'PhutilTestCase',
     'FuturePool' => 'Phobject',
     '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',
     'PhageExecWorkflow' => 'PhageWorkflow',
     'PhageExecuteAction' => 'PhageAction',
     'PhageLocalAction' => 'PhageAgentAction',
     'PhagePHPAgent' => 'Phobject',
     'PhagePHPAgentBootloader' => 'PhageAgentBootloader',
     'PhagePlanAction' => 'PhageAction',
     'PhageToolset' => 'ArcanistToolset',
     'PhageWorkflow' => 'ArcanistWorkflow',
     '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/query/ArcanistBrowseCommitHardpointQuery.php b/src/browse/query/ArcanistBrowseCommitHardpointQuery.php
index 37fbaf83..431f9b8f 100644
--- a/src/browse/query/ArcanistBrowseCommitHardpointQuery.php
+++ b/src/browse/query/ArcanistBrowseCommitHardpointQuery.php
@@ -1,65 +1,65 @@
 <?php
 
 final class ArcanistBrowseCommitHardpointQuery
-  extends ArcanistWorkflowHardpointQuery {
+  extends ArcanistRuntimeHardpointQuery {
 
   public function getHardpoints() {
     return array(
       ArcanistBrowseRef::HARDPOINT_COMMITREFS,
     );
   }
 
   protected function canLoadRef(ArcanistRef $ref) {
     return ($ref instanceof ArcanistBrowseRef);
   }
 
   public function loadHardpoint(array $refs, $hardpoint) {
     $api = $this->getRepositoryAPI();
 
     $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) {
       yield $this->yieldMap(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;
       }
     }
 
     yield $this->yieldMap($results);
   }
 
 }
diff --git a/src/browse/query/ArcanistBrowseURIHardpointQuery.php b/src/browse/query/ArcanistBrowseURIHardpointQuery.php
index 52494506..65d1569f 100644
--- a/src/browse/query/ArcanistBrowseURIHardpointQuery.php
+++ b/src/browse/query/ArcanistBrowseURIHardpointQuery.php
@@ -1,49 +1,49 @@
 <?php
 
 abstract class ArcanistBrowseURIHardpointQuery
-  extends ArcanistWorkflowHardpointQuery {
+  extends ArcanistRuntimeHardpointQuery {
 
   public function getSupportedBrowseType() {
     return $this->getPhobjectClassConstant('BROWSETYPE', 32);
   }
 
   public function getHardpoints() {
     return array(
       ArcanistBrowseRef::HARDPOINT_URIS,
     );
   }
 
   protected function canLoadRef(ArcanistRef $ref) {
     return ($ref instanceof ArcanistBrowseRef);
   }
 
   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 getAllBrowseQueries() {
     return id(new PhutilClassMapQuery())
       ->setAncestorClass(__CLASS__)
       ->execute();
   }
 
   final protected function newBrowseURIRef() {
     return id(new ArcanistBrowseURIRef())
       ->setType($this->getSupportedBrowseType());
   }
 
 }
diff --git a/src/query/ArcanistCommitUpstreamHardpointQuery.php b/src/query/ArcanistCommitUpstreamHardpointQuery.php
index b6020e7e..3ab734b6 100644
--- a/src/query/ArcanistCommitUpstreamHardpointQuery.php
+++ b/src/query/ArcanistCommitUpstreamHardpointQuery.php
@@ -1,53 +1,53 @@
 <?php
 
 final class ArcanistCommitUpstreamHardpointQuery
-  extends ArcanistWorkflowHardpointQuery {
+  extends ArcanistRuntimeHardpointQuery {
 
   public function getHardpoints() {
     return array(
       ArcanistCommitRef::HARDPOINT_UPSTREAM,
     );
   }
 
   protected function canLoadRef(ArcanistRef $ref) {
     return ($ref instanceof ArcanistCommitRef);
   }
 
   public function loadHardpoint(array $refs, $hardpoint) {
     $repository_ref = (yield $this->yieldRepositoryRef());
     if (!$repository_ref) {
       yield $this->yieldValue($refs, null);
     }
     $repository_phid = $repository_ref->getPHID();
 
     $commit_map = array();
     foreach ($refs as $key => $ref) {
       $hash = $ref->getCommitHash();
       $commit_map[$hash][] = $key;
     }
 
     $commit_info = (yield $this->yieldConduit(
       '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;
       }
     }
 
     yield $this->yieldMap($results);
   }
 
 }
diff --git a/src/query/ArcanistMessageRevisionHardpointQuery.php b/src/query/ArcanistMessageRevisionHardpointQuery.php
index ab871a5d..284558ee 100644
--- a/src/query/ArcanistMessageRevisionHardpointQuery.php
+++ b/src/query/ArcanistMessageRevisionHardpointQuery.php
@@ -1,76 +1,76 @@
 <?php
 
 final class ArcanistMessageRevisionHardpointQuery
-  extends ArcanistWorkflowHardpointQuery {
+  extends ArcanistRuntimeHardpointQuery {
 
   public function getHardpoints() {
     return array(
       ArcanistWorkingCopyStateRef::HARDPOINT_REVISIONREFS,
     );
   }
 
   protected function canLoadRef(ArcanistRef $ref) {
     return ($ref instanceof ArcanistWorkingCopyStateRef);
   }
 
   public function loadHardpoint(array $refs, $hardpoint) {
     yield $this->yieldRequests(
       $refs,
       array(
         ArcanistWorkingCopyStateRef::HARDPOINT_COMMITREF,
       ));
 
     $commit_refs = array();
     foreach ($refs as $ref) {
       $commit_refs[] = $ref->getCommitRef();
     }
 
     yield $this->yieldRequests(
       $commit_refs,
       array(
         ArcanistCommitRef::HARDPOINT_MESSAGE,
       ));
 
     $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 = (yield $this->yieldConduit(
         '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;
         }
       }
     }
 
     yield $this->yieldMap($results);
   }
 
 }
diff --git a/src/query/ArcanistWorkflowGitHardpointQuery.php b/src/query/ArcanistWorkflowGitHardpointQuery.php
index b8519c55..43a0b7d6 100644
--- a/src/query/ArcanistWorkflowGitHardpointQuery.php
+++ b/src/query/ArcanistWorkflowGitHardpointQuery.php
@@ -1,11 +1,11 @@
 <?php
 
 abstract class ArcanistWorkflowGitHardpointQuery
-  extends ArcanistWorkflowHardpointQuery {
+  extends ArcanistRuntimeHardpointQuery {
 
   final protected function canLoadHardpoint() {
     $api = $this->getRepositoryAPI();
     return ($api instanceof ArcanistGitAPI);
   }
 
 }
diff --git a/src/query/ArcanistWorkingCopyCommitHardpointQuery.php b/src/query/ArcanistWorkingCopyCommitHardpointQuery.php
index 9f78d2af..9f2b4672 100644
--- a/src/query/ArcanistWorkingCopyCommitHardpointQuery.php
+++ b/src/query/ArcanistWorkingCopyCommitHardpointQuery.php
@@ -1,39 +1,39 @@
 <?php
 
 final class ArcanistWorkingCopyCommitHardpointQuery
-  extends ArcanistWorkflowHardpointQuery {
+  extends ArcanistRuntimeHardpointQuery {
 
   public function getHardpoints() {
     return array(
       ArcanistWorkingCopyStateRef::HARDPOINT_COMMITREF,
     );
   }
 
   protected function canLoadRef(ArcanistRef $ref) {
     return ($ref instanceof ArcanistWorkingCopyStateRef);
   }
 
   public function loadHardpoint(array $refs, $hardpoint) {
     yield $this->yieldRequests(
       $refs,
       array(
         ArcanistWorkingCopyStateRef::HARDPOINT_BRANCHREF,
       ));
 
     $branch_refs = mpull($refs, 'getBranchRef');
 
     yield $this->yieldRequests(
       $branch_refs,
       array(
         ArcanistBranchRef::HARDPOINT_COMMITREF,
       ));
 
     $results = array();
     foreach ($refs as $key => $ref) {
       $results[$key] = $ref->getBranchRef()->getCommitRef();
     }
 
     yield $this->yieldMap($results);
   }
 
 }
diff --git a/src/ref/revision/ArcanistRevisionCommitMessageHardpointQuery.php b/src/ref/revision/ArcanistRevisionCommitMessageHardpointQuery.php
index 04dd8d55..29a6ca29 100644
--- a/src/ref/revision/ArcanistRevisionCommitMessageHardpointQuery.php
+++ b/src/ref/revision/ArcanistRevisionCommitMessageHardpointQuery.php
@@ -1,37 +1,37 @@
 <?php
 
 final class ArcanistRevisionCommitMessageHardpointQuery
-  extends ArcanistWorkflowHardpointQuery {
+  extends ArcanistRuntimeHardpointQuery {
 
   public function getHardpoints() {
     return array(
       ArcanistRevisionRef::HARDPOINT_COMMITMESSAGE,
     );
   }
 
   protected function canLoadRef(ArcanistRef $ref) {
     return ($ref instanceof ArcanistRevisionRef);
   }
 
   public function loadHardpoint(array $refs, $hardpoint) {
     $api = $this->getRepositoryAPI();
 
     // NOTE: This is not efficient, but no bulk API exists at time of
     // writing and no callers bulk-load this data.
 
     $results = array();
     foreach ($refs as $key => $ref) {
       $message = (yield $this->yieldConduit(
         'differential.getcommitmessage',
         array(
           'revision_id' => $ref->getID(),
           'edit' => false,
         )));
 
       $results[$key] = $message;
     }
 
     yield $this->yieldMap($results);
   }
 
 }
diff --git a/src/ref/revision/ArcanistRevisionRef.php b/src/ref/revision/ArcanistRevisionRef.php
index d0f3321c..07618bbc 100644
--- a/src/ref/revision/ArcanistRevisionRef.php
+++ b/src/ref/revision/ArcanistRevisionRef.php
@@ -1,90 +1,94 @@
 <?php
 
 final class ArcanistRevisionRef
   extends ArcanistRef
   implements
     ArcanistDisplayRefInterface {
 
   const HARDPOINT_COMMITMESSAGE = 'ref.revision.commitmessage';
 
   private $parameters;
   private $sources = array();
 
   public function getRefDisplayName() {
     return pht('Revision %s', $this->getMonogram());
   }
 
   protected function newHardpoints() {
     return array(
       $this->newHardpoint(self::HARDPOINT_COMMITMESSAGE),
     );
   }
 
   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 (int)idx($this->parameters, 'id');
   }
 
   public function getPHID() {
     return idx($this->parameters, 'phid');
   }
 
   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;
   }
 
+  public function getCommitMessage() {
+    return $this->getHardpoint(self::HARDPOINT_COMMITMESSAGE);
+  }
+
   public function getDisplayRefObjectName() {
     return $this->getMonogram();
   }
 
   public function getDisplayRefTitle() {
     return $this->getName();
   }
 
 }
diff --git a/src/ref/revision/ArcanistRevisionSymbolHardpointQuery.php b/src/ref/revision/ArcanistRevisionSymbolHardpointQuery.php
index 823f36f9..e722b710 100644
--- a/src/ref/revision/ArcanistRevisionSymbolHardpointQuery.php
+++ b/src/ref/revision/ArcanistRevisionSymbolHardpointQuery.php
@@ -1,40 +1,40 @@
 <?php
 
 final class ArcanistRevisionSymbolHardpointQuery
-  extends ArcanistWorkflowHardpointQuery {
+  extends ArcanistRuntimeHardpointQuery {
 
   public function getHardpoints() {
     return array(
       ArcanistRevisionSymbolRef::HARDPOINT_OBJECT,
     );
   }
 
   protected function canLoadRef(ArcanistRef $ref) {
     return ($ref instanceof ArcanistRevisionSymbolRef);
   }
 
   public function loadHardpoint(array $refs, $hardpoint) {
     $id_map = mpull($refs, 'getSymbol');
     $id_set = array_fuse($id_map);
 
     $revisions = (yield $this->yieldConduit(
       'differential.query',
       array(
         'ids' => $id_set,
       )));
 
     $refs = array();
     foreach ($revisions as $revision) {
       $ref = ArcanistRevisionRef::newFromConduit($revision);
       $refs[$ref->getID()] = $ref;
     }
 
     $results = array();
     foreach ($id_map as $key => $id) {
       $results[$key] = idx($refs, $id);
     }
 
     yield $this->yieldMap($results);
   }
 
 }
diff --git a/src/ref/user/ArcanistUserRef.php b/src/ref/user/ArcanistUserRef.php
index c55fd8ff..0d27ca6b 100644
--- a/src/ref/user/ArcanistUserRef.php
+++ b/src/ref/user/ArcanistUserRef.php
@@ -1,54 +1,66 @@
 <?php
 
 final class ArcanistUserRef
   extends ArcanistRef
   implements
     ArcanistDisplayRefInterface {
 
   private $parameters;
 
   public function getRefDisplayName() {
-    return pht('User "%s"', $this->getUsername());
+    return pht('User "%s"', $this->getMonogram());
   }
 
   public static function newFromConduit(array $parameters) {
     $ref = new self();
     $ref->parameters = $parameters;
     return $ref;
   }
 
   public static function newFromConduitWhoami(array $parameters) {
     // NOTE: The "user.whoami" call returns a different structure than
     // "user.search". Mangle the data so it looks similar.
 
     $parameters['fields'] = array(
       'username' => idx($parameters, 'userName'),
       'realName' => idx($parameters, 'realName'),
     );
 
     return self::newFromConduit($parameters);
   }
 
+  public function getID() {
+    return idx($this->parameters, 'id');
+  }
+
+  public function getPHID() {
+    return idx($this->parameters, 'phid');
+  }
+
+  public function getMonogram() {
+    return '@'.$this->getUsername();
+  }
+
   public function getUsername() {
     return idxv($this->parameters, array('fields', 'username'));
   }
 
   public function getRealName() {
     return idxv($this->parameters, array('fields', 'realName'));
   }
 
   public function getDisplayRefObjectName() {
-    return '@'.$this->getUsername();
+    return $this->getMonogram();
   }
 
   public function getDisplayRefTitle() {
     $real_name = $this->getRealName();
 
     if (strlen($real_name)) {
       $real_name = sprintf('(%s)', $real_name);
     }
 
     return $real_name;
   }
 
 }
diff --git a/src/ref/user/ArcanistUserSymbolHardpointQuery.php b/src/ref/user/ArcanistUserSymbolHardpointQuery.php
index 6d37c510..c363109e 100644
--- a/src/ref/user/ArcanistUserSymbolHardpointQuery.php
+++ b/src/ref/user/ArcanistUserSymbolHardpointQuery.php
@@ -1,155 +1,155 @@
 <?php
 
 final class ArcanistUserSymbolHardpointQuery
-  extends ArcanistWorkflowHardpointQuery {
+  extends ArcanistRuntimeHardpointQuery {
 
   public function getHardpoints() {
     return array(
       ArcanistUserSymbolRef::HARDPOINT_OBJECT,
     );
   }
 
   protected function canLoadRef(ArcanistRef $ref) {
     return ($ref instanceof ArcanistUserSymbolRef);
   }
 
   public function loadHardpoint(array $refs, $hardpoint) {
     $id_map = array();
     $phid_map = array();
     $username_map = array();
     $function_map = array();
 
     foreach ($refs as $key => $ref) {
       switch ($ref->getSymbolType()) {
         case ArcanistUserSymbolRef::TYPE_ID:
           $id_map[$key] = $ref->getSymbol();
           break;
         case ArcanistUserSymbolRef::TYPE_PHID:
           $phid_map[$key] = $ref->getSymbol();
           break;
         case ArcanistUserSymbolRef::TYPE_USERNAME:
           $username_map[$key] = $ref->getSymbol();
           break;
         case ArcanistUserSymbolRef::TYPE_FUNCTION:
           $symbol = $ref->getSymbol();
           if ($symbol !== 'viewer()') {
             throw new Exception(
               pht(
                 'Only the function "viewer()" is supported.'));
           }
           $function_map[$key] = $symbol;
           break;
       }
     }
 
     $futures = array();
 
     if ($function_map) {
       // The only function we support is "viewer()".
       $function_future = $this->newConduit(
         'user.whoami',
         array());
 
       $futures[] = $function_future;
     } else {
       $function_future = null;
     }
 
     if ($id_map) {
       $id_future = $this->newConduitSearch(
         'user.search',
         array(
           'ids' => array_values(array_fuse($id_map)),
         ));
 
       $futures[] = $id_future;
     } else {
       $id_future = null;
     }
 
     if ($phid_map) {
       $phid_future = $this->newConduitSearch(
         'user.search',
         array(
          'phids' => array_values(array_fuse($phid_map)),
         ));
 
       $futures[] = $phid_future;
     } else {
       $phid_future = null;
     }
 
     if ($username_map) {
       $username_future = $this->newConduitSearch(
         'user.search',
         array(
           'usernames' => array_values(array_fuse($username_map)),
         ));
 
       $futures[] = $username_future;
     } else {
       $username_future = null;
     }
 
     yield $this->yieldFutures($futures);
 
     $result_map = array();
 
     if ($id_future) {
       $id_results = $id_future->resolve();
       $id_results = ipull($id_results, null, 'id');
 
       foreach ($id_map as $key => $id) {
         $result_map[$key] = idx($id_results, $id);
       }
     }
 
     if ($phid_future) {
       $phid_results = $phid_future->resolve();
       $phid_results = ipull($phid_results, null, 'phid');
 
       foreach ($phid_map as $key => $phid) {
         $result_map[$key] = idx($phid_results, $phid);
       }
     }
 
     if ($username_future) {
       $raw_results = $username_future->resolve();
 
       $username_results = array();
       foreach ($raw_results as $raw_result) {
         $username = idxv($raw_result, array('fields', 'username'));
         $username_results[$username] = $raw_result;
       }
 
       foreach ($username_map as $key => $username) {
         $result_map[$key] = idx($username_results, $username);
       }
     }
 
     foreach ($result_map as $key => $raw_result) {
       if ($raw_result === null) {
         continue;
       }
 
       $result_map[$key] = ArcanistUserRef::newFromConduit($raw_result);
     }
 
     if ($function_future) {
       $raw_result = $function_future->resolve();
 
       if ($raw_result === null) {
         $function_ref = null;
       } else {
         $function_ref = ArcanistUserRef::newFromConduitWhoami($raw_result);
       }
 
       foreach ($function_map as $key => $function) {
         $result_map[$key] = $function_ref;
       }
     }
 
     yield $this->yieldMap($result_map);
   }
 
 }
diff --git a/src/repository/api/ArcanistGitAPI.php b/src/repository/api/ArcanistGitAPI.php
index ee0a4250..0e4af9cc 100644
--- a/src/repository/api/ArcanistGitAPI.php
+++ b/src/repository/api/ArcanistGitAPI.php
@@ -1,1690 +1,1694 @@
 <?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 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 getBaseCommitRef() {
     $base_commit = $this->getBaseCommit();
 
     if ($base_commit === self::GIT_MAGIC_ROOT_COMMIT) {
       return null;
     }
 
     $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 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;
   }
 
+  protected function newCurrentCommitSymbol() {
+    return 'HEAD';
+  }
+
 }
diff --git a/src/repository/api/ArcanistRepositoryAPI.php b/src/repository/api/ArcanistRepositoryAPI.php
index fe0bddfc..5d2c748f 100644
--- a/src/repository/api/ArcanistRepositoryAPI.php
+++ b/src/repository/api/ArcanistRepositoryAPI.php
@@ -1,712 +1,737 @@
 <?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;
 
+  private $runtime;
+  private $currentWorkingCopyStateRef = false;
+  private $currentCommitRef = false;
+
   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 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);
   }
 
   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();
-  }
-
-  final public function getCurrentCommitRef() {
-    $commit_hash = $this->newCurrentCommitHash();
-    return $this->newCommitRef()
-      ->setCommitHash($commit_hash);
+  final public function newFuture($pattern /* , ... */) {
+    $args = func_get_args();
+    return $this->buildLocalFuture($args)
+      ->setResolveOnError(false);
   }
 
-  protected function newCurrentCommitRef() {
-    $commit_hash = $this->newCurrentCommitHash();
-    return $this->newCommitRefForSymbol($commit_hash);
+  final public function setRuntime(ArcanistRuntime $runtime) {
+    $this->runtime = $runtime;
+    return $this;
   }
 
-  protected function newCommitRefForSymbol() {
-    throw new ArcanistCapabilityNotSupportedException($this);
+  final public function getRuntime() {
+    return $this->runtime;
   }
 
-  protected function newCurrentCommitHash() {
-    throw new ArcanistCapabilityNotSupportedException($this);
+  final protected function getSymbolEngine() {
+    return $this->getRuntime()->getSymbolEngine();
   }
 
   final public function getCurrentWorkingCopyStateRef() {
-    return $this->newCurrentWorkingCopyStateRef();
+    if ($this->currentWorkingCopyStateRef === false) {
+      $ref = $this->newCurrentWorkingCopyStateRef();
+      $this->currentWorkingCopyStateRef = $ref;
+    }
+
+    return $this->currentWorkingCopyStateRef;
   }
 
   protected function newCurrentWorkingCopyStateRef() {
     $commit_ref = $this->getCurrentCommitRef();
 
+    if (!$commit_ref) {
+      return null;
+    }
+
     return id(new ArcanistWorkingCopyStateRef())
       ->setCommitRef($commit_ref);
   }
 
-  final public function newFuture($pattern /* , ... */) {
-    $args = func_get_args();
-    return $this->buildLocalFuture($args)
-      ->setResolveOnError(false);
+  final public function getCurrentCommitRef() {
+    if ($this->currentCommitRef === false) {
+      $this->currentCommitRef = $this->newCurrentCommitRef();
+    }
+    return $this->currentCommitRef;
+  }
+
+  protected function newCurrentCommitRef() {
+    $symbols = $this->getSymbolEngine();
+
+    $commit_symbol = $this->newCurrentCommitSymbol();
+
+    return $symbols->loadCommitForSymbol($commit_symbol);
   }
 
+  protected function newCurrentCommitSymbol() {
+    throw new ArcanistCapabilityNotSupportedException($this);
+  }
+
+  final public function newCommitRef() {
+    return new ArcanistCommitRef();
+  }
+
+  final public function newBranchRef() {
+    return new ArcanistBranchRef();
+  }
 }
diff --git a/src/runtime/ArcanistRuntime.php b/src/runtime/ArcanistRuntime.php
index 2855a9b3..d6e16780 100644
--- a/src/runtime/ArcanistRuntime.php
+++ b/src/runtime/ArcanistRuntime.php
@@ -1,747 +1,840 @@
 <?php
 
 final class ArcanistRuntime {
 
   private $workflows;
   private $logEngine;
   private $lastInterruptTime;
 
   private $stack = array();
 
+  private $viewer;
+  private $hardpointEngine;
+  private $symbolEngine;
+  private $conduitEngine;
+  private $workingCopy;
+
   public function execute(array $argv) {
 
     try {
       $this->checkEnvironment();
     } catch (Exception $ex) {
       echo "CONFIGURATION ERROR\n\n";
       echo $ex->getMessage();
       echo "\n\n";
       return 1;
     }
 
     PhutilTranslator::getInstance()
       ->setLocale(PhutilLocale::loadLocale('en_US'))
       ->setTranslations(PhutilTranslation::getTranslationMapForLocale('en_US'));
 
     $log = new ArcanistLogEngine();
     $this->logEngine = $log;
 
     try {
       return $this->executeCore($argv);
     } catch (ArcanistConduitException $ex) {
       $log->writeError(pht('CONDUIT'), $ex->getMessage());
     } catch (PhutilArgumentUsageException $ex) {
       $log->writeError(pht('USAGE EXCEPTION'), $ex->getMessage());
     } catch (ArcanistUserAbortException $ex) {
       $log->writeError(pht('---'), $ex->getMessage());
     }
 
     return 1;
   }
 
   private function executeCore(array $argv) {
     $log = $this->getLogEngine();
 
     $config_args = array(
       array(
         'name' => 'library',
         'param' => 'path',
         'help' => pht('Load a library.'),
         'repeat' => true,
       ),
       array(
         'name' => 'config',
         'param' => 'key=value',
         'repeat' => true,
         'help' => pht('Specify a runtime configuration value.'),
       ),
       array(
         'name' => 'config-file',
         'param' => 'path',
         'repeat' => true,
         'help' => pht(
           'Load one or more configuration files. If this flag is provided, '.
           'the system and user configuration files are ignored.'),
       ),
     );
 
     $args = id(new PhutilArgumentParser($argv))
       ->parseStandardArguments();
 
     // If we can test whether STDIN is a TTY, and it isn't, require that "--"
     // appear in the argument list. This is intended to make it very hard to
     // write unsafe scripts on top of Arcanist.
 
     if (phutil_is_noninteractive()) {
       $args->setRequireArgumentTerminator(true);
     }
 
     $is_trace = $args->getArg('trace');
     $log->setShowTraceMessages($is_trace);
 
     $log->writeTrace(pht('ARGV'), csprintf('%Ls', $argv));
 
     // We're installing the signal handler after parsing "--trace" so that it
     // can emit debugging messages. This means there's a very small window at
     // startup where signals have no special handling, but we couldn't really
     // route them or do anything interesting with them anyway.
     $this->installSignalHandler();
 
     $args->parsePartial($config_args, true);
 
     $config_engine = $this->loadConfiguration($args);
     $config = $config_engine->newConfigurationSourceList();
 
     $this->loadLibraries($config_engine, $config, $args);
 
     // Now that we've loaded libraries, we can validate configuration.
     // Do this before continuing since configuration can impact other
     // behaviors immediately and we want to catch any issues right away.
     $config->setConfigOptions($config_engine->newConfigOptionsMap());
     $config->validateConfiguration($this);
 
     $toolset = $this->newToolset($argv);
 
     $args->parsePartial($toolset->getToolsetArguments());
 
     $workflows = $this->newWorkflows($toolset);
     $this->workflows = $workflows;
 
     $conduit_engine = $this->newConduitEngine($config);
+    $this->conduitEngine = $conduit_engine;
 
     $phutil_workflows = array();
     foreach ($workflows as $key => $workflow) {
       $phutil_workflows[$key] = $workflow->newPhutilWorkflow();
 
       $workflow
         ->setRuntime($this)
         ->setConfigurationEngine($config_engine)
         ->setConfigurationSourceList($config)
         ->setConduitEngine($conduit_engine);
     }
 
 
     $unconsumed_argv = $args->getUnconsumedArgumentVector();
 
     if (!$unconsumed_argv) {
       // TOOLSETS: This means the user just ran "arc" or some other top-level
       // toolset without any workflow argument. We should give them a summary
       // of the toolset, a list of workflows, and a pointer to "arc help" for
       // more details.
 
       // A possible exception is "arc --help", which should perhaps pass
       // through and act like "arc help".
       throw new PhutilArgumentUsageException(pht('Choose a workflow!'));
     }
 
     $alias_effects = id(new ArcanistAliasEngine())
       ->setRuntime($this)
       ->setToolset($toolset)
       ->setWorkflows($workflows)
       ->setConfigurationSourceList($config)
       ->resolveAliases($unconsumed_argv);
 
     foreach ($alias_effects as $alias_effect) {
       if ($alias_effect->getType() === ArcanistAliasEffect::EFFECT_SHELL) {
         return $this->executeShellAlias($alias_effect);
       }
     }
 
     $result_argv = $this->applyAliasEffects($alias_effects, $unconsumed_argv);
 
     $args->setUnconsumedArgumentVector($result_argv);
 
     // TOOLSETS: Some day, stop falling through to the old "arc" runtime.
 
     try {
       return $args->parseWorkflowsFull($phutil_workflows);
     } catch (ArcanistMissingArgumentTerminatorException $terminator_exception) {
       $log->writeHint(
         pht('USAGE'),
         pht(
           '"%s" is being run noninteractively, but the argument list is '.
           'missing "--" to indicate end of flags.',
           $toolset->getToolsetKey()));
 
       $log->writeHint(
         pht('USAGE'),
         pht(
           'When running noninteractively, you MUST provide "--" to all '.
           'commands (even if they take no arguments).'));
 
       $log->writeHint(
         pht('USAGE'),
         tsprintf(
           '%s <__%s__>',
           pht('Learn More:'),
           'https://phurl.io/u/noninteractive'));
 
       throw new PhutilArgumentUsageException(
         pht('Missing required "--" in argument list.'));
     } catch (PhutilArgumentUsageException $usage_exception) {
 
       // TODO: This is very, very hacky; we're trying to let errors like
       // "you passed the wrong arguments" through but fall back to classic
       // mode if the workflow itself doesn't exist.
       if (!preg_match('/invalid command/i', $usage_exception->getMessage())) {
         throw $usage_exception;
       }
 
     }
 
     $arcanist_root = phutil_get_library_root('arcanist');
     $arcanist_root = dirname($arcanist_root);
     $bin = $arcanist_root.'/scripts/arcanist.php';
 
     $err = phutil_passthru(
       'php -f %R -- %Ls',
       $bin,
       array_slice($argv, 1));
 
     return $err;
   }
 
 
   /**
    * 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.
    */
   private function checkEnvironment() {
     // NOTE: We don't have phutil_is_windows() yet here.
     $is_windows = (DIRECTORY_SEPARATOR != '/');
 
     // NOTE: There's a hard PHP version check earlier, in "init-script.php".
 
     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];
         }
       }
 
       list($what, $which) = $resolution;
 
       if ($what == 'flag' && strpos($config, $which) !== false) {
         $show_config = true;
         $problems[] = sprintf(
           'The build of PHP you are running was compiled with the configure '.
           'flag "%s", which means it does not support the function "%s()". '.
           'This function is required for Arcanist to run. Install a standard '.
           'build of PHP or rebuild it without this flag. You may also be '.
           'able to build or install the relevant extension separately.',
           $which,
           $fname);
         continue;
       }
 
       if ($what == 'builtin-dll') {
         $problems[] = sprintf(
           'The build of PHP you are running does not have the "%s" extension '.
           'enabled. Edit your php.ini file and uncomment the line which '.
           'reads "extension=%s".',
           $which,
           $which);
         continue;
       }
 
       if ($what == 'text') {
         $problems[] = $which;
         continue;
       }
 
       $problems[] = sprintf(
         'The build of PHP you are running is missing the required function '.
         '"%s()". Rebuild PHP or install the extension which provides "%s()".',
         $fname,
         $fname);
     }
 
     if ($problems) {
       if ($show_config) {
         $problems[] = "PHP was built with this configure command:\n\n{$config}";
       }
       $problems = implode("\n\n", $problems);
 
       throw new Exception($problems);
     }
   }
 
   private function loadConfiguration(PhutilArgumentParser $args) {
     $engine = id(new ArcanistConfigurationEngine())
       ->setArguments($args);
 
     $working_copy = ArcanistWorkingCopy::newFromWorkingDirectory(getcwd());
-    if ($working_copy) {
-      $engine->setWorkingCopy($working_copy);
-    }
+
+    $engine->setWorkingCopy($working_copy);
+
+    $this->workingCopy = $working_copy;
+
+    $working_copy
+      ->getRepositoryAPI()
+      ->setRuntime($this);
 
     return $engine;
   }
 
   private function loadLibraries(
     ArcanistConfigurationEngine $engine,
     ArcanistConfigurationSourceList $config,
     PhutilArgumentParser $args) {
 
     $sources = array();
 
     $cli_libraries = $args->getArg('library');
     if ($cli_libraries) {
       $sources = array();
       foreach ($cli_libraries as $cli_library) {
         $sources[] = array(
           'type' => 'flag',
           'library-source' => $cli_library,
         );
       }
     } else {
       $items = $config->getStorageValueList('load');
       foreach ($items as $item) {
         foreach ($item->getValue() as $library_path) {
           $sources[] = array(
             'type' => 'config',
             'config-source' => $item->getConfigurationSource(),
             'library-source' => $library_path,
           );
         }
       }
     }
 
     foreach ($sources as $spec) {
       $library_source = $spec['library-source'];
 
       switch ($spec['type']) {
         case 'flag':
           $description = pht('runtime --library flag');
           break;
         case 'config':
           $config_source = $spec['config-source'];
           $description = pht(
             'Configuration (%s)',
             $config_source->getSourceDisplayName());
           break;
       }
 
       $this->loadLibrary($engine, $library_source, $description);
     }
   }
 
   private function loadLibrary(
     ArcanistConfigurationEngine $engine,
     $location,
     $description) {
 
     // TODO: This is a legacy system that should be replaced with package
     // management.
 
     $log = $this->getLogEngine();
     $working_copy = $engine->getWorkingCopy();
     if ($working_copy) {
       $working_copy_root = $working_copy->getPath();
       $working_directory = $working_copy->getWorkingDirectory();
     } else {
       $working_copy_root = null;
       $working_directory = getcwd();
     }
 
     // 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.
     if ($working_copy_root !== null) {
       $resolved_location = Filesystem::resolvePath(
         $location,
         $working_copy_root);
       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_root));
         if (Filesystem::pathExists($resolved_location)) {
           $location = $resolved_location;
           $resolved = true;
         }
       }
     }
 
     // Look beside "arcanist/". This is rule (3) above.
 
     if (!$resolved) {
       $arcanist_root = phutil_get_library_root('arcanist');
       $arcanist_root = dirname(dirname($arcanist_root));
       $resolved_location = Filesystem::resolvePath(
         $location,
         $arcanist_root);
       if (Filesystem::pathExists($resolved_location)) {
         $location = $resolved_location;
         $resolved = true;
       }
     }
 
     $log->writeTrace(
       pht('LOAD'),
       pht('Loading library from "%s"...', $location));
 
     $error = null;
     try {
       phutil_load_library($location);
     } 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__));
 
       $log->writeWarn(
         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));
     } catch (PhutilBootloaderException $ex) {
       $log->writeError(
         pht('LIBRARY ERROR'),
         pht(
           'Failed to load library at location "%s". This library '.
           'is specified by "%s". Check that the library is up to date.',
           $location,
           $description));
 
       $prompt = pht('Continue without loading library?');
       if (!phutil_console_confirm($prompt)) {
         throw $ex;
       }
     } catch (Exception $ex) {
       $log->writeError(
         pht('LOAD ERROR'),
         pht(
           'Failed to load 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,
           $description));
 
       $prompt = pht('Continue without loading library?');
       if (!phutil_console_confirm($prompt)) {
         throw $ex;
       }
     }
   }
 
   private function newToolset(array $argv) {
     $binary = basename($argv[0]);
 
     $toolsets = ArcanistToolset::newToolsetMap();
     if (!isset($toolsets[$binary])) {
       throw new PhutilArgumentUsageException(
         pht(
           'Arcanist toolset "%s" is unknown. The Arcanist binary should '.
           'be executed so that "argv[0]" identifies a supported toolset. '.
           'Rename the binary or install the library that provides the '.
           'desired toolset. Current available toolsets: %s.',
           $binary,
           implode(', ', array_keys($toolsets))));
     }
 
     return $toolsets[$binary];
   }
 
   private function newWorkflows(ArcanistToolset $toolset) {
     $workflows = id(new PhutilClassMapQuery())
       ->setAncestorClass('ArcanistWorkflow')
       ->setContinueOnFailure(true)
       ->execute();
 
     foreach ($workflows as $key => $workflow) {
       if (!$workflow->supportsToolset($toolset)) {
         unset($workflows[$key]);
       }
     }
 
     $map = array();
     foreach ($workflows as $workflow) {
       $key = $workflow->getWorkflowName();
       if (isset($map[$key])) {
         throw new Exception(
           pht(
             'Two workflows ("%s" and "%s") both have the same name ("%s") '.
             'and both support the current toolset ("%s", "%s"). Each '.
             'workflow in a given toolset must have a unique name.',
             get_class($workflow),
             get_class($map[$key]),
             get_class($toolset),
             $toolset->getToolsetKey()));
       }
       $map[$key] = id(clone $workflow)
         ->setToolset($toolset);
     }
 
     return $map;
   }
 
   public function getWorkflows() {
     return $this->workflows;
   }
 
   public function getLogEngine() {
     return $this->logEngine;
   }
 
   private function applyAliasEffects(array $effects, array $argv) {
     assert_instances_of($effects, 'ArcanistAliasEffect');
 
     $log = $this->getLogEngine();
 
     $command = null;
     $arguments = null;
     foreach ($effects as $effect) {
       $message = $effect->getMessage();
 
       if ($message !== null) {
         $log->writeHint(pht('ALIAS'), $message);
       }
 
       if ($effect->getCommand()) {
         $command = $effect->getCommand();
         $arguments = $effect->getArguments();
       }
     }
 
     if ($command !== null) {
       $argv = array_merge(array($command), $arguments);
     }
 
     return $argv;
   }
 
   private function installSignalHandler() {
     $log = $this->getLogEngine();
 
     if (!function_exists('pcntl_signal')) {
       $log->writeTrace(
         pht('PCNTL'),
         pht(
           'Unable to install signal handler, pcntl_signal() unavailable. '.
           'Continuing without signal handling.'));
       return;
     }
 
     // NOTE: SIGHUP, SIGTERM and SIGWINCH are handled by "PhutilSignalRouter".
     // This logic is largely similar to the logic there, but more specific to
     // Arcanist workflows.
 
     pcntl_signal(SIGINT, array($this, 'routeSignal'));
   }
 
   public function routeSignal($signo) {
     switch ($signo) {
       case SIGINT:
         $this->routeInterruptSignal($signo);
         break;
     }
   }
 
   private function routeInterruptSignal($signo) {
     $log = $this->getLogEngine();
 
     $last_interrupt = $this->lastInterruptTime;
     $now = microtime(true);
     $this->lastInterruptTime = $now;
 
     $should_exit = false;
 
     // If we received another SIGINT recently, always exit. This implements
     // "press ^C twice in quick succession to exit" regardless of what the
     // workflow may decide to do.
     $interval = 2;
     if ($last_interrupt !== null) {
       if ($now - $last_interrupt < $interval) {
         $should_exit = true;
       }
     }
 
     $handler = null;
     if (!$should_exit) {
 
       // Look for an interrupt handler in the current workflow stack.
 
       $stack = $this->getWorkflowStack();
       foreach ($stack as $workflow) {
         if ($workflow->canHandleSignal($signo)) {
           $handler = $workflow;
           break;
         }
       }
 
       // If no workflow in the current execution stack can handle an interrupt
       // signal, just exit on the first interrupt.
 
       if (!$handler) {
         $should_exit = true;
       }
     }
 
     // It's common for users to ^C on prompts. Write a newline before writing
     // a response to the interrupt so the behavior is a little cleaner. This
     // also avoids lines that read "^C [ INTERRUPT ] ...".
     $log->writeNewline();
 
     if ($should_exit) {
       $log->writeHint(
         pht('INTERRUPT'),
         pht('Interrupted by SIGINT (^C).'));
       exit(128 + $signo);
     }
 
     $log->writeHint(
       pht('INTERRUPT'),
       pht('Press ^C again to exit.'));
 
     $handler->handleSignal($signo);
   }
 
   public function pushWorkflow(ArcanistWorkflow $workflow) {
     $this->stack[] = $workflow;
     return $this;
   }
 
   public function popWorkflow() {
     if (!$this->stack) {
       throw new Exception(pht('Trying to pop an empty workflow stack!'));
     }
 
     return array_pop($this->stack);
   }
 
   public function getWorkflowStack() {
     return $this->stack;
   }
 
+  public function getCurrentWorkflow() {
+    return last($this->stack);
+  }
+
   private function newConduitEngine(ArcanistConfigurationSourceList $config) {
 
     $conduit_uri = $config->getConfig('phabricator.uri');
     if ($conduit_uri === null) {
       // For now, read this older config from raw storage. There is currently
       // no definition of this option in the "toolsets" config list, and it
       // would be nice to get rid of it.
       $default_list = $config->getStorageValueList('default');
       if ($default_list) {
         $conduit_uri = last($default_list)->getValue();
       }
     }
 
     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 = phutil_string_cast($conduit_uri);
     }
 
     $engine = new ArcanistConduitEngine();
 
     if ($conduit_uri !== null) {
       $engine->setConduitURI($conduit_uri);
     }
 
     // TODO: This isn't using "getConfig()" because we aren't defining a
     // real config entry for the moment.
 
     $hosts = array();
 
     $hosts_list = $config->getStorageValueList('hosts');
     foreach ($hosts_list as $hosts_config) {
       $hosts += $hosts_config->getValue();
     }
 
     $host_config = idx($hosts, $conduit_uri, array());
     $user_name = idx($host_config, 'user');
     $conduit_token = idx($host_config, 'token');
 
     if ($conduit_token !== null) {
       $engine->setConduitToken($conduit_token);
     }
 
     return $engine;
   }
 
   private function executeShellAlias(ArcanistAliasEffect $effect) {
     $log = $this->getLogEngine();
 
     $message = $effect->getMessage();
     if ($message !== null) {
       $log->writeHint(pht('SHELL ALIAS'), $message);
     }
 
     return phutil_passthru('%Ls', $effect->getArguments());
   }
 
+  public function getSymbolEngine() {
+    if ($this->symbolEngine === null) {
+      $this->symbolEngine = $this->newSymbolEngine();
+    }
+    return $this->symbolEngine;
+  }
+
+  private function newSymbolEngine() {
+    return id(new ArcanistSymbolEngine())
+      ->setWorkflow($this);
+  }
+
+  public function getHardpointEngine() {
+    if ($this->hardpointEngine === null) {
+      $this->hardpointEngine = $this->newHardpointEngine();
+    }
+    return $this->hardpointEngine;
+  }
+
+  private function newHardpointEngine() {
+    $engine = new ArcanistHardpointEngine();
+
+    $queries = ArcanistRuntimeHardpointQuery::getAllQueries();
+
+    foreach ($queries as $key => $query) {
+      $queries[$key] = id(clone $query)
+        ->setRuntime($this);
+    }
+
+    $engine->setQueries($queries);
+
+    return $engine;
+  }
+
+  public function getViewer() {
+    if (!$this->viewer) {
+      $viewer = $this->getSymbolEngine()
+        ->loadUserForSymbol('viewer()');
+
+      // TODO: Deal with anonymous stuff.
+      if (!$viewer) {
+        throw new Exception(pht('No viewer!'));
+      }
+
+      $this->viewer = $viewer;
+    }
+
+    return $this->viewer;
+  }
+
+  public function loadHardpoints($objects, $requests) {
+    if (!is_array($objects)) {
+      $objects = array($objects);
+    }
+
+    if (!is_array($requests)) {
+      $requests = array($requests);
+    }
+
+    $engine = $this->getHardpointEngine();
+
+    $requests = $engine->requestHardpoints(
+      $objects,
+      $requests);
+
+    // TODO: Wait for only the required requests.
+    $engine->waitForRequests(array());
+  }
+
+  public function getWorkingCopy() {
+    return $this->workingCopy;
+  }
+
+  public function getConduitEngine() {
+    return $this->conduitEngine;
+  }
+
 }
diff --git a/src/toolset/query/ArcanistWorkflowHardpointQuery.php b/src/toolset/query/ArcanistRuntimeHardpointQuery.php
similarity index 83%
rename from src/toolset/query/ArcanistWorkflowHardpointQuery.php
rename to src/toolset/query/ArcanistRuntimeHardpointQuery.php
index 9999ff21..8408ab03 100644
--- a/src/toolset/query/ArcanistWorkflowHardpointQuery.php
+++ b/src/toolset/query/ArcanistRuntimeHardpointQuery.php
@@ -1,110 +1,113 @@
 <?php
 
-abstract class ArcanistWorkflowHardpointQuery
+abstract class ArcanistRuntimeHardpointQuery
   extends ArcanistHardpointQuery {
 
-  private $workflow;
+  private $runtime;
   private $canLoadHardpoint;
 
-  final public function setWorkflow(ArcanistWorkflow $workflow) {
-    $this->workflow = $workflow;
+  final public function setRuntime(ArcanistRuntime $runtime) {
+    $this->runtime = $runtime;
     return $this;
   }
 
-  final public function getWorkflow() {
-    return $this->workflow;
+  final public function getRuntime() {
+    return $this->runtime;
   }
 
   final public function getWorkingCopy() {
-    return $this->getWorkflow()->getWorkingCopy();
+    return $this->getRuntime()->getWorkingCopy();
   }
 
   final public function getRepositoryAPI() {
     return $this->getWorkingCopy()->getRepositoryAPI();
   }
 
   public static function getAllQueries() {
     return id(new PhutilClassMapQuery())
       ->setAncestorClass(__CLASS__)
       ->execute();
   }
 
   final public function canLoadObject(ArcanistHardpointObject $object) {
     if ($this->canLoadHardpoint === null) {
       $this->canLoadHardpoint = $this->canLoadHardpoint();
     }
 
     if (!$this->canLoadHardpoint) {
       return false;
     }
 
     if (!$object instanceof ArcanistRef) {
       return false;
     }
 
     return $this->canLoadRef($object);
   }
 
   protected function canLoadHardpoint() {
     return true;
   }
 
   abstract protected function canLoadRef(ArcanistRef $ref);
 
   final public function newConduitSearch($method, $constraints) {
-    $conduit_engine = $this->getWorkflow()
+    $conduit_engine = $this->getRuntime()
       ->getConduitEngine();
 
     $conduit_future = id(new ConduitSearchFuture())
       ->setConduitEngine($conduit_engine)
       ->setMethod($method)
       ->setConstraints($constraints);
 
     return $conduit_future;
   }
 
   final public function yieldConduitSearch($method, $constraints) {
     $conduit_future = $this->newConduitSearch($method, $constraints);
     return $this->yieldFuture($conduit_future);
   }
 
   final public function newConduit($method, $parameters) {
-    $conduit_engine = $this->getWorkflow()
+    $conduit_engine = $this->getRuntime()
       ->getConduitEngine();
 
     $call_object = $conduit_engine->newCall($method, $parameters);
     $call_future = $conduit_engine->newFuture($call_object);
 
     return $call_future;
   }
 
   final public function yieldConduit($method, array $parameters) {
     $call_future = $this->newConduit($method, $parameters);
     return $this->yieldFuture($call_future);
   }
 
   final public function yieldRepositoryRef() {
-    $workflow = $this->getWorkflow();
+    // TODO: This should probably move to Runtime.
+
+    $runtime = $this->getRuntime();
+    $workflow = $runtime->getCurrentWorkflow();
 
     // TODO: This is currently a blocking request, but should yield to the
     // hardpoint engine in the future.
 
     $repository_ref = $workflow->getRepositoryRef();
     $ref_future = new ImmediateFuture($repository_ref);
 
     return $this->yieldFuture($ref_future);
   }
 
   final public function yieldValue(array $refs, $value) {
     assert_instances_of($refs, 'ArcanistRef');
 
     $keys = array_keys($refs);
     $map = array_fill_keys($keys, $value);
     return $this->yieldMap($map);
   }
 
   final public function yieldMap(array $map) {
     return new ArcanistHardpointTaskResult($map);
   }
 
 }
diff --git a/src/workflow/ArcanistAmendWorkflow.php b/src/workflow/ArcanistAmendWorkflow.php
index e660d890..be1cf25f 100644
--- a/src/workflow/ArcanistAmendWorkflow.php
+++ b/src/workflow/ArcanistAmendWorkflow.php
@@ -1,210 +1,278 @@
 <?php
 
-/**
- * Synchronizes commit messages from Differential.
- */
-final class ArcanistAmendWorkflow extends ArcanistWorkflow {
+final class ArcanistAmendWorkflow
+  extends ArcanistArcWorkflow {
 
   public function getWorkflowName() {
     return 'amend';
   }
 
-  public function getCommandSynopses() {
-    return phutil_console_format(<<<EOTEXT
-      **amend** [--revision __revision_id__] [--show]
-EOTEXT
-      );
-  }
+  public function getWorkflowInformation() {
+    $help = pht(<<<EOTEXT
+Amend the working copy, synchronizing the local commit message from
+Differential.
 
-  public function getCommandHelp() {
-    return phutil_console_format(<<<EOTEXT
-          Supports: git, hg
-          Amend the working copy, synchronizing the local commit message from
-          Differential.
-
-          Supported in Mercurial 2.2 and newer.
+Supported in Mercurial 2.2 and newer.
 EOTEXT
       );
-  }
 
-  public function requiresWorkingCopy() {
-    return true;
+    return $this->newWorkflowInformation()
+      ->setSynopsis(
+        pht('Amend the working copy, synchronizing the local commit message.'))
+      ->addExample('**amend** [options] -- ')
+      ->setHelp($help);
   }
 
-  public function requiresConduit() {
-    return true;
-  }
-
-  public function requiresAuthentication() {
-    return true;
-  }
-
-  public function requiresRepositoryAPI() {
-    return true;
+  public function getWorkflowArguments() {
+    return array(
+      $this->newWorkflowArgument('show')
+        ->setHelp(
+          pht(
+            'Show the amended commit message, without modifying the '.
+            'working copy.')),
+      $this->newWorkflowArgument('revision')
+        ->setParameter('id')
+        ->setHelp(
+          pht(
+            'Use the message from a specific revision. If you do not specify '.
+            'a revision, arc will guess which revision is in the working '.
+            'copy.')),
+    );
   }
 
-  public function getArguments() {
+  protected function newPrompts() {
     return array(
-      'show' => array(
-        'help' => pht(
-          'Show the amended commit message, without modifying the '.
-          'working copy.'),
-      ),
-      'revision' => array(
-        'param' => 'revision_id',
-        'help' => pht(
-          'Use the message from a specific revision. If you do not specify '.
-          'a revision, arc will guess which revision is in the working '.
-          'copy.'),
-      ),
+      $this->newPrompt('arc.amend.unrelated')
+        ->setDescription(
+          pht(
+            'Confirms use of a revision that does not appear to be '.
+            'present in the working copy.')),
+      $this->newPrompt('arc.amend.author')
+        ->setDescription(
+          pht(
+            'Confirms use of a revision that you are not the author '.
+            'of.')),
+      $this->newPrompt('arc.amend.immutable')
+        ->setDescription(
+          pht(
+            'Confirms history mutation in a working copy marked as '.
+            'immutable.')),
     );
   }
 
-  public function run() {
+  public function runWorkflow() {
+    $symbols = $this->getSymbolEngine();
+
     $is_show = $this->getArgument('show');
 
     $repository_api = $this->getRepositoryAPI();
     if (!$is_show) {
-      if (!$repository_api->supportsAmend()) {
-        throw new ArcanistUsageException(
-          pht(
-            "You may only run '%s' in a git or hg ".
-            "(version 2.2 or newer) working copy.",
-            'arc amend'));
-      }
+      $this->requireAmendSupport($repository_api);
+    }
 
-      if ($this->isHistoryImmutable()) {
-        throw new ArcanistUsageException(
-          pht(
-            'This project is marked as adhering to a conservative history '.
-            'mutability doctrine (having an immutable local history), which '.
-            'precludes amending commit messages.'));
-      }
+    $revision_symbol = $this->getArgument('revision');
+
+    // We only care about the local working copy state if we need it to
+    // figure out which revision we're operating on, or we're planning to
+    // mutate it. If the caller is running "arc amend --show --revision X",
+    // the local state does not matter.
+
+    $need_state =
+      ($revision_symbol === null) ||
+      (!$is_show);
+
+    if ($need_state) {
+      $state_ref = $repository_api->getCurrentWorkingCopyStateRef();
+
+      $this->loadHardpoints(
+        $state_ref,
+        ArcanistWorkingCopyStateRef::HARDPOINT_REVISIONREFS);
+
+      $revision_refs = $state_ref->getRevisionRefs();
+    }
 
-      if ($repository_api->getUncommittedChanges()) {
-        throw new ArcanistUsageException(
+    if ($revision_symbol === null) {
+      $revision_ref = $this->selectRevisionRef($revision_refs);
+    } else {
+      $revision_ref = $symbols->loadRevisionForSymbol($revision_symbol);
+      if (!$revision_ref) {
+        throw new PhutilArgumentUsageException(
           pht(
-            'You have uncommitted changes in this branch. Stage and commit '.
-            '(or revert) them before proceeding.'));
+            'Revision "%s" does not exist, or you do not have permission '.
+            'to see it.',
+            $revision_symbol));
       }
     }
 
-    $revision_id = null;
-    if ($this->getArgument('revision')) {
-      $revision_id = $this->normalizeRevisionID($this->getArgument('revision'));
+    if (!$is_show) {
+      echo tsprintf(
+        "%s\n\n%s\n",
+        pht('Amending commit message to reflect revision:'),
+        $revision_ref->newDisplayRef());
+
+      $this->confirmAmendAuthor($revision_ref);
+      $this->confirmAmendNotFound($revision_ref, $state_ref);
     }
 
-    $repository_api->setBaseCommitArgumentRules('arc:this');
-    $in_working_copy = $repository_api->loadWorkingCopyDifferentialRevisions(
-      $this->getConduit(),
-      array(
-        'status'    => 'status-any',
-      ));
-    $in_working_copy = ipull($in_working_copy, null, 'id');
+    $this->loadHardpoints(
+      $revision_ref,
+      ArcanistRevisionRef::HARDPOINT_COMMITMESSAGE);
+
+    $message = $revision_ref->getCommitMessage();
+
+    if ($is_show) {
+      echo tsprintf(
+        "%B\n",
+        $message);
+    } else {
+      $repository_api->amendCommit($message);
+    }
 
-    if (!$revision_id) {
-      if (count($in_working_copy) == 0) {
-        throw new ArcanistUsageException(
+    return 0;
+  }
+
+  private function requireAmendSupport(ArcanistRepositoryAPI $api) {
+    if (!$api->supportsAmend()) {
+      if ($api instanceof ArcanistMercurialAPI) {
+        throw new PhutilArgumentUsageException(
           pht(
-            "No revision specified with '%s', and no revisions found ".
-            "in the working copy. Use '%s' to specify which revision ".
-            "you want to amend.",
-            '--revision',
-            '--revision <id>'));
-      } else if (count($in_working_copy) > 1) {
-        $message = pht(
-          "More than one revision was found in the working copy:\n%s\n".
-          "Use '%s' to specify which revision you want to amend.",
-          $this->renderRevisionList($in_working_copy),
-          '--revision <id>');
-        throw new ArcanistUsageException($message);
-      } else {
-        $revision_id = key($in_working_copy);
-        $revision = $in_working_copy[$revision_id];
-        if ($revision['authorPHID'] != $this->getUserPHID()) {
-          $other_author = $this->getConduit()->callMethodSynchronous(
-            'user.query',
-            array(
-              'phids' => array($revision['authorPHID']),
-            ));
-          $other_author = ipull($other_author, 'userName', 'phid');
-          $other_author = $other_author[$revision['authorPHID']];
-          $rev_title = $revision['title'];
-          $ok = phutil_console_confirm(
-            pht(
-              "You are amending the revision '%s' but you are not ".
-              "the author. Amend this revision by %s?",
-              "D{$revision_id}: {$rev_title}",
-              $other_author));
-          if (!$ok) {
-            throw new ArcanistUserAbortException();
-          }
-        }
+            '"arc amend" is only supported under Mercurial 2.2 or newer. '.
+            'Older versions of Mercurial do not support the "--amend" flag '.
+            'to "hg commit ...", which this workflow requires.'));
       }
+
+      throw new PhutilArgumentUsageException(
+        pht(
+          '"arc amend" must be run from inside a working copy of a '.
+          'repository using a version control system that supports '.
+          'amending commits, like Git or Mercurial.'));
     }
 
-    $conduit = $this->getConduit();
-    try {
-      $message = $conduit->callMethodSynchronous(
-        'differential.getcommitmessage',
-        array(
-          'revision_id' => $revision_id,
-          'edit'        => false,
-        ));
-    } catch (ConduitClientException $ex) {
-      if (strpos($ex->getMessage(), 'ERR_NOT_FOUND') === false) {
-        throw $ex;
-      } else {
-        throw new ArcanistUsageException(
-          pht("Revision '%s' does not exist.", "D{$revision_id}")
-        );
-      }
+    if ($this->isHistoryImmutable()) {
+      echo tsprintf(
+        "%!\n\n%W\n",
+        pht('IMMUTABLE WORKING COPY'),
+        pht(
+          'This working copy is configured to have an immutable local '.
+          'history, using the "history.immutable" configuration option. '.
+          'Amending the working copy will mutate local history.'));
+
+      $prompt = pht('Are you sure you want to mutate history?');
+
+      $this->getPrompt('arc.amend.immutable')
+        ->setQuery($prompt)
+        ->execute();
     }
 
-    $revision = $conduit->callMethodSynchronous(
-      'differential.query',
-      array(
-        'ids' => array($revision_id),
-      ));
-    if (empty($revision)) {
-      throw new Exception(
-        pht("Failed to lookup information for '%s'!", "D{$revision_id}"));
+    return;
+
+    if ($api->getUncommittedChanges()) {
+      // TODO: Make this class of error show the uncommitted changes.
+
+      // TODO: This only needs to check for staged-but-uncommitted changes.
+      // We can safely amend with untracked and unstaged changes.
+
+      throw new PhutilArgumentUsageException(
+        pht(
+          'You have uncommitted changes in this working copy. Commit or '.
+          'revert them before proceeding.'));
     }
-    $revision = head($revision);
-    $revision_title = $revision['title'];
+  }
 
-    if (!$is_show) {
-      if ($revision_id && empty($in_working_copy[$revision_id])) {
-        $ok = phutil_console_confirm(
-          pht(
-            "The revision '%s' does not appear to be in the working copy. Are ".
-            "you sure you want to amend HEAD with the commit message for '%s'?",
-            "D{$revision_id}",
-            "D{$revision_id}: {$revision_title}"));
-        if (!$ok) {
-          throw new ArcanistUserAbortException();
-        }
-      }
+  private function selectRevisionRef(array $revisions) {
+    if (!$revisions) {
+      throw new PhutilArgumentUsageException(
+        pht(
+          'No revision specified with "--revision", and no revisions found '.
+          'that match the current working copy state. Use "--revision <id>" '.
+          'to specify which revision you want to amend.'));
     }
 
-    if ($is_show) {
-      echo $message."\n";
-    } else {
-      echo pht(
-        "Amending commit message to reflect revision %s.\n",
-        phutil_console_format(
-          '**D%d: %s**',
-          $revision_id,
-          $revision_title));
+     if (count($revisions) > 1) {
+       echo tsprintf(
+         "%!\n%W\n\n%B\n",
+         pht('MULTIPLE REVISIONS IN WORKING COPY'),
+         pht('More than one revision was found in the working copy:'),
+         mpull($revisions, 'newDisplayRef'));
 
-      $repository_api->amendCommit($message);
+      throw new PhutilArgumentUsageException(
+        pht(
+          'Use "--revision <id>" to specify which revision you want '.
+          'to amend.'));
     }
 
-    return 0;
+    return head($revisions);
   }
 
-  public function getSupportedRevisionControlSystems() {
-    return array('git', 'hg');
+  private function confirmAmendAuthor(ArcanistRevisionRef $revision_ref) {
+    $viewer = $this->getViewer();
+    $viewer_phid = $viewer->getPHID();
+
+    $author_phid = $revision_ref->getAuthorPHID();
+
+    if ($viewer_phid === $author_phid) {
+      return;
+    }
+
+    $symbols = $this->getSymbolEngine();
+    $author_ref = $symbols->loadUserForSymbol($author_phid);
+    if (!$author_ref) {
+      // If we don't have any luck loading the author, skip this warning.
+      return;
+    }
+
+    echo tsprintf(
+      "%!\n\n%W\n\n%s",
+      pht('NOT REVISION AUTHOR'),
+      array(
+        pht(
+          'You are amending the working copy using information from '.
+          'a revision you are not the author of.'),
+        "\n\n",
+        pht(
+          'The author of this revision (%s) is:',
+          $revision_ref->getMonogram()),
+      ),
+      $author_ref->newDisplayRef());
+
+    $prompt = pht(
+      'Amend working copy using revision owned by %s?',
+      $author_ref->getMonogram());
+
+    $this->getPrompt('arc.amend.author')
+      ->setQuery($prompt)
+      ->execute();
+  }
+
+  private function confirmAmendNotFound(
+    ArcanistRevisionRef $revision_ref,
+    ArcanistWorkingCopyStateRef $state_ref) {
+
+    $local_refs = $state_ref->getRevisionRefs();
+    $local_refs = mpull($local_refs, null, 'getPHID');
+
+    $revision_phid = $revision_ref->getPHID();
+    $is_local = isset($local_refs[$revision_phid]);
+
+    if ($is_local) {
+      return;
+    }
+
+    echo tsprintf(
+      "%!\n\n%W\n",
+      pht('UNRELATED REVISION'),
+      pht(
+        'You are amending the working copy using information from '.
+        'a revision that does not appear to be associated with the '.
+        'current state of the working copy.'));
+
+    $prompt = pht(
+      'Amend working copy using unrelated revision %s?',
+      $revision_ref->getMonogram());
+
+    $this->getPrompt('arc.amend.unrelated')
+      ->setQuery($prompt)
+      ->execute();
   }
 
 }
diff --git a/src/workflow/ArcanistWorkflow.php b/src/workflow/ArcanistWorkflow.php
index 807e6b40..271c4c1f 100644
--- a/src/workflow/ArcanistWorkflow.php
+++ b/src/workflow/ArcanistWorkflow.php
@@ -1,2434 +1,2373 @@
 <?php
 
 /**
  * Implements a runnable command, like "arc diff" or "arc help".
  *
  * = Managing Conduit =
  *
  * Workflows have the builtin ability to open a Conduit connection to a
  * Phabricator installation, so methods can be invoked over the API. Workflows
  * may either not need this (e.g., "help"), or may need a Conduit but not
  * authentication (e.g., calling only public APIs), or may need a Conduit and
  * authentication (e.g., "arc diff").
  *
  * To specify that you need an //unauthenticated// conduit, override
  * @{method:requiresConduit} to return ##true##. To specify that you need an
  * //authenticated// conduit, override @{method:requiresAuthentication} to
  * return ##true##. You can also manually invoke @{method:establishConduit}
  * and/or @{method:authenticateConduit} later in a workflow to upgrade it.
  * Once a conduit is open, you can access the client by calling
  * @{method:getConduit}, which allows you to invoke methods. You can get
  * verified information about the user identity by calling @{method:getUserPHID}
  * or @{method:getUserName} after authentication occurs.
  *
  * = Scratch Files =
  *
  * Arcanist workflows can read and write 'scratch files', which are temporary
  * files stored in the project that persist across commands. They can be useful
  * if you want to save some state, or keep a copy of a long message the user
  * entered if something goes wrong.
  *
  *
  * @task  conduit   Conduit
  * @task  scratch   Scratch Files
  * @task  phabrep   Phabricator Repositories
  */
 abstract class ArcanistWorkflow extends Phobject {
 
   const COMMIT_DISABLE = 0;
   const COMMIT_ALLOW = 1;
   const COMMIT_ENABLE = 2;
 
   private $commitMode = self::COMMIT_DISABLE;
 
   private $conduit;
   private $conduitURI;
   private $conduitCredentials;
   private $conduitAuthenticated;
   private $conduitTimeout;
 
   private $userPHID;
   private $userName;
   private $repositoryAPI;
   private $configurationManager;
   private $arguments = array();
   private $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;
 
   private $toolset;
   private $runtime;
   private $configurationEngine;
   private $configurationSourceList;
 
-  private $viewer;
-  private $hardpointEngine;
-  private $symbolEngine;
   private $promptMap;
 
   final public function setToolset(ArcanistToolset $toolset) {
     $this->toolset = $toolset;
     return $this;
   }
 
   final public function getToolset() {
     return $this->toolset;
   }
 
   final public function setRuntime(ArcanistRuntime $runtime) {
     $this->runtime = $runtime;
     return $this;
   }
 
   final public function getRuntime() {
     return $this->runtime;
   }
 
   final public function setConfigurationEngine(
     ArcanistConfigurationEngine $engine) {
     $this->configurationEngine = $engine;
     return $this;
   }
 
   final public function getConfigurationEngine() {
     return $this->configurationEngine;
   }
 
   final public function setConfigurationSourceList(
     ArcanistConfigurationSourceList $list) {
     $this->configurationSourceList = $list;
     return $this;
   }
 
   final public function getConfigurationSourceList() {
     return $this->configurationSourceList;
   }
 
   public function newPhutilWorkflow() {
     $arguments = $this->getWorkflowArguments();
     assert_instances_of($arguments, 'ArcanistWorkflowArgument');
 
     $specs = mpull($arguments, 'getPhutilSpecification');
 
     $phutil_workflow = id(new ArcanistPhutilWorkflow())
       ->setName($this->getWorkflowName())
       ->setWorkflow($this)
       ->setArguments($specs);
 
     $information = $this->getWorkflowInformation();
 
     if ($information !== null) {
       if (!($information instanceof ArcanistWorkflowInformation)) {
         throw new Exception(
           pht(
             'Expected workflow ("%s", of class "%s") to return an '.
             '"ArcanistWorkflowInformation" object from call to '.
             '"getWorkflowInformation()", got %s.',
             $this->getWorkflowName(),
             get_class($this),
             phutil_describe_type($information)));
       }
     }
 
     if ($information) {
       $synopsis = $information->getSynopsis();
       if (strlen($synopsis)) {
         $phutil_workflow->setSynopsis($synopsis);
       }
 
       $examples = $information->getExamples();
       if ($examples) {
         $examples = implode("\n", $examples);
         $phutil_workflow->setExamples($examples);
       }
 
       $help = $information->getHelp();
       if (strlen($help)) {
         // Unwrap linebreaks in the help text so we don't get weird formatting.
         $help = preg_replace("/(?<=\S)\n(?=\S)/", ' ', $help);
 
         $phutil_workflow->setHelp($help);
       }
     }
 
     return $phutil_workflow;
   }
 
   final protected function newWorkflowArgument($key) {
     return id(new ArcanistWorkflowArgument())
       ->setKey($key);
   }
 
   final protected function newWorkflowInformation() {
     return new ArcanistWorkflowInformation();
   }
 
   final public function executeWorkflow(PhutilArgumentParser $args) {
     $runtime = $this->getRuntime();
 
     $this->arguments = $args;
     $caught = null;
 
     $runtime->pushWorkflow($this);
 
     try {
       $err = $this->runWorkflow($args);
     } catch (Exception $ex) {
       $caught = $ex;
     }
 
     try {
       $this->runWorkflowCleanup();
     } catch (Exception $ex) {
       phlog($ex);
     }
 
     $runtime->popWorkflow();
 
     if ($caught) {
       throw $caught;
     }
 
     return $err;
   }
 
   final protected function getLogEngine() {
     return $this->getRuntime()->getLogEngine();
   }
 
   protected function runWorkflowCleanup() {
     // TOOLSETS: Do we need this?
     return;
   }
 
   public function __construct() {}
 
   public function run() {
     throw new PhutilMethodNotImplementedException();
   }
 
   /**
    * Finalizes any cleanup operations that need to occur regardless of
    * whether the command succeeded or failed.
    */
   public function finalize() {
     $this->finalizeWorkingCopy();
   }
 
   /**
    * Return the command used to invoke this workflow from the command like,
    * e.g. "help" for @{class:ArcanistHelpWorkflow}.
    *
    * @return string   The command a user types to invoke this workflow.
    */
   abstract public function getWorkflowName();
 
   /**
    * Return console formatted string with all command synopses.
    *
    * @return string  6-space indented list of available command synopses.
    */
   public function getCommandSynopses() {
     return array();
   }
 
   /**
    * Return console formatted string with command help printed in `arc help`.
    *
    * @return string  10-space indented help to use the command.
    */
   public function getCommandHelp() {
     return null;
   }
 
   public function supportsToolset(ArcanistToolset $toolset) {
     return false;
   }
 
 
 /* -(  Conduit  )------------------------------------------------------------ */
 
 
   /**
    * Set the URI which the workflow will open a conduit connection to when
    * @{method:establishConduit} is called. Arcanist makes an effort to set
    * this by default for all workflows (by reading ##.arcconfig## and/or the
    * value of ##--conduit-uri##) even if they don't need Conduit, so a workflow
    * can generally upgrade into a conduit workflow later by just calling
    * @{method:establishConduit}.
    *
    * You generally should not need to call this method unless you are
    * specifically overriding the default URI. It is normally sufficient to
    * just invoke @{method:establishConduit}.
    *
    * NOTE: You can not call this after a conduit has been established.
    *
    * @param string  The URI to open a conduit to when @{method:establishConduit}
    *                is called.
    * @return this
    * @task conduit
    */
   final public function setConduitURI($conduit_uri) {
     if ($this->conduit) {
       throw new Exception(
         pht(
           'You can not change the Conduit URI after a '.
           'conduit is already open.'));
     }
     $this->conduitURI = $conduit_uri;
     return $this;
   }
 
   /**
    * Returns the URI the conduit connection within the workflow uses.
    *
    * @return string
    * @task conduit
    */
   final public function getConduitURI() {
     return $this->conduitURI;
   }
 
   /**
    * Open a conduit channel to the server which was previously configured by
    * calling @{method:setConduitURI}. Arcanist will do this automatically if
    * the workflow returns ##true## from @{method:requiresConduit}, or you can
    * later upgrade a workflow and build a conduit by invoking it manually.
    *
    * You must establish a conduit before you can make conduit calls.
    *
    * NOTE: You must call @{method:setConduitURI} before you can call this
    * method.
    *
    * @return this
    * @task conduit
    */
   final public function establishConduit() {
     if ($this->conduit) {
       return $this;
     }
 
     if (!$this->conduitURI) {
       throw new Exception(
         pht(
           'You must specify a Conduit URI with %s before you can '.
           'establish a conduit.',
           'setConduitURI()'));
     }
 
     $this->conduit = new ConduitClient($this->conduitURI);
 
     if ($this->conduitTimeout) {
       $this->conduit->setTimeout($this->conduitTimeout);
     }
 
     return $this;
   }
 
   final public function getConfigFromAnySource($key) {
     $source_list = $this->getConfigurationSourceList();
     if ($source_list) {
       $value_list = $source_list->getStorageValueList($key);
       if ($value_list) {
         return last($value_list)->getValue();
       }
 
       return null;
     }
 
     return $this->configurationManager->getConfigFromAnySource($key);
   }
 
 
   /**
    * Set credentials which will be used to authenticate against Conduit. These
    * credentials can then be used to establish an authenticated connection to
    * conduit by calling @{method:authenticateConduit}. Arcanist sets some
    * defaults for all workflows regardless of whether or not they return true
    * from @{method:requireAuthentication}, based on the ##~/.arcrc## and
    * ##.arcconf## files if they are present. Thus, you can generally upgrade a
    * workflow which does not require authentication into an authenticated
    * workflow by later invoking @{method:requireAuthentication}. You should not
    * normally need to call this method unless you are specifically overriding
    * the defaults.
    *
    * NOTE: You can not call this method after calling
    * @{method:authenticateConduit}.
    *
    * @param dict  A credential dictionary, see @{method:authenticateConduit}.
    * @return this
    * @task conduit
    */
   final public function setConduitCredentials(array $credentials) {
     if ($this->isConduitAuthenticated()) {
       throw new Exception(
         pht('You may not set new credentials after authenticating conduit.'));
     }
 
     $this->conduitCredentials = $credentials;
     return $this;
   }
 
 
   /**
    * Get the protocol version the client should identify with.
    *
    * @return int Version the client should claim to be.
    * @task conduit
    */
   final public function getConduitVersion() {
     return 6;
   }
 
 
   /**
    * Open and authenticate a conduit connection to a Phabricator server using
    * provided credentials. Normally, Arcanist does this for you automatically
    * when you return true from @{method:requiresAuthentication}, but you can
    * also upgrade an existing workflow to one with an authenticated conduit
    * by invoking this method manually.
    *
    * You must authenticate the conduit before you can make authenticated conduit
    * calls (almost all calls require authentication).
    *
    * This method uses credentials provided via @{method:setConduitCredentials}
    * to authenticate to the server:
    *
    *    - ##user## (required) The username to authenticate with.
    *    - ##certificate## (required) The Conduit certificate to use.
    *    - ##description## (optional) Description of the invoking command.
    *
    * Successful authentication allows you to call @{method:getUserPHID} and
    * @{method:getUserName}, as well as use the client you access with
    * @{method:getConduit} to make authenticated calls.
    *
    * NOTE: You must call @{method:setConduitURI} and
    * @{method:setConduitCredentials} before you invoke this method.
    *
    * @return this
    * @task conduit
    */
   final public function authenticateConduit() {
     if ($this->isConduitAuthenticated()) {
       return $this;
     }
 
     $this->establishConduit();
     $credentials = $this->conduitCredentials;
 
     try {
       if (!$credentials) {
         throw new Exception(
           pht(
             'Set conduit credentials with %s before authenticating conduit!',
             'setConduitCredentials()'));
       }
 
       // If we have `token`, this server supports the simpler, new-style
       // token-based authentication. Use that instead of all the certificate
       // stuff.
       $token = idx($credentials, 'token');
       if (strlen($token)) {
         $conduit = $this->getConduit();
 
         $conduit->setConduitToken($token);
 
         try {
           $result = $this->getConduit()->callMethodSynchronous(
             'user.whoami',
             array());
 
           $this->userName = $result['userName'];
           $this->userPHID = $result['phid'];
 
           $this->conduitAuthenticated = true;
 
           return $this;
         } catch (Exception $ex) {
           $conduit->setConduitToken(null);
           throw $ex;
         }
       }
 
       if (empty($credentials['user'])) {
         throw new ConduitClientException(
           'ERR-INVALID-USER',
           pht('Empty user in credentials.'));
       }
       if (empty($credentials['certificate'])) {
         throw new ConduitClientException(
           'ERR-NO-CERTIFICATE',
           pht('Empty certificate in credentials.'));
       }
 
       $description = idx($credentials, 'description', '');
       $user        = $credentials['user'];
       $certificate = $credentials['certificate'];
 
       $connection = $this->getConduit()->callMethodSynchronous(
         'conduit.connect',
         array(
           'client'              => 'arc',
           'clientVersion'       => $this->getConduitVersion(),
           'clientDescription'   => php_uname('n').':'.$description,
           'user'                => $user,
           'certificate'         => $certificate,
           'host'                => $this->conduitURI,
         ));
     } catch (ConduitClientException $ex) {
       if ($ex->getErrorCode() == 'ERR-NO-CERTIFICATE' ||
           $ex->getErrorCode() == 'ERR-INVALID-USER' ||
           $ex->getErrorCode() == 'ERR-INVALID-AUTH') {
         $conduit_uri = $this->conduitURI;
         $message = phutil_console_format(
           "\n%s\n\n    %s\n\n%s\n%s",
           pht('YOU NEED TO __INSTALL A CERTIFICATE__ TO LOGIN TO PHABRICATOR'),
           pht('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) {
     // TOOLSETS: Remove this legacy code.
     if (is_array($this->arguments)) {
       return idx($this->arguments, $key, $default);
     }
 
     return $this->arguments->getArg($key);
   }
 
   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() {
     $configuration_engine = $this->getConfigurationEngine();
 
     // TOOLSETS: Remove this once all workflows are toolset workflows.
     if (!$configuration_engine) {
       throw new Exception(
         pht(
           'This workflow has not yet been updated to Toolsets and can '.
           'not retrieve a modern WorkingCopy object. Use '.
           '"getWorkingCopyIdentity()" to retrieve a previous-generation '.
           'object.'));
     }
 
     return $configuration_engine->getWorkingCopy();
   }
 
 
   final public function getWorkingCopyIdentity() {
     $configuration_engine = $this->getConfigurationEngine();
     if ($configuration_engine) {
       $working_copy = $configuration_engine->getWorkingCopy();
       $working_path = $working_copy->getWorkingDirectory();
 
       return ArcanistWorkingCopyIdentity::newFromPath($working_path);
     }
 
     $working_copy = $this->getConfigurationManager()->getWorkingCopyIdentity();
     if (!$working_copy) {
       $workflow = get_class($this);
       throw new Exception(
         pht(
           "This workflow ('%s') requires a working copy, override ".
           "%s to return true.",
           $workflow,
           'requiresWorkingCopy()'));
     }
     return $working_copy;
   }
 
   final public function setRepositoryAPI($api) {
     $this->repositoryAPI = $api;
     return $this;
   }
 
   final public function hasRepositoryAPI() {
     try {
       return (bool)$this->getRepositoryAPI();
     } catch (Exception $ex) {
       return false;
     }
   }
 
   final public function getRepositoryAPI() {
     $configuration_engine = $this->getConfigurationEngine();
     if ($configuration_engine) {
       $working_copy = $configuration_engine->getWorkingCopy();
       return $working_copy->getRepositoryAPI();
     }
 
     if (!$this->repositoryAPI) {
       $workflow = get_class($this);
       throw new Exception(
         pht(
           "This workflow ('%s') requires a Repository API, override ".
           "%s to return true.",
           $workflow,
           'requiresRepositoryAPI()'));
     }
     return $this->repositoryAPI;
   }
 
   final protected function shouldRequireCleanUntrackedFiles() {
     return empty($this->arguments['allow-untracked']);
   }
 
   final public function setCommitMode($mode) {
     $this->commitMode = $mode;
     return $this;
   }
 
   final public function finalizeWorkingCopy() {
     if ($this->stashed) {
       $api = $this->getRepositoryAPI();
       $api->unstashChanges();
       echo pht('Restored stashed changes to the working directory.')."\n";
     }
   }
 
   final public function requireCleanWorkingCopy() {
     $api = $this->getRepositoryAPI();
 
     $must_commit = array();
 
     $working_copy_desc = phutil_console_format(
       "  %s: __%s__\n\n",
       pht('Working copy'),
       $api->getPath());
 
     // NOTE: this is a subversion-only concept.
     $incomplete = $api->getIncompleteChanges();
     if ($incomplete) {
       throw new ArcanistUsageException(
         sprintf(
           "%s\n\n%s  %s\n    %s\n\n%s",
           pht(
             "You have incompletely checked out directories in this working ".
             "copy. Fix them before proceeding.'"),
           $working_copy_desc,
           pht('Incomplete directories in working copy:'),
           implode("\n    ", $incomplete),
           pht(
             "You can fix these paths by running '%s' on them.",
             'svn update')));
     }
 
     $conflicts = $api->getMergeConflicts();
     if ($conflicts) {
       throw new ArcanistUsageException(
         sprintf(
           "%s\n\n%s  %s\n    %s",
           pht(
             'You have merge conflicts in this working copy. Resolve merge '.
             'conflicts before proceeding.'),
           $working_copy_desc,
           pht('Conflicts in working copy:'),
           implode("\n    ", $conflicts)));
     }
 
     $missing = $api->getMissingChanges();
     if ($missing) {
       throw new ArcanistUsageException(
         sprintf(
           "%s\n\n%s  %s\n    %s\n",
           pht(
             'You have missing files in this working copy. Revert or formally '.
             'remove them (with `%s`) before proceeding.',
             'svn rm'),
           $working_copy_desc,
           pht('Missing files in working copy:'),
           implode("\n    ", $missing)));
     }
 
     $externals = $api->getDirtyExternalChanges();
 
     // TODO: This state can exist in Subversion, but it is currently handled
     // elsewhere. It should probably be handled here, eventually.
     if ($api instanceof ArcanistSubversionAPI) {
       $externals = array();
     }
 
     if ($externals) {
       $message = pht(
         '%s submodule(s) have uncommitted or untracked changes:',
         new PhutilNumber(count($externals)));
 
       $prompt = pht(
         'Ignore the changes to these %s submodule(s) and continue?',
         new PhutilNumber(count($externals)));
 
       $list = id(new PhutilConsoleList())
         ->setWrap(false)
         ->addItems($externals);
 
       id(new PhutilConsoleBlock())
         ->addParagraph($message)
         ->addList($list)
         ->draw();
 
       $ok = phutil_console_confirm($prompt, $default_no = false);
       if (!$ok) {
         throw new ArcanistUserAbortException();
       }
     }
 
     $uncommitted = $api->getUncommittedChanges();
     $unstaged = $api->getUnstagedChanges();
 
     // We already dealt with externals.
     $unstaged = array_diff($unstaged, $externals);
 
     // We only want files which are purely uncommitted.
     $uncommitted = array_diff($uncommitted, $unstaged);
     $uncommitted = array_diff($uncommitted, $externals);
 
     $untracked = $api->getUntrackedChanges();
     if (!$this->shouldRequireCleanUntrackedFiles()) {
       $untracked = array();
     }
 
     if ($untracked) {
       echo sprintf(
         "%s\n\n%s",
         pht('You have untracked files in this working copy.'),
         $working_copy_desc);
 
       if ($api instanceof ArcanistGitAPI) {
         $hint = pht(
           '(To ignore these %s change(s), add them to "%s".)',
           phutil_count($untracked),
           '.git/info/exclude');
       } else if ($api instanceof ArcanistSubversionAPI) {
         $hint = pht(
           '(To ignore these %s change(s), add them to "%s".)',
           phutil_count($untracked),
           'svn:ignore');
       } else if ($api instanceof ArcanistMercurialAPI) {
         $hint = pht(
           '(To ignore these %s change(s), add them to "%s".)',
           phutil_count($untracked),
           '.hgignore');
       }
 
       $untracked_list = "    ".implode("\n    ", $untracked);
       echo sprintf(
         "  %s\n  %s\n%s",
         pht('Untracked changes in working copy:'),
         $hint,
         $untracked_list);
 
       $prompt = pht(
         'Ignore these %s untracked file(s) and continue?',
         phutil_count($untracked));
 
       if (!phutil_console_confirm($prompt)) {
         throw new ArcanistUserAbortException();
       }
     }
 
 
     $should_commit = false;
     if ($unstaged || $uncommitted) {
 
       // NOTE: We're running this because it builds a cache and can take a
       // perceptible amount of time to arrive at an answer, but we don't want
       // to pause in the middle of printing the output below.
       $this->getShouldAmend();
 
       echo sprintf(
         "%s\n\n%s",
         pht('You have uncommitted changes in this working copy.'),
         $working_copy_desc);
 
       $lists = array();
 
       if ($unstaged) {
         $unstaged_list = "    ".implode("\n    ", $unstaged);
         $lists[] = sprintf(
           "  %s\n%s",
           pht('Unstaged changes in working copy:'),
           $unstaged_list);
       }
 
       if ($uncommitted) {
         $uncommitted_list = "    ".implode("\n    ", $uncommitted);
         $lists[] = sprintf(
           "%s\n%s",
           pht('Uncommitted changes in working copy:'),
           $uncommitted_list);
       }
 
       echo implode("\n\n", $lists)."\n";
 
       $all_uncommitted = array_merge($unstaged, $uncommitted);
       if ($this->askForAdd($all_uncommitted)) {
         if ($unstaged) {
           $api->addToCommit($unstaged);
         }
         $should_commit = true;
       } else {
         $permit_autostash = $this->getConfigFromAnySource('arc.autostash');
         if ($permit_autostash && $api->canStashChanges()) {
            echo pht(
             'Stashing uncommitted changes. (You can restore them with `%s`).',
             'git stash pop')."\n";
           $api->stashChanges();
           $this->stashed = true;
         } else {
           throw new ArcanistUsageException(
             pht(
               'You can not continue with uncommitted changes. '.
               'Commit or discard them before proceeding.'));
         }
       }
     }
 
     if ($should_commit) {
       if ($this->getShouldAmend()) {
         $commit = head($api->getLocalCommitInformation());
         $api->amendCommit($commit['message']);
       } else if ($api->supportsLocalCommits()) {
         $template = sprintf(
           "\n\n# %s\n#\n# %s\n#\n",
           pht('Enter a commit message.'),
           pht('Changes:'));
 
         $paths = array_merge($uncommitted, $unstaged);
         $paths = array_unique($paths);
         sort($paths);
 
         foreach ($paths as $path) {
           $template .= "#     ".$path."\n";
         }
 
         $commit_message = $this->newInteractiveEditor($template)
           ->setName(pht('commit-message'))
           ->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->getWorkingCopyIdentity();
       foreach ($paths as $key => $path) {
         $full_path = Filesystem::resolvePath($path);
         if (!Filesystem::pathExists($full_path)) {
           throw new ArcanistUsageException(
             pht(
               "Path '%s' does not exist!",
               $path));
         }
         $relative_path = Filesystem::readablePath(
           $full_path,
           $working_copy->getProjectRoot());
         $paths[$key] = $relative_path;
       }
     } else {
       $repository_api = $this->getRepositoryAPI();
 
       if ($rev) {
         $this->parseBaseCommitArgument(array($rev));
       }
 
       $paths = $repository_api->getWorkingCopyStatus();
       foreach ($paths as $path => $flags) {
         if ($flags & $omit_mask) {
           unset($paths[$path]);
         }
       }
       $paths = array_keys($paths);
     }
 
     return array_values($paths);
   }
 
   final protected function renderRevisionList(array $revisions) {
     $list = array();
     foreach ($revisions as $revision) {
       $list[] = '     - D'.$revision['id'].': '.$revision['title']."\n";
     }
     return implode('', $list);
   }
 
 
 /* -(  Scratch Files  )------------------------------------------------------ */
 
 
   /**
    * Try to read a scratch file, if it exists and is readable.
    *
    * @param string Scratch file name.
    * @return mixed String for file contents, or false for failure.
    * @task scratch
    */
   final protected function readScratchFile($path) {
     if (!$this->repositoryAPI) {
       return false;
     }
     return $this->getRepositoryAPI()->readScratchFile($path);
   }
 
 
   /**
    * Try to read a scratch JSON file, if it exists and is readable.
    *
    * @param string Scratch file name.
    * @return array Empty array for failure.
    * @task scratch
    */
   final protected function readScratchJSONFile($path) {
     $file = $this->readScratchFile($path);
     if (!$file) {
       return array();
     }
     return phutil_json_decode($file);
   }
 
 
   /**
    * Try to write a scratch file, if there's somewhere to put it and we can
    * write there.
    *
    * @param  string Scratch file name to write.
    * @param  string Data to write.
    * @return bool   True on success, false on failure.
    * @task scratch
    */
   final protected function writeScratchFile($path, $data) {
     if (!$this->repositoryAPI) {
       return false;
     }
     return $this->getRepositoryAPI()->writeScratchFile($path, $data);
   }
 
 
   /**
    * Try to write a scratch JSON file, if there's somewhere to put it and we can
    * write there.
    *
    * @param  string Scratch file name to write.
    * @param  array Data to write.
    * @return bool   True on success, false on failure.
    * @task scratch
    */
   final protected function writeScratchJSONFile($path, array $data) {
     return $this->writeScratchFile($path, json_encode($data));
   }
 
 
   /**
    * Try to remove a scratch file.
    *
    * @param   string  Scratch file name to remove.
    * @return  bool    True if the file was removed successfully.
    * @task scratch
    */
   final protected function removeScratchFile($path) {
     if (!$this->repositoryAPI) {
       return false;
     }
     return $this->getRepositoryAPI()->removeScratchFile($path);
   }
 
 
   /**
    * Get a human-readable description of the scratch file location.
    *
    * @param string  Scratch file name.
    * @return mixed  String, or false on failure.
    * @task scratch
    */
   final protected function getReadableScratchFilePath($path) {
     if (!$this->repositoryAPI) {
       return false;
     }
     return $this->getRepositoryAPI()->getReadableScratchFilePath($path);
   }
 
 
   /**
    * Get the path to a scratch file, if possible.
    *
    * @param string  Scratch file name.
    * @return mixed  File path, or false on failure.
    * @task scratch
    */
   final protected function getScratchFilePath($path) {
     if (!$this->repositoryAPI) {
       return false;
     }
     return $this->getRepositoryAPI()->getScratchFilePath($path);
   }
 
   final protected function getRepositoryEncoding() {
     return nonempty(
       idx($this->loadProjectRepository(), 'encoding'),
       'UTF-8');
   }
 
   final protected function loadProjectRepository() {
     list($info, $reasons) = $this->loadRepositoryInformation();
     return coalesce($info, array());
   }
 
   final protected function newInteractiveEditor($text) {
     $editor = new PhutilInteractiveEditor($text);
 
     $preferred = $this->getConfigFromAnySource('editor');
     if ($preferred) {
       $editor->setPreferredEditor($preferred);
     }
 
     return $editor;
   }
 
   final protected function newDiffParser() {
     $parser = new ArcanistDiffParser();
     if ($this->repositoryAPI) {
       $parser->setRepositoryAPI($this->getRepositoryAPI());
     }
     $parser->setWriteDiffOnFailure(true);
     return $parser;
   }
 
   final protected function resolveCall(ConduitFuture $method) {
     try {
       return $method->resolve();
     } 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 {
       $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->getWorkingCopyIdentity();
     $config = $this->getConfigurationManager();
 
     if (!$engine_class) {
       $engine_class = $config->getConfigFromAnySource('lint.engine');
     }
 
     if (!$engine_class) {
       if (Filesystem::pathExists($working_copy->getProjectPath('.arclint'))) {
         $engine_class = 'ArcanistConfigurationDrivenLintEngine';
       }
     }
 
     if (!$engine_class) {
       throw new ArcanistNoEngineException(
         pht(
           "No lint engine is configured for this project. Create an '%s' ".
           "file, or configure an advanced engine with '%s' in '%s'.",
           '.arclint',
           'lint.engine',
           '.arcconfig'));
     }
 
     $base_class = 'ArcanistLintEngine';
     if (!class_exists($engine_class) ||
         !is_subclass_of($engine_class, $base_class)) {
       throw new ArcanistUsageException(
         pht(
           'Configured lint engine "%s" is not a subclass of "%s", but must be.',
           $engine_class,
           $base_class));
     }
 
     $engine = newv($engine_class, array())
       ->setWorkingCopy($working_copy)
       ->setConfigurationManager($config);
 
     return $engine;
   }
 
   /**
    * Build a new unit test engine for the current working copy.
    *
    * Optionally, you can pass an explicit engine class name to build an engine
    * of a particular class. Normally this is used to implement an `--engine`
    * flag from the CLI.
    *
    * @param string Optional explicit engine class name.
    * @return ArcanistUnitTestEngine Constructed engine.
    */
   protected function newUnitTestEngine($engine_class = null) {
     $working_copy = $this->getWorkingCopyIdentity();
     $config = $this->getConfigurationManager();
 
     if (!$engine_class) {
       $engine_class = $config->getConfigFromAnySource('unit.engine');
     }
 
     if (!$engine_class) {
       if (Filesystem::pathExists($working_copy->getProjectPath('.arcunit'))) {
         $engine_class = 'ArcanistConfigurationDrivenUnitTestEngine';
       }
     }
 
     if (!$engine_class) {
       throw new ArcanistNoEngineException(
         pht(
           "No unit test engine is configured for this project. Create an ".
           "'%s' file, or configure an advanced engine with '%s' in '%s'.",
           '.arcunit',
           'unit.engine',
           '.arcconfig'));
     }
 
     $base_class = 'ArcanistUnitTestEngine';
     if (!class_exists($engine_class) ||
         !is_subclass_of($engine_class, $base_class)) {
       throw new ArcanistUsageException(
         pht(
           'Configured unit test engine "%s" is not a subclass of "%s", '.
           'but must be.',
           $engine_class,
           $base_class));
     }
 
     $engine = newv($engine_class, array())
       ->setWorkingCopy($working_copy)
       ->setConfigurationManager($config);
 
     return $engine;
   }
 
 
   protected function openURIsInBrowser(array $uris) {
     $browser = $this->getBrowserCommand();
 
     // The "browser" may actually be a list of arguments.
     if (!is_array($browser)) {
       $browser = array($browser);
     }
 
     foreach ($uris as $uri) {
       $err = phutil_passthru('%LR %R', $browser, $uri);
       if ($err) {
         throw new ArcanistUsageException(
           pht(
             'Failed to open URI "%s" in browser ("%s"). '.
             'Check your "browser" config option.',
             $uri,
             $browser));
       }
     }
   }
 
   private function getBrowserCommand() {
     $config = $this->getConfigFromAnySource('browser');
     if ($config) {
       return $config;
     }
 
     if (phutil_is_windows()) {
       // See T13504. We now use "bypass_shell", so "start" alone is no longer
       // a valid binary to invoke directly.
       return array(
         'cmd',
         '/c',
         'start',
       );
     }
 
     $candidates = array(
       'sensible-browser' => array('sensible-browser'),
       'xdg-open' => array('xdg-open'),
       'open' => array('open', '--'),
     );
 
     // NOTE: The "open" command works well on OS X, but on many Linuxes "open"
     // exists and is not a browser. For now, we're just looking for other
     // commands first, but we might want to be smarter about selecting "open"
     // only on OS X.
 
     foreach ($candidates as $cmd => $argv) {
       if (Filesystem::binaryExists($cmd)) {
         return $argv;
       }
     }
 
     throw new ArcanistUsageException(
       pht(
         "Unable to find a browser command to run. Set '%s' in your ".
         "Arcanist config to specify a command to use.",
         'browser'));
   }
 
 
   /**
    * Ask Phabricator to update the current repository as soon as possible.
    *
    * Calling this method after pushing commits allows Phabricator to discover
    * the commits more quickly, so the system overall is more responsive.
    *
    * @return void
    */
   protected function askForRepositoryUpdate() {
     // If we know which repository we're in, try to tell Phabricator that we
     // pushed commits to it so it can update. This hint can help pull updates
     // more quickly, especially in rarely-used repositories.
     if ($this->getRepositoryPHID()) {
       try {
         $this->getConduit()->callMethodSynchronous(
           'diffusion.looksoon',
           array(
             'repositories' => array($this->getRepositoryPHID()),
           ));
       } catch (ConduitClientException $ex) {
         // If we hit an exception, just ignore it. Likely, we are running
         // against a Phabricator which is too old to support this method.
         // Since this hint is purely advisory, it doesn't matter if it has
         // no effect.
       }
     }
   }
 
   protected function getModernLintDictionary(array $map) {
     $map = $this->getModernCommonDictionary($map);
     return $map;
   }
 
   protected function getModernUnitDictionary(array $map) {
     $map = $this->getModernCommonDictionary($map);
 
     $details = idx($map, 'userData');
     if (strlen($details)) {
       $map['details'] = (string)$details;
     }
     unset($map['userData']);
 
     return $map;
   }
 
   private function getModernCommonDictionary(array $map) {
     foreach ($map as $key => $value) {
       if ($value === null) {
         unset($map[$key]);
       }
     }
     return $map;
   }
 
   final public function setConduitEngine(
     ArcanistConduitEngine $conduit_engine) {
     $this->conduitEngine = $conduit_engine;
     return $this;
   }
 
   final public function getConduitEngine() {
     return $this->conduitEngine;
   }
 
   final public function getRepositoryRef() {
     $configuration_engine = $this->getConfigurationEngine();
     if ($configuration_engine) {
       // This is a toolset workflow and can always build a repository ref.
     } else {
       if (!$this->getConfigurationManager()->getWorkingCopyIdentity()) {
         return null;
       }
 
       if (!$this->repositoryAPI) {
         return null;
       }
     }
 
     if (!$this->repositoryRef) {
       $ref = id(new ArcanistRepositoryRef())
         ->setPHID($this->getRepositoryPHID())
         ->setBrowseURI($this->getRepositoryURI());
 
       $this->repositoryRef = $ref;
     }
 
     return $this->repositoryRef;
   }
 
   final public function getToolsetKey() {
     return $this->getToolset()->getToolsetKey();
   }
 
   final public function getConfig($key) {
     return $this->getConfigurationSourceList()->getConfig($key);
   }
 
   public function canHandleSignal($signo) {
     return false;
   }
 
   public function handleSignal($signo) {
     return;
   }
 
   final public function newCommand(PhutilExecutableFuture $future) {
     return id(new ArcanistCommand())
       ->setLogEngine($this->getLogEngine())
       ->setExecutableFuture($future);
   }
 
   final public function loadHardpoints(
     $objects,
     $requests) {
-
-    if (!is_array($objects)) {
-      $objects = array($objects);
-    }
-
-    if (!is_array($requests)) {
-      $requests = array($requests);
-    }
-
-    $engine = $this->getHardpointEngine();
-
-    $requests = $engine->requestHardpoints(
-      $objects,
-      $requests);
-
-    // TODO: Wait for only the required requests.
-    $engine->waitForRequests(array());
-  }
-
-  private function getHardpointEngine() {
-    if ($this->hardpointEngine === null) {
-      $this->hardpointEngine = $this->newHardpointEngine();
-    }
-    return $this->hardpointEngine;
-  }
-
-  private function newHardpointEngine() {
-    $engine = new ArcanistHardpointEngine();
-
-    $queries = ArcanistWorkflowHardpointQuery::getAllQueries();
-
-    foreach ($queries as $key => $query) {
-      $queries[$key] = id(clone $query)
-        ->setWorkflow($this);
-    }
-
-    $engine->setQueries($queries);
-
-    return $engine;
+    return $this->getRuntime()->loadHardpoints($objects, $requests);
   }
 
   protected function newPrompts() {
     return array();
   }
 
   protected function newPrompt($key) {
     return id(new ArcanistPrompt())
       ->setWorkflow($this)
       ->setKey($key);
   }
 
   public function hasPrompt($key) {
     $map = $this->getPromptMap();
     return isset($map[$key]);
   }
 
   public function getPromptMap() {
     if ($this->promptMap === null) {
       $prompts = $this->newPrompts();
       assert_instances_of($prompts, 'ArcanistPrompt');
 
       $map = array();
       foreach ($prompts as $prompt) {
         $key = $prompt->getKey();
 
         if (isset($map[$key])) {
           throw new Exception(
             pht(
               'Workflow ("%s") generates two prompts with the same '.
               'key ("%s"). Each prompt a workflow generates must have a '.
               'unique key.',
               get_class($this),
               $key));
         }
 
         $map[$key] = $prompt;
       }
 
       $this->promptMap = $map;
     }
 
     return $this->promptMap;
   }
 
   protected function getPrompt($key) {
     $map = $this->getPromptMap();
 
     $prompt = idx($map, $key);
     if (!$prompt) {
       throw new Exception(
         pht(
           'Workflow ("%s") is requesting a prompt ("%s") but it did not '.
           'generate any prompt with that name in "newPrompts()".',
           get_class($this),
           $key));
     }
 
     return clone $prompt;
   }
 
   final protected function getSymbolEngine() {
-    if ($this->symbolEngine === null) {
-      $this->symbolEngine = $this->newSymbolEngine();
-    }
-    return $this->symbolEngine;
-  }
-
-  private function newSymbolEngine() {
-    return id(new ArcanistSymbolEngine())
-      ->setWorkflow($this);
+    return $this->getRuntime()->getSymbolEngine();
   }
 
   final protected function getViewer() {
-    if (!$this->viewer) {
-      $viewer = $this->getSymbolEngine()
-        ->loadUserForSymbol('viewer()');
-
-      // TODO: Deal with anonymous stuff.
-      if (!$viewer) {
-        throw new Exception(pht('No viewer!'));
-      }
-
-      $this->viewer = $viewer;
-    }
-
-    return $this->viewer;
+    return $this->getRuntime()->getViewer();
   }
 
 }
diff --git a/src/xsprintf/tsprintf.php b/src/xsprintf/tsprintf.php
index 0da8bb3f..8bc1d8b4 100644
--- a/src/xsprintf/tsprintf.php
+++ b/src/xsprintf/tsprintf.php
@@ -1,44 +1,61 @@
 <?php
 
 /**
  * Format text for terminal output. This function behaves like `sprintf`,
  * except that all the normal conversions (like "%s") will be properly escaped,
  * and additional conversions are supported:
  *
  *   %B (Block)
  *     Escapes text, but preserves tabs and newlines.
  *
  *   %R (Raw String)
  *     Inserts raw, unescaped text. DANGEROUS!
  *
  * Particularly, this will escape terminal control characters.
  */
 function tsprintf($pattern /* , ... */) {
   $args = func_get_args();
   $args[0] = PhutilConsoleFormatter::interpretFormat($args[0]);
   $string = xsprintf('xsprintf_terminal', null, $args);
   return new PhutilTerminalString($string);
 }
 
 /**
  * Callback for terminal encoding, see @{function:tsprintf} for use.
  */
 function xsprintf_terminal($userdata, &$pattern, &$pos, &$value, &$length) {
   $type = $pattern[$pos];
 
   switch ($type) {
     case 's':
       $value = PhutilTerminalString::escapeStringValue($value, false);
       $type = 's';
       break;
     case 'B':
       $value = PhutilTerminalString::escapeStringValue($value, true);
       $type = 's';
       break;
     case 'R':
       $type = 's';
       break;
+    case 'W':
+      $value = PhutilTerminalString::escapeStringValue($value, true);
+      $value = phutil_console_wrap($value);
+      $type = 's';
+      break;
+    case '!':
+      $value = tsprintf('<bg:yellow>** <!> %s **</bg>', $value);
+      $value = PhutilTerminalString::escapeStringValue($value, false);
+      $type = 's';
+      break;
+    default:
+      throw new Exception(
+        pht(
+          'Unsupported escape sequence "%s" found in pattern: %s',
+          $type,
+          $pattern));
+      break;
   }
 
   $pattern[$pos] = $type;
 }