diff --git a/src/parser/ArcanistBaseCommitParser.php b/src/parser/ArcanistBaseCommitParser.php
index 5d8a1fb9..215e9ee1 100644
--- a/src/parser/ArcanistBaseCommitParser.php
+++ b/src/parser/ArcanistBaseCommitParser.php
@@ -1,175 +1,176 @@
 <?php
 
 final class ArcanistBaseCommitParser {
 
   private $api;
   private $try;
   private $verbose = false;
 
   public function __construct(ArcanistRepositoryAPI $api) {
     $this->api = $api;
     return $this;
   }
 
   private function tokenizeBaseCommitSpecification($raw_spec) {
     if (!$raw_spec) {
       return array();
     }
 
     $spec = preg_split('/\s*,\s*/', $raw_spec);
     $spec = array_filter($spec);
 
     foreach ($spec as $rule) {
       if (strpos($rule, ':') === false) {
         throw new ArcanistUsageException(
           "Rule '{$rule}' is invalid, it must have a type and name like ".
           "'arc:upstream'.");
       }
     }
 
     return $spec;
   }
 
   private function log($message) {
     if ($this->verbose) {
       fwrite(STDERR, $message."\n");
     }
   }
 
   public function resolveBaseCommit(array $specs) {
     $specs += array(
       'args'    => '',
       'local'   => '',
       'project' => '',
       'global'  => '',
       'system'  => '',
     );
 
     foreach ($specs as $source => $spec) {
       $specs[$source] = self::tokenizeBaseCommitSpecification($spec);
     }
 
     $this->try = array(
       'args',
       'local',
       'project',
       'global',
       'system',
     );
 
     while ($this->try) {
       $source = head($this->try);
 
       if (!idx($specs, $source)) {
         $this->log("No rules left from source '{$source}'.");
         array_shift($this->try);
         continue;
       }
 
       $this->log("Trying rules from source '{$source}'.");
 
       $rules = &$specs[$source];
       while ($rule = array_shift($rules)) {
         $this->log("Trying rule '{$rule}'.");
 
         $commit = $this->resolveRule($rule, $source);
 
         if ($commit === false) {
           // If a rule returns false, it means to go to the next ruleset.
           break;
         } else if ($commit !== null) {
           $this->log("Resolved commit '{$commit}' from rule '{$rule}'.");
           return $commit;
         }
       }
     }
 
     return null;
   }
 
   /**
    * Handle resolving individual rules.
    */
   private function resolveRule($rule, $source) {
 
     // NOTE: Returning `null` from this method means "no match".
     // Returning `false` from this method means "stop current ruleset".
 
     list($type, $name) = explode(':', $rule, 2);
     switch ($type) {
       case 'literal':
         return $name;
       case 'git':
       case 'hg':
         return $this->api->resolveBaseCommitRule($rule, $source);
       case 'arc':
         return $this->resolveArcRule($rule, $name, $source);
       default:
         throw new ArcanistUsageException(
           "Base commit rule '{$rule}' (from source '{$source}') ".
           "is not a recognized rule.");
     }
   }
 
 
   /**
    * Handle resolving "arc:*" rules.
    */
   private function resolveArcRule($rule, $name, $source) {
     switch ($name) {
       case 'verbose':
         $this->verbose = true;
         $this->log("Enabled verbose mode.");
         break;
       case 'prompt':
         $reason = "it is what you typed when prompted.";
         $this->api->setBaseCommitExplanation($reason);
         return phutil_console_prompt('Against which commit?');
       case 'local':
       case 'global':
       case 'project':
       case 'args':
       case 'system':
         // Push the other source on top of the list.
         array_unshift($this->try, $name);
         $this->log("Switching to source '{$name}'.");
         return false;
       case 'yield':
         // Cycle this source to the end of the list.
         $this->try[] = array_shift($this->try);
         $this->log("Yielding processing of rules from '{$source}'.");
         return false;
       case 'halt':
         // Dump the whole stack.
         $this->try = array();
         $this->log("Halting all rule processing.");
         return false;
       case 'skip':
         return null;
       case 'empty':
       case 'upstream':
       case 'outgoing':
       case 'bookmark':
       case 'amended':
+      case 'this':
         return $this->api->resolveBaseCommitRule($rule, $source);
       default:
         $matches = null;
         if (preg_match('/^exec\((.*)\)$/', $name, $matches)) {
           $root = $this->api->getWorkingCopyIdentity()->getProjectRoot();
           $future = new ExecFuture($matches[1]);
           $future->setCWD($root);
           list($err, $stdout) = $future->resolve();
           if (!$err) {
             return trim($stdout);
           } else {
             return null;
           }
         }
 
         throw new ArcanistUsageException(
           "Base commit rule '{$rule}' (from source '{$source}') ".
           "is not a recognized rule.");
     }
   }
 
 }
diff --git a/src/parser/__tests__/ArcanistBundleTestCase.php b/src/parser/__tests__/ArcanistBundleTestCase.php
index 747286f1..0652e166 100644
--- a/src/parser/__tests__/ArcanistBundleTestCase.php
+++ b/src/parser/__tests__/ArcanistBundleTestCase.php
@@ -1,887 +1,891 @@
 <?php
 
 final class ArcanistBundleTestCase extends ArcanistTestCase {
 
   private function loadResource($name) {
     return Filesystem::readFile($this->getResourcePath($name));
   }
 
   private function getResourcePath($name) {
     return dirname(__FILE__).'/bundle/'.$name;
   }
 
   private function loadDiff($old, $new) {
     list($err, $stdout) = exec_manual(
       'diff --unified=65535 --label %s --label %s -- %s %s',
       'file 9999-99-99',
       'file 9999-99-99',
       $this->getResourcePath($old),
       $this->getResourcePath($new));
     $this->assertEqual(
       1,
       $err,
       "Expect `diff` to find changes between '{$old}' and '{$new}'.");
     return $stdout;
   }
 
   private function loadOneChangeBundle($old, $new) {
     $diff = $this->loadDiff($old, $new);
     return ArcanistBundle::newFromDiff($diff);
   }
 
   /**
    * Unarchive a saved git repository and apply each commit as though via
    * "arc patch", verifying that the resulting tree hash is identical to the
    * tree hash produced by the real commit.
    */
   public function testGitRepository() {
     if (phutil_is_windows()) {
       $this->assertSkipped('This test is not supported under Windows.');
     }
 
     $archive = dirname(__FILE__).'/bundle.git.tgz';
     $patches = dirname(__FILE__).'/patches/';
     $fixture = PhutilDirectoryFixture::newFromArchive($archive);
 
     chdir($fixture->getPath());
 
     list($commits) = execx(
       'git log --format=%s',
       '%H %T %s');
     $commits = explode("\n", trim($commits));
 
     // The very first commit doesn't have a meaningful parent, so don't examine
     // it.
     array_pop($commits);
 
     foreach ($commits as $commit) {
       list($commit_hash, $tree_hash, $subject) = explode(' ', $commit, 3);
       execx('git reset --hard %s --', $commit_hash);
 
-      $repository_api = new ArcanistGitAPI($fixture->getPath());
-      $repository_api->setDefaultBaseCommit();
+      $fixture_path = $fixture->getPath();
+      $working_copy = ArcanistWorkingCopyIdentity::newFromPath($fixture_path);
+
+      $repository_api = ArcanistRepositoryAPI::newAPIFromWorkingCopyIdentity(
+        $working_copy);
+      $repository_api->setBaseCommitArgumentRules('arc:this');
       $diff = $repository_api->getFullGitDiff();
 
       $parser = new ArcanistDiffParser();
       $parser->setRepositoryAPI($repository_api);
       $changes = $parser->parseDiff($diff);
 
       $this->makeChangeAssertions($commit_hash, $changes);
 
       $bundle = ArcanistBundle::newFromChanges($changes);
 
       execx('git reset --hard %s^ --', $commit_hash);
 
       $patch = $bundle->toGitPatch();
 
       $expect_path = $patches.'/'.$commit_hash.'.gitpatch';
       $expect = null;
       if (Filesystem::pathExists($expect_path)) {
         $expect = Filesystem::readFile($expect_path);
       }
 
       if ($patch === $expect) {
         $this->assertEqual($expect, $patch);
       } else {
         Filesystem::writeFile($expect_path.'.real', $patch);
         throw new Exception(
           "Expected patch and actual patch for {$commit_hash} differ. ".
           "Wrote actual patch to '{$expect_path}.real'.");
       }
 
       try {
         id(new ExecFuture('git apply --index --reject'))
           ->write($patch)
           ->resolvex();
       } catch (CommandException $ex) {
         $temp = new TempFile(substr($commit_hash, 0, 8).'.patch');
         $temp->setPreserveFile(true);
         Filesystem::writeFile($temp, $patch);
 
         PhutilConsole::getConsole()->writeErr(
           "Wrote failing patch to '%s'.\n",
           $temp);
         throw $ex;
       }
 
       execx('git commit -m %s', $subject);
       list($result_hash) = execx('git log -n1 --format=%s', '%T');
       $result_hash = trim($result_hash);
 
       $this->assertEqual(
         $tree_hash,
         $result_hash,
         "Commit {$commit_hash}: {$subject}");
     }
   }
 
   private function makeChangeAssertions($commit, array $raw_changes) {
     $changes = array();
 
     // Verify that there are no duplicate changes, and rekey the changes on
     // affected path because we don't care about the order in which the
     // changes appear.
     foreach ($raw_changes as $change) {
       $this->assertEqual(
         true,
         empty($changes[$change->getCurrentPath()]),
         "Unique Path: ".$change->getCurrentPath());
       $changes[$change->getCurrentPath()] = $change;
     }
 
     switch ($commit) {
       case '1830a13adf764b55743f7edc6066451898d8ffa4':
         // "Mark koan2 as +x and edit it."
 
         $this->assertEqual(1, count($changes));
 
         $c = $changes['koan2'];
         $this->assertEqual(
           ArcanistDiffChangeType::TYPE_CHANGE,
           $c->getType());
 
         $this->assertEqual(
           '100644',
           idx($c->getOldProperties(), 'unix:filemode'));
 
         $this->assertEqual(
           '100755',
           idx($c->getNewProperties(), 'unix:filemode'));
         break;
       case '8ecc728bcc9b482a9a91527ea471b04fc1a025cf':
         // "Move 'text' to 'executable' and mark it +x."
 
         $this->assertEqual(2, count($changes));
 
         $c = $changes['executable'];
         $this->assertEqual(
           ArcanistDiffChangeType::TYPE_MOVE_HERE,
           $c->getType());
 
         $this->assertEqual(
           '100644',
           idx($c->getOldProperties(), 'unix:filemode'));
 
         $this->assertEqual(
           '100755',
           idx($c->getNewProperties(), 'unix:filemode'));
         break;
       case '39c8e7dd3914edff087a6214f0cd996ad08e5b3d':
         // "Mark koan as +x."
         // Primarily a test against a recusive synthetic hunk construction bug.
         $this->assertEqual(1, count($changes));
 
         $c = $changes['koan'];
         $this->assertEqual(
           ArcanistDiffChangeType::TYPE_CHANGE,
           $c->getType());
 
         $this->assertEqual(
           '100644',
           idx($c->getOldProperties(), 'unix:filemode'));
 
         $this->assertEqual(
           '100755',
           idx($c->getNewProperties(), 'unix:filemode'));
         break;
       case 'c573c25d1a767d270fed504cd993e78aba936338':
         // "Copy a koan over text, editing the original koan."
         // Git doesn't really do anything meaningful with this.
 
         $this->assertEqual(2, count($changes));
 
         $c = $changes['koan'];
         $this->assertEqual(
           ArcanistDiffChangeType::TYPE_CHANGE,
           $c->getType());
 
         $c = $changes['text'];
         $this->assertEqual(
           ArcanistDiffChangeType::TYPE_CHANGE,
           $c->getType());
 
         break;
       case 'd26628e588cf7d16368845b121c6ac6c781e81d0':
         // "Copy a koan, modifying both the source and destination."
 
         $this->assertEqual(2, count($changes));
 
         $c = $changes['koan'];
         $this->assertEqual(
           ArcanistDiffChangeType::TYPE_COPY_AWAY,
           $c->getType());
 
         $c = $changes['koan2'];
         $this->assertEqual(
           ArcanistDiffChangeType::TYPE_COPY_HERE,
           $c->getType());
 
         break;
       case 'b0c9663ecda5f666f62dad245a3a7549aac5e636':
         // "Remove a koan copy."
 
         $this->assertEqual(1, count($changes));
 
         $c = $changes['koan2'];
         $this->assertEqual(
           ArcanistDiffChangeType::TYPE_DELETE,
           $c->getType());
 
         break;
       case 'b6ecdb3b4801f3028d88ba49940a558360847dbf':
         // "Copy a koan and edit the destination."
         // Git does not detect this as a copy without --find-copies-harder.
 
         $this->assertEqual(1, count($changes));
 
         $c = $changes['koan2'];
         $this->assertEqual(
           ArcanistDiffChangeType::TYPE_ADD,
           $c->getType());
 
         break;
       case '30d23787e1ecd254c884afbe37afa612f61e3904':
         // "Move and edit a koan."
 
         $this->assertEqual(2, count($changes));
 
         $c = $changes['koan2'];
         $this->assertEqual(
           ArcanistDiffChangeType::TYPE_MOVE_AWAY,
           $c->getType());
 
         $c = $changes['koan'];
         $this->assertEqual(
           ArcanistDiffChangeType::TYPE_MOVE_HERE,
           $c->getType());
 
         break;
       case 'c0ba9bfe3695f95c3f558bc5797eeba421d32483':
         // "Remove two koans."
 
         $this->assertEqual(2, count($changes));
 
         $c = $changes['koan3'];
         $this->assertEqual(
           ArcanistDiffChangeType::TYPE_DELETE,
           $c->getType());
 
         $c = $changes['koan4'];
         $this->assertEqual(
           ArcanistDiffChangeType::TYPE_DELETE,
           $c->getType());
 
         break;
       case '2658fd01d5355abe5d4c7ead3a0e7b4b3449fe77':
         // "Multicopy a koan."
 
         $this->assertEqual(3, count($changes));
 
         $c = $changes['koan'];
         $this->assertEqual(
           ArcanistDiffChangeType::TYPE_MULTICOPY,
           $c->getType());
 
         $c = $changes['koan3'];
         $this->assertEqual(
           ArcanistDiffChangeType::TYPE_COPY_HERE,
           $c->getType());
 
         $c = $changes['koan4'];
         $this->assertEqual(
           ArcanistDiffChangeType::TYPE_MOVE_HERE,
           $c->getType());
 
         break;
       case '1c5fe4e2243bb19d6b3bf15896177b13768e6eb6':
         // "Copy a koan."
         // Git does not detect this as a copy without --find-copies-harder.
 
         $this->assertEqual(1, count($changes));
 
         $c = $changes['koan'];
         $this->assertEqual(
           ArcanistDiffChangeType::TYPE_ADD,
           $c->getType());
 
         break;
       case '6d9eb65a2c2b56dee64d72f59554c1cca748dd34':
         // "Move a koan."
 
         $this->assertEqual(2, count($changes));
 
         $c = $changes['koan'];
         $this->assertEqual(
           ArcanistDiffChangeType::TYPE_MOVE_AWAY,
           $c->getType());
 
         $c = $changes['koan2'];
         $this->assertEqual(
           ArcanistDiffChangeType::TYPE_MOVE_HERE,
           $c->getType());
 
         break;
       case '141452e2a775ee86409e8779dd2eda767b4fe8ab':
         // "Add a koan."
 
         $this->assertEqual(1, count($changes));
 
         $c = $changes['koan'];
         $this->assertEqual(
           ArcanistDiffChangeType::TYPE_ADD,
           $c->getType());
 
         break;
       case '5dec8bf28557f078d1987c4e8cfb53d08310f522':
         // "Copy an image, and replace the original."
         // `image_2.png` is copied to `image.png` and then replaced.
 
         $this->assertEqual(2, count($changes));
 
         $c = $changes['image.png'];
         $this->assertEqual(
           ArcanistDiffChangeType::TYPE_COPY_HERE,
           $c->getType());
         $this->assertEqual(
           ArcanistDiffChangeType::FILE_BINARY,
           $c->getFileType());
         $this->assertEqual(
           null,
           $c->getOriginalFileData());
         $this->assertEqual(
           '8645053452b2cc2f955ef3944ac0831a',
           md5($c->getCurrentFileData()));
 
         $c = $changes['image_2.png'];
         $this->assertEqual(
           ArcanistDiffChangeType::TYPE_COPY_AWAY,
           $c->getType());
         $this->assertEqual(
           ArcanistDiffChangeType::FILE_BINARY,
           $c->getFileType());
         $this->assertEqual(
           '8645053452b2cc2f955ef3944ac0831a',
           md5($c->getOriginalFileData()));
         $this->assertEqual(
           'c9ec1b952480da09b393ba672d9b13da',
           md5($c->getCurrentFileData()));
 
         break;
       case 'fb28468d25a5fdd063aca4ca559454c998a0af51':
         // "Multicopy image."
         // `image.png` is copied to `image_2.png` and `image_3.png` and then
         // deleted. Git detects this as a move and an add.
 
         $this->assertEqual(3, count($changes));
 
         $c = $changes['image.png'];
         $this->assertEqual(
           ArcanistDiffChangeType::TYPE_MULTICOPY,
           $c->getType());
         $this->assertEqual(
           ArcanistDiffChangeType::FILE_BINARY,
           $c->getFileType());
         $this->assertEqual(
           '8645053452b2cc2f955ef3944ac0831a',
           md5($c->getOriginalFileData()));
         $this->assertEqual(
           null,
           $c->getCurrentFileData());
 
         $c = $changes['image_2.png'];
         $this->assertEqual(
           ArcanistDiffChangeType::TYPE_COPY_HERE,
           $c->getType());
         $this->assertEqual(
           ArcanistDiffChangeType::FILE_BINARY,
           $c->getFileType());
         $this->assertEqual(
           null,
           $c->getOriginalFileData());
         $this->assertEqual(
           '8645053452b2cc2f955ef3944ac0831a',
           md5($c->getCurrentFileData()));
 
         $c = $changes['image_3.png'];
         $this->assertEqual(
           ArcanistDiffChangeType::TYPE_MOVE_HERE,
           $c->getType());
         $this->assertEqual(
           ArcanistDiffChangeType::FILE_BINARY,
           $c->getFileType());
         $this->assertEqual(
           null,
           $c->getOriginalFileData());
         $this->assertEqual(
           '8645053452b2cc2f955ef3944ac0831a',
           md5($c->getCurrentFileData()));
 
         break;
       case 'df340e88d8aba12e8f2b8827f01f0cd9f35eb758':
         // "Remove binary image."
         // `image_2.png` is deleted.
 
         $this->assertEqual(1, count($changes));
 
         $c = $changes['image_2.png'];
         $this->assertEqual(
           ArcanistDiffChangeType::TYPE_DELETE,
           $c->getType());
         $this->assertEqual(
           ArcanistDiffChangeType::FILE_BINARY,
           $c->getFileType());
         $this->assertEqual(
           '8645053452b2cc2f955ef3944ac0831a',
           md5($c->getOriginalFileData()));
         $this->assertEqual(
           null,
           $c->getCurrentFileData());
 
         break;
       case '3f5c6d735e64c25a04f83be48ef184b25b5282f0':
         // "Copy binary image."
         // `image_2.png` is copied to `image.png`. Git does not detect this as
         // a copy without --find-copies-harder.
 
         $this->assertEqual(1, count($changes));
 
         $c = $changes['image.png'];
         $this->assertEqual(
           ArcanistDiffChangeType::TYPE_ADD,
           $c->getType());
         $this->assertEqual(
           ArcanistDiffChangeType::FILE_BINARY,
           $c->getFileType());
         $this->assertEqual(
           null,
           $c->getOriginalFileData());
         $this->assertEqual(
           '8645053452b2cc2f955ef3944ac0831a',
           md5($c->getCurrentFileData()));
 
         break;
       case 'b454edb3bb29890ee5b3af5ef66ce6a24d15d882':
         // "Move binary image."
         // `image.png` is moved to `image_2.png`.
 
         $this->assertEqual(2, count($changes));
 
         $c = $changes['image.png'];
         $this->assertEqual(
           ArcanistDiffChangeType::TYPE_MOVE_AWAY,
           $c->getType());
         $this->assertEqual(
           ArcanistDiffChangeType::FILE_BINARY,
           $c->getFileType());
         $this->assertEqual(
           '8645053452b2cc2f955ef3944ac0831a',
           md5($c->getOriginalFileData()));
         $this->assertEqual(
           null,
           $c->getCurrentFileData());
 
         $c = $changes['image_2.png'];
         $this->assertEqual(
           ArcanistDiffChangeType::TYPE_MOVE_HERE,
           $c->getType());
         $this->assertEqual(
           ArcanistDiffChangeType::FILE_BINARY,
           $c->getFileType());
         $this->assertEqual(
           null,
           $c->getOriginalFileData());
         $this->assertEqual(
           '8645053452b2cc2f955ef3944ac0831a',
           md5($c->getCurrentFileData()));
 
         break;
       case '5de5f3dfda1b7db2eb054e57699f05aaf1f4483e':
         // "Add a binary image."
         // `image.png` is added.
 
         $c = $changes['image.png'];
         $this->assertEqual(
           ArcanistDiffChangeType::TYPE_ADD,
           $c->getType());
         $this->assertEqual(
           ArcanistDiffChangeType::FILE_BINARY,
           $c->getFileType());
         $this->assertEqual(
           null,
           $c->getOriginalFileData());
         $this->assertEqual(
           '8645053452b2cc2f955ef3944ac0831a',
           md5($c->getCurrentFileData()));
 
         break;
       case '176a4c2c3fd88b2d598ce41a55d9c3958be9fd2d':
         // "Convert \r\n newlines to \n newlines."
       case 'a73b28e139296d23ade768f2346038318b331f94':
         // "Add text with \r\n newlines."
       case '337ccec314075a2bdb4a912ef467d35d04a713e4':
         // "Convert \n newlines to \r\n newlines.";
       case '6d5e64a4a7a6a036c53b1d087184cb2c70099f2c':
         // "Remove tabs."
       case '49395994a1a8a06287e40a3b318be4349e8e0288':
         // "Add tabs."
       case 'a5a53c424f3c2a7e85f6aee35e834c8ec5b3dbe3':
         // "Add trailing newline."
       case 'd53dc614090c6c7d6d023e170877d7f611f18f5a':
         // "Remove trailing newline."
       case 'f19fb9fa1385c01b53bdb6d8842dd154e47151ec':
         // "Edit a text file."
 
         $this->assertEqual(1, count($changes));
 
         $c = $changes['text'];
         $this->assertEqual(
           ArcanistDiffChangeType::TYPE_CHANGE,
           $c->getType());
         $this->assertEqual(
           ArcanistDiffChangeType::FILE_TEXT,
           $c->getFileType());
         break;
       case '228d7be4840313ed805c25c15bba0f7b188af3e6':
         // "Add a text file."
         // This commit is never reached because we skip the 0th commit junk.
         $this->assertEqual(true, "This is never reached.");
         break;
       default:
         throw new Exception(
           "Commit {$commit} has no change assertions!");
     }
   }
 
   public function testTrailingContext() {
     // Diffs need to generate without extra trailing context, or 'patch' will
     // choke on them.
     $this->assertEqual(
       $this->loadResource('trailing-context.diff'),
       $this->loadOneChangeBundle(
         'trailing-context.old',
         'trailing-context.new')->toUnifiedDiff());
   }
 
   public function testDisjointHunks() {
     // Diffs need to generate without overlapping hunks.
     $this->assertEqual(
       $this->loadResource('disjoint-hunks.diff'),
       $this->loadOneChangeBundle(
         'disjoint-hunks.old',
         'disjoint-hunks.new')->toUnifiedDiff());
   }
 
   public function testNonlocalTrailingNewline() {
     // Diffs without changes near the end of the file should not generate a
     // bogus, change-free hunk if the file has no trailing newline.
     $this->assertEqual(
       $this->loadResource('trailing-newline.diff'),
       $this->loadOneChangeBundle(
         'trailing-newline.old',
         'trailing-newline.new')->toUnifiedDiff());
   }
 
   public function testEncodeBase85() {
 
     $data = '';
     for ($ii = 0; $ii <= 255; $ii++) {
       $data .= chr($ii);
     }
     for ($ii = 255; $ii >= 0; $ii--) {
       $data .= chr($ii);
     }
 
     $expect = Filesystem::readFile(dirname(__FILE__).'/base85/expect1.txt');
     $expect = trim($expect);
 
     $this->assertEqual(
       $expect,
       ArcanistBundle::encodeBase85($data));
 
     // This is just a large block of random binary data, it has no special
     // significance.
 
     $data =
       "\x56\x4c\xb3\x63\xe5\x4a\x9f\x03\xa3\x4c\xdd\x5d\x85\x86\x10".
       "\x30\x3f\xc1\x28\x51\xd8\xb2\x1a\xc3\x79\x15\x85\x31\x66\xf9".
       "\x8e\xe1\x20\x8f\x12\xa1\x94\x0e\xbf\xb6\x9c\xb5\xc0\x15\x43".
       "\x3d\xad\xed\x00\x3c\x16\xfa\x76\x2f\xed\x99\x3a\x78\x3e\xd1".
       "\x91\xf8\xb0\xca\xb9\x29\xfe\xd4\x0f\x16\x70\x19\xad\xd9\x42".
       "\x15\xb4\x8f\xd6\x8f\x80\x62\xe9\x48\x77\x9f\x38\x6d\x3f\xd6".
       "\x0e\x40\x68\x68\x93\xae\x75\x6d\x7f\x75\x9c\x80\x69\x94\x22".
       "\x87\xb6\xc0\x62\x6b\xab\x49\xb8\x91\xe9\x96\xbf\x04\xc2\x50".
       "\x30\xae\xea\xc1\x70\x8e\x91\xd0\xb6\xec\x56\x14\x78\xd5\x8a".
       "\x8c\x52\xd1\x3c\xde\x65\x21\xec\x93\xab\xcf\x7e\xf5\xfd\x6d".
       "\x2d\x69\xb9\x2e\xa3\x42\x7b\x4d\xa5\xfb\x28\x6d\x74\xa3\x7b".
       "\x3a\xc5\x34\x7c\x63\xa9\xf9\x8e\x34\x14\x42\xb0\xf1\x0e\xe2".
       "\xd0\xd2\x04\x81\xff\x62\xd5\xd9\x46\x3b\x36\x88\x8a\x93\x55".
       "\x02\x2c\xff\x9f\x48\xd6\x7a\xcb\xbf\x6a\x33\xaa\x6b\x08\x4c".
       "\x96\x98\x89\x53\x56\xb4\xb3\x9b\x06\xb1\xa0\x13\x69\xfa\x6a".
       "\xa8\x0d\x6a\xda\xb2\x6f\x62\x0b\xa8\xf6\x59\x29\x46\x7d\x04".
       "\x44\xeb\x90\x6f\xd7\xc7\xb6\xca\xc5\xeb\xde\x10\x9b\xbd\xf2".
       "\x66\x8e\xd0\x0b\xda\x8c\xeb\x90\x73\x73\x33\xe7\x6f\x26\x57".
       "\x4e\xfc\x95\xe0\xfc\x62\x93\xa7\x28\xe6\x0c\x46\x73\xdd\x01".
       "\xce\x43\x9b\x4e\x16\x74\x5b\x36\x92\x5a\x66\x4c\xe3\x9e\x90".
       "\x2d\x9a\x1a\x3d\x69\x39\x67\x04\xd6\xf8\x5f\x45\xee\xbb\xd4".
       "\x63\xcf\x8c\x9b\x31\x69\x98\x1a\x98\x57\x4b\xa9\x49\xf6\x1b".
       "\x76\x28\xd7\xe3\x8f\x63\x95\x5b\x06\xe2\xa8\x66\x60\xf9\x49".
       "\x4e\x40\x53\x32\x9b\x74\x36\xc0\x56\xf4\x33\xec\x83\xd2\x2c".
       "\x69\x60\x55\x11\x3b\x4f\xd6\x0a\xf6\x04\x38\x75\xb6\xc2\x82".
       "\x4d\xfa\x83\x56\xba\x35\x42\xc3\xcb\xdc\x28\xf4\x69\x48\xa9".
       "\xe0\x51\x41\x79\x66\xfe\x61\xd1\xf2\x9f\x7b\xde\xc4\x3e\x8f".
       "\x8f\xb6\x9c\x0a\x74\xf8\x71\x03\x37\x37\x30\x8d\x2a\x6a\xc9".
       "\x51\xa1\xe2\x34\xe5\x42\xdb\x4f\x61\x4e\x16\xfc\x23\x72\x12".
       "\x46\x53\x12\x82\x3e\x44\x63\x23\x82\xaa\xab\x7e\x8d\x70\x66".
       "\xf1\x94\x86\x02\xc5\x3e\x9c\x79\x17\x1e\x9f\x13\x89\x3d\x25".
       "\x45\xc9\x3b\x1e\xa0\x1a\x03\x20\x1c\x81\x6b\xfc\xb5\xc9\xe2".
       "\xda\xb1\x87\x34\xa0\xb2\x72\x36\x68\x12\x05\x53\x7c\x68\x6b".
       "\x1e\x2a\x56\x2a\x7e\x7f\xd0\x9c\x13\xa9\xb2\x4c\xe6\x8a\x65".
       "\xd7\x67\xad\xf3\xf3\x2b\x9c\xe8\x10\x07\x8a\xe2\x20\x67\xe4".
       "\x51\x47\xc1\x22\x91\x05\x22\x39\x1a\xef\x54\xd2\x8a\x88\x55".
       "\x3f\x83\xba\x73\xd4\x95\xc7\xb8\xa2\xfd\x4d\x4e\x5d\xff\xdd".
       "\xaf\x1a\xc2\x7e\xb5\xfa\x86\x5f\x93\x38\x5d\xca\x9a\x5a\x7e".
       "\xb7\x47\xd5\x5c\x6b\xf3\x32\x03\x11\x44\xe9\x49\x12\x40\x82".
       "\x67\x7d\x2a\x5a\x61\x81\xbd\x24\xaa\xd7\x7c\xc9\xcf\xaf\xb0".
       "\x3e\xb0\x43\xcd\xce\x21\xe4\x1b\x5a\xd6\x40\xf5\x0e\x23\xef".
       "\x70\xf4\xc6\xd2\xd7\x36\xd7\x20\xda\x8d\x39\x46\xea\xfc\x78".
       "\x55\xa2\x02\xd6\x77\x21\xc8\x97\x1e\xdf\x45\xde\x93\xa7\x74".
       "\xd8\x59\x10\x24\x8a\xe8\xcd\xe9\x00\xb5\x4e\xe6\x49\xb0\xde".
       "\x14\x1a\x5d\xdd\x38\x47\xb0\xc7\x1e\xec\x7c\x76\xc9\x21\x3c".
       "\x3a\x85\x4f\x71\x97\xed\x4a\x94\x2c\x51\x48\x9c\x43\x90\x70".
       "\xe9\x0e\x84\x55\xd2\xa4\x48\xfa\xfd\x54\x12\x11\xb9\x32\xfc".
       "\x1d\x66\xe7\x42\xe3\x5e\x65\xf4\x3d\xea\x1a\x53\xe3\x7b\x4b".
       "\xee\xdb\x74\xce\x30\xd3\x04\xcb\xda\xa4\xdd\xad\x98\x3a\x76".
       "\xe8\xba\x1b\x03\x53\xed\x46\x5d\xef\xd4\x34\xc2\x8d\xef\xae".
       "\x51\x35\x0f\x4d\x40\xaa\x3a\xdb\x50\x1a\xbe\x5f\x8b\xb8\x24".
       "\x40\x19\x8f\x8a\x6b\x44\x4f\x9b\xe0\xf4\x9c\x4b\xc4\x23\x37".
       "\xf0\xb3\xe1\x58\x9d\x0e\xd9\xa9\xf7\x3e\x86\x43\x9b\x5b\x90".
       "\x3c\xc0\x20\xa0\xc5\x86\x4f\xc6\xcb\xb5\xcb\xd4\x88\xc6\x72".
       "\x57\xa7\x57\x2c\x34\x26\x91\x44\x15\xa8\xf4\x88\xca\x74\x56".
       "\x9e\x12\x6c\xdf\x52\xef\xc0\xb4\x5c\x16\xe8\xaa\xf7\xb6\xf3".
       "\x7c\xda\xcd\x42\xf9\x1c\x40\x88\x44\x68\x4f\x1b\x5a\x7b\x8f".
       "\xc3\x47\x48\xd3\xf3\xe5\xf5\x66\x35\x48\xbe\x64\xdf\xfe\x35".
       "\xf1\xc3\xe4\xa8\xfc\x86\xfb\x69\x20\xc9\xf4\x16\x96\xc1\x7a".
       "\x51\x14\x77\xa4\x6e\x13\xe8\x59\x35\x24\xf1\xe5\xfe\xe9\x98".
       "\x0d\xd1\xe8\xce\x9c\x7f\xf8\x3b\x79\x39\x3a\x1d\xa3\x77\xef".
       "\x4f\x4b\x59\x73\x03\xb3\xfe\xae\x70\x2a\x3a\xf0\x79\x9d\x7e".
       "\x9b\xaa\xb1\x18\xf9\x43\x69\xf3\x55\x46\xad\x38\xa2\xf1\xcb".
       "\xce\x37\xa9\x88\x20\x38\xea\x19\x29\x95\x8c\x75\x06\x9d\x1d".
       "\x9e\xf2\xb7\x64\x98\x21\x36\x90\x92\xf8\xb8\x89\x1e\x5c\x5d".
       "\x09\x3b\x52\xc5\x6a\x87\x7e\x46\xca\x8c\xdf\xe7\xca\xa9\x7b".
       "\x11\x63\x0f\x9e\x42\x9a\x3e\xe0\x8b\x80\x9e\x91\x76\x88\x9a".
       "\xa1\xe2\x96\xae\xfb\x18\x39\xdc\x92\x99\x34\xfd\x98\x20\xa8".
       "\x89\x61\x2c\x26\xe0\xb8\x83\xa7\xe7\x50\x42\x8f\xfc\x36\x66".
       "\x6b\x25\xc5\x6d\xb4\x31\xe1\x4d\x0f\x2e\xf8\x44\xe2\xb6\x6a".
       "\x6d\xfe\x83\x9e\x2c\x07\x2f\x15\x41\xf3\xe7\xa6\x18\x2b\x84".
       "\x7e\xeb\x43\xcc\xbb\xdb\xa9\x54\x5c\xbc\x59\x6a\xdc\x26\x2a".
       "\xf4\x59\xa7\x75\xa4\xac\xed\x73\x8f\x16\x43\x0d\x97\x10\x2c".
       "\x70\xef\x9e\xb2\xc9\xdf\xe6\xa7\x9b\x08\x79\xa3\xf7\x99\xf5".
       "\x59\xe4\xd5\x89\x10\xe5\xc9\xf7\xe7\x29\x72\x06\xc6\x54\xc3".
       "\xcd\xd0\xff\x69\xf8\xdf\x19\xf2\x66\x1c\x69\x40\xbc\x97\xf1".
       "\x49\x5e\x78\x62\x52\x46\x7f\xcf\x44\x50\x8b\x5f\xe7\xa8\xeb".
       "\xd5\x84\x24\x81\xc0\x2c\x65\xf7\x95\xbd\xf2\x8e\x43\xfb\x6a".
       "\x49\x3c\x6a\xe5\x2a\x39\xf0\xfa\x89\x59\x5f\x39\x75\xb4\x6f".
       "\x04\xf1\xe0\x2c\xcd\x77\x34\xec\x6b\x45\x16\xe3\x18\x24\x05".
       "\xb9\x68\xc1\x4e\x71\x4b\xff\x88\x18\xea\x0d\x56\x49\x55\xdf".
       "\xe5\xb0\x59\xdb\x74\x9e\x0b\x38\x03\x9f\x10\x6f\xd9\x34\x07".
       "\x44\x29\x08\xb1\xd4\x77\xc6\x84\x0d\xbb\xb5\xd5\x09\x05\x19".
       "\x01\x62\x29\x45\x52\x1d\xc6\x4f\x25\x78\x7e\xbc\xae\x07\xb3".
       "\xd4\xe0\x19\x91\x03\xd6\x8d\x2f\x00\xc9\xb2\x66\x3b\x4e\x3d".
       "\x75\xf7\x23\x9a\x3e\xa4\xd5\x7f\x75\x47\xd0\xbc\xc3\xc8\x2a".
       "\xdc\x85\x09\x6c\x0c\x90\x38\xd8\xef\xcf\xf4\x7a\x1b\xc7\x76".
       "\xe0\xdb\x81\xa8\x1b\x2b\x8d\xd4\x36\x90\x76\xde\x8a\x90\xc8".
       "\x5b\x05\x00\xeb\xb3\x20\xce\x6e\x5c\xb9\x35\x3d\x95\x3a\x79".
       "\x4a\x60\xeb\x23\x11\xfb\x90\x2d\xf6\xb7\x05\x4a\x43\x41\x79".
       "\x51\xaa\xe6\x90\x0a\x71\x87\x80\xbe\xb0\x89\x0f\xd3\x84\x19".
       "\xce\x6c\xf9\xbb\x1b\x15\x4d\x0f\x33\x65\xf7\x9e\x3a\xd9\x8c".
       "\x02\x43\xcf\xdf\xb2\x60\xc1\x4c\xe9\xa5\x3c\xaf\xfa\x41\x2d".
       "\xb9\x1f\x45\x32\xcb\x39\x2f\x94\xae\x44\x6d\x69\xc1\xc9\x57".
       "\x8c\xe5\xf4\xa4\x3a\xb6\x70\x61\xf9\xbb\x41\xdc\x78\xf0\xf7".
       "\xbf\xa8\x8e\xe3\x77\x51\xce\x25\x2f\xdf\x27\x6b\x07\x30\x9f".
       "\xce\xdb\x59\x58\xaa\xb2\x2e\xdc\x90\x92\x82\x55\xfe\x25\x36".
       "\x49\x7f\x6d\x2d\x39\x51\xef\x3d\xc8\xa3\x87\x0b\xe7\xf2\xac".
       "\x90\xa0\x1d\xd8\xc7\xea\x93\x53\x3b\x21\x84\x2e\x52\x6c\xfb".
       "\x4f\x31\xda\xd1\xea\x45\x3e\xdc\xeb\x52\x81\x8c\x2b\xf4\x2a".
       "\xbc\x01\xc4\xe7\x68\x36\x9c\xd5\x2d\xc1\x61\xcb\x9a\x5f\x18".
       "\x00\x6a\xc8\x9a\x4e\xfd\x31\x5b\xce\x90\x4e\x45\xff\x7f\xea".
       "\xb2\x26\xad\xc1\x3a\x21\xa9\xe8\x7c\x14\xae\x81\x1e\xbe\xa3".
       "\x6d\xda\x92\x1b\xeb\xf2\x69\x76\x3e\xf1\x2b\xf7\x1a\x45\xd5".
       "\xb3\x81\xb1\xbe\x80\x7f\x24\xba\x0e\xd5\x68\x34\x3f\x1a\x29".
       "\x15\x0e\xc2\x26\x62\x0c\xaa\xa9\x20\x4c\x61\x65\x49\x07\xbe".
       "\x69\xf4\xc9\xec\x2f\x1c\xfa\x59\x2e\x72\xc0\x17\xc5\x4c\xfa".
       "\xba\x2f\x64\xab\xa9\xb4\xcb\xdc\xcb\x25\x5f\xcf\x0c\x87\xcc".
       "\xf0\x36\x2b\xce\x81\x5a\x22\x85\xa0\x50\x50\x97\x8e\xda\x36".
       "\x80\x74\xb5\x1e\x02\x3f\xd7\xc8\x29\x11\xeb\x1d\x3d\x74\x9f".
       "\x26\x1a\xa4\x3d\xf9\x0e\xf0\x2d\x5c\xa9\x43\xbf\x51\x6c\x8d".
       "\xe6\x78\xe0\x67\x57\xf0\xc8\x0e\x97\x9c\x57\x23\x30\xac\x63".
       "\xdf\x46\x98\xa4\xaf\x4e\xa7\xe5\xac\x31\xbd\xeb\x6a\xa0\xb0".
       "\xe4\x94\x7e\x51\xf6\x89\x81\x3e\xab\x4f\x64\xb7\xc5\x51\x71".
       "\xcd\x74\x02\xa9\x02\x99\x5c\xab\x0e\x14\x47\x3b\x04\xc1\x9b".
       "\x59\x1a\x93\x92\x4c\x71\x20\x5f\x6e\xd3\xf3\xa7\x47\x1b\x39".
       "\x3e\x73\x69\xe2\xec\xcb\x52\xb3\x5c\x7a\x95\x25\x3f\x16\x98".
       "\x60\xa8\xa2\x5d\xc4\x5a\x67\xe4\x11\x06\x06\xf9\x7a\xb4\x14".
       "\xe0\xbc\x7b\x13\x1d\x0f\xf2\xca\x0b\xd4\xaa\x71\x35\x3e\xd6".
       "\x2e\x2e\x5d\x7b\x15\xc9\x23\x1a\xa9\x24\x31\x48\xd4\xcf\x4a".
       "\xf4\x32\x17\x9b\x1d\x4b\xfe\x49\x69\xd6\xc0\x8f\xb9\xdb\x72".
       "\x52\x2c\xe8\xf3\xc4\xfc\x46\xf5\xb8\x1b\x05\x06\xcf\xcc\x23".
       "\x34\xbf\x25\x6a\xea\x3c\xc7\x64\xd4\xd5\xb3\x67\xed\x24\x27".
       "\xd3\x67\xc1\xbd\x9f\x7b\x7d\x19\x04\x5c\xd1\x96\x7e\xa5\xc7".
       "\xbb\xb2\x84\x68\x98\x38\x11\x90\xfb\x62\x15\xfd\xe6\xb7\x24".
       "\x77\xb2\x78\xc7\x73\x91\xc9\x60\x1d\x91\x6d\x04\x2b\x41\xe9".
       "\xc9\xfa\xe4\x98\x54\x83\x9a\x6e\x76\x8c\x21\xf9\x91\x38\x1f".
       "\xdc\xfe\x13\x09\x30\xd7\x53\x63\x62\xba\xe3\x2c\x70\xd5\xfc".
       "\x78\x35\x36\x79\x5d\xb6\x0e\x35\x3d\x46\x87\xfb\xf5\x64\x1f".
       "\x3e\xfd\x2f\x1c\xbb\xed\x95\x2d\xd6\x63\xdc\xa7\x6a\x39\x8f".
       "\xbd\xcb\x79\x95\xe9\x45\xbf\xe4\x3e\x05\x55\x00\xdb\x33\x28".
       "\x3a\x6c\xe2\x35\xbb\xac\x70\x52\x2b\xac\x4e\x11\x44\x58\x16".
       "\x21\xb4\xae\x0d\x6a\xb9\xdc\x85\x5d\x90\x11\x26\x85\xdb\xc3".
       "\xf0\x38\x6f\x8a\xff\x12\xf0\xc9\x9e\xf0\xfc\xae\x94\x11\x4d".
       "\xce\x96\x29\x09\x6c\xf4\x2a\x6c\xda\x1e\x4c\x4a\xa2\x96\x5a".
       "\xef\xc6\x38\x5c\x60\xa2\x28\x13\x58\x73\x96\xde\x59\x2a\x57".
       "\x64\x6c\x14\x94\x8a\x2e\x8e\x21\x3f\xa2\x43\xde\xf6\x2d\x23".
       "\x74\x5c\xbd\x7a\x10\xdb\x17\xa8\x93\xd0\x74\x86\x9d\x33\x07".
       "\x48\xee\xac\x18\x6d\x64\x61\x7b\x61\x2b\xa4\xa2\xab\x99\x59".
       "\xbe\x19\xd7\x19\x41\x1e\x61\x87\xad\x40\x5b\x69\x8c\x32\xf5".
       "\xb6\x49\xbe\x1f\xad\xd8\x0f\x3e\xd9\x62\xac\x3a\x76\xde\x32".
       "\xa3\xb2\x41\x95\xad\x17\x23\xab\xa1\x37\x9c\xab\x73\x79\x70".
       "\xd6\x66\x0d\x6e\x4d\x8b\xa0\xac\xe3\x44\x1e\x0a\xee\xf0\x74".
       "\x64\xd8\x44\xd1\x6c\xa6\xd5\x36\x2e\xd9\x55\x6e\x90\x63\xb7".
       "\xf7\x8e\xc6\x28\xa3\x40\x00\x60\x9a\x3c\xfe\xff\x03\x30\x11".
       "\x18\x92\x2f\x5b\x23\xe1\x4e\x99\xe4\x82\xc9\x51\xe2\x15\x6a".
       "\x76\x5c\x67\xae\xa3\xa2\x9c\x85\x51\xe0\x44\x89\x63\xa5\x71".
       "\x99\xbc\x2d\x9c\xab\x9a\xfb\x20\x37\x58\xd6\x2d\x8b\x7d\x42".
       "\x13\x35\x44\x4c\x11\x97\x66\x27\x17\xac\x44\xe8\x6a\x03\x78".
       "\xa2\x88\xc6\x36\x71\x5a\x5a\x5a\x72\xa3\xe9\x72\x0c\x91\x31".
       "\xfc\xae\x7b\xa0\x75\x21\x0a\xc1\x4b\x95\xcb\xe3\xc2\xee\x03".
       "\x0f\xb8\xb2\x51\xc7\xc8\x9c\x8d\x6d\x3a\xe7\x4e\x2c\xaa\xeb".
       "\x5e\x49\x93\xe0\x8f\xa1\x54\x93\xe7\x7c\x5d\x31\xc7\x05\x00".
       "\x28\x14\x57\x47\xb3\x05\x2d\x17\x92\x28\x45\xee\x85\x3a\x59".
       "\xb6\xa6\x04\xc0\x5c\x07\x1f\xe6\x5b\x36\x53\x62\x82\x64\xd5".
       "\xb6\xf2\xf5\x67\x19\x11\xee\xd2\x70\xc5\x14\x63\xc1\x75\xe1".
       "\x24\xe5\x01\x59\x52\x7c\x88\x17\xb4\xe0\x15\xe9\x12\x05\xcd".
       "\x88\x7a\xd5\xea\x45\xc3\xbb\x65\xd4\xdd\x0d\xde\x36\x94\x98".
       "\x0d\x2c\xfb\x3c\x2f\x69\xd0\x28\xe2\x85\xd9\x27\xf3\x7a\xad".
       "\x50\x68\x96\x54\x5e\xeb\xbc\x2a\x74\xde\xf3\x4e\x8b\x27\x0a".
       "\xcf\x4c\x60\x40\xe8\xc5\x72\xab\x8c\xfd\xe9\xab\xff\x51\xe5".
       "\xd6\xea\x9e\x34\x73\xe1\xe6\xf8\x5b\xb1\x10\xf0\xf9\x2d\x23".
       "\x0e\xfe\xe5\xf4\x8d\xb6\x6d\x37\x14\xed\x54\x97\x92\x5c\x68".
       "\x40\x88\xf1\x43\x29\xef\x5e\x96\x77\xa2\xe8\x3c\xae\x7f\xb1".
       "\x99\x17\xa7\x0c\x6f\xe2\x43\x32\x9b\x14\x43\xf2\x15\x6b\x13".
       "\x10\x68\x56\x0b\xaa\x06\x2e\xc0\xf8\xde\x9e\x54\x9d\xba\xff".
       "\x76\x26\x6d\x5e\x9e\x88\x3a\x2b\x9b\x20\x43\xb9\x1a\x0e\x58".
       "\x65\xec\xdb\x9e\x97\xb8\xfb\x03\x6c\xb0\x7f\xa2\xf1\xf4\x27".
       "\x24\x21\x47\x51\x21\x40\x45\x28\x71\xf7\xa1\x6b\xbe\x0e\xc8".
       "\x3f\x9b\xda\x62\x9d\x73\xf7\x5f\x70\x6c\xba\x1e\xeb\x16\x5c".
       "\x2e\x44\x0a\x22\x02\x6c\xbe\xb9\x69\x93\xfd\xa5\x33\x26\x64".
       "\x24\x6c\xc2\x3d\x2f\xf3\xd1\x97\xde\x60\x43\x1c\x0d\x1b\x94".
       "\xb3\x48\x45\x7c\xd5\xd0\x71\x4d\xad\xbf\xa4\x0a\x22\x27\x04".
       "\x38\x84\x19\x66\x63\xf0\xf3\xfc\xb0\xf3\x1d\xea\xba\xb9\xe4".
       "\xe5\x80\xed\xe3\xf1\x78\x24\xc3\x25\x27\x71\x81\xc2\xec\x54".
       "\xed\xcc\x63\xf7\x39\xcd\x83\xdf\x32\x88\xc0\x3b\xd4\x62\xb8".
       "\xea\x34\xd8\xcf\xbc\x3a\x89\x38\x64\x60\x44\xde\xb6\x76\x59".
       "\xb1\x95\x6a\x26\x08\xf0\xf4\x71\x25\x8b\xf8\x81\xdd\x0d\x2f".
       "\x8c\xe2\x70\xc2\x96\xc2\xd8\x9b\xe4\x3f\xec\x8b\xfd\xbd\xc9".
       "\x36\x33\xb7\xbc\x59\x37\x19\x09\x30\x5e\xef\x67\xae\x67\x48".
       "\x72\x0b\xf4\x2a\x82\xff\xcb\xd7\xd9\x9d\x6d\x7c\xa6\x20\x42".
       "\x50\x2b\x0a\x2f\x45\x99\x5b\x76\x6d\x99\x39\xa9\xb6\x32\x06".
       "\x11\xf8\x19\xd1\x3f\xc0\xd6\x1f\x67\xfa\xd5\xae\x7a\x71\x8c".
       "\xbc\x3d\xb4\x5f\x5c\x81\x7c\xa1\x39\x70\x0a\x17\x24\xb7\x22".
       "\x86\x50\xd8\x1f\xc8\x6c\x59\x9a\xdc\xf0\x71\x01\xda\xd8\x53".
       "\x98\x1c\x73\x36\xf1\x09\x86\xc9\xa7\x26\x25\xc0\x03\x3e\x13".
       "\x4e\x29\xeb\xf0\x8d\xe3\x38\x03\x54\xee\x37\xfb\x51\x2e\xb4".
       "\xf6\x12\x1f\xb2\x8c\x66\x75\x00\x30\x5b\xef\x59\xf9\x63\xa9".
       "\x74\x07\x91\xe4\x9c\xb7\xc9\x89\xd9\xa9\x51\x93\xcb\xb1\xa7".
       "\x64\x08\x79\x8f\xb4\x6d\x09\xd7\xc5\xbf\x0a\xdb\x50\xe0\x1c".
       "\x83\xca\xf8\xcf\xa7\x81\xbb\x0b\xe6\xcf\x1b\x0e\x0a\xe0\xcd".
       "\x68\xe2\xde\xc4\x2d\xba\x55\xc7\xc7\x1e\x6c\x5e\xca\x9b\x20".
       "\x75\x96\x94\x92\x84\xec\xf5\x22\x25\x78\x67\xcd\xbe\x01\xfe".
       "\x53\xa5\xcc\x6a\x40\x33\x83\xa4\x7a\x44\x93\x0b\xf9\x4c\xb2".
       "\x95\xb6\x7e\x4b\xa4\xc8\x86\xfe\x8a\xf1\x77\x40\x56\x13\xc1".
       "\x31\x2c\x8c\x4a\xa8\x89\x61\x0c\x39\x33\x78\x8c\xd5\x50\x3b".
       "\x89\xc3\xd3\x80\x1c\xa7\xb6\x36\xc2\x00\x8d\x0a\x7f\xcc\xd3".
       "\x20\x74\x60\x70\x36\x7d\xda\xdc\xc4\x49\x04\xf0\xe6\x6c\xd1".
       "\xbe\xcb\xfb\xf1\xa2\xd6\xd4\xe4\x97\x3f\x35\x09\x5b\xda\x06".
       "\x6b\x6d\x86\x53\x23\x0c\x26\x51\x2a\x15\xaa\xe2\x73\xfb\xc7".
       "\x41\x54\xdc\x5d\x99\x0b\x0a\x1e\xd4\xdb\x70\xa3\x8e\xfd\x5b".
       "\xf0\xa8\x3e\x9b\xff\x57\x98\xbc\xd9\x2a\x56\xd3\x19\xf9\x0b".
       "\xd9\x67\x0f\x10\x9c\x23\xe5\x6b\x12\xc6\xb6\x4b\xd1\x0c\xe9".
       "\x45\x36\xdf\x54\x6f\xcc\xfe\xb5\xcc\xb9\xfe\xde\xc8\xb5\xc9".
       "\x04\x59\x61\x75\x1e\x72\x37\x54\xfd\xc6\xc3\x7e\x74\xae\x55".
       "\x31\x6a\xbc\x8a\xd8\x45\x91\xe2\x8d\x20\x97\x71\xe7\x55\xd6".
       "\x8a\xb8\x82\x2a\x27\x4f\xdc\x53\x89\x28\xf7\x3a\xfe\x07\xef".
       "\x60\xb2\x32\x7c\xbc\x13\xc4\x3d\xda\xd7\xfb\xb8\x61\x7d\x69".
       "\xae\x0e\x9a\x71\xd6\x00\x26\x97\xff\xdb\xe6\xbe\x45\x7a\xb5".
       "\x00\x31\xfd\x70\xcc\xd7\x34\x88\xe4\x05\x61\xf5\x72\x1d\x14".
       "\xf0\x7e\x90\xdb\x0e\xc7\xda\xd4\xf3\x99\xd4\x60\xd9\xa7\xc8".
       "\x5b\x33\x34\xb5\x23\x74\x2c\x5f\x6b\x56\x95\x9c\x1b\x2a\xac".
       "\xf9\xfe\x46\xc3\xf1\x9b\x24\x7e\x4b\xca\x25\x58\x41\x10\x63".
       "\xe8\xe7\x68\xda\xcc\xb6\x4d\x5b\x8f\xc9\xa9\x31\xeb\x5c\x2a".
       "\xcf\x9d\x89\xd5\x51\x93\x80\x30\xf4\xc9\x2c\x8c\xb8\x8c\x62".
       "\xd6\x33\xbd\x95\x9f\xfa\x19\xf2\x48\x28\x09\x73\xc9\x53\x61".
       "\x94\x3a\x62\x68\x6c\xc6\xd6\x0a\xb4\xae\x27\x96\xfb\x29\xd7".
       "\x46\x67\x11\x7a\xe8\x3a\x9a\x3f\xf4\x9a\x75\xed\x24\x67\x45".
       "\x79\xdc\x8b\x19\xf2\xef\x57\xaa\xc7\x84\xff\x9d\x2d\xc3\xa8".
       "\x85\x54\xb7\x9d\xe1\xd6\x2b\xe9\x31\x9d\x6c\xb8\x4e\x76\x50".
       "\x80\x44\x46\x8f\x5e\x7e\x20\xaa\xa0\x8a\x36\x6b\xef\xd1\x75".
       "\xf8\x3f\x20\xdd\x09\x73\xbf\xa5\xf7\xb4\x87\xb2\x44\xc0\x0f".
       "\x10\xc0\x95\x2e\x8a\x42\xfa\xc3\x49\x17\xb9\xb5\x1a\xc3\x80".
       "\x93\x0c\xd8\xe3\xcd\xa4\x38\x61\x7a\x22\x73\x8e\x32\x8f\x55".
       "\x9c\x91\x08\xd9\x65\xa9\x02\x28\xc6\x59\xc8\x51\x32\x20\x48".
       "\xea\x2c\xae\x0e\xa6\x35\x5b\xe2\x63\xf9\xf2\x9d\x5f\xe3\x45".
       "\xdc\x41\xba\xfb\x40\xcc\x8d\xde\x6c\x3d\x50\x97\x9d\x83\xa0".
       "\xda\x41\x61\xba\xaf\xf8\x74\xd2\x21\x7b\x09\xcc\x83\xe1\x08".
       "\x01\x04\x42\xce\xcb\xec\x1d\x6b\xb7\x6f\x0f\x4b\xd4\x53\x90".
       "\x55\x3b\xcf\x9f\x93\xb8\xad\xce\x5f\x13\x83\xb3\x89\x6f\x5a".
       "\x1b\xa4\xf5\x95\x4b\xb4\x22\x22\x1d\x35\xaa\xfa\xc7\x14\x8c".
       "\xcd\x50\x66\x14\x47\xff\x67\xb2\xf8\x12\x09\xb3\x8a\xe5\x7d".
       "\xb8\xc9\xe4\x89\xf7\xa4\xb5\x70\xfa\x2d\xeb\x95\x89\xec\xbb".
       "\x49\x59\xd2\xc1\x6d\x0e\x06\xe4\x5e\xd5\x13\x13\x0d\x72\x6e".
       "\xf0\x6d\xa9\xd5\xe7\x54\x68\x35\xcd\xd0\xd5\xa6\xe5\xb2\xe4".
       "\xb1\x19\xe4\xf1\xe3\x8a\x56\x4c\x3b\x3d\xb8\x03\xfe\x22\x2f".
       "\xc6\xdc\x88\x7b\xca\x5c\xc6\xdd\x17\x34\x08\x22\xf0\x17\x61".
       "\x0e\x60\x9c\xb4\x27\x57\x30\x6e\xb8\x4f\xdd\x25\x7b\xef\x9e".
       "\x8e\x88\x6b\xd8\x10\x23\xc2\x44\x53\x73\x64\x8f\x40\x22\xe1".
       "\xe8\xa2\xb0\x3f\x8a\x07\x66\xcd\x64\x4f\x9c\x1e\x89\x76\x04".
       "\x6d\xab\xc2\xbb\x16\x85\x80\x01\xa5\xb1\xe2\x12\x04\x2e\x39".
       "\x87\x8c\xee\xbc\xfb\x07\x6d\x03\x4c\x3a\xa5\x7b\x95\xd9\xd7".
       "\xd6\xee\x2b\xe9\xcb\xe6\xec\xa8\x84\x6a\x42\xf9\xb2\x25\xc8".
       "\xf3\x6a\xaa\x34\x3b\xd9\x72\xd9\x70\x81\x3b\xd4\x5e\x66\x97".
       "\x1b\xe6\x2b\x88\x71\x82\xa3\x8a\x98\xb0\x16\xd9\xbb\x97\x8b".
       "\x57\x79\x41\x56\x6e\xc2\x8f\xdf\xfa\x5b\xc7\x68\x5b\xb8\x09".
       "\x41\x31\x7c\x19\xe1\x95\x2e\x05\x4c\xac\x38\x81\xda\xb3\x8b".
       "\x3e\x1c\x79\x9a\x31\xac\x3e\x3d\x6d\xab\xf3\x5a\x5e\xc7\x6e".
       "\x8e\x39\xcd\x7b\x6f\x62\xee\xb9\x73\xdd\x82\x42\x6f\x09\xe4".
       "\xc3\xae\x92\xe8\x18\x99\xa0\x5e\xa2\x12\xf4\xe2\xe0\xe6\x95".
       "\x58\x3a\x45\xad\xfe\x23\x79\x5f\x82\xce\x95\x88\x73\xeb\x46".
       "\xc8\x00\xac\xc3\x2a\xdc\x7e\xab\x9b\xf8\xbb\x46\x5c\xa8\x46".
       "\xbc\xfd\x99\xae\x4c\xa7\x77\xeb\x7c\x58\xbf\xbb\x52\x68\x62".
       "\x3d\x0b\x79\x64\x38\x65\xa7\xcb\x7b\xe9\xb2\x33\xb5\x59\x52".
       "\x7b\x17\xb4\x02\x2b\x07\x0d\x3a\x11\x57\x92\xa5\x22\x2b\xbc".
       "\xe6\x97\x05\x12\x05\xe7\x91\xe3\xfa\xae\x15\xbe\x20\xe5\x5c".
       "\x71\x24\x80\x85\xc9\x66\xc1\x53\x5c\x8f\x08\xd4\x52\xe1\x10".
       "\xb6\xd6\x20\x08\x01\x79\x33\x9f\x1b\xbd\xa0\xab\x7c\xb1\xd9".
       "\xdc\xca\x44\x22\x49\xb7\xb7\x3d\x84\xac\x92\xf4\xfa\x0a\xc9".
       "\xc5\xb2\x42\x2b\x9a\x63\xbb\x8a\x82\x04\x2f\xf7\xe9\x30\x05".
       "\x67\x32\xd1\x41\x1a\x69\x6e\xb9\xf8\x5f\x6d\xb7\xe5\x4e\x85".
       "\x21\xfa\x16\x8a\x44\xfd\xf6\xd9\xa2\x5f\x68\x2b\xf3\xe2\x3c".
       "\x8a\x69\xd2\xc1\x38\xed\x83\xef\x0d\x53\x86\x93\x32\x23\xc6".
       "\x14\x0c\xb0\xb6\x6e\x77\xa4\x20\x0f\xb1\x6e\xe2\xce\xca\x6f".
       "\x93\x1c\x3a\x8f\xd0\xd2\x5a\x6e\x30\xd6\x8e\x5f\x4b\xa5\xef".
       "\xa9\x62\xeb\x28\xa0\x5e\x3f\xc1\xbc\x0a\x68\xab\xd7\xfa\xa2".
       "\xb7\x8f\x12\xb0\x99\xbc\x93\x20\xb8\x95\x8d\xca\xc7\xa7\xd9".
       "\x2e\x19\xac\x06\xb9\x4e\x56\x8e\x74\xef\x2a\x04\xd8\x75\x04".
       "\x38\x2a\xc7\xa0\xa4\x89\xf3\xa4\x8a\xd4\x2c\x2c\x58\x6f\x00".
       "\x03\x23\xb8\xaf\x02\x48\x7d\x50\x46\x6f\x5a\x08\x41\xe3\x56".
       "\x6d\xcb\xe2\x4f\xea\x8e\xab\x74\xcd\xf9\xef\xcf\xf9\x1e\xf1".
       "\xf8\xb9\x6c\xaa\x3b\x37\xd1\x21\x42\x67\xec\xd6\x44\x55\x33".
       "\xe8\x1d\xa4\x18\xf3\x73\x82\xb4\x50\x59\xc2\x34\x36\x05\xeb";
 
     $expect = Filesystem::readFile(dirname(__FILE__).'/base85/expect2.txt');
     $expect = trim($expect);
 
     $this->assertEqual(
       $expect,
       ArcanistBundle::encodeBase85($data));
   }
 
 }
diff --git a/src/repository/api/ArcanistGitAPI.php b/src/repository/api/ArcanistGitAPI.php
index f3de6260..87673012 100644
--- a/src/repository/api/ArcanistGitAPI.php
+++ b/src/repository/api/ArcanistGitAPI.php
@@ -1,998 +1,998 @@
 <?php
 
 /**
  * Interfaces with Git working copies.
  *
  * @group workingcopy
  */
 final class ArcanistGitAPI extends ArcanistRepositoryAPI {
 
   private $relativeCommit = null;
   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';
 
   public static function newHookAPI($root) {
     return new ArcanistGitAPI($root);
   }
 
   protected function buildLocalFuture(array $argv) {
 
     $argv[0] = 'git '.$argv[0];
 
     $future = newv('ExecFuture', $argv);
     $future->setCWD($this->getPath());
     return $future;
   }
 
 
   public function getSourceControlSystemName() {
     return 'git';
   }
 
   public function getMetadataPath() {
     return $this->getPath('.git');
   }
 
   public function getHasCommits() {
     return !$this->repositoryHasNoCommits;
   }
 
   public function setRelativeCommit($relative_commit) {
     $this->relativeCommit = $relative_commit;
     return $this;
   }
 
   public function getLocalCommitInformation() {
     if ($this->repositoryHasNoCommits) {
       // Zero commits.
       throw new Exception(
         "You can't get local commit information for a repository with no ".
         "commits.");
     } else if ($this->relativeCommit == 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 relative 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.
 
       $against = csprintf('%s --not %s', 'HEAD', $this->getRelativeCommit());
     }
 
     // NOTE: Windows escaping of "%" symbols apparently is inherently broken;
     // when passed throuhgh 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%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, $title, $message)
         = explode("\1", trim($line), 7);
       $message = rtrim($message);
 
       $commits[$commit] = array(
         'commit'  => $commit,
         'tree'    => $tree,
         'parents' => array_filter(explode(' ', $parents)),
         'time'    => $time,
         'author'  => $author,
         'summary' => $title,
         'message' => $message,
       );
     }
 
     return $commits;
   }
 
   public function getRelativeCommit() {
     if ($this->relativeCommit === null) {
 
       // 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;
         }
 
         $this->relativeCommit = self::GIT_MAGIC_ROOT_COMMIT;
 
         if ($this->repositoryHasNoCommits) {
           $this->setBaseCommitExplanation(
             "the repository has no commits.");
         } else {
           $this->setBaseCommitExplanation(
             "the repository has only one commit.");
         }
 
         return $this->relativeCommit;
       }
 
       if ($this->getBaseCommitArgumentRules() ||
           $this->getWorkingCopyIdentity()->getConfigFromAnySource('base')) {
         $base = $this->resolveBaseCommit();
         if (!$base) {
           throw new ArcanistUsageException(
             "None of the rules in your 'base' configuration matched a valid ".
             "commit. Adjust rules or specify which commit you want to use ".
             "explicitly.");
         }
         $this->relativeCommit = $base;
         return $this->relativeCommit;
       }
 
       $do_write = false;
       $default_relative = null;
       $working_copy = $this->getWorkingCopyIdentity();
       if ($working_copy) {
         $default_relative = $working_copy->getConfig(
           'git.default-relative-commit');
         $this->setBaseCommitExplanation(
           "it is the merge-base of '{$default_relative}' and HEAD, as ".
           "specified in 'git.default-relative-commit' in '.arcconfig'. This ".
           "setting overrides other settings.");
       }
 
       if (!$default_relative) {
         list($err, $upstream) = $this->execManualLocal(
           "rev-parse --abbrev-ref --symbolic-full-name '@{upstream}'");
 
         if (!$err) {
           $default_relative = trim($upstream);
           $this->setBaseCommitExplanation(
             "it is the merge-base of '{$default_relative}' (the Git upstream ".
             "of the current branch) HEAD.");
         }
       }
 
       if (!$default_relative) {
         $default_relative = $this->readScratchFile('default-relative-commit');
         $default_relative = trim($default_relative);
         if ($default_relative) {
           $this->setBaseCommitExplanation(
             "it is the merge-base of '{$default_relative}' and HEAD, as ".
             "specified in '.git/arc/default-relative-commit'.");
         }
       }
 
       if (!$default_relative) {
 
         // TODO: Remove the history lesson soon.
 
         echo phutil_console_format(
           "<bg:green>** Select a Default Commit Range **</bg>\n\n");
         echo phutil_console_wrap(
           "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 'HEAD^' when you did not specify ".
           "a start revision, but this behavior does not make much sense in ".
           "most workflows outside of Facebook's historic git-svn workflow.\n\n".
           "arc no longer assumes 'HEAD^'. You must specify a relative commit ".
           "explicitly when you invoke a command (e.g., `arc diff HEAD^`, not ".
           "just `arc diff`) or select a default for this working copy.\n\n".
           "In most cases, the best default is 'origin/master'. You can also ".
           "select 'HEAD^' 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.)");
 
         $prompt = "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(
           "Relative commit '{$default_relative}' is not the name of a commit!");
       }
 
       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(
           "it is the merge-base of '{$default_relative}' and HEAD, as you ".
           "just specified.");
       }
 
       list($merge_base) = $this->execxLocal(
         'merge-base %s HEAD',
         $default_relative);
 
       $this->relativeCommit = trim($merge_base);
     }
 
     return $this->relativeCommit;
   }
 
   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',
     );
     return implode(' ', $options);
   }
 
   public function getFullGitDiff() {
     $options = $this->getDiffFullOptions();
     list($stdout) = $this->execxLocal(
       "diff {$options} %s --",
       $this->getRelativeCommit());
     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->getRelativeCommit(),
       $path);
     return $stdout;
   }
 
   public function getBranchName() {
     // TODO: consider:
     //
     //    $ git rev-parse --abbrev-ref `git symbolic-ref HEAD`
     //
     // But that may fail if you're not on a branch.
     list($stdout) = $this->execxLocal('branch --no-color');
 
     // Assume that any branch beginning with '(' means 'no branch', or whatever
     // 'no branch' is in the current locale.
     $matches = null;
     if (preg_match('/^\* ([^\(].*)$/m', $stdout, $matches)) {
       return $matches[1];
     }
     return null;
   }
 
   public function getSourceControlPath() {
     // TODO: Try to get something useful here.
     return null;
   }
 
   public function getGitCommitLog() {
     $relative = $this->getRelativeCommit();
     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..HEAD',
         $this->getRelativeCommit());
     }
     return $stdout;
   }
 
   public function getGitHistoryLog() {
     list($stdout) = $this->execxLocal(
       'log --format=medium -n%d %s',
       self::SEARCH_LENGTH_FOR_PARENT_REVISIONS,
       $this->getRelativeCommit());
     return $stdout;
   }
 
   public function getSourceControlBaseRevision() {
     list($stdout) = $this->execxLocal(
       'rev-parse %s',
       $this->getRelativeCommit());
     return rtrim($stdout, "\n");
   }
 
   public function getCanonicalRevisionName($string) {
     $match = null;
     if (preg_match('/@([0-9]+)$/', $string, $match)) {
       list($stdout) = $this->execxLocal(
         'svn find-rev r%d',
         $match[1]);
     } else {
       list($stdout) = $this->execxLocal(
         'show -s --format=%C %s',
         '%H',
         $string);
     }
     return rtrim($stdout);
   }
 
   protected function buildUncommittedStatus() {
     $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',
       ));
 
     // TODO: This doesn't list unstaged adds. It's not clear how to get that
     // list other than "git status --porcelain" and then parsing it. :/
 
     // Unstaged changes
     $unstaged_future = $this->buildLocalFuture(
       array(
         'ls-files -m',
       ));
 
     $futures = array(
       $uncommitted_future,
       $untracked_future,
       $unstaged_future,
     );
 
     Futures($futures)->resolveAll();
 
     $result = new PhutilArrayWithDefaultValue();
 
     list($stdout) = $uncommitted_future->resolvex();
     $uncommitted_files = $this->parseGitStatus($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 --',
       $this->getDiffBaseOptions(),
       $this->getRelativeCommit());
 
     return $this->parseGitStatus($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 -- %Ls',
       $paths);
   }
 
   public function doCommit($message) {
     $tmp_file = new TempFile();
     Filesystem::writeFile($tmp_file, $message);
     $this->execxLocal(
       'commit --allow-empty-message -F %s',
       $tmp_file);
 
     $this->reloadWorkingCopy();
 
     return $this;
   }
 
   public function amendCommit($message) {
     $tmp_file = new TempFile();
     Filesystem::writeFile($tmp_file, $message);
     $this->execxLocal(
       'commit --amend --allow-empty -F %s',
       $tmp_file);
   }
 
   public function getPreReceiveHookStatus($old_ref, $new_ref) {
     $options = $this->getDiffBaseOptions();
     list($stdout) = $this->execxLocal(
       "diff {$options} --raw %s %s --",
       $old_ref,
       $new_ref);
     return $this->parseGitStatus($stdout, $full = true);
   }
 
   private function parseGitStatus($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;
       $flag = $line[4];
       $file = $line[5];
       foreach ($flags as $key => $bits) {
         if ($flag == $key) {
           $mask |= $bits;
         }
       }
       if ($full) {
         $files[$file] = array(
           'mask' => $mask,
           'ref'  => rtrim($line[3], '.'),
         );
       } 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->parseGitStatus($stdout);
   }
 
   public function getBlame($path) {
     // TODO: 'git blame' supports --porcelain and we should probably use it.
     list($stdout) = $this->execxLocal(
       'blame --date=iso -w -M %s -- %s',
       $this->getRelativeCommit(),
       $path);
 
     $blame = array();
     foreach (explode("\n", trim($stdout)) as $line) {
       if (!strlen($line)) {
         continue;
       }
 
       // lines predating a git repo's history are blamed to the oldest revision,
       // with the commit hash prepended by a ^. we shouldn't count these lines
       // as blaming to the oldest diff's unfortunate author
       if ($line[0] == '^') {
         continue;
       }
 
       $matches = null;
       $ok = preg_match(
         '/^([0-9a-f]+)[^(]+?[(](.*?) +\d\d\d\d-\d\d-\d\d/',
         $line,
         $matches);
       if (!$ok) {
         throw new Exception("Bad blame? `{$line}'");
       }
       $revision = $matches[1];
       $author = $matches[2];
 
       $blame[] = array($author, $revision);
     }
 
     return $blame;
   }
 
   public function getOriginalFileData($path) {
     return $this->getFileDataAtRevision($path, $this->getRelativeCommit());
   }
 
   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) ([a-z0-9]{40})[\t](.*)$/',
         $line,
         $matches);
       if (!$ok) {
         throw new Exception("Failed to parse git ls-tree output!");
       }
       $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.
 
     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() {
     list($branch_info) = $this->execxLocal(
       'branch --no-color');
     $lines = explode("\n", rtrim($branch_info));
 
     $result = array();
     foreach ($lines as $line) {
 
       if (preg_match('/^[* ]+\(no branch\)/', $line)) {
         // This is indicating that the working copy is in a detached state;
         // just ignore it.
         continue;
       }
 
       list($current, $name) = preg_split('/\s+/', $line, 2);
       $result[] = array(
         'current' => !empty($current),
         'name'    => $name,
       );
     }
 
     return $result;
   }
 
   public function getWorkingCopyRevision() {
     list($stdout) = $this->execxLocal('rev-parse HEAD');
     return rtrim($stdout, "\n");
   }
 
   public function getUnderlyingWorkingCopyRevision() {
     list($err, $stdout) = $this->execManualLocal('svn find-rev HEAD');
     if (!$err && $stdout) {
       return rtrim($stdout, "\n");
     }
     return $this->getWorkingCopyRevision();
   }
 
   public function isHistoryDefaultImmutable() {
     return false;
   }
 
   public function supportsAmend() {
     return true;
   }
 
   public function supportsRelativeLocalCommits() {
     return true;
   }
 
-  public function setDefaultBaseCommit() {
-    $this->setRelativeCommit('HEAD^');
-    return $this;
-  }
-
   public function hasLocalCommit($commit) {
     try {
       if (!$this->getCanonicalRevisionName($commit)) {
         return false;
       }
     } catch (CommandException $exception) {
       return false;
     }
     return true;
   }
 
   public function parseRelativeLocalCommit(array $argv) {
     if (count($argv) == 0) {
       return;
     }
     if (count($argv) != 1) {
       throw new ArcanistUsageException("Specify only one commit.");
     }
     $base = reset($argv);
     if ($base == ArcanistGitAPI::GIT_MAGIC_ROOT_COMMIT) {
       $merge_base = $base;
       $this->setBaseCommitExplanation(
         "you explicitly specified the empty tree.");
     } else {
       list($err, $merge_base) = $this->execManualLocal(
         'merge-base %s HEAD',
         $base);
       if ($err) {
         throw new ArcanistUsageException(
           "Unable to find any git commit named '{$base}' in this repository.");
       }
       $this->setBaseCommitExplanation(
         "it is the merge-base of '{$base}' and HEAD, as you explicitly ".
         "specified.");
     }
     $this->setRelativeCommit(trim($merge_base));
   }
 
   public function getAllLocalChanges() {
     $diff = $this->getFullGitDiff();
     if (!strlen(trim($diff))) {
       return array();
     }
     $parser = new ArcanistDiffParser();
     return $parser->parseDiff($diff);
   }
 
   public function supportsLocalBranchMerge() {
     return true;
   }
 
   public function performLocalBranchMerge($branch, $message) {
     if (!$branch) {
       throw new ArcanistUsageException(
         "Under git, you must specify the branch you want to merge.");
     }
     $err = phutil_passthru(
       '(cd %s && git merge --no-ff -m %s %s)',
       $this->getPath(),
       $message,
       $branch);
 
     if ($err) {
       throw new ArcanistUsageException("Merge failed!");
     }
   }
 
   public function getFinalizedRevisionMessage() {
     return "You may now push this commit upstream, as appropriate (e.g. with ".
            "'git push', or 'git svn dcommit', or by printing and faxing it).";
   }
 
   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'] =
           "Commit message for '{$hash}' has explicit 'Differential Revision'.";
       }
 
       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'] =
         "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');
   }
 
   public function getCommitSummary($commit) {
     if ($commit == self::GIT_MAGIC_ROOT_COMMIT) {
       return '(The Empty Tree)';
     }
 
     list($summary) = $this->execxLocal(
       'log -n 1 --format=%C %s',
       '%s',
       $commit);
 
     return trim($summary);
   }
 
   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(
               "it is the merge-base of '{$matches[1]}' and HEAD, as ".
               "specified by '{$rule}' in your {$source} 'base' ".
               "configuration.");
             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;
           foreach ($commits as $commit) {
             list($branches) = $this->execxLocal(
               'branch --contains %s',
               $commit);
             $branches = array_filter(explode("\n", $branches));
             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) {
               foreach ($branches as $key => $branch) {
                 $branches[$key] = trim($branch, ' *');
               }
               $branches = implode(', ', $branches);
               $this->setBaseCommitExplanation(
                 "it is the first commit between '{$merge_base}' (the ".
                 "merge-base of '{$matches[1]}' and HEAD) which is also ".
                 "contained by another branch ({$branches}).");
               return $commit;
             }
           }
         } else {
           list($err) = $this->execManualLocal(
             'cat-file -t %s',
             $name);
           if (!$err) {
             $this->setBaseCommitExplanation(
               "it is specified by '{$rule}' in your {$source} 'base' ".
               "configuration.");
             return $name;
           }
         }
         break;
       case 'arc':
         switch ($name) {
           case 'empty':
             $this->setBaseCommitExplanation(
               "you specified '{$rule}' in your {$source} 'base' ".
               "configuration.");
             return self::GIT_MAGIC_ROOT_COMMIT;
           case 'amended':
             $text = $this->getCommitMessage('HEAD');
             $message = ArcanistDifferentialCommitMessage::newFromRawCorpus(
               $text);
             if ($message->getRevisionID()) {
               $this->setBaseCommitExplanation(
                 "HEAD has been amended with 'Differential Revision:', ".
                 "as specified by '{$rule}' in your {$source} 'base' ".
                 "configuration.");
               return 'HEAD^';
             }
             break;
           case 'upstream':
             list($err, $upstream) = $this->execManualLocal(
               "rev-parse --abbrev-ref --symbolic-full-name '@{upstream}'");
             if (!$err) {
               list($upstream_merge_base) = $this->execxLocal(
                 'merge-base %s HEAD',
                 $upstream);
               $this->setBaseCommitExplanation(
                 "it is the merge-base of the upstream of the current branch ".
                 "and HEAD, and matched the rule '{$rule}' in your {$source} ".
                 "'base' configuration.");
               return $upstream_merge_base;
             }
             break;
+          case 'this':
+            $this->setBaseCommitExplanation(
+              "you specified '{$rule}' in your {$source} 'base' ".
+              "configuration.");
+            return 'HEAD^';
         }
       default:
         return null;
     }
 
     return null;
   }
 
 }
diff --git a/src/repository/api/ArcanistMercurialAPI.php b/src/repository/api/ArcanistMercurialAPI.php
index 50e28014..ecadd58d 100644
--- a/src/repository/api/ArcanistMercurialAPI.php
+++ b/src/repository/api/ArcanistMercurialAPI.php
@@ -1,872 +1,873 @@
 <?php
 
 /**
  * Interfaces with the Mercurial working copies.
  *
  * @group workingcopy
  */
 final class ArcanistMercurialAPI extends ArcanistRepositoryAPI {
 
   private $base;
   private $relativeCommit;
   private $branch;
   private $workingCopyRevision;
   private $localCommitInfo;
   private $includeDirectoryStateInDiffs;
   private $rawDiffCache = array();
 
   protected function buildLocalFuture(array $argv) {
 
     // Mercurial has a "defaults" feature which basically breaks automation by
     // allowing the user to add random flags to any command. This feature is
     // "deprecated" and "a bad idea" that you should "forget ... existed"
     // according to project lead Matt Mackall:
     //
     //  http://markmail.org/message/hl3d6eprubmkkqh5
     //
     // There is an HGPLAIN environmental variable which enables "plain mode"
     // and hopefully disables this stuff.
 
     if (phutil_is_windows()) {
       $argv[0] = 'set HGPLAIN=1 & hg '.$argv[0];
     } else {
       $argv[0] = 'HGPLAIN=1 hg '.$argv[0];
     }
 
     $future = newv('ExecFuture', $argv);
     $future->setCWD($this->getPath());
     return $future;
   }
 
   public function execPassthru($pattern /* , ... */) {
     $args = func_get_args();
     if (phutil_is_windows()) {
       $args[0] = 'set HGPLAIN=1 & hg '.$args[0];
     } else {
       $args[0] = 'HGPLAIN=1 hg '.$args[0];
     }
 
     return call_user_func_array("phutil_passthru", $args);
   }
 
   public function getSourceControlSystemName() {
     return 'hg';
   }
 
   public function getMetadataPath() {
     return $this->getPath('.hg');
   }
 
   public function getSourceControlBaseRevision() {
     return $this->getCanonicalRevisionName($this->getRelativeCommit());
   }
 
   public function getCanonicalRevisionName($string) {
     list($stdout) = $this->execxLocal(
       'log -l 1 --template %s -r %s --',
       '{node}',
       $string);
     return $stdout;
   }
 
   public function getSourceControlPath() {
     return '/';
   }
 
   public function getBranchName() {
     if (!$this->branch) {
       list($stdout) = $this->execxLocal('branch');
       $this->branch = trim($stdout);
     }
     return $this->branch;
   }
 
   public function setRelativeCommit($commit) {
     try {
       $commit = $this->getCanonicalRevisionName($commit);
     } catch (Exception $ex) {
       throw new ArcanistUsageException(
         "Commit '{$commit}' is not a valid Mercurial commit identifier.");
     }
 
     $this->relativeCommit = $commit;
     $this->status = null;
     $this->localCommitInfo = null;
 
     return $this;
   }
 
   public function getRelativeCommit() {
     if (empty($this->relativeCommit)) {
 
       if ($this->getBaseCommitArgumentRules() ||
           $this->getWorkingCopyIdentity()->getConfigFromAnySource('base')) {
         $base = $this->resolveBaseCommit();
         if (!$base) {
           throw new ArcanistUsageException(
             "None of the rules in your 'base' configuration matched a valid ".
             "commit. Adjust rules or specify which commit you want to use ".
             "explicitly.");
         }
         $this->relativeCommit = $base;
         return $this->relativeCommit;
       }
 
       list($err, $stdout) = $this->execManualLocal(
         'outgoing --branch %s --style default',
         $this->getBranchName());
 
       if (!$err) {
         $logs = ArcanistMercurialParser::parseMercurialLog($stdout);
       } else {
         // Mercurial (in some versions?) raises an error when there's nothing
         // outgoing.
         $logs = array();
       }
 
       if (!$logs) {
 
         $this->setBaseCommitExplanation(
           "you have no outgoing commits, so arc assumes you intend to submit ".
           "uncommitted changes in the working copy.");
         // In Mercurial, we support operations against uncommitted changes.
         $this->setRelativeCommit($this->getWorkingCopyRevision());
         return $this->relativeCommit;
       }
 
       $outgoing_revs = ipull($logs, 'rev');
 
       // This is essentially an implementation of a theoretical `hg merge-base`
       // command.
       $against = $this->getWorkingCopyRevision();
       while (true) {
         // NOTE: The "^" and "~" syntaxes were only added in hg 1.9, which is
         // new as of July 2011, so do this in a compatible way. Also, "hg log"
         // and "hg outgoing" don't necessarily show parents (even if given an
         // explicit template consisting of just the parents token) so we need
         // to separately execute "hg parents".
 
         list($stdout) = $this->execxLocal(
           'parents --style default --rev %s',
           $against);
         $parents_logs = ArcanistMercurialParser::parseMercurialLog($stdout);
 
         list($p1, $p2) = array_merge($parents_logs, array(null, null));
 
         if ($p1 && !in_array($p1['rev'], $outgoing_revs)) {
           $against = $p1['rev'];
           break;
         } else if ($p2 && !in_array($p2['rev'], $outgoing_revs)) {
           $against = $p2['rev'];
           break;
         } else if ($p1) {
           $against = $p1['rev'];
         } else {
           // This is the case where you have a new repository and the entire
           // thing is outgoing; Mercurial literally accepts "--rev null" as
           // meaning "diff against the empty state".
           $against = 'null';
           break;
         }
       }
 
       if ($against == 'null') {
         $this->setBaseCommitExplanation(
           "this is a new repository (all changes are outgoing).");
       } else {
         $this->setBaseCommitExplanation(
           "it is the first commit reachable from the working copy state ".
           "which is not outgoing.");
       }
 
       $this->setRelativeCommit($against);
     }
     return $this->relativeCommit;
   }
 
   public function getLocalCommitInformation() {
     if ($this->localCommitInfo === null) {
       list($info) = $this->execxLocal(
         "log --template '%C' --rev %s --branch %s --",
         "{node}\1{rev}\1{author}\1{date|rfc822date}\1".
           "{branch}\1{tag}\1{parents}\1{desc}\2",
         '(ancestors(.) - ancestors('.$this->getRelativeCommit().'))',
         $this->getBranchName());
       $logs = array_filter(explode("\2", $info));
 
       $last_node = null;
 
       $futures = array();
 
       $commits = array();
       foreach ($logs as $log) {
         list($node, $rev, $author, $date, $branch, $tag, $parents, $desc) =
           explode("\1", $log);
 
         // NOTE: If a commit has only one parent, {parents} returns empty.
         // If it has two parents, {parents} returns revs and short hashes, not
         // full hashes. Try to avoid making calls to "hg parents" because it's
         // relatively expensive.
         $commit_parents = null;
         if (!$parents) {
           if ($last_node) {
             $commit_parents = array($last_node);
           }
         }
 
         if (!$commit_parents) {
           // We didn't get a cheap hit on previous commit, so do the full-cost
           // "hg parents" call. We can run these in parallel, at least.
           $futures[$node] = $this->execFutureLocal(
             "parents --template='{node}\\n' --rev %s",
             $node);
         }
 
         $commits[$node] = array(
           'author'  => $author,
           'time'    => strtotime($date),
           'branch'  => $branch,
           'tag'     => $tag,
           'commit'  => $node,
           'rev'     => $node, // TODO: Remove eventually.
           'local'   => $rev,
           'parents' => $commit_parents,
           'summary' => head(explode("\n", $desc)),
           'message' => $desc,
         );
 
         $last_node = $node;
       }
 
       foreach (Futures($futures)->limit(4) as $node => $future) {
         list($parents) = $future->resolvex();
         $parents = array_filter(explode("\n", $parents));
         $commits[$node]['parents'] = $parents;
       }
 
       // Put commits in newest-first order, to be consistent with Git and the
       // expected order of "hg log" and "git log" under normal circumstances.
       // The order of ancestors() is oldest-first.
       $commits = array_reverse($commits);
 
       $this->localCommitInfo = $commits;
     }
 
     return $this->localCommitInfo;
   }
 
   public function getAllFiles() {
     // TODO: Handle paths with newlines.
     $future = $this->buildLocalFuture(array('manifest'));
     return new LinesOfALargeExecFuture($future);
   }
 
   public function getChangedFiles($since_commit) {
     list($stdout) = $this->execxLocal(
       'status --rev %s',
       $since_commit);
     return ArcanistMercurialParser::parseMercurialStatus($stdout);
   }
 
   public function getBlame($path) {
     list($stdout) = $this->execxLocal(
       'annotate -u -v -c --rev %s -- %s',
       $this->getRelativeCommit(),
       $path);
 
     $blame = array();
     foreach (explode("\n", trim($stdout)) as $line) {
       if (!strlen($line)) {
         continue;
       }
 
       $matches = null;
       $ok = preg_match('/^\s*([^:]+?) [a-f0-9]{12}: (.*)$/', $line, $matches);
 
       if (!$ok) {
         throw new Exception("Unable to parse Mercurial blame line: {$line}");
       }
 
       $revision = $matches[2];
       $author = trim($matches[1]);
       $blame[] = array($author, $revision);
     }
 
     return $blame;
   }
 
   protected function buildUncommittedStatus() {
     list($stdout) = $this->execxLocal('status');
 
     $results = new PhutilArrayWithDefaultValue();
 
     $working_status = ArcanistMercurialParser::parseMercurialStatus($stdout);
     foreach ($working_status as $path => $mask) {
       if (!($mask & ArcanistRepositoryAPI::FLAG_UNTRACKED)) {
         // Mark tracked files as uncommitted.
         $mask |= self::FLAG_UNCOMMITTED;
       }
 
       $results[$path] |= $mask;
     }
 
     return $results->toArray();
   }
 
   protected function buildCommitRangeStatus() {
     // TODO: Possibly we should use "hg status --rev X --rev ." for this
     // instead, but we must run "hg diff" later anyway in most cases, so
     // building and caching it shouldn't hurt us.
 
     $diff = $this->getFullMercurialDiff();
     if (!$diff) {
       return array();
     }
 
     $parser = new ArcanistDiffParser();
     $changes = $parser->parseDiff($diff);
 
     $status_map = array();
     foreach ($changes as $change) {
       $flags = 0;
       switch ($change->getType()) {
         case ArcanistDiffChangeType::TYPE_ADD:
         case ArcanistDiffChangeType::TYPE_MOVE_HERE:
         case ArcanistDiffChangeType::TYPE_COPY_HERE:
           $flags |= self::FLAG_ADDED;
           break;
         case ArcanistDiffChangeType::TYPE_CHANGE:
         case ArcanistDiffChangeType::TYPE_COPY_AWAY: // Check for changes?
           $flags |= self::FLAG_MODIFIED;
           break;
         case ArcanistDiffChangeType::TYPE_DELETE:
         case ArcanistDiffChangeType::TYPE_MOVE_AWAY:
         case ArcanistDiffChangeType::TYPE_MULTICOPY:
           $flags |= self::FLAG_DELETED;
           break;
       }
       $status_map[$change->getCurrentPath()] = $flags;
     }
 
     return $status_map;
   }
 
   protected function didReloadWorkingCopy() {
     // Diffs are against ".", so we need to drop the cache if we change the
     // working copy.
     $this->rawDiffCache = array();
   }
 
   private function getDiffOptions() {
     $options = array(
       '--git',
       '-U'.$this->getDiffLinesOfContext(),
     );
     return implode(' ', $options);
   }
 
   public function getRawDiffText($path) {
     $options = $this->getDiffOptions();
 
     // NOTE: In Mercurial, "--rev x" means "diff between x and the working
     // copy state", while "--rev x..." means "diff between x and the working
     // copy commit" (i.e., from 'x' to '.'). The latter excludes any dirty
     // changes in the working copy.
 
     $range = $this->getRelativeCommit();
     if (!$this->includeDirectoryStateInDiffs) {
       $range .= '...';
     }
 
     $raw_diff_cache_key = $options.' '.$range.' '.$path;
     if (idx($this->rawDiffCache, $raw_diff_cache_key)) {
       return idx($this->rawDiffCache, $raw_diff_cache_key);
     }
 
     list($stdout) = $this->execxLocal(
       'diff %C --rev %s -- %s',
       $options,
       $range,
       $path);
 
     $this->rawDiffCache[$raw_diff_cache_key] = $stdout;
 
     return $stdout;
   }
 
   public function getFullMercurialDiff() {
     return $this->getRawDiffText('');
   }
 
   public function getOriginalFileData($path) {
     return $this->getFileDataAtRevision($path, $this->getRelativeCommit());
   }
 
   public function getCurrentFileData($path) {
     return $this->getFileDataAtRevision(
       $path,
       $this->getWorkingCopyRevision());
   }
 
   private function getFileDataAtRevision($path, $revision) {
     list($err, $stdout) = $this->execManualLocal(
       'cat --rev %s -- %s',
       $revision,
       $path);
     if ($err) {
       // Assume this is "no file at revision", i.e. a deleted or added file.
       return null;
     } else {
       return $stdout;
     }
   }
 
   public function getWorkingCopyRevision() {
     return '.';
   }
 
   public function isHistoryDefaultImmutable() {
     return true;
   }
 
   public function supportsAmend() {
     list($err, $stdout) = $this->execManualLocal('help commit');
     if ($err) {
       return false;
     } else {
       return (strpos($stdout, "amend") !== false);
     }
   }
 
   public function supportsRelativeLocalCommits() {
     return true;
   }
 
-  public function setDefaultBaseCommit() {
-    $this->setRelativeCommit('.^');
-    return $this;
-  }
-
   public function hasLocalCommit($commit) {
     try {
       $this->getCanonicalRevisionName($commit);
       return true;
     } catch (Exception $ex) {
       return false;
     }
   }
 
   public function getCommitMessage($commit) {
     list($message) = $this->execxLocal(
       'log --template={desc} --rev %s',
       $commit);
     return $message;
   }
 
   public function parseRelativeLocalCommit(array $argv) {
     if (count($argv) == 0) {
       return;
     }
     if (count($argv) != 1) {
       throw new ArcanistUsageException("Specify only one commit.");
     }
 
     $this->setBaseCommitExplanation("you explicitly specified it.");
 
     // This does the "hg id" call we need to normalize/validate the revision
     // identifier.
     $this->setRelativeCommit(reset($argv));
   }
 
   public function getAllLocalChanges() {
     $diff = $this->getFullMercurialDiff();
     if (!strlen(trim($diff))) {
       return array();
     }
     $parser = new ArcanistDiffParser();
     return $parser->parseDiff($diff);
   }
 
   public function supportsLocalBranchMerge() {
     return true;
   }
 
   public function performLocalBranchMerge($branch, $message) {
     if ($branch) {
       $err = phutil_passthru(
         '(cd %s && HGPLAIN=1 hg merge --rev %s && hg commit -m %s)',
         $this->getPath(),
         $branch,
         $message);
     } else {
       $err = phutil_passthru(
         '(cd %s && HGPLAIN=1 hg merge && hg commit -m %s)',
         $this->getPath(),
         $message);
     }
 
     if ($err) {
       throw new ArcanistUsageException("Merge failed!");
     }
   }
 
   public function getFinalizedRevisionMessage() {
     return "You may now push this commit upstream, as appropriate (e.g. with ".
            "'hg push' or by printing and faxing it).";
   }
 
   public function getCommitMessageLog() {
     list($stdout) = $this->execxLocal(
       "log --template '{node}\\2{desc}\\1' --rev %s --branch %s --",
       'ancestors(.) - ancestors('.$this->getRelativeCommit().')',
       $this->getBranchName());
 
     $map = array();
 
     $logs = explode("\1", trim($stdout));
     foreach (array_filter($logs) as $log) {
       list($node, $desc) = explode("\2", $log);
       $map[$node] = $desc;
     }
 
     return array_reverse($map);
   }
 
   public function loadWorkingCopyDifferentialRevisions(
     ConduitClient $conduit,
     array $query) {
 
     $messages = $this->getCommitMessageLog();
     $parser = new ArcanistDiffParser();
 
     // First, try to find revisions by explicit revision IDs in commit messages.
     $reason_map = array();
     $revision_ids = array();
     foreach ($messages as $node_id => $message) {
       $object = ArcanistDifferentialCommitMessage::newFromRawCorpus($message);
 
       if ($object->getRevisionID()) {
         $revision_ids[] = $object->getRevisionID();
         $reason_map[$object->getRevisionID()] = $node_id;
       }
     }
 
     if ($revision_ids) {
       $results = $conduit->callMethodSynchronous(
         'differential.query',
         $query + array(
           'ids' => $revision_ids,
         ));
 
       foreach ($results as $key => $result) {
         $hash = substr($reason_map[$result['id']], 0, 16);
         $results[$key]['why'] =
           "Commit message for '{$hash}' has explicit 'Differential Revision'.";
       }
 
       return $results;
     }
 
     // Try to find revisions by hash.
     $hashes = array();
     foreach ($this->getLocalCommitInformation() as $commit) {
       $hashes[] = array('hgcm', $commit['commit']);
     }
 
     if ($hashes) {
 
       // NOTE: In the case of "arc diff . --uncommitted" in a Mercurial working
       // copy with dirty changes, there may be no local commits.
 
       $results = $conduit->callMethodSynchronous(
         'differential.query',
         $query + array(
           'commitHashes' => $hashes,
         ));
 
       foreach ($results as $key => $hash) {
         $results[$key]['why'] =
           "A mercurial commit hash in the commit range is already attached ".
           "to the Differential revision.";
       }
 
       return $results;
     }
 
     return array();
   }
 
   public function updateWorkingCopy() {
     $this->execxLocal('up');
   }
 
   private function getMercurialConfig($key, $default = null) {
     list($stdout) = $this->execxLocal('showconfig %s', $key);
     if ($stdout == '') {
       return $default;
     }
     return rtrim($stdout);
   }
 
   public function getAuthor() {
     return $this->getMercurialConfig('ui.username');
   }
 
   public function addToCommit(array $paths) {
     $this->execxLocal(
       'add -- %Ls',
       $paths);
   }
 
   public function doCommit($message) {
     $tmp_file = new TempFile();
     Filesystem::writeFile($tmp_file, $message);
     $this->execxLocal(
       'commit -l %s',
       $tmp_file);
     $this->reloadWorkingCopy();
   }
 
   public function amendCommit($message) {
     $tmp_file = new TempFile();
     Filesystem::writeFile($tmp_file, $message);
     $this->execxLocal(
       'commit --amend -l %s',
       $tmp_file);
   }
 
   public function setIncludeDirectoryStateInDiffs($include) {
     $this->includeDirectoryStateInDiffs = $include;
     return $this;
   }
 
   public function getCommitSummary($commit) {
     if ($commit == 'null') {
       return '(The Empty Void)';
     }
 
     list($summary) = $this->execxLocal(
       'log --template {desc} --limit 1 --rev %s',
       $commit);
 
     $summary = head(explode("\n", $summary));
 
     return trim($summary);
   }
 
   public function resolveBaseCommitRule($rule, $source) {
     list($type, $name) = explode(':', $rule, 2);
 
     switch ($type) {
       case 'hg':
         $matches = null;
         if (preg_match('/^gca\((.+)\)$/', $name, $matches)) {
           list($err, $merge_base) = $this->execManualLocal(
             'log --template={node} --rev %s',
             sprintf('ancestor(., %s)', $matches[1]));
           if (!$err) {
             $this->setBaseCommitExplanation(
               "it is the greatest common ancestor of '{$matches[1]}' and ., as".
               "specified by '{$rule}' in your {$source} 'base' ".
               "configuration.");
             return trim($merge_base);
           }
         } else {
           list($err) = $this->execManualLocal(
             'id -r %s',
             $name);
           if (!$err) {
             $this->setBaseCommitExplanation(
               "it is specified by '{$rule}' in your {$source} 'base' ".
               "configuration.");
             return $name;
           }
         }
         break;
       case 'arc':
         switch ($name) {
           case 'empty':
             $this->setBaseCommitExplanation(
               "you specified '{$rule}' in your {$source} 'base' ".
               "configuration.");
             return 'null';
           case 'outgoing':
             list($err, $outgoing_base) = $this->execManualLocal(
               'log --template={node} --rev %s',
               'limit(reverse(ancestors(.) - outgoing()), 1)'
             );
             if (!$err) {
               $this->setBaseCommitExplanation(
                 "it is the first ancestor of the working copy that is not ".
                 "outgoing, and it matched the rule {$rule} in your {$source} ".
                 "'base' configuration.");
               return trim($outgoing_base);
             }
           case 'amended':
             $text = $this->getCommitMessage('.');
             $message = ArcanistDifferentialCommitMessage::newFromRawCorpus(
               $text);
             if ($message->getRevisionID()) {
               $this->setBaseCommitExplanation(
                 "'.' has been amended with 'Differential Revision:', ".
                 "as specified by '{$rule}' in your {$source} 'base' ".
                 "configuration.");
               // NOTE: This should be safe because Mercurial doesn't support
               // amend until 2.2.
               return '.^';
             }
             break;
           case 'bookmark':
             $revset =
               'limit('.
               '  sort('.
               '    (ancestors(.) and bookmark() - .) or'.
               '    (ancestors(.) - outgoing()), '.
               '  -rev),'.
               '1)';
             list($err, $bookmark_base) = $this->execManualLocal(
               'log --template={node} --rev %s',
               $revset);
             if (!$err) {
               $this->setBaseCommitExplanation(
                 "it is the first ancestor of . that either has a bookmark, or ".
                 "is already in the remote and it matched the rule {$rule} in ".
                 "your {$source} 'base' configuration");
               return trim($bookmark_base);
             }
+            break;
+          case 'this':
+            $this->setBaseCommitExplanation(
+              "you specified '{$rule}' in your {$source} 'base' ".
+              "configuration.");
+            return '.^';
         }
         break;
       default:
         return null;
     }
 
     return null;
 
   }
 
   public function getSubversionInfo() {
     $info = array();
     $base_path = null;
     $revision = null;
     list($err, $raw_info) = $this->execManualLocal('svn info');
     if (!$err) {
       foreach (explode("\n", trim($raw_info)) as $line) {
         list($key, $value) = explode(': ', $line, 2);
         switch ($key) {
           case 'URL':
             $info['base_path'] = $value;
             $base_path = $value;
             break;
           case 'Repository UUID':
             $info['uuid'] = $value;
             break;
           case 'Revision':
             $revision = $value;
             break;
           default:
             break;
         }
       }
       if ($base_path && $revision) {
         $info['base_revision'] = $base_path.'@'.$revision;
       }
     }
     return $info;
   }
 
   public function getActiveBookmark() {
     $bookmarks = $this->getBookmarks();
     foreach ($bookmarks as $bookmark) {
       if ($bookmark['is_active']) {
         return $bookmark['name'];
       }
     }
 
     return null;
   }
 
   public function isBookmark($name) {
     $bookmarks = $this->getBookmarks();
     foreach ($bookmarks as $bookmark) {
       if ($bookmark['name'] === $name) {
         return true;
       }
     }
 
     return false;
   }
 
   public function isBranch($name) {
     $branches = $this->getBranches();
     foreach ($branches as $branch) {
       if ($branch['name'] === $name) {
         return true;
       }
     }
 
     return false;
   }
 
   public function getBranches() {
     $branches = array();
 
     list($raw_output) = $this->execxLocal('branches');
     $raw_output = trim($raw_output);
 
     foreach (explode("\n", $raw_output) as $line) {
       // example line: default                 0:a5ead76cdf85 (inactive)
       list($name, $rev_line) = $this->splitBranchOrBookmarkLine($line);
 
       // strip off the '(inactive)' bit if it exists
       $rev_parts = explode(' ', $rev_line);
       $revision = $rev_parts[0];
 
       $branches[] = array(
         'name' => $name,
         'revision' => $revision);
     }
 
     return $branches;
   }
 
   public function getBookmarks() {
     $bookmarks = array();
 
     list($raw_output) = $this->execxLocal('bookmarks');
     $raw_output = trim($raw_output);
     if ($raw_output !== 'no bookmarks set') {
       foreach (explode("\n", $raw_output) as $line) {
         // example line:  * mybook               2:6b274d49be97
         list($name, $revision) = $this->splitBranchOrBookmarkLine($line);
 
         $is_active = false;
         if ('*' === $name[0]) {
           $is_active = true;
           $name = substr($name, 2);
         }
 
         $bookmarks[] = array(
           'is_active' => $is_active,
           'name' => $name,
           'revision' => $revision);
       }
     }
 
     return $bookmarks;
   }
 
   private function splitBranchOrBookmarkLine($line) {
     // branches and bookmarks are printed in the format:
     // default                 0:a5ead76cdf85 (inactive)
     // * mybook               2:6b274d49be97
     // this code divides the name half from the revision half
     // it does not parse the * and (inactive) bits
     $colon_index = strrpos($line, ':');
     $before_colon = substr($line, 0, $colon_index);
     $start_rev_index = strrpos($before_colon, ' ');
     $name = substr($line, 0, $start_rev_index);
     $rev = substr($line, $start_rev_index);
 
     return array(trim($name), trim($rev));
   }
 }
diff --git a/src/repository/api/ArcanistRepositoryAPI.php b/src/repository/api/ArcanistRepositoryAPI.php
index 9af523ab..c7a7e405 100644
--- a/src/repository/api/ArcanistRepositoryAPI.php
+++ b/src/repository/api/ArcanistRepositoryAPI.php
@@ -1,598 +1,583 @@
 <?php
 
 /**
  * Interfaces with the VCS in the working copy.
  *
  * @task  status      Path Status
  * @group workingcopy
  */
 abstract class ArcanistRepositoryAPI {
 
   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;
   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 $workingCopyIdentity;
   private $baseCommitArgumentRules;
 
   private $uncommittedStatusCache;
   private $commitRangeStatusCache;
 
   abstract public function getSourceControlSystemName();
 
   public function getDiffLinesOfContext() {
     return $this->diffLinesOfContext;
   }
 
   public function setDiffLinesOfContext($lines) {
     $this->diffLinesOfContext = $lines;
     return $this;
   }
 
   public function getWorkingCopyIdentity() {
     return $this->workingCopyIdentity;
   }
 
   public static function newAPIFromWorkingCopyIdentity(
     ArcanistWorkingCopyIdentity $working_copy) {
 
     $root = $working_copy->getProjectRoot();
 
     if (!$root) {
       throw new ArcanistUsageException(
         "There is no readable '.arcconfig' file in the working directory or ".
         "any parent directory. Create an '.arcconfig' file to configure arc.");
     }
 
     if (Filesystem::pathExists($root.'/.hg')) {
       $api = new ArcanistMercurialAPI($root);
       $api->workingCopyIdentity = $working_copy;
       return $api;
     }
 
     $git_root = self::discoverGitBaseDirectory($root);
     if ($git_root) {
       if (!Filesystem::pathsAreEquivalent($root, $git_root)) {
         throw new ArcanistUsageException(
           "'.arcconfig' file is located at '{$root}', but working copy root ".
           "is '{$git_root}'. Move '.arcconfig' file to the working copy root.");
       }
 
       $api = new ArcanistGitAPI($root);
       $api->workingCopyIdentity = $working_copy;
       return $api;
     }
 
     // check if we're in an svn working copy
     list($err) = id(new ExecFuture('svn info'))
       ->setCWD($root)
       ->resolve();
     if (!$err) {
       $api = new ArcanistSubversionAPI($root);
       $api->workingCopyIdentity = $working_copy;
       return $api;
     }
 
     throw new ArcanistUsageException(
       "The current working directory is not part of a working copy for a ".
       "supported version control system (svn, git or mercurial).");
   }
 
   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
    */
   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 retreive 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();
 
     return $this;
   }
 
 
   /**
    * Hook for implementations to dirty working copy caches after the working
    * copy has been updated.
    *
    * @return this
    * @task status
    */
   protected function didReloadWorkingCopy() {
     return;
   }
 
 
 
   private static function discoverGitBaseDirectory($root) {
     try {
 
       // NOTE: This awkward construction is to make sure things work on Windows.
       $future = new ExecFuture('git rev-parse --show-cdup');
       $future->setCWD($root);
       list($stdout) = $future->resolvex();
 
       return Filesystem::resolvePath(rtrim($stdout, "\n"), $root);
     } catch (CommandException $ex) {
       if (preg_match('/^fatal: Not a git repository/', $ex->getStdErr())) {
         return null;
       }
       throw $ex;
     }
   }
 
 
   /**
    * @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 supportsRelativeLocalCommits();
   abstract public function getWorkingCopyRevision();
   abstract public function updateWorkingCopy();
   abstract public function getMetadataPath();
   abstract public function loadWorkingCopyDifferentialRevisions(
     ConduitClient $conduit,
     array $query);
 
   public function getUnderlyingWorkingCopyRevision() {
     return $this->getWorkingCopyRevision();
   }
 
-  /**
-   * Set the base commit to a reasonable default value so that working copy
-   * status checks can do something meaningful and won't invoke configured
-   * 'base' rules.
-   *
-   * This is primarily useful for workflows which do not operate on commit
-   * ranges but need to verify the working copy is not dirty, like "amend",
-   * "upgrade" and "patch".
-   *
-   * @return this
-   */
-  public function setDefaultBaseCommit() {
-    throw new ArcanistCapabilityNotSupportedException($this);
-  }
-
   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);
   }
 
   public function doCommit($message) {
     throw new ArcanistCapabilityNotSupportedException($this);
   }
 
   public function amendCommit($message) {
     throw new ArcanistCapabilityNotSupportedException($this);
   }
 
   public function getAllBranches() {
     // TODO: Implement for Mercurial/SVN and make abstract.
     return array();
   }
 
   public function hasLocalCommit($commit) {
     throw new ArcanistCapabilityNotSupportedException($this);
   }
 
   public function getCommitMessage($commit) {
     throw new ArcanistCapabilityNotSupportedException($this);
   }
 
   public function parseRelativeLocalCommit(array $argv) {
     throw new ArcanistCapabilityNotSupportedException($this);
   }
 
   public function getCommitSummary($commit) {
     throw new ArcanistCapabilityNotSupportedException($this);
   }
 
   public function getAllLocalChanges() {
     throw new ArcanistCapabilityNotSupportedException($this);
   }
 
   abstract public function supportsLocalBranchMerge();
 
   public function performLocalBranchMerge($branch, $message) {
     throw new ArcanistCapabilityNotSupportedException($this);
   }
 
   public function getFinalizedRevisionMessage() {
     throw new ArcanistCapabilityNotSupportedException($this);
   }
 
   public function execxLocal($pattern /* , ... */) {
     $args = func_get_args();
     return $this->buildLocalFuture($args)->resolvex();
   }
 
   public function execManualLocal($pattern /* , ... */) {
     $args = func_get_args();
     return $this->buildLocalFuture($args)->resolve();
   }
 
   public function execFutureLocal($pattern /* , ... */) {
     $args = func_get_args();
     return $this->buildLocalFuture($args);
   }
 
   abstract protected function buildLocalFuture(array $argv);
 
 
 /* -(  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  )------------------------------------------------------- */
 
 
   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() {
     $working_copy = $this->getWorkingCopyIdentity();
     $global_config = ArcanistBaseWorkflow::readGlobalArcConfig();
     $system_config = ArcanistBaseWorkflow::readSystemArcConfig();
 
     $parser = new ArcanistBaseCommitParser($this);
     $commit = $parser->resolveBaseCommit(
       array(
         'args'    => $this->getBaseCommitArgumentRules(),
         'local'   => $working_copy->getLocalConfig('base', ''),
         'project' => $working_copy->getConfig('base', ''),
         'global'  => idx($global_config, 'base', ''),
         'system'  => idx($system_config, 'base', ''),
       ));
 
     return $commit;
   }
 
 }
diff --git a/src/repository/api/__tests__/ArcanistRepositoryAPIStateTestCase.php b/src/repository/api/__tests__/ArcanistRepositoryAPIStateTestCase.php
index e139d3d0..d3c89f1f 100644
--- a/src/repository/api/__tests__/ArcanistRepositoryAPIStateTestCase.php
+++ b/src/repository/api/__tests__/ArcanistRepositoryAPIStateTestCase.php
@@ -1,93 +1,90 @@
 <?php
 
 final class ArcanistRepositoryAPIStateTestCase extends ArcanistTestCase {
 
   public function testStateParsing() {
     $dir = dirname(__FILE__).'/state/';
 
     $tests = Filesystem::listDirectory($dir, $include_hidden = false);
     foreach ($tests as $test) {
       $fixture = PhutilDirectoryFixture::newFromArchive($dir.'/'.$test);
 
       $fixture_path = $fixture->getPath();
       $working_copy = ArcanistWorkingCopyIdentity::newFromPath($fixture_path);
 
       $api = ArcanistRepositoryAPI::newAPIFromWorkingCopyIdentity(
         $working_copy);
-
-      if ($api->supportsRelativeLocalCommits()) {
-        $api->setDefaultBaseCommit();
-      }
+      $api->setBaseCommitArgumentRules('arc:this');
 
       $this->assertCorrectState($test, $api);
     }
   }
 
   private function assertCorrectState($test, ArcanistRepositoryAPI $api) {
     $f_mod = ArcanistRepositoryAPI::FLAG_MODIFIED;
     $f_add = ArcanistRepositoryAPI::FLAG_ADDED;
     $f_del = ArcanistRepositoryAPI::FLAG_DELETED;
     $f_unt = ArcanistRepositoryAPI::FLAG_UNTRACKED;
     $f_con = ArcanistRepositoryAPI::FLAG_CONFLICT;
     $f_mis = ArcanistRepositoryAPI::FLAG_MISSING;
     $f_uns = ArcanistRepositoryAPI::FLAG_UNSTAGED;
     $f_unc = ArcanistRepositoryAPI::FLAG_UNCOMMITTED;
     $f_ext = ArcanistRepositoryAPI::FLAG_EXTERNALS;
     $f_obs = ArcanistRepositoryAPI::FLAG_OBSTRUCTED;
     $f_inc = ArcanistRepositoryAPI::FLAG_INCOMPLETE;
 
     switch ($test) {
       case 'svn_basic.svn.tgz':
         $expect = array(
           'ADDED'       => $f_add,
           'COPIED_TO'   => $f_add,
           'DELETED'     => $f_del,
           'MODIFIED'    => $f_mod,
           'MOVED'       => $f_del,
           'MOVED_TO'    => $f_add,
           'PROPCHANGE'  => $f_mod,
           'UNTRACKED'   => $f_unt,
         );
         $this->assertEqual($expect, $api->getUncommittedStatus());
         $this->assertEqual($expect, $api->getCommitRangeStatus());
         break;
       case 'git_basic.git.tgz':
         $expect_uncommitted = array(
           'UNCOMMITTED' => $f_add | $f_unc,
           'UNSTAGED'    => $f_mod | $f_uns | $f_unc,
           'UNTRACKED'   => $f_unt,
         );
         $this->assertEqual($expect_uncommitted, $api->getUncommittedStatus());
 
         $expect_range = array(
           'ADDED'       => $f_add,
           'DELETED'     => $f_del,
           'MODIFIED'    => $f_mod,
           'UNCOMMITTED' => $f_add,
           'UNSTAGED'    => $f_add,
         );
         $this->assertEqual($expect_range, $api->getCommitRangeStatus());
         break;
       case 'hg_basic.hg.tgz':
         $expect_uncommitted = array(
           'UNCOMMITTED' => $f_mod | $f_unc,
           'UNTRACKED'   => $f_unt,
         );
         $this->assertEqual($expect_uncommitted, $api->getUncommittedStatus());
 
         $expect_range = array(
           'ADDED'       => $f_add,
           'DELETED'     => $f_del,
           'MODIFIED'    => $f_mod,
           'UNCOMMITTED' => $f_add,
         );
         $this->assertEqual($expect_range, $api->getCommitRangeStatus());
         break;
       default:
         throw new Exception(
           "No test cases for working copy '{$test}'!");
     }
   }
 
 
 }
diff --git a/src/workflow/ArcanistAmendWorkflow.php b/src/workflow/ArcanistAmendWorkflow.php
index 0aed0d22..ceb504d6 100644
--- a/src/workflow/ArcanistAmendWorkflow.php
+++ b/src/workflow/ArcanistAmendWorkflow.php
@@ -1,191 +1,188 @@
 <?php
 
 /**
  * Updates git commit messages after a revision is "Accepted".
  *
  * @group workflow
  */
 final class ArcanistAmendWorkflow extends ArcanistBaseWorkflow {
 
   public function getWorkflowName() {
     return 'amend';
   }
 
   public function getCommandSynopses() {
     return phutil_console_format(<<<EOTEXT
       **amend** [--revision __revision_id__] [--show]
 EOTEXT
       );
   }
 
   public function getCommandHelp() {
     return phutil_console_format(<<<EOTEXT
           Supports: git, hg
           Amend the working copy after a revision has been accepted, so commits
           can be marked 'committed' and pushed upstream.
 
           Supported in Mercurial 2.2 and newer.
 EOTEXT
       );
   }
 
   public function requiresWorkingCopy() {
     return true;
   }
 
   public function requiresConduit() {
     return true;
   }
 
   public function requiresAuthentication() {
     return true;
   }
 
   public function requiresRepositoryAPI() {
     return true;
   }
 
   public function getArguments() {
     return array(
       'show' => array(
         'help' =>
           "Show the amended commit message, without modifying the working copy."
       ),
       'revision' => array(
         'param' => 'revision_id',
         'help' =>
           "Amend a specific revision. If you do not specify a revision, ".
           "arc will look in the commit message at HEAD.",
       ),
     );
   }
 
   public function run() {
     $is_show = $this->getArgument('show');
 
     $repository_api = $this->getRepositoryAPI();
     if (!$is_show) {
       if (!$repository_api->supportsAmend()) {
         throw new ArcanistUsageException(
           "You may only run 'arc amend' in a git or hg (version ".
           "2.2 or newer) working copy.");
       }
 
       if ($this->isHistoryImmutable()) {
         throw new ArcanistUsageException(
           "This project is marked as adhering to a conservative history ".
           "mutability doctrine (having an immutable local history), which ".
           "precludes amending commit messages. You can use 'arc merge' to ".
           "merge feature branches instead.");
       }
       if ($repository_api->getUncommittedChanges()) {
         throw new ArcanistUsageException(
           "You have uncommitted changes in this branch. Stage and commit (or ".
           "revert) them before proceeding.");
       }
     }
 
     $revision_id = null;
     if ($this->getArgument('revision')) {
       $revision_id = $this->normalizeRevisionID($this->getArgument('revision'));
     }
 
-    if ($repository_api->supportsRelativeLocalCommits()) {
-      $repository_api->setDefaultBaseCommit();
-    }
-
+    $repository_api->setBaseCommitArgumentRules('arc:this');
     $in_working_copy = $repository_api->loadWorkingCopyDifferentialRevisions(
       $this->getConduit(),
       array(
         'authors'   => array($this->getUserPHID()),
         'status'    => 'status-any',
       ));
     $in_working_copy = ipull($in_working_copy, null, 'id');
 
     if (!$revision_id) {
       if (count($in_working_copy) == 0) {
         throw new ArcanistUsageException(
           "No revision specified with '--revision', and no revisions found ".
           "in the working copy. Use '--revision <id>' to specify which ".
           "revision you want to amend.");
       } else if (count($in_working_copy) > 1) {
         $message = "More than one revision was found in the working copy:\n".
           $this->renderRevisionList($in_working_copy)."\n".
           "Use '--revision <id>' to specify which revision you want to ".
           "amend.";
         throw new ArcanistUsageException($message);
       } else {
         $revision_id = key($in_working_copy);
       }
     }
 
     $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(
           "Revision D{$revision_id} does not exist."
         );
       }
     }
 
     $revision = $conduit->callMethodSynchronous(
       'differential.query',
       array(
         'ids' => array($revision_id),
       ));
     if (empty($revision)) {
       throw new Exception(
         "Failed to lookup information for 'D{$revision_id}'!");
     }
     $revision = head($revision);
     $revision_title = $revision['title'];
 
     if (!$is_show) {
       if ($revision_id && empty($in_working_copy[$revision_id])) {
         $ok = phutil_console_confirm(
           "The revision 'D{$revision_id}' does not appear to be in the ".
           "working copy. Are you sure you want to amend HEAD with the ".
           "commit message for 'D{$revision_id}: {$revision_title}'?");
         if (!$ok) {
           throw new ArcanistUserAbortException();
         }
       }
     }
 
     if ($is_show) {
       echo $message."\n";
     } else {
       echo phutil_console_format(
         "Amending commit message to reflect revision **%s**.\n",
         "D{$revision_id}: {$revision_title}");
 
       $repository_api->amendCommit($message);
 
       $mark_workflow = $this->buildChildWorkflow(
         'close-revision',
         array(
           '--finalize',
           $revision_id,
         ));
       $mark_workflow->run();
     }
 
     return 0;
   }
 
 
   protected function getSupportedRevisionControlSystems() {
     return array('git', 'hg');
   }
 
 }
diff --git a/src/workflow/ArcanistPatchWorkflow.php b/src/workflow/ArcanistPatchWorkflow.php
index e04a6377..d6b45646 100644
--- a/src/workflow/ArcanistPatchWorkflow.php
+++ b/src/workflow/ArcanistPatchWorkflow.php
@@ -1,1006 +1,1002 @@
 <?php
 
 /**
  * Applies changes from Differential or a file to the working copy.
  *
  * @group workflow
  */
 final class ArcanistPatchWorkflow extends ArcanistBaseWorkflow {
 
   const SOURCE_BUNDLE         = 'bundle';
   const SOURCE_PATCH          = 'patch';
   const SOURCE_REVISION       = 'revision';
   const SOURCE_DIFF           = 'diff';
 
   private $source;
   private $sourceParam;
 
   public function getWorkflowName() {
     return 'patch';
   }
 
   public function getCommandSynopses() {
     return phutil_console_format(<<<EOTEXT
       **patch** __D12345__
       **patch** __--revision__ __revision_id__
       **patch** __--diff__ __diff_id__
       **patch** __--patch__ __file__
       **patch** __--arcbundle__ __bundlefile__
 EOTEXT
       );
   }
 
   public function getCommandHelp() {
     return phutil_console_format(<<<EOTEXT
           Supports: git, svn, hg
           Apply the changes in a Differential revision, patchfile, or arc
           bundle to the working copy.
 EOTEXT
       );
   }
 
   public function getArguments() {
     return array(
       'revision' => array(
         'param' => 'revision_id',
         'paramtype' => 'complete',
         'help' =>
           "Apply changes from a Differential revision, using the most recent ".
           "diff that has been attached to it. You can run 'arc patch D12345' ".
           "as a shorthand.",
       ),
       'diff' => array(
         'param' => 'diff_id',
         'help' =>
           "Apply changes from a Differential diff. Normally you want to use ".
           "--revision to get the most recent changes, but you can ".
           "specifically apply an out-of-date diff or a diff which was never ".
           "attached to a revision by using this flag.",
       ),
       'arcbundle' => array(
         'param' => 'bundlefile',
         'paramtype' => 'file',
         'help' =>
           "Apply changes from an arc bundle generated with 'arc export'.",
       ),
       'patch' => array(
         'param' => 'patchfile',
         'paramtype' => 'file',
         'help' =>
           "Apply changes from a git patchfile or unified patchfile.",
       ),
       'encoding' => array(
         'param' => 'encoding',
         'help' =>
           "Attempt to convert non UTF-8 patch into specified encoding.",
       ),
       'update' => array(
         'supports' => array(
           'git', 'svn', 'hg'
         ),
         'help' =>
           "Update the local working copy before applying the patch.",
         'conflicts' => array(
           'nobranch' => true,
           'bookmark' => true,
         ),
       ),
       'nocommit' => array(
         'supports' => array(
           'git', 'hg'
         ),
         'help' =>
           "Normally under git/hg, if the patch is successful, the changes ".
           "are committed to the working copy. This flag prevents the commit.",
       ),
       'nobranch' => array(
         'supports' => array(
           'git'
         ),
         'help' =>
           "Normally under git, a new branch is created and then the patch ".
           "is applied and committed in the new branch. This flag ".
           "cherry-picks the resultant commit onto the original branch and ".
           "deletes the temporary branch.",
         'conflicts' => array(
           'update' => true,
         ),
       ),
       'bookmark' => array(
         'supports' => array(
           'hg'
         ),
         'help' =>
           "Normally under hg, a new bookmark is not created and the patch ".
           "is applied and committed in the current bookmark. With this flag, ".
           "a new bookmark is created and the patch is applied and committed ".
           "in the new bookmark.",
         'conflicts' => array(
           'update' => true,
         ),
       ),
       'force' => array(
         'help' =>
           "Do not run any sanity checks.",
       ),
       '*' => 'name',
     );
   }
 
   protected function didParseArguments() {
     $source = null;
     $requested = 0;
     if ($this->getArgument('revision')) {
       $source = self::SOURCE_REVISION;
       $requested++;
     }
     if ($this->getArgument('diff')) {
       $source = self::SOURCE_DIFF;
       $requested++;
     }
     if ($this->getArgument('arcbundle')) {
       $source = self::SOURCE_BUNDLE;
       $requested++;
     }
     if ($this->getArgument('patch')) {
       $source = self::SOURCE_PATCH;
       $requested++;
     }
 
     $use_revision_id = null;
     if ($this->getArgument('name')) {
       $namev = $this->getArgument('name');
       if (count($namev) > 1) {
         throw new ArcanistUsageException("Specify at most one revision name.");
       }
       $source = self::SOURCE_REVISION;
       $requested++;
 
       $use_revision_id = $this->normalizeRevisionID(head($namev));
     }
 
     if ($requested === 0) {
       throw new ArcanistUsageException(
         "Specify one of 'D12345', '--revision <revision_id>' (to select the ".
         "current changes attached to a Differential revision), ".
         "'--diff <diff_id>' (to select a specific, out-of-date diff or a ".
         "diff which is not attached to a revision), '--arcbundle <file>' ".
         "or '--patch <file>' to choose a patch source.");
     } else if ($requested > 1) {
       throw new ArcanistUsageException(
         "Options 'D12345', '--revision', '--diff', '--arcbundle' and ".
         "'--patch' are not compatible. Choose exactly one patch source.");
     }
 
     $this->source = $source;
     $this->sourceParam = nonempty(
       $use_revision_id,
       $this->getArgument($source));
   }
 
   public function requiresConduit() {
     return ($this->getSource() != self::SOURCE_PATCH);
   }
 
   public function requiresRepositoryAPI() {
     return true;
   }
 
   public function requiresWorkingCopy() {
     return true;
   }
 
   private function getSource() {
     return $this->source;
   }
 
   private function getSourceParam() {
     return $this->sourceParam;
   }
 
   private function shouldCommit() {
     $no_commit = $this->getArgument('nocommit', false);
     if ($no_commit) {
       return false;
     }
 
     return true;
   }
 
   private function canBranch() {
     // git only for now
     $repository_api = $this->getRepositoryAPI();
     if (!($repository_api instanceof ArcanistGitAPI)) {
       return false;
     }
     return true;
   }
 
   private function shouldBranch() {
     $no_branch = $this->getArgument('nobranch', false);
     if ($no_branch) {
       return false;
     }
     return true;
   }
 
   private function shouldBookmark() {
     // specific to hg
     $repository_api = $this->getRepositoryAPI();
     if (!($repository_api instanceof ArcanistMercurialAPI)) {
       return false;
     }
 
     $bookmark = $this->getArgument('bookmark', false);
     if ($bookmark) {
       return true;
     }
 
     return false;
   }
 
 
   private function getBranchName(ArcanistBundle $bundle) {
     $branch_name    = null;
     $repository_api = $this->getRepositoryAPI();
     $revision_id    = $bundle->getRevisionID();
     $base_name      = "arcpatch";
     if ($revision_id) {
       $base_name .= "-D{$revision_id}";
     }
 
     $suffixes = array(null, '-1', '-2', '-3');
     foreach ($suffixes as $suffix) {
       $proposed_name = $base_name.$suffix;
 
       list($err) = $repository_api->execManualLocal(
         'rev-parse --verify %s',
         $proposed_name);
 
       // no error means git rev-parse found a branch
       if (!$err) {
         echo phutil_console_format(
           "Branch name {$proposed_name} already exists; trying a new name.\n"
         );
         continue;
       } else {
         $branch_name = $proposed_name;
         break;
       }
     }
 
     if (!$branch_name) {
       throw new Exception(
         "Arc was unable to automagically make a name for this patch.  ".
         "Please clean up your working copy and try again."
       );
     }
 
     return $branch_name;
   }
 
   private function getBookmarkName(ArcanistBundle $bundle) {
     $bookmark_name    = null;
     $repository_api = $this->getRepositoryAPI();
     $revision_id    = $bundle->getRevisionID();
     $base_name      = "arcpatch";
     if ($revision_id) {
       $base_name .= "-D{$revision_id}";
     }
 
     $suffixes = array(null, '-1', '-2', '-3');
     foreach ($suffixes as $suffix) {
       $proposed_name = $base_name.$suffix;
 
       list($err) = $repository_api->execManualLocal(
         'log -r %s',
         $proposed_name);
 
       // no error means hg log found a bookmark
       if (!$err) {
         echo phutil_console_format(
           "Bookmark name {$proposed_name} already exists; trying a new name.\n"
         );
         continue;
       } else {
         $bookmark_name = $proposed_name;
         break;
       }
     }
 
     if (!$bookmark_name) {
       throw new Exception(
         "Arc was unable to automagically make a name for this patch. ".
         "Please clean up your working copy and try again."
       );
     }
 
     return $bookmark_name;
   }
 
   private function hasBaseRevision(ArcanistBundle $bundle) {
     $base_revision = $bundle->getBaseRevision();
     $repository_api = $this->getRepositoryAPI();
 
     // verify the base revision is valid
     // in a working copy that uses the git-svn bridge, the base revision might
     // be a svn uri instead of a git ref
 
     // NOTE: Use 'cat-file', not 'rev-parse --verify', because 'rev-parse'
     // always "verifies" any properly-formatted commit even if it does not
     // exist.
     list($err) = $repository_api->execManualLocal(
       'cat-file -t %s',
       $base_revision);
     return !$err;
   }
 
   private function createBranch(ArcanistBundle $bundle, $has_base_revision) {
     $branch_name = $this->getBranchName($bundle);
     $base_revision = $bundle->getBaseRevision();
     $repository_api = $this->getRepositoryAPI();
 
     if ($base_revision && $has_base_revision) {
       $repository_api->execxLocal(
         'checkout -b %s %s',
         $branch_name,
         $base_revision);
     } else {
       $repository_api->execxLocal(
         'checkout -b %s',
         $branch_name);
     }
 
     echo phutil_console_format(
       "Created and checked out branch %s.\n",
       $branch_name);
 
     return $branch_name;
   }
 
   private function createBookmark(ArcanistBundle $bundle) {
     $bookmark_name    = $this->getBookmarkName($bundle);
     $repository_api = $this->getRepositoryAPI();
 
     $repository_api->execxLocal(
       'bookmark %s',
       $bookmark_name);
 
     echo phutil_console_format(
       "Created and applied bookmark %s.\n",
       $bookmark_name);
   }
 
   private function shouldUpdateWorkingCopy() {
     return $this->getArgument('update', false);
   }
 
   private function updateWorkingCopy() {
     echo "Updating working copy...\n";
     $this->getRepositoryAPI()->updateWorkingCopy();
     echo "Done.\n";
   }
 
   public function run() {
 
     $source = $this->getSource();
     $param = $this->getSourceParam();
     try {
       switch ($source) {
         case self::SOURCE_PATCH:
           if ($param == '-') {
             $patch = @file_get_contents('php://stdin');
             if (!strlen($patch)) {
               throw new ArcanistUsageException(
                 "Failed to read patch from stdin!");
             }
           } else {
             $patch = Filesystem::readFile($param);
           }
           $bundle = ArcanistBundle::newFromDiff($patch);
           break;
         case self::SOURCE_BUNDLE:
           $path = $this->getArgument('arcbundle');
           $bundle = ArcanistBundle::newFromArcBundle($path);
           break;
         case self::SOURCE_REVISION:
           $bundle = $this->loadRevisionBundleFromConduit(
             $this->getConduit(),
             $param);
           break;
         case self::SOURCE_DIFF:
           $bundle = $this->loadDiffBundleFromConduit(
             $this->getConduit(),
             $param);
           break;
       }
     } catch (ConduitClientException $ex) {
       if ($ex->getErrorCode() == 'ERR-INVALID-SESSION') {
         // Phabricator is not configured to allow anonymous access to
         // Differential.
         $this->authenticateConduit();
         return $this->run();
       } else {
         throw $ex;
       }
     }
 
     $try_encoding = nonempty($this->getArgument('encoding'), null);
     if (!$try_encoding) {
       if ($this->requiresConduit()) {
         try {
           $try_encoding = $this->getRepositoryEncoding();
         } catch (ConduitClientException $e) {
           $try_encoding = null;
         }
       }
     }
 
     if ($try_encoding) {
       $bundle->setEncoding($try_encoding);
     }
 
     $force = $this->getArgument('force', false);
     if ($force) {
       // force means don't do any sanity checks about the patch
     } else {
       $this->sanityCheck($bundle);
     }
 
     // we should update the working copy before we do ANYTHING else
     if ($this->shouldUpdateWorkingCopy()) {
       $this->updateWorkingCopy();
     }
 
     $repository_api = $this->getRepositoryAPI();
 
     $has_base_revision = $this->hasBaseRevision($bundle);
     if ($this->shouldCommit() &&
         $this->canBranch() &&
         ($this->shouldBranch() || $has_base_revision)) {
 
       $original_branch = $repository_api->getBranchName();
       // If we weren't on a branch, then record the ref we'll return to
       // instead.
       if ($original_branch === null) {
         $original_branch = $repository_api->getCanonicalRevisionName('HEAD');
       }
       $new_branch = $this->createBranch($bundle, $has_base_revision);
     }
 
     if ($this->shouldBookmark()) {
       $this->createBookmark($bundle);
     }
 
     if ($repository_api instanceof ArcanistSubversionAPI) {
       $patch_err = 0;
 
       $copies = array();
       $deletes = array();
       $patches = array();
       $propset = array();
       $adds = array();
       $symlinks = array();
 
       $changes = $bundle->getChanges();
       foreach ($changes as $change) {
         $type = $change->getType();
         $should_patch = true;
 
         $filetype = $change->getFileType();
         switch ($filetype) {
           case ArcanistDiffChangeType::FILE_SYMLINK:
             $should_patch = false;
             $symlinks[] = $change;
             break;
         }
 
         switch ($type) {
           case ArcanistDiffChangeType::TYPE_MOVE_AWAY:
           case ArcanistDiffChangeType::TYPE_MULTICOPY:
           case ArcanistDiffChangeType::TYPE_DELETE:
             $path = $change->getCurrentPath();
             $fpath = $repository_api->getPath($path);
             if (!@file_exists($fpath)) {
               $ok = phutil_console_confirm(
                 "Patch deletes file '{$path}', but the file does not exist in ".
                 "the working copy. Continue anyway?");
               if (!$ok) {
                 throw new ArcanistUserAbortException();
               }
             } else {
               $deletes[] = $change->getCurrentPath();
             }
             $should_patch = false;
             break;
           case ArcanistDiffChangeType::TYPE_COPY_HERE:
           case ArcanistDiffChangeType::TYPE_MOVE_HERE:
             $path = $change->getOldPath();
             $fpath = $repository_api->getPath($path);
             if (!@file_exists($fpath)) {
               $cpath = $change->getCurrentPath();
               if ($type == ArcanistDiffChangeType::TYPE_COPY_HERE) {
                 $verbs = 'copies';
               } else {
                 $verbs = 'moves';
               }
               $ok = phutil_console_confirm(
                 "Patch {$verbs} '{$path}' to '{$cpath}', but source path ".
                 "does not exist in the working copy. Continue anyway?");
               if (!$ok) {
                 throw new ArcanistUserAbortException();
               }
             } else {
               $copies[] = array(
                 $change->getOldPath(),
                 $change->getCurrentPath());
             }
             break;
           case ArcanistDiffChangeType::TYPE_ADD:
             $adds[] = $change->getCurrentPath();
             break;
         }
         if ($should_patch) {
           $cbundle = ArcanistBundle::newFromChanges(array($change));
           $patches[$change->getCurrentPath()] = $cbundle->toUnifiedDiff();
           $prop_old = $change->getOldProperties();
           $prop_new = $change->getNewProperties();
           $props = $prop_old + $prop_new;
           foreach ($props as $key => $ignored) {
             if (idx($prop_old, $key) !== idx($prop_new, $key)) {
               $propset[$change->getCurrentPath()][$key] = idx($prop_new, $key);
             }
           }
         }
       }
 
       // Before we start doing anything, create all the directories we're going
       // to add files to if they don't already exist.
       foreach ($copies as $copy) {
         list($src, $dst) = $copy;
         $this->createParentDirectoryOf($dst);
       }
 
       foreach ($patches as $path => $patch) {
         $this->createParentDirectoryOf($path);
       }
 
       foreach ($adds as $add) {
         $this->createParentDirectoryOf($add);
       }
 
       // TODO: The SVN patch workflow likely does not work on windows because
       // of the (cd ...) stuff.
 
       foreach ($copies as $copy) {
         list($src, $dst) = $copy;
         passthru(
           csprintf(
             '(cd %s; svn cp %s %s)',
             $repository_api->getPath(),
             $src,
             $dst));
       }
 
       foreach ($deletes as $delete) {
         passthru(
           csprintf(
             '(cd %s; svn rm %s)',
             $repository_api->getPath(),
             $delete));
       }
 
       foreach ($symlinks as $symlink) {
         $link_target = $symlink->getSymlinkTarget();
         $link_path = $symlink->getCurrentPath();
         switch ($symlink->getType()) {
           case ArcanistDiffChangeType::TYPE_ADD:
           case ArcanistDiffChangeType::TYPE_CHANGE:
           case ArcanistDiffChangeType::TYPE_MOVE_HERE:
           case ArcanistDiffChangeType::TYPE_COPY_HERE:
             execx(
               '(cd %s && ln -sf %s %s)',
               $repository_api->getPath(),
               $link_target,
               $link_path);
             break;
         }
       }
 
       foreach ($patches as $path => $patch) {
         $err = null;
         if ($patch) {
           $tmp = new TempFile();
           Filesystem::writeFile($tmp, $patch);
           passthru(
             csprintf(
               '(cd %s; patch -p0 < %s)',
               $repository_api->getPath(),
               $tmp),
             $err);
         } else {
           passthru(
             csprintf(
               '(cd %s; touch %s)',
               $repository_api->getPath(),
               $path),
             $err);
         }
         if ($err) {
           $patch_err = max($patch_err, $err);
         }
       }
 
       foreach ($adds as $add) {
         passthru(
           csprintf(
             '(cd %s; svn add %s)',
             $repository_api->getPath(),
             $add));
       }
 
       foreach ($propset as $path => $changes) {
         foreach ($changes as $prop => $value) {
           if ($prop == 'unix:filemode') {
             // Setting this property also changes the file mode.
             $prop = 'svn:executable';
             $value = (octdec($value) & 0111 ? 'on' : null);
           }
           if ($value === null) {
             passthru(
               csprintf(
                 '(cd %s; svn propdel %s %s)',
                 $repository_api->getPath(),
                 $prop,
                 $path));
           } else {
             passthru(
               csprintf(
                 '(cd %s; svn propset %s %s %s)',
                 $repository_api->getPath(),
                 $prop,
                 $value,
                 $path));
           }
         }
       }
 
       if ($patch_err == 0) {
         echo phutil_console_format(
           "<bg:green>** OKAY **</bg> Successfully applied patch ".
           "to the working copy.\n");
       } else {
         echo phutil_console_format(
           "\n\n<bg:yellow>** WARNING **</bg> Some hunks could not be applied ".
           "cleanly by the unix 'patch' utility. Your working copy may be ".
           "different from the revision's base, or you may be in the wrong ".
           "subdirectory. You can export the raw patch file using ".
           "'arc export --unified', and then try to apply it by fiddling with ".
           "options to 'patch' (particularly, -p), or manually. The output ".
           "above, from 'patch', may be helpful in figuring out what went ".
           "wrong.\n");
       }
 
       return $patch_err;
     } else if ($repository_api instanceof ArcanistGitAPI) {
       $future = $repository_api->execFutureLocal(
         'apply --index --reject');
       $future->write($bundle->toGitPatch());
 
       try {
         $future->resolvex();
       } catch (CommandException $ex) {
         echo phutil_console_format(
           "\n<bg:red>** Patch Failed! **</bg>\n");
         $stderr = $ex->getStdErr();
         if (preg_match('/already exists in working directory/', $stderr)) {
           echo phutil_console_wrap(
             phutil_console_format(
               "\n<bg:yellow>** WARNING **</bg> This patch may have failed ".
               "because it attempts to change the case of a filename (for ".
               "instance, from 'example.c' to 'Example.c'). Git cannot apply ".
               "patches like this on case-insensitive filesystems. You must ".
               "apply this patch manually.\n"));
         }
         throw $ex;
       }
 
       if ($this->shouldCommit()) {
         // git is really, really finicky about the author information so we
         // make sure it is in the
         // "George Washington <gwashington@example.com> format or don't use it.
         $author_cmd = '';
         $author = $bundle->getAuthor();
         if ($author) {
           $address = new PhutilEmailAddress($author);
           if ($address->getDisplayName() && $address->getAddress()) {
             $author = sprintf('%s <%s>',
                               $address->getDisplayName(),
                               $address->getAddress());
             $author_cmd = csprintf('--author=%s ', $author);
           }
         }
         $commit_message = $this->getCommitMessage($bundle);
         $future = $repository_api->execFutureLocal(
           'commit -a %C-F -',
           $author_cmd);
         $future->write($commit_message);
         $future->resolvex();
         $verb = 'committed';
       } else {
         $verb = 'applied';
       }
 
       if ($this->shouldCommit() && $this->canBranch() &&
           !$this->shouldBranch() && $has_base_revision) {
         $repository_api->execxLocal('checkout %s', $original_branch);
         $ex = null;
         try {
           $repository_api->execxLocal('cherry-pick %s', $new_branch);
         } catch (Exception $ex) {}
         $repository_api->execxLocal('branch -D %s', $new_branch);
         if ($ex) {
           echo phutil_console_format(
             "\n<bg:red>** Cherry Pick Failed!**</bg>\n");
           throw $ex;
         }
       }
 
       echo phutil_console_format(
         "<bg:green>** OKAY **</bg> Successfully {$verb} patch.\n");
     } else if ($repository_api instanceof ArcanistMercurialAPI) {
 
       $future = $repository_api->execFutureLocal(
         'import --no-commit -');
       $future->write($bundle->toGitPatch());
 
       try {
         $future->resolvex();
       } catch (CommandException $ex) {
         echo phutil_console_format(
           "\n<bg:red>** Patch Failed! **</bg>\n");
         $stderr = $ex->getStdErr();
         if (preg_match('/case-folding collision/', $stderr)) {
           echo phutil_console_wrap(
             phutil_console_format(
               "\n<bg:yellow>** WARNING **</bg> This patch may have failed ".
               "because it attempts to change the case of a filename (for ".
               "instance, from 'example.c' to 'Example.c'). Mercurial cannot ".
               "apply patches like this on case-insensitive filesystems. You ".
               "must apply this patch manually.\n"));
         }
         throw $ex;
       }
 
       if ($this->shouldCommit()) {
         $author_cmd = '';
         $author = $bundle->getAuthor();
         if ($author) {
           $author_cmd = sprintf('-u %s ', $author);
         }
         $commit_message = $this->getCommitMessage($bundle);
         $future = $repository_api->execFutureLocal(
           'commit -A %C-l -',
           $author_cmd);
         $future->write($commit_message);
         $future->resolvex();
         $verb = 'committed';
       } else {
         $verb = 'applied';
       }
       echo phutil_console_format(
         "<bg:green>** OKAY **</bg> Successfully {$verb} patch.\n");
 
     } else {
       throw new Exception('Unknown version control system.');
     }
 
     return 0;
   }
 
   private function getCommitMessage(ArcanistBundle $bundle) {
     $revision_id    = $bundle->getRevisionID();
     $commit_message = null;
     $prompt_message = null;
 
     // if we have a revision id the commit message is in differential
 
     // TODO: See T848 for the authenticated stuff.
     if ($revision_id && $this->isConduitAuthenticated()) {
 
       $conduit        = $this->getConduit();
       $commit_message = $conduit->callMethodSynchronous(
         'differential.getcommitmessage',
         array(
           'revision_id' => $revision_id,
         ));
       $prompt_message = "  Note arcanist failed to load the commit message ".
                         "from differential for revision D{$revision_id}.";
     }
 
     // no revision id or failed to fetch commit message so get it from the
     // user on the command line
     if (!$commit_message) {
       $template =
         "\n\n".
         "# Enter a commit message for this patch.  If you just want to apply ".
         "the patch to the working copy without committing, re-run arc patch ".
         "with the --nocommit flag.".
         $prompt_message.
         "\n";
 
       $commit_message = $this->newInteractiveEditor($template)
         ->setName('arcanist-patch-commit-message')
         ->editInteractively();
 
       $commit_message = ArcanistCommentRemover::removeComments($commit_message);
       if (!strlen(trim($commit_message))) {
         throw new ArcanistUserAbortException();
       }
     }
 
     return $commit_message;
   }
 
   public function getShellCompletions(array $argv) {
     // TODO: Pull open diffs from 'arc list'?
     return array('ARGUMENT');
   }
 
   /**
    * Do the best we can to prevent PEBKAC and id10t issues.
    */
   private function sanityCheck(ArcanistBundle $bundle) {
     $repository_api = $this->getRepositoryAPI();
 
-    if ($repository_api->supportsRelativeLocalCommits()) {
-      $repository_api->setDefaultBaseCommit();
-    }
-
     // Require clean working copy
     $this->requireCleanWorkingCopy();
 
     // Check to see if the bundle's project id matches the working copy
     // project id
     $bundle_project_id = $bundle->getProjectID();
     $working_copy_project_id = $this->getWorkingCopy()->getProjectID();
     if (empty($bundle_project_id)) {
       // this means $source is SOURCE_PATCH || SOURCE_BUNDLE w/ $version = 0
       // they don't come with a project id so just do nothing
     } else if ($bundle_project_id != $working_copy_project_id) {
       if ($working_copy_project_id) {
         $issue =
           "This patch is for the '{$bundle_project_id}' project,  but the ".
           "working copy belongs to the '{$working_copy_project_id}' project.";
       } else {
         $issue =
           "This patch is for the '{$bundle_project_id}' project, but the ".
           "working copy does not have an '.arcconfig' file to identify which ".
           "project it belongs to.";
       }
       $ok = phutil_console_confirm(
         "{$issue} Still try to apply the patch?",
         $default_no = false
       );
       if (!$ok) {
         throw new ArcanistUserAbortException();
       }
     }
 
     // Check to see if the bundle's base revision matches the working copy
     // base revision
     if ($repository_api->supportsRelativeLocalCommits()) {
       $bundle_base_rev = $bundle->getBaseRevision();
       if (empty($bundle_base_rev)) {
         // this means $source is SOURCE_PATCH || SOURCE_BUNDLE w/ $version < 2
         // they don't have a base rev so just do nothing
         $commit_exists = true;
       } else {
         $commit_exists =
           $repository_api->hasLocalCommit($bundle_base_rev);
       }
       if (!$commit_exists) {
         // we have a problem...! lots of work because we need to ask
         // differential for revision information for these base revisions
         // to improve our error message.
         $bundle_base_rev_str = null;
         $source_base_rev     = $repository_api->getWorkingCopyRevision();
         $source_base_rev_str = null;
 
         if ($repository_api instanceof ArcanistGitAPI) {
           $hash_type = ArcanistDifferentialRevisionHash::HASH_GIT_COMMIT;
         } else if ($repository_api instanceof ArcanistMercurialAPI) {
           $hash_type = ArcanistDifferentialRevisionHash::HASH_MERCURIAL_COMMIT;
         } else {
           $hash_type = null;
         }
 
         if ($hash_type) {
           // 2 round trips because even though we could send off one query
           // we wouldn't be able to tell which revisions were for which hash
           $hash = array($hash_type, $bundle_base_rev);
           $bundle_revision = $this->loadRevisionFromHash($hash);
           $hash = array($hash_type, $source_base_rev);
           $source_revision = $this->loadRevisionFromHash($hash);
 
           if ($bundle_revision) {
             $bundle_base_rev_str = $bundle_base_rev .
                                    ' \ D' . $bundle_revision['id'];
           }
           if ($source_revision) {
             $source_base_rev_str = $source_base_rev .
                                    ' \ D' . $source_revision['id'];
           }
         }
         $bundle_base_rev_str = nonempty($bundle_base_rev_str,
                                         $bundle_base_rev);
         $source_base_rev_str = nonempty($source_base_rev_str,
                                         $source_base_rev);
 
         $ok = phutil_console_confirm(
           "This diff is against commit {$bundle_base_rev_str}, but the ".
           "commit is nowhere in the working copy. Try to apply it against ".
           "the current working copy state? ({$source_base_rev_str})",
           $default_no = false
         );
         if (!$ok) {
           throw new ArcanistUserAbortException();
         }
       }
     }
 
     // TODO -- more sanity checks here
   }
 
   /**
    * Create parent directories one at a time, since we need to "svn add" each
    * one. (Technically we could "svn add" just the topmost new directory.)
    */
   private function createParentDirectoryOf($path) {
     $repository_api = $this->getRepositoryAPI();
     $dir = dirname($path);
     if (Filesystem::pathExists($dir)) {
       return;
     } else {
       // Make sure the parent directory exists before we make this one.
       $this->createParentDirectoryOf($dir);
       execx(
         '(cd %s && mkdir %s)',
         $repository_api->getPath(),
         $dir);
       passthru(
         csprintf(
           '(cd %s && svn add %s)',
           $repository_api->getPath(),
           $dir));
     }
   }
 
   private function loadRevisionFromHash($hash) {
     // TODO -- de-hack this as permissions become more clear with things
     // like T848 (add scope to OAuth)
     if (!$this->isConduitAuthenticated()) {
       return null;
     }
 
     $conduit = $this->getConduit();
 
     $revisions = $conduit->callMethodSynchronous(
       'differential.query',
       array(
         'commitHashes' => array($hash),
       )
     );
 
 
     // grab the latest closed revision only
     $found_revision = null;
     $revisions = isort($revisions, 'dateModified');
     foreach ($revisions as $revision) {
       if ($revision['status'] == ArcanistDifferentialRevisionStatus::CLOSED) {
         $found_revision = $revision;
       }
     }
     return $found_revision;
   }
 }
diff --git a/src/workflow/ArcanistUpgradeWorkflow.php b/src/workflow/ArcanistUpgradeWorkflow.php
index 348686ce..803fc0d2 100644
--- a/src/workflow/ArcanistUpgradeWorkflow.php
+++ b/src/workflow/ArcanistUpgradeWorkflow.php
@@ -1,86 +1,82 @@
 <?php
 
 /**
  * Upgrade arcanist itself.
  *
  * @group workflow
  */
 final class ArcanistUpgradeWorkflow extends ArcanistBaseWorkflow {
 
   public function getWorkflowName() {
     return 'upgrade';
   }
 
   public function getCommandSynopses() {
     return phutil_console_format(<<<EOTEXT
       **upgrade**
 EOTEXT
       );
   }
 
   public function getCommandHelp() {
     return phutil_console_format(<<<EOTEXT
           Supports: cli
           Upgrade arcanist and libphutil to the latest versions.
 EOTEXT
       );
   }
 
   public function getArguments() {
     return array();
   }
 
   public function run() {
     $roots = array();
     $roots['libphutil'] = dirname(phutil_get_library_root('phutil'));
     $roots['arcanist'] = dirname(phutil_get_library_root('arcanist'));
 
     foreach ($roots as $lib => $root) {
       echo "Upgrading {$lib}...\n";
 
       if (!Filesystem::pathExists($root.'/.git')) {
         throw new ArcanistUsageException(
           "{$lib} must be in its git working copy to be automatically ".
           "upgraded. This copy of {$lib} (in '{$root}') is not in a git ".
           "working copy.");
       }
 
       $working_copy = ArcanistWorkingCopyIdentity::newFromPath($root);
 
       $repository_api = ArcanistRepositoryAPI::newAPIFromWorkingCopyIdentity(
         $working_copy);
 
-      if ($repository_api->supportsRelativeLocalCommits()) {
-        $repository_api->setDefaultBaseCommit();
-      }
-
       $this->setRepositoryAPI($repository_api);
 
       // Require no local changes.
       $this->requireCleanWorkingCopy();
 
       // Require the library be on master.
       $branch_name = $repository_api->getBranchName();
       if ($branch_name != 'master') {
         throw new ArcanistUsageException(
           "{$lib} must be on branch 'master' to be automatically upgraded. ".
           "This copy of {$lib} (in '{$root}') is on branch '{$branch_name}'.");
       }
 
       chdir($root);
       try {
         phutil_passthru('git pull --rebase');
       } catch (Exception $ex) {
         phutil_passthru('git rebase --abort');
         throw $ex;
       }
     }
 
     echo phutil_console_wrap(
       phutil_console_format(
         "**Updated!** Your copy of arc is now up to date.\n"));
 
     return 0;
   }
 
 }