diff --git a/src/repository/api/ArcanistGitAPI.php b/src/repository/api/ArcanistGitAPI.php
index 70ce4649..2ccbed0b 100644
--- a/src/repository/api/ArcanistGitAPI.php
+++ b/src/repository/api/ArcanistGitAPI.php
@@ -1,849 +1,857 @@
 <?php
 
 /*
  * Copyright 2012 Facebook, Inc.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
  *
  *   http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
 
 /**
  * Interfaces with Git working copies.
  *
  * @group workingcopy
  */
 final class ArcanistGitAPI extends ArcanistRepositoryAPI {
 
   private $status;
   private $relativeCommit = null;
   private $relativeExplanation = '???';
   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.
    */
   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 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->relativeExplanation = "the repository has no commits.";
         } else {
           $this->relativeExplanation = "the repository has only one commit.";
         }
 
         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->relativeExplanation =
           "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->relativeExplanation =
             "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->relativeExplanation =
             "it is the merge-base of '{$default_relative}' and HEAD, as ".
             "specified in '.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 '{$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->relativeExplanation =
           "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');
 
     $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) {
     list($stdout) = $this->execxLocal('show -s --format=%C %s',
       '%H', $string);
     return rtrim($stdout);
   }
 
   public function getWorkingCopyStatus() {
     if (!isset($this->status)) {
 
       $options = $this->getDiffBaseOptions();
 
       // -- parallelize these slow cpu bound git calls.
 
       // Find committed changes.
       $committed_future = $this->buildLocalFuture(
         array(
           "diff {$options} --raw %s --",
           $this->getRelativeCommit(),
         ));
 
       // Find uncommitted changes.
       $uncommitted_future = $this->buildLocalFuture(
         array(
           "diff {$options} --raw %s --",
           $this->repositoryHasNoCommits
             ? self::GIT_MAGIC_ROOT_COMMIT
             : 'HEAD',
         ));
 
       // Untracked files
       $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(
         $committed_future,
         $uncommitted_future,
         $untracked_future,
         $unstaged_future
       );
       Futures($futures)->resolveAll();
 
 
       // -- read back and process the results
 
       list($stdout, $stderr) = $committed_future->resolvex();
       $files = $this->parseGitStatus($stdout);
 
       list($stdout, $stderr) = $uncommitted_future->resolvex();
       $uncommitted_files = $this->parseGitStatus($stdout);
       foreach ($uncommitted_files as $path => $mask) {
         $mask |= self::FLAG_UNCOMMITTED;
         if (!isset($files[$path])) {
           $files[$path] = 0;
         }
         $files[$path] |= $mask;
       }
 
       list($stdout, $stderr) = $untracked_future->resolvex();
       $stdout = rtrim($stdout, "\n");
       if (strlen($stdout)) {
         $stdout = explode("\n", $stdout);
         foreach ($stdout as $file) {
           $files[$file] = self::FLAG_UNTRACKED;
         }
       }
 
       list($stdout, $stderr) = $unstaged_future->resolvex();
       $stdout = rtrim($stdout, "\n");
       if (strlen($stdout)) {
         $stdout = explode("\n", $stdout);
         foreach ($stdout as $file) {
           $files[$file] = isset($files[$file])
             ? ($files[$file] | self::FLAG_UNSTAGED)
             : self::FLAG_UNSTAGED;
         }
       }
 
       $this->status = $files;
     }
 
     return $this->status;
   }
 
-  public function amendGitHeadCommit($message) {
+  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);
       }
     }
 
     $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 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 array where each element is a triple ('name', 'sha1', 'current')
    */
   public function getAllBranches() {
     list($branch_info) = $this->execxLocal('branch --no-color');
     $lines = explode("\n", trim($branch_info));
     $result = array();
     foreach ($lines as $line) {
       $match = array();
       preg_match('/^(\*?)\s*(.*)$/', $line, $match);
       $name = $match[2];
       if ($name == '(no branch)') {
         // Just ignore this, we could theoretically try to figure out the ref
         // and treat it like a real branch but that's sort of ridiculous.
         continue;
       }
       $result[] = array(
         'current' => !empty($match[1]),
         'name'    => $name,
       );
     }
     $all_names = ipull($result, 'name');
     // Calling 'git branch' first and then 'git rev-parse' is way faster than
     // 'git branch -v' for some reason.
     list($sha1s_string) = $this->execxLocal('rev-parse %Ls', $all_names);
 
     $sha1_map = array_combine($all_names, explode("\n", trim($sha1s_string)));
     foreach ($result as &$branch) {
       $branch['sha1'] = $sha1_map[$branch['name']];
     }
     return $result;
   }
 
   /**
    * Returns git commit messages for the given revisions,
    * in the specified format (see git show --help for options).
    *
    * @param array $revs a list of commit hashes
    * @param string $format the format to show messages in
    */
   public function multigetCommitMessages($revs, $format) {
 
     list($commits_string) = $this->execxLocal(
       "show -s --pretty='format:'%s%s %Ls",
       $format,
       '%x00',
       $revs);
 
     $commits_list = array_slice(explode("\0", $commits_string), 0, -1);
     $commits_list = array_combine($revs, $commits_list);
     return $commits_list;
   }
 
   public function getRepositoryOwner() {
     list($owner) = $this->execxLocal('config --get user.name');
     return trim($owner);
   }
 
   public function getWorkingCopyRevision() {
     list($stdout) = $this->execxLocal('rev-parse HEAD');
     return rtrim($stdout, "\n");
   }
 
+  public function isHistoryDefaultImmutable() {
+    return false;
+  }
+
+  public function supportsAmend() {
+    return true;
+  }
+
   public function supportsRelativeLocalCommits() {
     return true;
   }
 
   public function hasLocalCommit($commit) {
     try {
       $this->getCanonicalRevisionName($commit);
     } 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->relativeExplanation =
         "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->relativeExplanation =
         "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 getCommitMessageForRevision($rev) {
     list($message) = $this->execxLocal(
       'log -n1 %s',
       $rev);
     $parser = new ArcanistDiffParser();
     return head($parser->parseDiff($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 getRelativeExplanation() {
     return $this->relativeExplanation;
   }
 
   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);
   }
 
 }
diff --git a/src/repository/api/ArcanistMercurialAPI.php b/src/repository/api/ArcanistMercurialAPI.php
index 2acb0de1..fa5c74c6 100644
--- a/src/repository/api/ArcanistMercurialAPI.php
+++ b/src/repository/api/ArcanistMercurialAPI.php
@@ -1,560 +1,612 @@
 <?php
 
 /*
  * Copyright 2012 Facebook, Inc.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
  *
  *   http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
 
 /**
  * Interfaces with the Mercurial working copies.
  *
  * @group workingcopy
  */
 final class ArcanistMercurialAPI extends ArcanistRepositoryAPI {
 
   private $status;
   private $base;
   private $relativeCommit;
   private $relativeExplanation;
   private $workingCopyRevision;
   private $localCommitInfo;
   private $includeDirectoryStateInDiffs;
 
   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 getSourceControlSystemName() {
     return '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() {
     // TODO: I have nearly no idea how hg branches work.
     list($stdout) = $this->execxLocal('branch');
     return trim($stdout);
   }
 
   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->dropCaches();
 
     return $this;
   }
 
   public function getRelativeCommit() {
     if (empty($this->relativeCommit)) {
       list($err, $stdout) = $this->execManualLocal(
         'outgoing --branch `hg branch` --style default');
 
       if (!$err) {
         $logs = ArcanistMercurialParser::parseMercurialLog($stdout);
       } else {
         // Mercurial (in some versions?) raises an error when there's nothing
         // outgoing.
         $logs = array();
       }
 
       if (!$logs) {
 
         $this->relativeExplanation =
           "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->relativeExplanation =
           "this is a new repository (all changes are outgoing).";
       } else {
         $this->relativeExplanation =
           "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' --prune %s --rev %s --branch %s --",
         "{node}\1{rev}\1{author}\1{date|rfc822date}\1".
           "{branch}\1{tag}\1{parents}\1{desc}\2",
         $this->getRelativeCommit(),
         "ancestors({$this->getWorkingCopyRevision()})",
         $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 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;
   }
 
   public function getWorkingCopyStatus() {
 
     if (!isset($this->status)) {
       // A reviewable revision spans multiple local commits in Mercurial, but
       // there is no way to get file change status across multiple commits, so
       // just take the entire diff and parse it to figure out what's changed.
 
       $diff = $this->getFullMercurialDiff();
 
       if (!$diff) {
         $this->status = array();
         return $this->status;
       }
 
       $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;
       }
 
       list($stdout) = $this->execxLocal('status');
 
       $working_status = ArcanistMercurialParser::parseMercurialStatus($stdout);
       foreach ($working_status as $path => $status) {
         if ($status & ArcanistRepositoryAPI::FLAG_UNTRACKED) {
           // If the file is untracked, don't mark it uncommitted.
           continue;
         }
         $status |= self::FLAG_UNCOMMITTED;
         if (!empty($status_map[$path])) {
           $status_map[$path] |= $status;
         } else {
           $status_map[$path] = $status;
         }
       }
 
       $this->status = $status_map;
     }
 
     return $this->status;
   }
 
   private function getDiffOptions() {
     $options = array(
       '--git',
       '-U'.$this->getDiffLinesOfContext(),
     );
     return implode(' ', $options);
   }
 
   public function getRawDiffText($path) {
     $options = $this->getDiffOptions();
 
     list($stdout) = $this->execxLocal(
       'diff %C --rev %s --rev %s -- %s',
       $options,
       $this->getRelativeCommit(),
       $this->getDiffToRevision(),
       $path);
 
     return $stdout;
   }
 
   public function getFullMercurialDiff() {
     $options = $this->getDiffOptions();
 
     list($stdout) = $this->execxLocal(
       'diff %C --rev %s --rev %s --',
       $options,
       $this->getRelativeCommit(),
       $this->getDiffToRevision());
 
     return $stdout;
   }
 
   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() {
     if ($this->workingCopyRevision === null) {
       // In Mercurial, "tip" means the tip of the current branch, not what's in
       // the working copy. The tip may be ahead of the working copy. We need to
       // use "hg summary" to figure out what is actually in the working copy.
       // For instance, "hg up 4 && arc diff" should not show commits 5 and
       // above.
 
       // Without arguments, "hg id" shows the current working directory's
       // commit, and "--debug" expands it to a 40-character hash.
       list($stdout) = $this->execxLocal('--debug id --id');
 
       // Even with "--id", "hg id" will print a trailing "+" after the hash
       // if the working copy is dirty (has uncommitted changes). We'll
       // explicitly detect this later by calling getWorkingCopyStatus(); ignore
       // it for now.
       $stdout = trim($stdout);
       $this->workingCopyRevision = rtrim($stdout, '+');
     }
     return $this->workingCopyRevision;
   }
 
+  public function isHistoryDefaultImmutable() {
+    return true;
+  }
+
+  public function supportsAmend() {
+    list ($err, $stdout) = $this->execManualLocal('help commit');
+    if ($err) {
+        return false;
+    } else {
+        return (strstr($stdout, "amend") !== false);
+    }
+  }
+
   public function supportsRelativeLocalCommits() {
     return true;
   }
 
   public function hasLocalCommit($commit) {
     try {
       $this->getCanonicalRevisionName($commit);
       return true;
     } catch (Exception $ex) {
       return false;
     }
   }
 
   public function parseRelativeLocalCommit(array $argv) {
     if (count($argv) == 0) {
       return;
     }
     if (count($argv) != 1) {
       throw new ArcanistUsageException("Specify only one commit.");
     }
 
     $this->relativeExplanation = "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}\\1{desc}\\0' --rev %s..%s --",
+      "log --template '{node}\\1{desc}\\0' --prune %s --rev %s --",
       $this->getRelativeCommit(),
-      $this->getWorkingCopyRevision());
+      "ancestors({$this->getWorkingCopyRevision()})");
 
     $map = array();
 
     $logs = explode("\0", trim($stdout));
     foreach (array_filter($logs) as $log) {
       list($node, $desc) = explode("\1", $log);
       $map[$node] = $desc;
     }
 
     return array_reverse($map);
   }
 
   public function loadWorkingCopyDifferentialRevisions(
     ConduitClient $conduit,
     array $query) {
 
+    $messages = $this->getCommitMessageLog();
+    $parser = new ArcanistDiffParser();
+
+    // First, try to find revisions by explicit revision IDs in commit messages.
+    $reason_map = array();
+    $revision_ids = array();
+    foreach ($messages as $node_id => $message) {
+      $object = ArcanistDifferentialCommitMessage::newFromRawCorpus($message);
+
+      if ($object->getRevisionID()) {
+        $revision_ids[] = $object->getRevisionID();
+        $reason_map[$object->getRevisionID()] = $node_id;
+      }
+    }
+
+    if ($revision_ids) {
+      $results = $conduit->callMethodSynchronous(
+        'differential.query',
+        $query + array(
+          'ids' => $revision_ids,
+        ));
+
+      foreach ($results as $key => $result) {
+        $hash = substr($reason_map[$result['id']], 0, 16);
+        $results[$key]['why'] =
+          "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']);
     }
 
     $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;
   }
 
   public function updateWorkingCopy() {
     $this->execxLocal('up');
   }
 
+  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;
   }
 
   private function getDiffToRevision() {
     $this->dropCaches();
 
     if ($this->includeDirectoryStateInDiffs) {
       // This is a magic Mercurial revision name which means "current
       // directory state"; see lookup() in localrepo.py.
       return '.';
     } else {
       return $this->getWorkingCopyRevision();
     }
   }
 
   private function dropCaches() {
     $this->status = null;
     $this->localCommitInfo = null;
   }
 
   public function getRelativeExplanation() {
     return $this->relativeExplanation;
   }
 
   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);
   }
 
 }
diff --git a/src/repository/api/ArcanistRepositoryAPI.php b/src/repository/api/ArcanistRepositoryAPI.php
index 30f77db7..44feef77 100644
--- a/src/repository/api/ArcanistRepositoryAPI.php
+++ b/src/repository/api/ArcanistRepositoryAPI.php
@@ -1,353 +1,359 @@
 <?php
 
 /*
  * Copyright 2012 Facebook, Inc.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
  *
  *   http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
 
 /**
  * Interfaces with the VCS in the working copy.
  *
  * @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 $workingCopyIdentity;
 
   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.");
     }
 
     // check if we're in an svn working copy
     list($err) = exec_manual('svn info');
     if (!$err) {
       $api = new ArcanistSubversionAPI($root);
       $api->workingCopyIdentity = $working_copy;
       return $api;
     }
 
     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;
     }
 
     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;
     }
   }
 
   public function getUntrackedChanges() {
     return $this->getWorkingCopyFilesWithMask(self::FLAG_UNTRACKED);
   }
 
   public function getUnstagedChanges() {
     return $this->getWorkingCopyFilesWithMask(self::FLAG_UNSTAGED);
   }
 
   public function getUncommittedChanges() {
     return $this->getWorkingCopyFilesWithMask(self::FLAG_UNCOMMITTED);
   }
 
   public function getMergeConflicts() {
     return $this->getWorkingCopyFilesWithMask(self::FLAG_CONFLICT);
   }
 
   public function getIncompleteChanges() {
     return $this->getWorkingCopyFilesWithMask(self::FLAG_INCOMPLETE);
   }
 
   private function getWorkingCopyFilesWithMask($mask) {
     $match = array();
     foreach ($this->getWorkingCopyStatus() as $file => $flags) {
       if ($flags & $mask) {
         $match[] = $file;
       }
     }
     return $match;
   }
 
   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;
     }
   }
 
   abstract public function getBlame($path);
   abstract public function getWorkingCopyStatus();
   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 isHistoryDefaultImmutable();
+  abstract public function supportsAmend();
   abstract public function supportsRelativeLocalCommits();
   abstract public function getWorkingCopyRevision();
   abstract public function updateWorkingCopy();
   abstract public function loadWorkingCopyDifferentialRevisions(
     ConduitClient $conduit,
     array $query);
 
+  public function amendCommit() {
+    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 getCommitMessageForRevision($revision) {
     throw new ArcanistCapabilityNotSupportedException($this);
   }
 
   public function parseRelativeLocalCommit(array $argv) {
     throw new ArcanistCapabilityNotSupportedException($this);
   }
 
   public function getRelativeExplanation() {
     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) {
     return $this->getPath('.arc/'.$path);
   }
 
 }
diff --git a/src/repository/api/ArcanistSubversionAPI.php b/src/repository/api/ArcanistSubversionAPI.php
index fa8e15b5..ee27665a 100644
--- a/src/repository/api/ArcanistSubversionAPI.php
+++ b/src/repository/api/ArcanistSubversionAPI.php
@@ -1,568 +1,576 @@
 <?php
 
 /*
  * Copyright 2012 Facebook, Inc.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
  *
  *   http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
 
 /**
  * Interfaces with Subversion working copies.
  *
  * @group workingcopy
  */
 final class ArcanistSubversionAPI extends ArcanistRepositoryAPI {
 
   protected $svnStatus;
   protected $svnBaseRevisions;
   protected $svnInfo = array();
 
   protected $svnInfoRaw = array();
   protected $svnDiffRaw = array();
 
   private $svnBaseRevisionNumber;
 
   public function getSourceControlSystemName() {
     return 'svn';
   }
 
   protected function buildLocalFuture(array $argv) {
 
     $argv[0] = 'svn '.$argv[0];
 
     $future = newv('ExecFuture', $argv);
     $future->setCWD($this->getPath());
     return $future;
   }
 
 
   public function hasMergeConflicts() {
     foreach ($this->getSVNStatus() as $path => $mask) {
       if ($mask & self::FLAG_CONFLICT) {
         return true;
       }
     }
     return false;
   }
 
   public function getWorkingCopyStatus() {
     return $this->getSVNStatus();
   }
 
   public function getSVNBaseRevisions() {
     if ($this->svnBaseRevisions === null) {
       $this->getSVNStatus();
     }
     return $this->svnBaseRevisions;
   }
 
   public function getSVNStatus($with_externals = false) {
     if ($this->svnStatus === null) {
       list($status) = execx('(cd %s && svn --xml status)', $this->getPath());
       $xml = new SimpleXMLElement($status);
 
       if (count($xml->target) != 1) {
         throw new Exception("Expected exactly one XML status target.");
       }
 
       $externals = array();
       $files = array();
 
       $target = $xml->target[0];
       $this->svnBaseRevisions = array();
       foreach ($target->entry as $entry) {
         $path = (string)$entry['path'];
         $mask = 0;
 
         $props = (string)($entry->{'wc-status'}[0]['props']);
         $item  = (string)($entry->{'wc-status'}[0]['item']);
 
         $base = (string)($entry->{'wc-status'}[0]['revision']);
         $this->svnBaseRevisions[$path] = $base;
 
         switch ($props) {
           case 'none':
           case 'normal':
             break;
           case 'modified':
             $mask |= self::FLAG_MODIFIED;
             break;
           default:
             throw new Exception("Unrecognized property status '{$props}'.");
         }
 
         switch ($item) {
           case 'normal':
             break;
           case 'external':
             $mask |= self::FLAG_EXTERNALS;
             $externals[] = $path;
             break;
           case 'unversioned':
             $mask |= self::FLAG_UNTRACKED;
             break;
           case 'obstructed':
             $mask |= self::FLAG_OBSTRUCTED;
             break;
           case 'missing':
             $mask |= self::FLAG_MISSING;
             break;
           case 'added':
             $mask |= self::FLAG_ADDED;
             break;
           case 'replaced':
             // This is the result of "svn rm"-ing a file, putting another one
             // in place of it, and then "svn add"-ing the new file. Just treat
             // this as equivalent to "modified".
             $mask |= self::FLAG_MODIFIED;
             break;
           case 'modified':
             $mask |= self::FLAG_MODIFIED;
             break;
           case 'deleted':
             $mask |= self::FLAG_DELETED;
             break;
           case 'conflicted':
             $mask |= self::FLAG_CONFLICT;
             break;
           case 'incomplete':
             $mask |= self::FLAG_INCOMPLETE;
             break;
           default:
             throw new Exception("Unrecognized item status '{$item}'.");
         }
 
         // This is new in or around Subversion 1.6.
         $tree_conflicts = (string)($entry->{'wc-status'}[0]['tree-conflicted']);
         if ($tree_conflicts) {
           $mask |= self::FLAG_CONFLICT;
         }
 
         $files[$path] = $mask;
       }
 
       foreach ($files as $path => $mask) {
         foreach ($externals as $external) {
           if (!strncmp($path, $external, strlen($external))) {
             $files[$path] |= self::FLAG_EXTERNALS;
           }
         }
       }
 
       $this->svnStatus = $files;
     }
 
     $status = $this->svnStatus;
     if (!$with_externals) {
       foreach ($status as $path => $mask) {
         if ($mask & ArcanistRepositoryAPI::FLAG_EXTERNALS) {
           unset($status[$path]);
         }
       }
     }
 
     return $status;
   }
 
   public function getSVNProperty($path, $property) {
     list($stdout) = execx(
       'svn propget %s %s@',
       $property,
       $this->getPath($path));
     return trim($stdout);
   }
 
   public function getSourceControlPath() {
     return idx($this->getSVNInfo('/'), 'URL');
   }
 
   public function getSourceControlBaseRevision() {
     $info = $this->getSVNInfo('/');
     return $info['URL'].'@'.$this->getSVNBaseRevisionNumber();
   }
 
   public function getCanonicalRevisionName($string) {
     throw new ArcanistCapabilityNotSupportedException($this);
   }
 
   public function getSVNBaseRevisionNumber() {
     if ($this->svnBaseRevisionNumber) {
       return $this->svnBaseRevisionNumber;
     }
     $info = $this->getSVNInfo('/');
     return $info['Revision'];
   }
 
   public function overrideSVNBaseRevisionNumber($effective_base_revision) {
     $this->svnBaseRevisionNumber = $effective_base_revision;
     return $this;
   }
 
   public function getBranchName() {
     return 'svn';
   }
 
   public function buildInfoFuture($path) {
     if ($path == '/') {
       // When the root of a working copy is referenced by a symlink and you
       // execute 'svn info' on that symlink, svn fails. This is a longstanding
       // bug in svn:
       //
       // See http://subversion.tigris.org/issues/show_bug.cgi?id=2305
       //
       // To reproduce, do:
       //
       //  $ ln -s working_copy working_link
       //  $ svn info working_copy # ok
       //  $ svn info working_link # fails
       //
       // Work around this by cd-ing into the directory before executing
       // 'svn info'.
       return new ExecFuture(
         '(cd %s && svn info .)',
         $this->getPath());
     } else {
       // Note: here and elsewhere we need to append "@" to the path because if
       // a file has a literal "@" in it, everything after that will be
       // interpreted as a revision. By appending "@" with no argument, SVN
       // parses it properly.
       return new ExecFuture(
         'svn info %s@',
         $this->getPath($path));
     }
   }
 
   public function buildDiffFuture($path) {
     // The "--depth empty" flag prevents us from picking up changes in
     // children when we run 'diff' against a directory. Specifically, when a
     // user has added or modified some directory "example/", we want to return
     // ONLY changes to that directory when given it as a path. If we run
     // without "--depth empty", svn will give us changes to the directory
     // itself (such as property changes) and also give us changes to any
     // files within the directory (basically, implicit recursion). We don't
     // want that, so prevent recursive diffing.
     return new ExecFuture(
       '(cd %s; svn diff --depth empty --diff-cmd diff -x -U%d %s)',
       $this->getPath(),
       $this->getDiffLinesOfContext(),
       $path);
   }
 
   public function primeSVNInfoResult($path, $result) {
     $this->svnInfoRaw[$path] = $result;
     return $this;
   }
 
   public function primeSVNDiffResult($path, $result) {
     $this->svnDiffRaw[$path] = $result;
     return $this;
   }
 
   public function getSVNInfo($path) {
 
     if (empty($this->svnInfo[$path])) {
 
       if (empty($this->svnInfoRaw[$path])) {
         $this->svnInfoRaw[$path] = $this->buildInfoFuture($path)->resolve();
       }
 
       list($err, $stdout) = $this->svnInfoRaw[$path];
       if ($err) {
         throw new Exception(
           "Error #{$err} executing svn info against '{$path}'.");
       }
 
       $patterns = array(
         '/^(URL): (\S+)$/m',
         '/^(Revision): (\d+)$/m',
         '/^(Last Changed Author): (\S+)$/m',
         '/^(Last Changed Rev): (\d+)$/m',
         '/^(Last Changed Date): (.+) \(.+\)$/m',
         '/^(Copied From URL): (\S+)$/m',
         '/^(Copied From Rev): (\d+)$/m',
         '/^(Repository UUID): (\S+)$/m',
         '/^(Node Kind): (\S+)$/m',
       );
 
       $result = array();
       foreach ($patterns as $pattern) {
         $matches = null;
         if (preg_match($pattern, $stdout, $matches)) {
           $result[$matches[1]] = $matches[2];
         }
       }
 
       if (isset($result['Last Changed Date'])) {
         $result['Last Changed Date'] = strtotime($result['Last Changed Date']);
       }
 
       if (empty($result)) {
         throw new Exception('Unable to parse SVN info.');
       }
 
       $this->svnInfo[$path] = $result;
     }
 
     return $this->svnInfo[$path];
   }
 
 
   public function getRawDiffText($path) {
     $status = $this->getSVNStatus();
     if (!isset($status[$path])) {
       return null;
     }
 
     $status = $status[$path];
 
     // Build meaningful diff text for "svn copy" operations.
     if ($status & ArcanistRepositoryAPI::FLAG_ADDED) {
       $info = $this->getSVNInfo($path);
       if (!empty($info['Copied From URL'])) {
         return $this->buildSyntheticAdditionDiff(
           $path,
           $info['Copied From URL'],
           $info['Copied From Rev']);
       }
     }
 
     // If we run "diff" on a binary file which doesn't have the "svn:mime-type"
     // of "application/octet-stream", `diff' will explode in a rain of
     // unhelpful hellfire as it tries to build a textual diff of the two
     // files. We just fix this inline since it's pretty unambiguous.
     // TODO: Move this to configuration?
     $matches = null;
     if (preg_match('/\.(gif|png|jpe?g|swf|pdf|ico)$/i', $path, $matches)) {
       $mime = $this->getSVNProperty($path, 'svn:mime-type');
       if ($mime != 'application/octet-stream') {
         execx(
           'svn propset svn:mime-type application/octet-stream %s',
           $this->getPath($path));
       }
     }
 
     if (empty($this->svnDiffRaw[$path])) {
       $this->svnDiffRaw[$path] = $this->buildDiffFuture($path)->resolve();
     }
 
     list($err, $stdout, $stderr) = $this->svnDiffRaw[$path];
 
     // Note: GNU Diff returns 2 when SVN hands it binary files to diff and they
     // differ. This is not an error; it is documented behavior. But SVN isn't
     // happy about it. SVN will exit with code 1 and return the string below.
     if ($err != 0 && $stderr !== "svn: 'diff' returned 2\n") {
       throw new Exception(
         "svn diff returned unexpected error code: $err\n".
         "stdout: $stdout\n".
         "stderr: $stderr");
     }
 
     if ($err == 0 && empty($stdout)) {
       // If there are no changes, 'diff' exits with no output, but that means
       // we can not distinguish between empty and unmodified files. Build a
       // synthetic "diff" without any changes in it.
       return $this->buildSyntheticUnchangedDiff($path);
     }
 
     return $stdout;
   }
 
   protected function buildSyntheticAdditionDiff($path, $source, $rev) {
     $type = $this->getSVNProperty($path, 'svn:mime-type');
     if ($type == 'application/octet-stream') {
       return <<<EODIFF
 Index: {$path}
 ===================================================================
 Cannot display: file marked as a binary type.
 svn:mime-type = application/octet-stream
 
 EODIFF;
     }
 
     if (is_dir($this->getPath($path))) {
       return null;
     }
 
     $data = Filesystem::readFile($this->getPath($path));
     list($orig) = execx('svn cat %s@%s', $source, $rev);
 
     $src = new TempFile();
     $dst = new TempFile();
     Filesystem::writeFile($src, $orig);
     Filesystem::writeFile($dst, $data);
 
     list($err, $diff) = exec_manual(
       'diff -L a/%s -L b/%s -U%d %s %s',
       str_replace($this->getSourceControlPath().'/', '', $source),
       $path,
       $this->getDiffLinesOfContext(),
       $src,
       $dst);
 
     if ($err == 1) { // 1 means there are differences.
       return <<<EODIFF
 Index: {$path}
 ===================================================================
 {$diff}
 
 EODIFF;
     } else {
       return $this->buildSyntheticUnchangedDiff($path);
     }
   }
 
   protected function buildSyntheticUnchangedDiff($path) {
     $full_path = $this->getPath($path);
     if (is_dir($full_path)) {
       return null;
     }
 
     if (!file_exists($full_path)) {
       return null;
     }
 
     $data = Filesystem::readFile($full_path);
     $lines = explode("\n", $data);
     $len = count($lines);
     foreach ($lines as $key => $line) {
       $lines[$key] = ' '.$line;
     }
     $lines = implode("\n", $lines);
     return <<<EODIFF
 Index: {$path}
 ===================================================================
 --- {$path} (synthetic)
 +++ {$path} (synthetic)
 @@ -1,{$len} +1,{$len} @@
 {$lines}
 
 EODIFF;
   }
 
   public function getBlame($path) {
     $blame = array();
 
     list($stdout) = execx(
       '(cd %s && svn blame %s)',
       $this->getPath(),
       $path);
 
     $stdout = trim($stdout);
     if (!strlen($stdout)) {
       // Empty file.
       return $blame;
     }
 
     foreach (explode("\n", $stdout) as $line) {
       $m = array();
       if (!preg_match('/^\s*(\d+)\s+(\S+)/', $line, $m)) {
         throw new Exception("Bad blame? `{$line}'");
       }
       $revision = $m[1];
       $author = $m[2];
       $blame[] = array($author, $revision);
     }
 
     return $blame;
   }
 
   public function getOriginalFileData($path) {
     // SVN issues warnings for nonexistent paths, directories, etc., but still
     // returns no error code. However, for new paths in the working copy it
     // fails. Assume that failure means the original file does not exist.
     list($err, $stdout) = exec_manual(
       '(cd %s && svn cat %s@)',
       $this->getPath(),
       $path);
     if ($err) {
       return null;
     }
     return $stdout;
   }
 
   public function getCurrentFileData($path) {
     $full_path = $this->getPath($path);
     if (Filesystem::pathExists($full_path)) {
       return Filesystem::readFile($full_path);
     }
     return null;
   }
 
   public function getRepositorySVNUUID() {
     $info = $this->getSVNInfo('/');
     return $info['Repository UUID'];
   }
 
   public function getLocalCommitInformation() {
     return null;
   }
 
+  public function isHistoryDefaultImmutable() {
+    return true;
+  }
+
+  public function supportsAmend() {
+    return false;
+  }
+
   public function supportsRelativeLocalCommits() {
     return false;
   }
 
   public function hasLocalCommit($commit) {
     return false;
   }
 
   public function getWorkingCopyRevision() {
     return $this->getSourceControlBaseRevision();
   }
 
   public function supportsLocalBranchMerge() {
     return false;
   }
 
   public function getFinalizedRevisionMessage() {
     // In other VCSes we give push instructions here, but it never makes sense
     // in SVN.
     return "Done.";
   }
 
   public function loadWorkingCopyDifferentialRevisions(
     ConduitClient $conduit,
     array $query) {
 
     // We don't have much to go on in SVN, look for revisions that came from
     // this directory and belong to the same project.
 
     $project = $this->getWorkingCopyIdentity()->getProjectID();
     if (!$project) {
       return array();
     }
 
     $results = $conduit->callMethodSynchronous(
       'differential.query',
       $query + array(
         'arcanistProjects' => array($project),
       ));
 
     foreach ($results as $key => $result) {
       if ($result['sourcePath'] != $this->getPath()) {
         unset($results[$key]);
       }
     }
 
     foreach ($results as $key => $result) {
       $results[$key]['why'] =
         "Matching arcanist project name and working copy directory path.";
     }
 
     return $results;
   }
 
   public function updateWorkingCopy() {
     $this->execxLocal('up');
   }
 
 }
diff --git a/src/workflow/ArcanistAmendWorkflow.php b/src/workflow/ArcanistAmendWorkflow.php
index db7e2220..d4eb3972 100644
--- a/src/workflow/ArcanistAmendWorkflow.php
+++ b/src/workflow/ArcanistAmendWorkflow.php
@@ -1,197 +1,201 @@
 <?php
 
 /*
  * Copyright 2012 Facebook, Inc.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
  *
  *   http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
 
 /**
  * Updates git commit messages after a revision is "Accepted".
  *
  * @group workflow
  */
 final class ArcanistAmendWorkflow extends ArcanistBaseWorkflow {
 
   public function getCommandSynopses() {
     return phutil_console_format(<<<EOTEXT
       **amend** [--revision __revision_id__] [--show]
 EOTEXT
       );
   }
 
   public function getCommandHelp() {
     return phutil_console_format(<<<EOTEXT
-          Supports: git
+          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 (!($repository_api instanceof ArcanistGitAPI)) {
-      throw new ArcanistUsageException(
-        "You may only run 'arc amend' in a git working copy.");
-    }
-
     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'));
     }
 
     $repository_api->setRelativeCommit('HEAD^');
 
     $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->amendGitHeadCommit($message);
+
+      $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');
+    return array('git', 'hg');
   }
 
 }
diff --git a/src/workflow/ArcanistBaseWorkflow.php b/src/workflow/ArcanistBaseWorkflow.php
index d97ffaaf..19841126 100644
--- a/src/workflow/ArcanistBaseWorkflow.php
+++ b/src/workflow/ArcanistBaseWorkflow.php
@@ -1,1212 +1,1219 @@
 <?php
 
 /*
  * Copyright 2012 Facebook, Inc.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
  *
  *   http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
 
 /**
  * Implements a runnable command, like "arc diff" or "arc help".
  *
  * = Managing Conduit =
  *
  * Workflows have the builtin ability to open a Conduit connection to a
  * Phabricator installation, so methods can be invoked over the API. Workflows
  * may either not need this (e.g., "help"), or may need a Conduit but not
  * authentication (e.g., calling only public APIs), or may need a Conduit and
  * authentication (e.g., "arc diff").
  *
  * To specify that you need an //unauthenticated// conduit, override
  * @{method:requiresConduit} to return ##true##. To specify that you need an
  * //authenticated// conduit, override @{method:requiresAuthentication} to
  * return ##true##. You can also manually invoke @{method:establishConduit}
  * and/or @{method:authenticateConduit} later in a workflow to upgrade it.
  * Once a conduit is open, you can access the client by calling
  * @{method:getConduit}, which allows you to invoke methods. You can get
  * verified information about the user identity by calling @{method:getUserPHID}
  * or @{method:getUserName} after authentication occurs.
  *
  * = Scratch Files =
  *
  * Arcanist workflows can read and write 'scratch files', which are temporary
  * files stored in the project that persist across commands. They can be useful
  * if you want to save some state, or keep a copy of a long message the user
  * entered in something goes wrong..
  *
  *
  * @task  conduit   Conduit
  * @task  scratch   Scratch Files
  * @group workflow
  * @stable
  */
 abstract class ArcanistBaseWorkflow {
 
   private $conduit;
   private $conduitURI;
   private $conduitCredentials;
   private $conduitAuthenticated;
   private $forcedConduitVersion;
   private $conduitTimeout;
 
   private $userPHID;
   private $userName;
   private $repositoryAPI;
   private $workingCopy;
   private $arguments;
   private $command;
 
   private $repositoryEncoding;
 
   private $arcanistConfiguration;
   private $parentWorkflow;
   private $workingDirectory;
 
   private $changeCache = array();
 
   public function __construct() {
 
   }
 
 
 /* -(  Conduit  )------------------------------------------------------------ */
 
 
   /**
    * Set the URI which the workflow will open a conduit connection to when
    * @{method:establishConduit} is called. Arcanist makes an effort to set
    * this by default for all workflows (by reading ##.arcconfig## and/or the
    * value of ##--conduit-uri##) even if they don't need Conduit, so a workflow
    * can generally upgrade into a conduit workflow later by just calling
    * @{method:establishConduit}.
    *
    * You generally should not need to call this method unless you are
    * specifically overriding the default URI. It is normally sufficient to
    * just invoke @{method:establishConduit}.
    *
    * NOTE: You can not call this after a conduit has been established.
    *
    * @param string  The URI to open a conduit to when @{method:establishConduit}
    *                is called.
    * @return this
    * @task conduit
    */
   final public function setConduitURI($conduit_uri) {
     if ($this->conduit) {
       throw new Exception(
         "You can not change the Conduit URI after a conduit is already open.");
     }
     $this->conduitURI = $conduit_uri;
     return $this;
   }
 
   /**
    * Returns the URI the conduit connection within the workflow uses.
    *
    * @return string
    * @task conduit
    */
   final public function getConduitURI() {
     return $this->conduitURI;
   }
 
   /**
    * Open a conduit channel to the server which was previously configured by
    * calling @{method:setConduitURI}. Arcanist will do this automatically if
    * the workflow returns ##true## from @{method:requiresConduit}, or you can
    * later upgrade a workflow and build a conduit by invoking it manually.
    *
    * You must establish a conduit before you can make conduit calls.
    *
    * NOTE: You must call @{method:setConduitURI} before you can call this
    * method.
    *
    * @return this
    * @task conduit
    */
   final public function establishConduit() {
     if ($this->conduit) {
       return $this;
     }
 
     if (!$this->conduitURI) {
       throw new Exception(
         "You must specify a Conduit URI with setConduitURI() before you can ".
         "establish a conduit.");
     }
 
     $this->conduit = new ConduitClient($this->conduitURI);
 
     if ($this->conduitTimeout) {
       $this->conduit->setTimeout($this->conduitTimeout);
     }
 
     return $this;
   }
 
 
   /**
    * Set credentials which will be used to authenticate against Conduit. These
    * credentials can then be used to establish an authenticated connection to
    * conduit by calling @{method:authenticateConduit}. Arcanist sets some
    * defaults for all workflows regardless of whether or not they return true
    * from @{method:requireAuthentication}, based on the ##~/.arcrc## and
    * ##.arcconf## files if they are present. Thus, you can generally upgrade a
    * workflow which does not require authentication into an authenticated
    * workflow by later invoking @{method:requireAuthentication}. You should not
    * normally need to call this method unless you are specifically overriding
    * the defaults.
    *
    * NOTE: You can not call this method after calling
    * @{method:authenticateConduit}.
    *
    * @param dict  A credential dictionary, see @{method:authenticateConduit}.
    * @return this
    * @task conduit
    */
   final public function setConduitCredentials(array $credentials) {
     if ($this->isConduitAuthenticated()) {
       throw new Exception(
         "You may not set new credentials after authenticating conduit.");
     }
 
     $this->conduitCredentials = $credentials;
     return $this;
   }
 
 
   /**
    * Force arc to identify with a specific Conduit version during the
    * protocol handshake. This is primarily useful for development (especially
    * for sending diffs which bump the client Conduit version), since the client
    * still actually speaks the builtin version of the protocol.
    *
    * Controlled by the --conduit-version flag.
    *
    * @param int Version the client should pretend to be.
    * @return this
    * @task conduit
    */
   public function forceConduitVersion($version) {
     $this->forcedConduitVersion = $version;
     return $this;
   }
 
 
   /**
    * Get the protocol version the client should identify with.
    *
    * @return int Version the client should claim to be.
    * @task conduit
    */
   public function getConduitVersion() {
     return nonempty($this->forcedConduitVersion, 5);
   }
 
 
   /**
    * Override the default timeout for Conduit.
    *
    * Controlled by the --conduit-timeout flag.
    *
    * @param float Timeout, in seconds.
    * @return this
    * @task conduit
    */
   public function setConduitTimeout($timeout) {
     $this->conduitTimeout = $timeout;
     if ($this->conduit) {
       $this->conduit->setConduitTimeout($timeout);
     }
     return $this;
   }
 
 
   /**
    * Open and authenticate a conduit connection to a Phabricator server using
    * provided credentials. Normally, Arcanist does this for you automatically
    * when you return true from @{method:requiresAuthentication}, but you can
    * also upgrade an existing workflow to one with an authenticated conduit
    * by invoking this method manually.
    *
    * You must authenticate the conduit before you can make authenticated conduit
    * calls (almost all calls require authentication).
    *
    * This method uses credentials provided via @{method:setConduitCredentials}
    * to authenticate to the server:
    *
    *    - ##user## (required) The username to authenticate with.
    *    - ##certificate## (required) The Conduit certificate to use.
    *    - ##description## (optional) Description of the invoking command.
    *
    * Successful authentication allows you to call @{method:getUserPHID} and
    * @{method:getUserName}, as well as use the client you access with
    * @{method:getConduit} to make authenticated calls.
    *
    * NOTE: You must call @{method:setConduitURI} and
    * @{method:setConduitCredentials} before you invoke this method.
    *
    * @return this
    * @task conduit
    */
   final public function authenticateConduit() {
     if ($this->isConduitAuthenticated()) {
       return $this;
     }
 
     $this->establishConduit();
 
     $credentials = $this->conduitCredentials;
     if (!$credentials) {
       throw new Exception(
         "Set conduit credentials with setConduitCredentials() before ".
         "authenticating conduit!");
     }
 
     if (empty($credentials['user']) || empty($credentials['certificate'])) {
       throw new Exception(
         "Credentials must include a 'user' and a 'certificate'.");
     }
 
     $description = idx($credentials, 'description', '');
     $user        = $credentials['user'];
     $certificate = $credentials['certificate'];
 
     try {
       $connection = $this->getConduit()->callMethodSynchronous(
         'conduit.connect',
         array(
           'client'              => 'arc',
           'clientVersion'       => $this->getConduitVersion(),
           'clientDescription'   => php_uname('n').':'.$description,
           'user'                => $user,
           'certificate'         => $certificate,
           'host'                => $this->conduitURI,
         ));
     } catch (ConduitClientException $ex) {
       if ($ex->getErrorCode() == 'ERR-NO-CERTIFICATE' ||
           $ex->getErrorCode() == 'ERR-INVALID-USER') {
         $conduit_uri = $this->conduitURI;
         $message =
           "\n".
           phutil_console_format(
             "YOU NEED TO __INSTALL A CERTIFICATE__ TO LOGIN TO PHABRICATOR").
           "\n\n".
           phutil_console_format(
             "    To do this, run: **arc install-certificate**").
           "\n\n".
           "The server '{$conduit_uri}' rejected your request:".
           "\n".
           $ex->getMessage();
         throw new ArcanistUsageException($message);
       } else if ($ex->getErrorCode() == 'NEW-ARC-VERSION') {
 
         // Cleverly disguise this as being AWESOME!!!
 
         echo phutil_console_format("**New Version Available!**\n\n");
         echo phutil_console_wrap($ex->getMessage());
         echo "\n\n";
         echo "In most cases, arc can be upgraded automatically.\n";
 
         $ok = phutil_console_confirm(
           "Upgrade arc now?",
           $default_no = false);
         if (!$ok) {
           throw $ex;
         }
 
         $root = dirname(phutil_get_library_root('arcanist'));
 
         chdir($root);
         $err = phutil_passthru('%s upgrade', $root.'/bin/arc');
         if (!$err) {
           echo "\nTry running your arc command again.\n";
         }
         exit(1);
       } else {
         throw $ex;
       }
     }
 
     $this->userName = $user;
     $this->userPHID = $connection['userPHID'];
 
     $this->conduitAuthenticated = true;
 
     return $this;
   }
 
   /**
    * @return bool True if conduit is authenticated, false otherwise.
    * @task conduit
    */
   final protected function isConduitAuthenticated() {
     return (bool)$this->conduitAuthenticated;
   }
 
 
   /**
    * Override this to return true if your workflow requires a conduit channel.
    * Arc will build the channel for you before your workflow executes. This
    * implies that you only need an unauthenticated channel; if you need
    * authentication, override @{method:requiresAuthentication}.
    *
    * @return bool True if arc should build a conduit channel before running
    *              the workflow.
    * @task conduit
    */
   public function requiresConduit() {
     return false;
   }
 
 
   /**
    * Override this to return true if your workflow requires an authenticated
    * conduit channel. This implies that it requires a conduit. Arc will build
    * and authenticate the channel for you before the workflow executes.
    *
    * @return bool True if arc should build an authenticated conduit channel
    *              before running the workflow.
    * @task conduit
    */
   public function requiresAuthentication() {
     return false;
   }
 
 
   /**
    * Returns the PHID for the user once they've authenticated via Conduit.
    *
    * @return phid Authenticated user PHID.
    * @task conduit
    */
   final public function getUserPHID() {
     if (!$this->userPHID) {
       $workflow = get_class($this);
       throw new Exception(
         "This workflow ('{$workflow}') requires authentication, override ".
         "requiresAuthentication() to return true.");
     }
     return $this->userPHID;
   }
 
   /**
    * Deprecated. See @{method:getUserPHID}.
    *
    * @deprecated
    */
   final public function getUserGUID() {
     phutil_deprecated(
       'ArcanistBaseWorkflow::getUserGUID',
       'This method has been renamed to getUserPHID().');
     return $this->getUserPHID();
   }
 
   /**
    * Return the username for the user once they've authenticated via Conduit.
    *
    * @return string Authenticated username.
    * @task conduit
    */
   final public function getUserName() {
     return $this->userName;
   }
 
 
   /**
    * Get the established @{class@libphutil:ConduitClient} in order to make
    * Conduit method calls. Before the client is available it must be connected,
    * either implicitly by making @{method:requireConduit} or
    * @{method:requireAuthentication} return true, or explicitly by calling
    * @{method:establishConduit} or @{method:authenticateConduit}.
    *
    * @return @{class@libphutil:ConduitClient} Live conduit client.
    * @task conduit
    */
   final public function getConduit() {
     if (!$this->conduit) {
       $workflow = get_class($this);
       throw new Exception(
         "This workflow ('{$workflow}') requires a Conduit, override ".
         "requiresConduit() to return true.");
     }
     return $this->conduit;
   }
 
 
   public function setArcanistConfiguration($arcanist_configuration) {
     $this->arcanistConfiguration = $arcanist_configuration;
     return $this;
   }
 
   public function getArcanistConfiguration() {
     return $this->arcanistConfiguration;
   }
 
   public function getCommandSynopses() {
     return get_class($this).": Undocumented";
   }
 
   public function getCommandHelp() {
     return get_class($this).": Undocumented";
   }
 
   public function requiresWorkingCopy() {
     return false;
   }
 
 
   public function requiresRepositoryAPI() {
     return false;
   }
 
   public function setCommand($command) {
     $this->command = $command;
     return $this;
   }
 
   public function getCommand() {
     return $this->command;
   }
 
   public function getArguments() {
     return array();
   }
 
   public function setWorkingDirectory($working_directory) {
     $this->workingDirectory = $working_directory;
     return $this;
   }
 
   public function getWorkingDirectory() {
     return $this->workingDirectory;
   }
 
   private function setParentWorkflow($parent_workflow) {
     $this->parentWorkflow = $parent_workflow;
     return $this;
   }
 
   protected function getParentWorkflow() {
     return $this->parentWorkflow;
   }
 
   public function buildChildWorkflow($command, array $argv) {
     $arc_config = $this->getArcanistConfiguration();
     $workflow = $arc_config->buildWorkflow($command);
     $workflow->setParentWorkflow($this);
     $workflow->setCommand($command);
 
     if ($this->repositoryAPI) {
       $workflow->setRepositoryAPI($this->repositoryAPI);
     }
 
     if ($this->userPHID) {
       $workflow->userPHID = $this->getUserPHID();
       $workflow->userName = $this->getUserName();
     }
 
     if ($this->conduit) {
       $workflow->conduit = $this->conduit;
     }
 
     if ($this->workingCopy) {
       $workflow->setWorkingCopy($this->workingCopy);
     }
 
     $workflow->setArcanistConfiguration($arc_config);
 
     $workflow->parseArguments(array_values($argv));
 
     return $workflow;
   }
 
   public function getArgument($key, $default = null) {
     $args = $this->arguments;
     if (!array_key_exists($key, $args)) {
       return $default;
     }
     return $args[$key];
   }
 
   final public function getCompleteArgumentSpecification() {
     $spec = $this->getArguments();
     $arc_config = $this->getArcanistConfiguration();
     $command = $this->getCommand();
     $spec += $arc_config->getCustomArgumentsForCommand($command);
     return $spec;
   }
 
   public function parseArguments(array $args) {
 
     $spec = $this->getCompleteArgumentSpecification();
 
     $dict = array();
 
     $more_key = null;
     if (!empty($spec['*'])) {
       $more_key = $spec['*'];
       unset($spec['*']);
       $dict[$more_key] = array();
     }
 
     $short_to_long_map = array();
     foreach ($spec as $long => $options) {
       if (!empty($options['short'])) {
         $short_to_long_map[$options['short']] = $long;
       }
     }
 
     $more = array();
     for ($ii = 0; $ii < count($args); $ii++) {
       $arg = $args[$ii];
       $arg_name = null;
       $arg_key = null;
       if ($arg == '--') {
         $more = array_merge(
           $more,
           array_slice($args, $ii + 1));
         break;
       } else if (!strncmp($arg, '--', 2)) {
         $arg_key = substr($arg, 2);
         if (!array_key_exists($arg_key, $spec)) {
           throw new ArcanistUsageException(
             "Unknown argument '{$arg_key}'. Try 'arc help'.");
         }
       } else if (!strncmp($arg, '-', 1)) {
         $arg_key = substr($arg, 1);
         if (empty($short_to_long_map[$arg_key])) {
           throw new ArcanistUsageException(
             "Unknown argument '{$arg_key}'. Try 'arc help'.");
         }
         $arg_key = $short_to_long_map[$arg_key];
       } else {
         $more[] = $arg;
         continue;
       }
 
       $options = $spec[$arg_key];
       if (empty($options['param'])) {
         $dict[$arg_key] = true;
       } else {
         if ($ii == count($args) - 1) {
           throw new ArcanistUsageException(
             "Option '{$arg}' requires a parameter.");
         }
         $dict[$arg_key] = $args[$ii + 1];
         $ii++;
       }
     }
 
     if ($more) {
       if ($more_key) {
         $dict[$more_key] = $more;
       } else {
         $example = reset($more);
         throw new ArcanistUsageException(
           "Unrecognized argument '{$example}'. Try 'arc help'.");
       }
     }
 
     foreach ($dict as $key => $value) {
       if (empty($spec[$key]['conflicts'])) {
         continue;
       }
       foreach ($spec[$key]['conflicts'] as $conflict => $more) {
         if (isset($dict[$conflict])) {
           if ($more) {
             $more = ': '.$more;
           } else {
             $more = '.';
           }
           // TODO: We'll always display these as long-form, when the user might
           // have typed them as short form.
           throw new ArcanistUsageException(
             "Arguments '--{$key}' and '--{$conflict}' are mutually exclusive".
             $more);
         }
       }
     }
 
     $this->arguments = $dict;
 
     $this->didParseArguments();
 
     return $this;
   }
 
   protected function didParseArguments() {
     // Override this to customize workflow argument behavior.
   }
 
   public function getWorkingCopy() {
     if (!$this->workingCopy) {
       $workflow = get_class($this);
       throw new Exception(
         "This workflow ('{$workflow}') requires a working copy, override ".
         "requiresWorkingCopy() to return true.");
     }
     return $this->workingCopy;
   }
 
   public function setWorkingCopy(
     ArcanistWorkingCopyIdentity $working_copy) {
     $this->workingCopy = $working_copy;
     return $this;
   }
 
   public function setRepositoryAPI($api) {
     $this->repositoryAPI = $api;
     return $this;
   }
 
   public function getRepositoryAPI() {
     if (!$this->repositoryAPI) {
       $workflow = get_class($this);
       throw new Exception(
         "This workflow ('{$workflow}') requires a Repository API, override ".
         "requiresRepositoryAPI() to return true.");
     }
     return $this->repositoryAPI;
   }
 
   protected function shouldRequireCleanUntrackedFiles() {
     return empty($this->arguments['allow-untracked']);
   }
 
   public function requireCleanWorkingCopy() {
     $api = $this->getRepositoryAPI();
 
     $working_copy_desc = phutil_console_format(
       "  Working copy: __%s__\n\n",
       $api->getPath());
 
     $untracked = $api->getUntrackedChanges();
     if ($this->shouldRequireCleanUntrackedFiles()) {
 
       // Exempt ".arc/" scratch files from this warning so that things work
       // a little more smoothly if no one has gotten around to adding .arc to
       // the ignore list.
       foreach ($untracked as $key => $path) {
         if (preg_match('@\.arc/@', $path)) {
           unset($untracked[$key]);
         }
       }
 
       if (!empty($untracked)) {
         echo "You have untracked files in this working copy.\n\n".
              $working_copy_desc.
              "  Untracked files in working copy:\n".
              "    ".implode("\n    ", $untracked)."\n\n";
 
         if ($api instanceof ArcanistGitAPI) {
           echo phutil_console_wrap(
             "Since you don't have '.gitignore' rules for these files and have ".
             "not listed them in '.git/info/exclude', you may have forgotten ".
             "to 'git add' them to your commit.");
         } else if ($api instanceof ArcanistSubversionAPI) {
           echo phutil_console_wrap(
             "Since you don't have 'svn:ignore' rules for these files, you may ".
             "have forgotten to 'svn add' them.");
         } else if ($api instanceof ArcanistMercurialAPI) {
           echo phutil_console_wrap(
             "Since you don't have '.hgignore' rules for these files, you ".
             "may have forgotten to 'hg add' them to your commit.");
         }
 
         $prompt = "Do you want to continue without adding these files?";
         if (!phutil_console_confirm($prompt, $default_no = false)) {
           throw new ArcanistUserAbortException();
         }
       }
     }
 
     $incomplete = $api->getIncompleteChanges();
     if ($incomplete) {
       throw new ArcanistUsageException(
         "You have incompletely checked out directories in this working copy. ".
         "Fix them before proceeding.\n\n".
         $working_copy_desc.
         "  Incomplete directories in working copy:\n".
         "    ".implode("\n    ", $incomplete)."\n\n".
         "You can fix these paths by running 'svn update' on them.");
     }
 
     $conflicts = $api->getMergeConflicts();
     if ($conflicts) {
       throw new ArcanistUsageException(
         "You have merge conflicts in this working copy. Resolve merge ".
         "conflicts before proceeding.\n\n".
         $working_copy_desc.
         "  Conflicts in working copy:\n".
         "    ".implode("\n    ", $conflicts)."\n");
     }
 
     $unstaged = $api->getUnstagedChanges();
     if ($unstaged) {
       throw new ArcanistUsageException(
         "You have unstaged changes in this working copy. Stage and commit (or ".
         "revert) them before proceeding.\n\n".
         $working_copy_desc.
         "  Unstaged changes in working copy:\n".
         "    ".implode("\n    ", $unstaged)."\n");
     }
 
     $uncommitted = $api->getUncommittedChanges();
     if ($uncommitted) {
       throw new ArcanistUncommittedChangesException(
         "You have uncommitted changes in this working copy. Commit (or ".
         "revert) them before proceeding.\n\n".
         $working_copy_desc.
         "  Uncommitted changes in working copy\n".
         "    ".implode("\n    ", $uncommitted)."\n");
     }
   }
 
 
   protected function loadDiffBundleFromConduit(
     ConduitClient $conduit,
     $diff_id) {
 
     return $this->loadBundleFromConduit(
       $conduit,
       array(
       'diff_id' => $diff_id,
     ));
   }
 
   protected function loadRevisionBundleFromConduit(
     ConduitClient $conduit,
     $revision_id) {
 
     return $this->loadBundleFromConduit(
       $conduit,
       array(
       'revision_id' => $revision_id,
     ));
   }
 
   private function loadBundleFromConduit(
     ConduitClient $conduit,
     $params) {
 
     $future = $conduit->callMethod('differential.getdiff', $params);
     $diff = $future->resolve();
 
     $changes = array();
     foreach ($diff['changes'] as $changedict) {
       $changes[] = ArcanistDiffChange::newFromDictionary($changedict);
     }
     $bundle = ArcanistBundle::newFromChanges($changes);
     $bundle->setConduit($conduit);
     $bundle->setProjectID($diff['projectName']);
     $bundle->setBaseRevision($diff['sourceControlBaseRevision']);
     $bundle->setRevisionID($diff['revisionID']);
     return $bundle;
   }
 
   /**
    * Return a list of lines changed by the current diff, or ##null## if the
    * change list is meaningless (for example, because the path is a directory
    * or binary file).
    *
    * @param string      Path within the repository.
    * @param string      Change selection mode (see ArcanistDiffHunk).
    * @return list|null  List of changed line numbers, or null to indicate that
    *                    the path is not a line-oriented text file.
    */
   protected function getChangedLines($path, $mode) {
     $repository_api = $this->getRepositoryAPI();
     $full_path = $repository_api->getPath($path);
     if (is_dir($full_path)) {
       return null;
     }
 
     if (!file_exists($full_path)) {
       return null;
     }
 
     $change = $this->getChange($path);
 
     if ($change->getFileType() !== ArcanistDiffChangeType::FILE_TEXT) {
       return null;
     }
 
     $lines = $change->getChangedLines($mode);
     return array_keys($lines);
   }
 
   private function getChange($path) {
     $repository_api = $this->getRepositoryAPI();
 
     if ($repository_api instanceof ArcanistSubversionAPI) {
       // NOTE: In SVN, we don't currently support a "get all local changes"
       // operation, so special case it.
       if (empty($this->changeCache[$path])) {
         $diff = $repository_api->getRawDiffText($path);
         $parser = new ArcanistDiffParser();
         $changes = $parser->parseDiff($diff);
         if (count($changes) != 1) {
           throw new Exception("Expected exactly one change.");
         }
         $this->changeCache[$path] = reset($changes);
       }
     } else if ($repository_api->supportsRelativeLocalCommits()) {
       if (empty($this->changeCache)) {
         $changes = $repository_api->getAllLocalChanges();
         foreach ($changes as $change) {
           $this->changeCache[$change->getCurrentPath()] = $change;
         }
       }
     } else {
       throw new Exception("Missing VCS support.");
     }
 
     if (empty($this->changeCache[$path])) {
       if ($repository_api instanceof ArcanistGitAPI) {
         // This can legitimately occur under git if you make a change, "git
         // commit" it, and then revert the change in the working copy and run
         // "arc lint".
         $change = new ArcanistDiffChange();
         $change->setCurrentPath($path);
         return $change;
       } else {
         throw new Exception(
           "Trying to get change for unchanged path '{$path}'!");
       }
     }
 
     return $this->changeCache[$path];
   }
 
   final public function willRunWorkflow() {
     $spec = $this->getCompleteArgumentSpecification();
     foreach ($this->arguments as $arg => $value) {
       if (empty($spec[$arg])) {
         continue;
       }
       $options = $spec[$arg];
       if (!empty($options['supports'])) {
         $system_name = $this->getRepositoryAPI()->getSourceControlSystemName();
         if (!in_array($system_name, $options['supports'])) {
           $extended_info = null;
           if (!empty($options['nosupport'][$system_name])) {
             $extended_info = ' '.$options['nosupport'][$system_name];
           }
           throw new ArcanistUsageException(
             "Option '--{$arg}' is not supported under {$system_name}.".
             $extended_info);
         }
       }
     }
   }
 
   protected function normalizeRevisionID($revision_id) {
     return ltrim(strtoupper($revision_id), 'D');
   }
 
   protected function shouldShellComplete() {
     return true;
   }
 
   protected function getShellCompletions(array $argv) {
     return array();
   }
 
   protected function getSupportedRevisionControlSystems() {
     return array('any');
   }
 
   protected function getPassthruArgumentsAsMap($command) {
     $map = array();
     foreach ($this->getCompleteArgumentSpecification() as $key => $spec) {
       if (!empty($spec['passthru'][$command])) {
         if (isset($this->arguments[$key])) {
           $map[$key] = $this->arguments[$key];
         }
       }
     }
     return $map;
   }
 
   protected function getPassthruArgumentsAsArgv($command) {
     $spec = $this->getCompleteArgumentSpecification();
     $map = $this->getPassthruArgumentsAsMap($command);
     $argv = array();
     foreach ($map as $key => $value) {
       $argv[] = '--'.$key;
       if (!empty($spec[$key]['param'])) {
         $argv[] = $value;
       }
     }
     return $argv;
   }
 
   public static function getUserConfigurationFileLocation() {
     if (phutil_is_windows()) {
       return getenv('APPDATA').'/.arcrc';
     } else {
       return getenv('HOME').'/.arcrc';
     }
   }
 
   public static function readUserConfigurationFile() {
     $user_config = array();
     $user_config_path = self::getUserConfigurationFileLocation();
     if (Filesystem::pathExists($user_config_path)) {
 
       if (!phutil_is_windows()) {
         $mode = fileperms($user_config_path);
         if (!$mode) {
           throw new Exception("Unable to get perms of '{$user_config_path}'!");
         }
         if ($mode & 0177) {
           // Mode should allow only owner access.
           $prompt = "File permissions on your ~/.arcrc are too open. ".
                     "Fix them by chmod'ing to 600?";
           if (!phutil_console_confirm($prompt, $default_no = false)) {
             throw new ArcanistUsageException("Set ~/.arcrc to file mode 600.");
           }
           execx('chmod 600 %s', $user_config_path);
         }
       }
 
       $user_config_data = Filesystem::readFile($user_config_path);
       $user_config = json_decode($user_config_data, true);
       if (!is_array($user_config)) {
         throw new ArcanistUsageException(
           "Your '~/.arcrc' file is not a valid JSON file.");
       }
     }
     return $user_config;
   }
 
 
   public static function writeUserConfigurationFile($config) {
     $json_encoder = new PhutilJSON();
     $json = $json_encoder->encodeFormatted($config);
 
     $path = self::getUserConfigurationFileLocation();
     Filesystem::writeFile($path, $json);
 
     if (!phutil_is_windows()) {
       execx('chmod 600 %s', $path);
     }
   }
 
   public static function readGlobalArcConfig() {
     return idx(self::readUserConfigurationFile(), 'config', array());
   }
 
   public static function writeGlobalArcConfig(array $options) {
     $config = self::readUserConfigurationFile();
     $config['config'] = $options;
     self::writeUserConfigurationFile($config);
   }
 
 
   /**
    * Write a message to stderr so that '--json' flags or stdout which is meant
    * to be piped somewhere aren't disrupted.
    *
    * @param string  Message to write to stderr.
    * @return void
    */
   protected function writeStatusMessage($msg) {
     file_put_contents('php://stderr', $msg);
   }
 
   protected function isHistoryImmutable() {
+    $repository_api = $this->getRepositoryAPI();
     $working_copy = $this->getWorkingCopy();
-    return ($working_copy->getConfig('immutable_history') === true);
+
+    $project_config = $working_copy->getConfig('immutable_history');
+    if ($project_config !== null) {
+      return $project_config;
+    }
+
+    return $repository_api->isHistoryDefaultImmutable();
   }
 
   /**
    * Workflows like 'lint' and 'unit' operate on a list of working copy paths.
    * The user can either specify the paths explicitly ("a.js b.php"), or by
    * specfifying a revision ("--rev a3f10f1f") to select all paths modified
    * since that revision, or by omitting both and letting arc choose the
    * default relative revision.
    *
    * This method takes the user's selections and returns the paths that the
    * workflow should act upon.
    *
    * @param   list          List of explicitly provided paths.
    * @param   string|null   Revision name, if provided.
    * @param   mask          Mask of ArcanistRepositoryAPI flags to exclude.
    *                        Defaults to ArcanistRepositoryAPI::FLAG_UNTRACKED.
    * @return  list          List of paths the workflow should act on.
    */
   protected function selectPathsForWorkflow(
     array $paths,
     $rev,
     $omit_mask = null) {
 
     if ($omit_mask === null) {
       $omit_mask = ArcanistRepositoryAPI::FLAG_UNTRACKED;
     }
 
     if ($paths) {
       $working_copy = $this->getWorkingCopy();
       foreach ($paths as $key => $path) {
         $full_path = Filesystem::resolvePath($path);
         if (!Filesystem::pathExists($full_path)) {
           throw new ArcanistUsageException("Path '{$path}' does not exist!");
         }
         $relative_path = Filesystem::readablePath(
           $full_path,
           $working_copy->getProjectRoot());
         $paths[$key] = $relative_path;
       }
     } else {
       $repository_api = $this->getRepositoryAPI();
       if ($rev) {
         $repository_api->parseRelativeLocalCommit(array($rev));
       }
 
       $paths = $repository_api->getWorkingCopyStatus();
       foreach ($paths as $path => $flags) {
         if ($flags & $omit_mask) {
           unset($paths[$path]);
         }
       }
       $paths = array_keys($paths);
     }
 
     return array_values($paths);
   }
 
   protected function renderRevisionList(array $revisions) {
     $list = array();
     foreach ($revisions as $revision) {
       $list[] = '     - D'.$revision['id'].': '.$revision['title']."\n";
     }
     return implode('', $list);
   }
 
 
 /* -(  Scratch Files  )------------------------------------------------------ */
 
 
   /**
    * Try to read a scratch file, if it exists and is readable.
    *
    * @param string Scratch file name.
    * @return mixed String for file contents, or false for failure.
    * @task scratch
    */
   protected function readScratchFile($path) {
     if (!$this->repositoryAPI) {
       return false;
     }
     return $this->getRepositoryAPI()->readScratchFile($path);
   }
 
 
   /**
    * 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
    */
   protected function writeScratchFile($path, $data) {
     if (!$this->repositoryAPI) {
       return false;
     }
     return $this->getRepositoryAPI()->writeScratchFile($path, $data);
   }
 
 
   /**
    * Try to remove a scratch file.
    *
    * @param   string  Scratch file name to remove.
    * @return  bool    True if the file was removed successfully.
    * @task scratch
    */
   protected function removeScratchFile($path) {
     if (!$this->repositoryAPI) {
       return false;
     }
     return $this->getRepositoryAPI()->removeScratchFile($path);
   }
 
 
   /**
    * Get a human-readable description of the scratch file location.
    *
    * @param string  Scratch file name.
    * @return mixed  String, or false on failure.
    * @task scratch
    */
   protected function getReadableScratchFilePath($path) {
     if (!$this->repositoryAPI) {
       return false;
     }
     return $this->getRepositoryAPI()->getReadableScratchFilePath($path);
   }
 
 
   /**
    * Get the path to a scratch file, if possible.
    *
    * @param string  Scratch file name.
    * @return mixed  File path, or false on failure.
    * @task scratch
    */
   protected function getScratchFilePath($path) {
     if (!$this->repositoryAPI) {
       return false;
     }
     return $this->getRepositoryAPI()->getScratchFilePath($path);
   }
 
   protected function getRepositoryEncoding() {
     if ($this->repositoryEncoding) {
       return $this->repositoryEncoding;
     }
 
     $default = 'UTF-8';
 
     $project_id = $this->getWorkingCopy()->getProjectID();
     if (!$project_id) {
       return $default;
     }
 
     $project_info = $this->getConduit()->callMethodSynchronous(
       'arcanist.projectinfo',
       array(
         'name' => $project_id,
       ));
 
     $this->repositoryEncoding = nonempty($project_info['encoding'], $default);
 
     return $this->repositoryEncoding;
   }
 
   protected static function formatConfigValueForDisplay($value) {
     if (is_array($value)) {
       // TODO: Both json_encode() and PhutilJSON do a bad job with one-liners.
       // PhutilJSON splits them across a bunch of lines, while json_encode()
       // escapes all kinds of stuff like "/". It would be nice if PhutilJSON
       // had a mode for pretty one-liners.
       $value = json_encode($value);
       return $value;
     }
     return $value;
   }
 
 }
diff --git a/src/workflow/ArcanistDiffWorkflow.php b/src/workflow/ArcanistDiffWorkflow.php
index fa0054a6..ea135461 100644
--- a/src/workflow/ArcanistDiffWorkflow.php
+++ b/src/workflow/ArcanistDiffWorkflow.php
@@ -1,2135 +1,2138 @@
 <?php
 
 /*
  * Copyright 2012 Facebook, Inc.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
  *
  *   http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
 
 /**
  * Sends changes from your working copy to Differential for code review.
  *
  * @task lintunit   Lint and Unit Tests
  * @task message    Commit and Update Messages
  * @task diffspec   Diff Specification
  * @task diffprop   Diff Properties
  *
  * @group workflow
  */
 final class ArcanistDiffWorkflow extends ArcanistBaseWorkflow {
 
   private $hasWarnedExternals = false;
   private $unresolvedLint;
   private $lintExcuse;
   private $unitExcuse;
   private $testResults;
   private $diffID;
   private $revisionID;
   private $unitWorkflow;
 
   public function getCommandSynopses() {
     return phutil_console_format(<<<EOTEXT
       **diff** [__paths__] (svn)
       **diff** [__commit__] (git, hg)
 EOTEXT
       );
   }
 
   public function getCommandHelp() {
     return phutil_console_format(<<<EOTEXT
           Supports: git, svn, hg
           Generate a Differential diff or revision from local changes.
 
           Under git, you can specify a commit (like __HEAD^^^__ or __master__)
           and Differential will generate a diff against the merge base of that
           commit and HEAD.
 
           Under svn, you can choose to include only some of the modified files
           in the working copy in the diff by specifying their paths. If you
           omit paths, all changes are included in the diff.
 EOTEXT
       );
   }
   public function requiresWorkingCopy() {
     return !$this->isRawDiffSource();
   }
 
   public function requiresConduit() {
     return true;
   }
 
   public function requiresAuthentication() {
     return true;
   }
 
   public function requiresRepositoryAPI() {
     if (!$this->isRawDiffSource()) {
       return true;
     }
 
     if ($this->getArgument('use-commit-message')) {
       return true;
     }
 
     return false;
   }
 
   public function getDiffID() {
     return $this->diffID;
   }
 
   public function getArguments() {
     return array(
       'message' => array(
         'short'       => 'm',
         'param'       => 'message',
         'help' =>
           "When updating a revision, use the specified message instead of ".
           "prompting.",
       ),
       'message-file' => array(
         'short' => 'F',
         'param' => 'file',
         'paramtype' => 'file',
         'help' => 'When creating a revision, read revision information '.
                   'from this file.',
       ),
       'use-commit-message' => array(
         'supports' => array(
           'git',
           // TODO: Support mercurial.
         ),
         'short' => 'C',
         'param' => 'commit',
         'help' => 'Read revision information from a specific commit.',
         'conflicts' => array(
           'only'    => null,
           'preview' => null,
           'update'  => null,
         ),
       ),
       'edit' => array(
         'supports'    => array(
           'git',
         ),
         'nosupport'   => array(
           'svn' => 'Edit revisions via the web interface when using SVN.',
         ),
         'help' =>
           "When updating a revision under git, edit revision information ".
           "before updating.",
       ),
       'raw' => array(
         'help' =>
           "Read diff from stdin, not from the working copy. This disables ".
           "many Arcanist/Phabricator features which depend on having access ".
           "to the working copy.",
         'conflicts' => array(
           'less-context'        => null,
           'apply-patches'       => '--raw disables lint.',
           'never-apply-patches' => '--raw disables lint.',
           'advice'              => '--raw disables lint.',
           'lintall'             => '--raw disables lint.',
 
           'create'              => '--raw and --create both need stdin. '.
                                    'Use --raw-command.',
           'edit'                => '--raw and --edit both need stdin. '.
                                    'Use --raw-command.',
           'raw-command'         => null,
         ),
       ),
       'raw-command' => array(
         'param' => 'command',
         'help' =>
           "Generate diff by executing a specified command, not from the ".
           "working copy. This disables many Arcanist/Phabricator features ".
           "which depend on having access to the working copy.",
         'conflicts' => array(
           'less-context'        => null,
           'apply-patches'       => '--raw-command disables lint.',
           'never-apply-patches' => '--raw-command disables lint.',
           'advice'              => '--raw-command disables lint.',
           'lintall'             => '--raw-command disables lint.',
         ),
       ),
       'create' => array(
         'help' => "Always create a new revision.",
         'conflicts' => array(
           'edit'    => '--create can not be used with --edit.',
           'only'    => '--create can not be used with --only.',
           'preview' => '--create can not be used with --preview.',
           'update'  => '--create can not be used with --update.',
         ),
       ),
       'update' => array(
         'param' => 'revision_id',
         'help'  => "Always update a specific revision.",
       ),
       'nounit' => array(
         'help' =>
           "Do not run unit tests.",
       ),
       'nolint' => array(
         'help' =>
           "Do not run lint.",
         'conflicts' => array(
           'lintall'   => '--nolint suppresses lint.',
           'advice'    => '--nolint suppresses lint.',
           'apply-patches' => '--nolint suppresses lint.',
           'never-apply-patches' => '--nolint suppresses lint.',
         ),
       ),
       'only' => array(
         'help' =>
           "Only generate a diff, without running lint, unit tests, or other ".
           "auxiliary steps. See also --preview.",
         'conflicts' => array(
           'preview'   => null,
           'message'   => '--only does not affect revisions.',
           'edit'      => '--only does not affect revisions.',
           'lintall'   => '--only suppresses lint.',
           'advice'    => '--only suppresses lint.',
           'apply-patches' => '--only suppresses lint.',
           'never-apply-patches' => '--only suppresses lint.',
         ),
       ),
       'preview' => array(
         'help' =>
           "Instead of creating or updating a revision, only create a diff, ".
           "which you may later attach to a revision. This still runs lint ".
           "unit tests. See also --only.",
         'conflicts' => array(
           'only'      => null,
           'edit'      => '--preview does affect revisions.',
           'message'   => '--preview does not update any revision.',
         ),
       ),
       'encoding' => array(
         'param' => 'encoding',
         'help' =>
           "Attempt to convert non UTF-8 hunks into specified encoding.",
       ),
       'allow-untracked' => array(
         'help' =>
           "Skip checks for untracked files in the working copy.",
       ),
       'excuse' => array(
         'param' => 'excuse',
         'help' => 'Provide a prepared in advance excuse for any lints/tests'.
           ' shall they fail.',
       ),
       'less-context' => array(
         'help' =>
           "Normally, files are diffed with full context: the entire file is ".
           "sent to Differential so reviewers can 'show more' and see it. If ".
           "you are making changes to very large files with tens of thousands ".
           "of lines, this may not work well. With this flag, a diff will ".
           "be created that has only a few lines of context.",
       ),
       'lintall' => array(
         'help' =>
           "Raise all lint warnings, not just those on lines you changed.",
         'passthru' => array(
           'lint' => true,
         ),
       ),
       'advice' => array(
         'help' =>
           "Raise lint advice in addition to lint warnings and errors.",
         'passthru' => array(
           'lint' => true,
         ),
       ),
       'apply-patches' => array(
         'help' =>
           'Apply patches suggested by lint to the working copy without '.
           'prompting.',
         'conflicts' => array(
           'never-apply-patches' => true,
         ),
         'passthru' => array(
           'lint' => true,
         ),
       ),
       'never-apply-patches' => array(
         'help' => 'Never apply patches suggested by lint.',
         'conflicts' => array(
           'apply-patches' => true,
         ),
         'passthru' => array(
           'lint' => true,
         ),
       ),
       'amend-all' => array(
         'help' =>
           'When linting git repositories, amend HEAD with all patches '.
           'suggested by lint without prompting.',
         'passthru' => array(
           'lint' => true,
         ),
       ),
       'amend-autofixes' => array(
         'help' =>
           'When linting git repositories, amend HEAD with autofix '.
           'patches suggested by lint without prompting.',
         'passthru' => array(
           'lint' => true,
         ),
       ),
       'json' => array(
         'help' =>
           'Emit machine-readable JSON. EXPERIMENTAL! Probably does not work!',
       ),
       'no-amend' => array(
         'help' => 'Never amend commits in the working copy.',
       ),
       'uncommitted' => array(
         'help' => 'Include uncommitted changes without prompting.',
         'supports' => array(
           'hg',
         ),
       ),
       'verbatim' => array(
         'help' => 'When creating a revision, try to use the working copy '.
                   'commit message verbatim, without prompting to edit it. '.
                   'When updating a revision, update some fields from the '.
                   'local commit message.',
         'supports' => array(
           'hg',
           'git',
         ),
         'conflicts' => array(
           'use-commit-message'  => true,
           'update'              => true,
           'only'                => true,
           'preview'             => true,
           'raw'                 => true,
           'raw-command'         => true,
           'message-file'        => true,
         ),
       ),
       'reviewers' => array(
         'param' => 'usernames',
         'help' => 'When creating a revision, add reviewers.',
         'conflicts' => array(
           'only'    => true,
           'preview' => true,
           'update'  => true,
         ),
       ),
       'cc' => array(
         'param' => 'usernames',
         'help' => 'When creating a revision, add CCs.',
         'conflicts' => array(
           'only'    => true,
           'preview' => true,
           'update'  => true,
         ),
       ),
       'skip-binaries' => array(
         'help'  => 'Do not upload binaries (like images).',
       ),
       '*' => 'paths',
     );
   }
 
   public function isRawDiffSource() {
     return $this->getArgument('raw') || $this->getArgument('raw-command');
   }
 
   public function run() {
     $this->runDiffSetupBasics();
 
     $paths = $this->generateAffectedPaths();
 
     // Do this before we start linting or running unit tests so we can detect
     // things like a missing test plan or invalid reviewers immediately.
     $commit_message = $this->buildCommitMessage();
 
     $lint_result = $this->runLint($paths);
     $unit_result = $this->runUnit($paths);
 
     $changes = $this->generateChanges();
     if (!$changes) {
       throw new ArcanistUsageException(
         "There are no changes to generate a diff from!");
     }
 
     $diff_spec = array(
       'changes'                   => mpull($changes, 'toDictionary'),
       'lintStatus'                => $this->getLintStatus($lint_result),
       'unitStatus'                => $this->getUnitStatus($unit_result),
     ) + $this->buildDiffSpecification();
 
     $conduit = $this->getConduit();
     $diff_info = $conduit->callMethodSynchronous(
       'differential.creatediff',
       $diff_spec);
 
     $this->diffID = $diff_info['diffid'];
 
     if ($this->unitWorkflow) {
       $this->unitWorkflow->setDifferentialDiffID($diff_info['diffid']);
     }
 
     $this->updateLintDiffProperty();
     $this->updateUnitDiffProperty();
     $this->updateLocalDiffProperty();
 
     $output_json = $this->getArgument('json');
 
     if ($this->shouldOnlyCreateDiff()) {
       if (!$output_json) {
         echo phutil_console_format(
           "Created a new Differential diff:\n".
           "        **Diff URI:** __%s__\n\n",
           $diff_info['uri']);
       } else {
         $human = ob_get_clean();
         echo json_encode(array(
           'diffURI' => $diff_info['uri'],
           'diffID'  => $this->getDiffID(),
           'human'   => $human,
         ))."\n";
         ob_start();
       }
     } else {
 
       $message = $commit_message;
 
       $revision = array(
         'diffid' => $this->getDiffID(),
         'fields' => $message->getFields(),
       );
 
       if ($message->getRevisionID()) {
 
         // With '--verbatim', pass the (possibly modified) local fields. This
         // allows the user to edit some fields (like "title" and "summary")
         // locally without '--edit' and have changes automatically synchronized.
         // Without '--verbatim', we do not update the revision to reflect local
         // commit message changes.
         if ($this->getArgument('verbatim')) {
           $use_fields = $message->getFields();
         } else {
           $use_fields = array();
         }
 
         // TODO: This is silly -- we're getting a text corpus from the server
         // and then sending it right back to be parsed. This should be a
         // single call.
         $remote_corpus = $conduit->callMethodSynchronous(
           'differential.getcommitmessage',
           array(
             'revision_id' => $message->getRevisionID(),
             'edit'        => 'edit',
             'fields'      => $use_fields,
           ));
 
         $should_edit = $this->getArgument('edit');
         if ($should_edit) {
           $remote_corpus = id(new PhutilInteractiveEditor($remote_corpus))
             ->setName('differential-edit-revision-info')
             ->editInteractively();
         }
 
         $new_message = ArcanistDifferentialCommitMessage::newFromRawCorpus(
           $remote_corpus);
 
         $new_message->pullDataFromConduit($conduit);
         $revision['fields'] = $new_message->getFields();
 
         $revision['id'] = $message->getRevisionID();
         $this->revisionID = $revision['id'];
 
         $update_message = $this->getUpdateMessage($revision['fields']);
 
         $revision['message'] = $update_message;
         $future = $conduit->callMethod(
           'differential.updaterevision',
           $revision);
         $result = $future->resolve();
         echo "Updated an existing Differential revision:\n";
       } else {
         $revision['user'] = $this->getUserPHID();
         $future = $conduit->callMethod(
           'differential.createrevision',
           $revision);
         $result = $future->resolve();
 
         $revised_message = $conduit->callMethodSynchronous(
           'differential.getcommitmessage',
           array(
             'revision_id' => $result['revisionid'],
           ));
 
-        if (!$this->isRawDiffSource()) {
+        if (!$this->isRawDiffSource() && $this->shouldAmend()) {
           $repository_api = $this->getRepositoryAPI();
-          if (($repository_api instanceof ArcanistGitAPI) &&
-              $this->shouldAmend()) {
+
+          if ($repository_api->supportsAmend()) {
             echo "Updating commit message...\n";
-            $repository_api->amendGitHeadCommit($revised_message);
+            $repository_api->amendCommit($revised_message);
+          } else {
+            echo "Commit message was not amended. Amending commit message is ".
+                 "only supported in git and hg (version 2.2 or newer)";
           }
         }
 
         echo "Created a new Differential revision:\n";
       }
 
       $uri = $result['uri'];
       echo phutil_console_format(
         "        **Revision URI:** __%s__\n\n",
         $uri);
     }
 
     echo "Included changes:\n";
     foreach ($changes as $change) {
       echo '  '.$change->renderTextSummary()."\n";
     }
 
     if ($output_json) {
       ob_get_clean();
     }
 
     $this->removeScratchFile('create-message');
 
     return 0;
   }
 
   private function runDiffSetupBasics() {
     if ($this->requiresRepositoryAPI()) {
       $repository_api = $this->getRepositoryAPI();
       if ($this->getArgument('less-context')) {
         $repository_api->setDiffLinesOfContext(3);
       }
 
       if ($repository_api->supportsRelativeLocalCommits()) {
 
         // Parse the relative commit as soon as we can, to avoid generating
         // caches we need to drop later and expensive discovery operations
         // (particularly in Mercurial).
 
         $relative = $this->getArgument('paths');
         if ($relative) {
           $repository_api->parseRelativeLocalCommit($relative);
         }
       }
     }
 
     $output_json = $this->getArgument('json');
     if ($output_json) {
       // TODO: We should move this to a higher-level and put an indirection
       // layer between echoing stuff and stdout.
       ob_start();
     }
 
     if ($this->requiresWorkingCopy()) {
       try {
         $this->requireCleanWorkingCopy();
       } catch (ArcanistUncommittedChangesException $ex) {
         if ($repository_api instanceof ArcanistMercurialAPI) {
 
           // Some Mercurial users prefer to use it like SVN, where they don't
           // commit changes before sending them for review. This would be a
           // pretty bad workflow in Git, but Mercurial users are significantly
           // more expert at change management.
 
           $use_dirty_changes = false;
           if ($this->getArgument('uncommitted')) {
             // OK.
           } else {
             $ok = phutil_console_confirm(
               "You have uncommitted changes in your working copy. You can ".
               "include them in the diff, or abort and deal with them. (Use ".
               "'--uncommitted' to include them and skip this prompt.) ".
               "Do you want to include uncommitted changes in the diff?");
             if (!$ok) {
               throw $ex;
             }
           }
 
           $repository_api->setIncludeDirectoryStateInDiffs(true);
         }
       }
     }
   }
 
   protected function shouldOnlyCreateDiff() {
 
     if ($this->getArgument('create')) {
       return false;
     }
 
     if ($this->getArgument('update')) {
       return false;
     }
 
     if ($this->getArgument('use-commit-message')) {
       return false;
     }
 
     if ($this->isRawDiffSource()) {
       return true;
     }
 
     return $this->getArgument('preview') ||
            $this->getArgument('only');
   }
 
   private function generateAffectedPaths() {
     if ($this->isRawDiffSource()) {
       return array();
     }
 
     $repository_api = $this->getRepositoryAPI();
     if ($repository_api instanceof ArcanistSubversionAPI) {
       $file_list = new FileList($this->getArgument('paths', array()));
       $paths = $repository_api->getSVNStatus($externals = true);
       foreach ($paths as $path => $mask) {
         if (!$file_list->contains($repository_api->getPath($path), true)) {
           unset($paths[$path]);
         }
       }
 
       $warn_externals = array();
       foreach ($paths as $path => $mask) {
         $any_mod = ($mask & ArcanistRepositoryAPI::FLAG_ADDED) ||
                    ($mask & ArcanistRepositoryAPI::FLAG_MODIFIED) ||
                    ($mask & ArcanistRepositoryAPI::FLAG_DELETED);
         if ($mask & ArcanistRepositoryAPI::FLAG_EXTERNALS) {
           unset($paths[$path]);
           if ($any_mod) {
             $warn_externals[] = $path;
           }
         }
       }
 
       if ($warn_externals && !$this->hasWarnedExternals) {
         echo phutil_console_format(
           "The working copy includes changes to 'svn:externals' paths. These ".
           "changes will not be included in the diff because SVN can not ".
           "commit 'svn:externals' changes alongside normal changes.".
           "\n\n".
           "Modified 'svn:externals' files:".
           "\n\n".
           phutil_console_wrap(implode("\n", $warn_externals), 8));
         $prompt = "Generate a diff (with just local changes) anyway?";
         if (!phutil_console_confirm($prompt)) {
           throw new ArcanistUserAbortException();
         } else {
           $this->hasWarnedExternals = true;
         }
       }
 
     } else if ($repository_api->supportsRelativeLocalCommits()) {
       $paths = $repository_api->getWorkingCopyStatus();
     } else {
       throw new Exception("Unknown VCS!");
     }
 
     foreach ($paths as $path => $mask) {
       if ($mask & ArcanistRepositoryAPI::FLAG_UNTRACKED) {
         unset($paths[$path]);
       }
     }
 
     return $paths;
   }
 
 
   protected function generateChanges() {
     $parser = new ArcanistDiffParser();
 
     $is_raw = $this->isRawDiffSource();
     if ($is_raw) {
 
       if ($this->getArgument('raw')) {
         file_put_contents('php://stderr', "Reading diff from stdin...\n");
         $raw_diff = file_get_contents('php://stdin');
       } else if ($this->getArgument('raw-command')) {
         list($raw_diff) = execx($this->getArgument('raw-command'));
       } else {
         throw new Exception("Unknown raw diff source.");
       }
 
       $changes = $parser->parseDiff($raw_diff);
       foreach ($changes as $key => $change) {
         // Remove "message" changes, e.g. from "git show".
         if ($change->getType() == ArcanistDiffChangeType::TYPE_MESSAGE) {
           unset($changes[$key]);
         }
       }
       return $changes;
     }
 
     $repository_api = $this->getRepositoryAPI();
 
     if ($repository_api instanceof ArcanistSubversionAPI) {
       $paths = $this->generateAffectedPaths();
       $this->primeSubversionWorkingCopyData($paths);
 
       // Check to make sure the user is diffing from a consistent base revision.
       // This is mostly just an abuse sanity check because it's silly to do this
       // and makes the code more difficult to effectively review, but it also
       // affects patches and makes them nonportable.
       $bases = $repository_api->getSVNBaseRevisions();
 
       // Remove all files with baserev "0"; these files are new.
       foreach ($bases as $path => $baserev) {
         if ($bases[$path] <= 0) {
           unset($bases[$path]);
         }
       }
 
       if ($bases) {
         $rev = reset($bases);
 
         $revlist = array();
         foreach ($bases as $path => $baserev) {
           $revlist[] = "    Revision {$baserev}, {$path}";
         }
         $revlist = implode("\n", $revlist);
 
         foreach ($bases as $path => $baserev) {
           if ($baserev !== $rev) {
             throw new ArcanistUsageException(
               "Base revisions of changed paths are mismatched. Update all ".
               "paths to the same base revision before creating a diff: ".
               "\n\n".
               $revlist);
           }
         }
 
         // If you have a change which affects several files, all of which are
         // at a consistent base revision, treat that revision as the effective
         // base revision. The use case here is that you made a change to some
         // file, which updates it to HEAD, but want to be able to change it
         // again without updating the entire working copy. This is a little
         // sketchy but it arises in Facebook Ops workflows with config files and
         // doesn't have any real material tradeoffs (e.g., these patches are
         // perfectly applyable).
         $repository_api->overrideSVNBaseRevisionNumber($rev);
       }
 
       $changes = $parser->parseSubversionDiff(
         $repository_api,
         $paths);
     } else if ($repository_api instanceof ArcanistGitAPI) {
       $diff = $repository_api->getFullGitDiff();
       if (!strlen($diff)) {
         throw new ArcanistUsageException(
           "No changes found. (Did you specify the wrong commit range?)");
       }
       $changes = $parser->parseDiff($diff);
     } else if ($repository_api instanceof ArcanistMercurialAPI) {
       $diff = $repository_api->getFullMercurialDiff();
       if (!strlen($diff)) {
         throw new ArcanistUsageException(
           "No changes found. (Did you specify the wrong commit range?)");
       }
       $changes = $parser->parseDiff($diff);
     } else {
       throw new Exception("Repository API is not supported.");
     }
 
     if (count($changes) > 250) {
       $count = number_format(count($changes));
       $message =
         "This diff has a very large number of changes ({$count}). ".
         "Differential works best for changes which will receive detailed ".
         "human review, and not as well for large automated changes or ".
         "bulk checkins. Continue anyway?";
       if (!phutil_console_confirm($message)) {
         throw new ArcanistUsageException(
           "Aborted generation of gigantic diff.");
       }
     }
 
     $limit = 1024 * 1024 * 4;
     foreach ($changes as $change) {
       $size = 0;
       foreach ($change->getHunks() as $hunk) {
         $size += strlen($hunk->getCorpus());
       }
       if ($size > $limit) {
         $file_name = $change->getCurrentPath();
         $change_size = number_format($size);
         $byte_warning =
           "Diff for '{$file_name}' with context is {$change_size} bytes in ".
           "length. Generally, source changes should not be this large.";
         if (!$this->getArgument('less-context')) {
           $byte_warning .=
             " If this file is a huge text file, try using the ".
             "'--less-context' flag.";
         }
         if ($repository_api instanceof ArcanistSubversionAPI) {
           throw new ArcanistUsageException(
             "{$byte_warning} If the file is not a text file, mark it as ".
             "binary with:".
             "\n\n".
             "  $ svn propset svn:mime-type application/octet-stream <filename>".
             "\n");
         } else {
           $confirm =
             "{$byte_warning} If the file is not a text file, you can ".
             "mark it 'binary'. Mark this file as 'binary' and continue?";
           if (phutil_console_confirm($confirm)) {
             $change->convertToBinaryChange();
           } else {
             throw new ArcanistUsageException(
               "Aborted generation of gigantic diff.");
           }
         }
       }
     }
 
     $try_encoding = nonempty($this->getArgument('encoding'), null);
 
     $utf8_problems = array();
     foreach ($changes as $change) {
       foreach ($change->getHunks() as $hunk) {
         $corpus = $hunk->getCorpus();
         if (!phutil_is_utf8($corpus)) {
 
           // If this corpus is heuristically binary, don't try to convert it.
           // mb_check_encoding() and mb_convert_encoding() are both very very
           // liberal about what they're willing to process.
           $is_binary = ArcanistDiffUtils::isHeuristicBinaryFile($corpus);
           if (!$is_binary) {
 
             if (!$try_encoding) {
               try {
                 $try_encoding = $this->getRepositoryEncoding();
               } catch (ConduitClientException $e) {
                 if ($e->getErrorCode() == 'ERR-BAD-ARCANIST-PROJECT') {
                   echo phutil_console_wrap(
                     "Lookup of encoding in arcanist project failed\n".
                     $e->getMessage());
                 } else {
                   throw $e;
                 }
               }
             }
 
             if ($try_encoding) {
               // NOTE: This feature is HIGHLY EXPERIMENTAL and will cause a lot
               // of issues. Use it at your own risk.
               $corpus = mb_convert_encoding($corpus, 'UTF-8', $try_encoding);
               $name = $change->getCurrentPath();
               if (phutil_is_utf8($corpus)) {
                 $this->writeStatusMessage(
                   "[Experimental] Converted a '{$name}' hunk from ".
                   "'{$try_encoding}' to UTF-8.\n");
                 $hunk->setCorpus($corpus);
                 continue;
               }
             }
           }
           $utf8_problems[] = $change;
           break;
         }
       }
     }
 
     // If there are non-binary files which aren't valid UTF-8, warn the user
     // and treat them as binary changes. See D327 for discussion of why Arcanist
     // has this behavior.
     if ($utf8_problems) {
       $learn_more =
         "You can learn more about how Phabricator handles character encodings ".
         "(and how to configure encoding settings and detect and correct ".
         "encoding problems) by reading 'User Guide: UTF-8 and Character ".
         "Encoding' in the Phabricator documentation.\n\n";
       if (count($utf8_problems) == 1) {
         $utf8_warning =
           "This diff includes a file which is not valid UTF-8 (it has invalid ".
           "byte sequences). You can either stop this workflow and fix it, or ".
           "continue. If you continue, this file will be marked as binary.\n\n".
           $learn_more.
           "    AFFECTED FILE\n";
 
         $confirm = "Do you want to mark this file as binary and continue?";
       } else {
         $utf8_warning =
           "This diff includes files which are not valid UTF-8 (they contain ".
           "invalid byte sequences). You can either stop this workflow and fix ".
           "these files, or continue. If you continue, these files will be ".
           "marked as binary.\n\n".
           $learn_more.
           "    AFFECTED FILES\n";
 
         $confirm = "Do you want to mark these files as binary and continue?";
       }
 
       echo phutil_console_format("**Invalid Content Encoding (Non-UTF8)**\n");
       echo phutil_console_wrap($utf8_warning);
 
       $file_list = mpull($utf8_problems, 'getCurrentPath');
       $file_list = '    '.implode("\n    ", $file_list);
       echo $file_list;
 
       if (!phutil_console_confirm($confirm, $default_no = false)) {
         throw new ArcanistUsageException("Aborted workflow to fix UTF-8.");
       } else {
         foreach ($utf8_problems as $change) {
           $change->convertToBinaryChange();
         }
       }
     }
 
     foreach ($changes as $change) {
       $path = $change->getCurrentPath();
 
       // Certain types of changes (moves and copies) don't contain change data
       // when expressed in raw "git diff" form. Augment any such diffs with
       // textual data.
       if ($change->getNeedsSyntheticGitHunks()) {
         $diff = $repository_api->getRawDiffText($path, $moves = false);
         $parser = new ArcanistDiffParser();
         $raw_changes = $parser->parseDiff($diff);
         foreach ($raw_changes as $raw_change) {
           if ($raw_change->getCurrentPath() == $path) {
             $change->setFileType($raw_change->getFileType());
             foreach ($raw_change->getHunks() as $hunk) {
               $change->addHunk($hunk);
             }
             break;
           }
         }
 
         $change->setNeedsSyntheticGitHunks(false);
       }
 
       if ($change->getFileType() != ArcanistDiffChangeType::FILE_BINARY) {
         continue;
       }
 
       $name = basename($path);
 
       $old_file = $repository_api->getOriginalFileData($path);
       $old_dict = $this->uploadFile($old_file, $name, 'old binary');
       if ($old_dict['guid']) {
         $change->setMetadata('old:binary-phid', $old_dict['guid']);
       }
       $change->setMetadata('old:file:size',      $old_dict['size']);
       $change->setMetadata('old:file:mime-type', $old_dict['mime']);
 
       $new_file = $repository_api->getCurrentFileData($path);
       $new_dict = $this->uploadFile($new_file, $name, 'new binary');
       if ($new_dict['guid']) {
         $change->setMetadata('new:binary-phid', $new_dict['guid']);
       }
       $change->setMetadata('new:file:size',      $new_dict['size']);
       $change->setMetadata('new:file:mime-type', $new_dict['mime']);
 
       if (preg_match('@^image/@', $new_dict['mime'])) {
         $change->setFileType(ArcanistDiffChangeType::FILE_IMAGE);
       }
     }
 
     return $changes;
   }
 
   private function uploadFile($data, $name, $desc) {
     $result = array(
       'guid' => null,
       'mime' => null,
       'size' => null
     );
 
     if ($this->getArgument('skip-binaries')) {
       return $result;
     }
 
     $result['size'] = $size = strlen($data);
     if (!$size) {
       return $result;
     }
 
     $tmp = new TempFile();
     Filesystem::writeFile($tmp, $data);
     $mime_type = Filesystem::getMimeType($tmp);
     $result['mime'] = $mime_type;
 
     echo "Uploading {$desc} '{$name}' ({$mime_type}, {$size} bytes)...\n";
 
     try {
       $guid = $this->getConduit()->callMethodSynchronous(
         'file.upload',
         array(
           'data_base64' => base64_encode($data),
           'name'        => $name,
       ));
 
       $result['guid'] = $guid;
     } catch (Exception $e) {
       echo "Failed to upload {$desc} '{$name}'.\n";
 
       if (!phutil_console_confirm('Continue?', $default_no = false)) {
         throw new ArcanistUsageException(
           'Aborted due to file upload failure. You can use --skip-binaries '.
           'to skip binary uploads.');
       }
     }
     return $result;
   }
 
   private function getGitParentLogInfo() {
     $info = array(
       'parent'        => null,
       'base_revision' => null,
       'base_path'     => null,
       'uuid'          => null,
     );
 
     $conduit = $this->getConduit();
     $repository_api = $this->getRepositoryAPI();
 
     $parser = new ArcanistDiffParser();
     $history_messages = $repository_api->getGitHistoryLog();
     if (!$history_messages) {
       // This can occur on the initial commit.
       return $info;
     }
     $history_messages = $parser->parseDiff($history_messages);
 
     foreach ($history_messages as $key => $change) {
       try {
         $message = ArcanistDifferentialCommitMessage::newFromRawCorpus(
           $change->getMetadata('message'));
         if ($message->getRevisionID() && $info['parent'] === null) {
           $info['parent'] = $message->getRevisionID();
         }
         if ($message->getGitSVNBaseRevision() &&
             $info['base_revision'] === null) {
           $info['base_revision'] = $message->getGitSVNBaseRevision();
           $info['base_path']     = $message->getGitSVNBasePath();
         }
         if ($message->getGitSVNUUID()) {
           $info['uuid'] = $message->getGitSVNUUID();
         }
         if ($info['parent'] && $info['base_revision']) {
           break;
         }
       } catch (ArcanistDifferentialCommitMessageParserException $ex) {
         // Ignore.
       } catch (ArcanistUsageException $ex) {
         // Ignore an invalid Differential Revision field in the parent commit
       }
     }
 
     return $info;
   }
 
   protected function primeSubversionWorkingCopyData($paths) {
     $repository_api = $this->getRepositoryAPI();
 
     $futures = array();
     $targets = array();
     foreach ($paths as $path => $mask) {
       $futures[] = $repository_api->buildDiffFuture($path);
       $targets[] = array('command' => 'diff', 'path' => $path);
       $futures[] = $repository_api->buildInfoFuture($path);
       $targets[] = array('command' => 'info', 'path' => $path);
     }
 
     foreach (Futures($futures)->limit(8) as $key => $future) {
       $target = $targets[$key];
       if ($target['command'] == 'diff') {
         $repository_api->primeSVNDiffResult(
           $target['path'],
           $future->resolve());
       } else {
         $repository_api->primeSVNInfoResult(
           $target['path'],
           $future->resolve());
       }
     }
   }
 
   private function shouldAmend() {
     return !$this->isHistoryImmutable() && !$this->getArgument('no-amend');
   }
 
 
 /* -(  Lint and Unit Tests  )------------------------------------------------ */
 
 
   /**
    * @task lintunit
    */
   private function runLint($paths) {
     if ($this->getArgument('nolint') ||
         $this->getArgument('only') ||
         $this->isRawDiffSource()) {
       return ArcanistLintWorkflow::RESULT_SKIP;
     }
 
     $repository_api = $this->getRepositoryAPI();
 
     echo "Linting...\n";
     try {
       $argv = $this->getPassthruArgumentsAsArgv('lint');
       if ($repository_api->supportsRelativeLocalCommits()) {
         $argv[] = '--rev';
         $argv[] = $repository_api->getRelativeCommit();
       }
       $lint_workflow = $this->buildChildWorkflow('lint', $argv);
 
       if ($this->shouldAmend()) {
         // TODO: We should offer to create a checkpoint commit.
         $lint_workflow->setShouldAmendChanges(true);
       }
 
       $lint_result = $lint_workflow->run();
 
       switch ($lint_result) {
         case ArcanistLintWorkflow::RESULT_OKAY:
           echo phutil_console_format(
             "<bg:green>** LINT OKAY **</bg> No lint problems.\n");
           break;
         case ArcanistLintWorkflow::RESULT_WARNINGS:
           $this->lintExcuse = $this->getErrorExcuse(
             "Lint issued unresolved warnings.",
             $repository_api->getScratchFilePath('lint-excuses'));
           break;
         case ArcanistLintWorkflow::RESULT_ERRORS:
           echo phutil_console_format(
             "<bg:red>** LINT ERRORS **</bg> Lint raised errors!\n");
           $this->lintExcuse = $this->getErrorExcuse(
             "Lint issued unresolved errors!",
             $repository_api->getScratchFilePath('lint-excuses'));
           break;
       }
 
       $this->unresolvedLint = $lint_workflow->getUnresolvedMessages();
 
       return $lint_result;
     } catch (ArcanistNoEngineException $ex) {
       echo "No lint engine configured for this project.\n";
     } catch (ArcanistNoEffectException $ex) {
       echo "No paths to lint.\n";
     }
 
     return null;
   }
 
 
   /**
    * @task lintunit
    */
   private function runUnit($paths) {
     if ($this->getArgument('nounit') ||
         $this->getArgument('only') ||
         $this->isRawDiffSource()) {
       return ArcanistUnitWorkflow::RESULT_SKIP;
     }
 
     $repository_api = $this->getRepositoryAPI();
 
     echo "Running unit tests...\n";
     try {
       $argv = $this->getPassthruArgumentsAsArgv('unit');
       if ($repository_api->supportsRelativeLocalCommits()) {
         $argv[] = '--rev';
         $argv[] = $repository_api->getRelativeCommit();
       }
       $this->unitWorkflow = $this->buildChildWorkflow('unit', $argv);
       $unit_result = $this->unitWorkflow->run();
 
       switch ($unit_result) {
         case ArcanistUnitWorkflow::RESULT_OKAY:
           echo phutil_console_format(
             "<bg:green>** UNIT OKAY **</bg> No unit test failures.\n");
           break;
         case ArcanistUnitWorkflow::RESULT_UNSOUND:
           $continue = phutil_console_confirm(
             "Unit test results included failures, but all failing tests ".
             "are known to be unsound. Ignore unsound test failures?");
           if (!$continue) {
             throw new ArcanistUserAbortException();
           }
           break;
         case ArcanistUnitWorkflow::RESULT_FAIL:
           echo phutil_console_format(
             "<bg:red>** UNIT ERRORS **</bg> Unit testing raised errors!\n");
           $this->unitExcuse = $this->getErrorExcuse(
             "Unit test results include failures!",
             $repository_api->getScratchFilePath('unit-excuses'));
           break;
       }
 
       $this->testResults = $this->unitWorkflow->getTestResults();
 
       return $unit_result;
     } catch (ArcanistNoEngineException $ex) {
       echo "No unit test engine is configured for this project.\n";
     } catch (ArcanistNoEffectException $ex) {
       echo "No tests to run.\n";
     }
 
     return null;
   }
 
   private function getErrorExcuse($prompt, $history = '') {
     if ($this->getArgument('excuse')) {
       $prompt .= " Ignore them?";
       if (!phutil_console_confirm($prompt)) {
         throw new ArcanistUserAbortException();
       }
       return $this->getArgument('excuse');
     }
 
     $prompt .= " Provide explanation to continue or press Enter to abort.";
     echo "\n\n";
     echo phutil_console_format($prompt);
     $return = phutil_console_prompt("Explanation:", $history);
     if ($return == '') {
       throw new ArcanistUserAbortException();
     }
     return $return;
   }
 
 
 /* -(  Commit and Update Messages  )----------------------------------------- */
 
 
   /**
    * @task message
    */
   private function buildCommitMessage() {
     if ($this->getArgument('preview') || $this->getArgument('only')) {
       return null;
     }
 
     $is_create = $this->getArgument('create');
     $is_update = $this->getArgument('update');
     $is_raw = $this->isRawDiffSource();
     $is_message = $this->getArgument('use-commit-message');
     $is_verbatim = $this->getArgument('verbatim');
 
     if ($is_message) {
       return $this->getCommitMessageFromCommit($is_message);
     }
 
     if ($is_verbatim) {
       return $this->getCommitMessageFromUser();
     }
 
     if (!$is_raw && !$is_create && !$is_update) {
       $repository_api = $this->getRepositoryAPI();
       $revisions = $repository_api->loadWorkingCopyDifferentialRevisions(
         $this->getConduit(),
         array(
           'authors' => array($this->getUserPHID()),
           'status'  => 'status-open',
         ));
       if (!$revisions) {
         $is_create = true;
       } else if (count($revisions) == 1) {
         $revision = head($revisions);
         $is_update = $revision['id'];
       } else {
         throw new ArcanistUsageException(
           "There are several revisions which match the working copy:\n\n".
           $this->renderRevisionList($revisions)."\n".
           "Use '--update' to choose one, or '--create' to create a new ".
           "revision.");
       }
     }
 
     $message = null;
     if ($is_create) {
       $message_file = $this->getArgument('message-file');
       if ($message_file) {
         return $this->getCommitMessageFromFile($message_file);
       } else {
         return $this->getCommitMessageFromUser();
       }
     } else if ($is_update) {
       $revision_id = $this->normalizeRevisionID($is_update);
       if (!is_numeric($revision_id)) {
         throw new ArcanistUsageException(
           'Parameter to --update must be a Differential Revision number');
       }
       return $this->getCommitMessageFromRevision($revision_id);
     } else {
       // This is --raw without enough info to create a revision, so force just
       // a diff.
       return null;
     }
   }
 
 
   /**
    * @task message
    */
   private function getCommitMessageFromCommit($rev) {
     $change = $this->getRepositoryAPI()->getCommitMessageForRevision($rev);
     $message = ArcanistDifferentialCommitMessage::newFromRawCorpus(
       $change->getMetadata('message'));
     $message->pullDataFromConduit($this->getConduit());
     $this->validateCommitMessage($message);
     return $message;
   }
 
 
   /**
    * @task message
    */
   private function getCommitMessageFromUser() {
     $conduit = $this->getConduit();
 
     $template = null;
 
     if (!$this->getArgument('verbatim')) {
       $saved = $this->readScratchFile('create-message');
       if ($saved) {
         $where = $this->getReadableScratchFilePath('create-message');
 
         $preview = explode("\n", $saved);
         $preview = array_shift($preview);
         $preview = trim($preview);
         $preview = phutil_utf8_shorten($preview, 64);
 
         if ($preview) {
           $preview = "Message begins:\n\n       {$preview}\n\n";
         } else {
           $preview = null;
         }
 
         echo
           "You have a saved revision message in '{$where}'.\n".
           "{$preview}".
           "You can use this message, or discard it.";
 
         $use = phutil_console_confirm(
           "Do you want to use this message?",
           $default_no = false);
         if ($use) {
           $template = $saved;
         } else {
           $this->removeScratchFile('create-message');
         }
       }
     }
 
     $template_is_default = false;
     $notes = array();
     $included = array();
 
     list($fields, $notes, $included) = $this->getDefaultCreateFields();
     if ($template) {
       $fields = array();
       $notes = array();
     } else {
       if (!$fields) {
         $template_is_default = true;
       }
 
       $template = $conduit->callMethodSynchronous(
         'differential.getcommitmessage',
         array(
           'revision_id' => null,
           'edit'        => 'create',
           'fields'      => $fields,
         ));
     }
 
     if ($included) {
       foreach ($included as $k => $commit) {
         $included[$k] = '        '.$commit;
       }
       $in_branch = '';
       if (!$this->isRawDiffSource()) {
         $in_branch = ' in branch '.$this->getRepositoryAPI()->getBranchName();
       }
       $included = array_merge(
         array(
           "",
           "Included commits{$in_branch}:",
           "",
         ),
         $included,
         array(
           "",
         ));
     } else {
       $included = array(
         '',
       );
     }
 
     $issues = array_merge(
       array(
         'NEW DIFFERENTIAL REVISION',
         'Describe the changes in this new revision.',
       ),
       $included,
       array(
         'arc could not identify any existing revision in your working copy.',
         'If you intended to update an existing revision, use:',
         '',
         '  $ arc diff --update <revision>',
       ));
     if ($notes) {
       $issues = array_merge($issues, array(''), $notes);
     }
 
     $done = false;
     $first = true;
     while (!$done) {
       $template = rtrim($template, "\r\n")."\n\n";
       foreach ($issues as $issue) {
         $template .= '# '.$issue."\n";
       }
       $template .= "\n";
 
       if ($first && $this->getArgument('verbatim') && !$template_is_default) {
         $new_template = $template;
       } else {
         $new_template = id(new PhutilInteractiveEditor($template))
           ->setName('new-commit')
           ->editInteractively();
       }
       $first = false;
 
       if ($template_is_default && ($new_template == $template)) {
         throw new ArcanistUsageException("Template not edited.");
       }
 
       $template = ArcanistCommentRemover::removeComments($new_template);
       $wrote = $this->writeScratchFile('create-message', $template);
       $where = $this->getReadableScratchFilePath('create-message');
 
       try {
         $message = ArcanistDifferentialCommitMessage::newFromRawCorpus(
           $template);
         $message->pullDataFromConduit($conduit);
         $this->validateCommitMessage($message);
         $done = true;
       } catch (ArcanistDifferentialCommitMessageParserException $ex) {
         echo "Commit message has errors:\n\n";
         $issues = array('Resolve these errors:');
         foreach ($ex->getParserErrors() as $error) {
           echo "      - ".$error."\n";
           $issues[] = '  - '.$error;
         }
         echo "\n";
         echo "You must resolve these errors to continue.";
         $again = phutil_console_confirm(
           "Do you want to edit the message?",
           $default_no = false);
         if ($again) {
           // Keep going.
         } else {
           $saved = null;
           if ($wrote) {
             $saved = "A copy was saved to '{$where}'.";
           }
           throw new ArcanistUsageException(
             "Message has unresolved errrors. {$saved}");
         }
       } catch (Exception $ex) {
         if ($wrote) {
           echo phutil_console_wrap("(Commit messaged saved to '{$where}'.)\n");
         }
         throw $ex;
       }
     }
 
     return $message;
   }
 
 
   /**
    * @task message
    */
   private function getCommitMessageFromFile($file) {
     $conduit = $this->getConduit();
 
     $data = Filesystem::readFile($file);
     $message = ArcanistDifferentialCommitMessage::newFromRawCorpus($data);
     $message->pullDataFromConduit($conduit);
 
     $this->validateCommitMessage($message);
 
     return $message;
   }
 
 
   /**
    * @task message
    */
   private function getCommitMessageFromRevision($revision_id) {
     $id = $revision_id;
 
     $revision = $this->getConduit()->callMethodSynchronous(
       'differential.query',
       array(
         'ids' => array($id),
       ));
     $revision = head($revision);
 
     if (!$revision) {
       throw new ArcanistUsageException(
         "Revision '{$revision_id}' does not exist!");
     }
 
     if ($revision['authorPHID'] != $this->getUserPHID()) {
       $rev_title = $revision['title'];
       throw new ArcanistUsageException(
         "You don't own revision D{$id} '{$rev_title}'. You can only update ".
         "revisions you own.");
     }
 
     $message = $this->getConduit()->callMethodSynchronous(
       'differential.getcommitmessage',
       array(
         'revision_id' => $id,
         'edit'        => false,
       ));
 
     $obj = ArcanistDifferentialCommitMessage::newFromRawCorpus($message);
     $obj->pullDataFromConduit($this->getConduit());
 
     return $obj;
   }
 
 
   /**
    * @task message
    */
   private function validateCommitMessage(
     ArcanistDifferentialCommitMessage $message) {
     $reviewers = $message->getFieldValue('reviewerPHIDs');
     if (!$reviewers) {
       $confirm = "You have not specified any reviewers. Continue anyway?";
       if (!phutil_console_confirm($confirm)) {
         throw new ArcanistUsageException('Specify reviewers and retry.');
       }
     } else if (in_array($this->getUserPHID(), $reviewers)) {
       throw new ArcanistUsageException(
         "You can not be a reviewer for your own revision.");
     } else {
       $users = $this->getConduit()->callMethodSynchronous(
         'user.query',
         array(
           'phids' => $reviewers,
         ));
       $untils = array();
       foreach ($users as $user) {
         if (idx($user, 'currentStatus') == 'away') {
           $untils[] = $user['currentStatusUntil'];
         }
       }
       if (count($untils) == count($reviewers)) {
         $until = date('l, M j Y', min($untils));
         $confirm = "All reviewers are away until {$until}. Continue anyway?";
         if (!phutil_console_confirm($confirm)) {
           throw new ArcanistUsageException(
             'Specify available reviewers and retry.');
         }
       }
     }
   }
 
 
   /**
    * @task message
    */
   private function getUpdateMessage(array $fields) {
     $comments = $this->getArgument('message');
     if (strlen($comments)) {
       return $comments;
     }
 
     if ($this->getArgument('raw')) {
       throw new ArcanistUsageException(
         "When using '--raw' to update a revision, specify an update message ".
         "with '--message'. (Normally, we'd launch an editor to ask you for a ".
         "message, but can not do that because stdin is the diff source.)");
     }
 
     // When updating a revision using git without specifying '--message', try
     // to prefill with the message in HEAD if it isn't a template message. The
     // idea is that if you do:
     //
     //  $ git commit -a -m 'fix some junk'
     //  $ arc diff
     //
     // ...you shouldn't have to retype the update message. Similar things apply
     // to Mercurial.
 
     $comments = $this->getDefaultUpdateMessage();
 
     $template =
       rtrim($comments).
       "\n\n".
       "# Updating D{$fields['revisionID']}: {$fields['title']}\n".
       "#\n".
       "# Enter a brief description of the changes included in this update.\n".
       "# The first line is used as subject, next lines as comment.\n".
       "#\n".
       "# If you intended to create a new revision, use:\n".
       "#  $ arc diff --create\n".
       "\n";
 
     $comments = id(new PhutilInteractiveEditor($template))
       ->setName('differential-update-comments')
       ->editInteractively();
 
     $comments = ArcanistCommentRemover::removeComments($comments);
     if (!strlen(trim($comments))) {
       throw new ArcanistUserAbortException();
     }
 
     return $comments;
   }
 
   private function getDefaultCreateFields() {
     $result = array(array(), array(), array());
 
     if ($this->isRawDiffSource()) {
       return $result;
     }
 
     $repository_api = $this->getRepositoryAPI();
     $local = $repository_api->getLocalCommitInformation();
     if ($local) {
       $result = $this->parseCommitMessagesIntoFields($local);
     }
 
     $result[0] = $this->dispatchWillBuildEvent($result[0]);
 
     return $result;
   }
 
   /**
    * Convert a list of commits from `getLocalCommitInformation()` into
    * a format usable by arc to create a new diff. Specifically, we emit:
    *
    *   - A dictionary of commit message fields.
    *   - A list of errors encountered while parsing the messages.
    *   - A human-readable list of the commits themselves.
    *
    * For example, if the user runs "arc diff HEAD^^^" and selects a diff range
    * which includes several diffs, we attempt to merge them somewhat
    * intelligently into a single message, because we can only send one
    * "Summary:", "Reviewers:", etc., field to Differential. We also return
    * errors (e.g., if the user typed a reviewer name incorrectly) and a
    * summary of the commits themselves.
    *
    * @param dict  Local commit information.
    * @return list Complex output, see summary.
    * @task message
    */
   private function parseCommitMessagesIntoFields(array $local) {
     $conduit = $this->getConduit();
     $local = ipull($local, null, 'commit');
 
     // If the user provided "--reviewers" or "--ccs", add a faux message to
     // the list with the implied fields.
 
     $faux_message = array();
     if ($this->getArgument('reviewers')) {
       $faux_message[] = 'Reviewers: '.$this->getArgument('reviewers');
     }
     if ($this->getArgument('cc')) {
       $faux_message[] = 'CC: '.$this->getArgument('cc');
     }
 
     if ($faux_message) {
       $faux_message = implode("\n\n", $faux_message);
       $local = array(
         '(Flags)     ' => array(
           'message' => $faux_message,
           'summary' => 'Command-Line Flags',
         ),
       ) + $local;
     }
 
     // Build a human-readable list of the commits, so we can show the user which
     // commits are included in the diff.
     $included = array();
     foreach ($local as $hash => $info) {
       $included[] = substr($hash, 0, 12).' '.$info['summary'];
     }
 
     // Parse all of the messages into fields.
     $messages = array();
     foreach ($local as $hash => $info) {
       $text = $info['message'];
       $obj = ArcanistDifferentialCommitMessage::newFromRawCorpus($text);
       $messages[$hash] = $obj;
     }
 
     $notes = array();
     $fields = array();
     foreach ($messages as $hash => $message) {
       try {
         $message->pullDataFromConduit($conduit, $partial = true);
         $fields[$hash] = $message->getFields();
       } catch (ArcanistDifferentialCommitMessageParserException $ex) {
         if ($this->getArgument('verbatim')) {
           // In verbatim mode, just bail when we hit an error. The user can
           // rerun without --verbatim if they want to fix it manually. Most
           // users will probably `git commit --amend` instead.
           throw $ex;
         }
         $fields[$hash] = $message->getFields();
 
         $frev = substr($hash, 0, 12);
         $notes[] = "NOTE: commit {$frev} could not be completely parsed:";
         foreach ($ex->getParserErrors() as $error) {
           $notes[] = "  - {$error}";
         }
       }
     }
 
     // Merge commit message fields. We do this somewhat-intelligently so that
     // multiple "Reviewers" or "CC" fields will merge into the concatenation
     // of all values.
 
     // We have special parsing rules for 'title' because we can't merge
     // multiple titles, and one-line commit messages like "fix stuff" will
     // parse as titles. Instead, pick the first title we encounter. When we
     // encounter subsequent titles, treat them as part of the summary. Then
     // we merge all the summaries together below.
 
     $result = array();
 
     // Process fields in oldest-first order, so earlier commits get to set the
     // title of record and reviewers/ccs are listed in chronological order.
     $fields = array_reverse($fields);
 
     foreach ($fields as $hash => $dict) {
       $title = idx($dict, 'title');
       if (!strlen($title)) {
         continue;
       }
 
       if (!isset($result['title'])) {
         // We don't have a title yet, so use this one.
         $result['title'] = $title;
       } else {
         // We already have a title, so merge this new title into the summary.
         $summary = idx($dict, 'summary');
         if ($summary) {
           $summary = $title."\n\n".$summary;
         } else {
           $summary = $title;
         }
         $fields[$hash]['summary'] = $summary;
       }
     }
 
     // Now, merge all the other fields in a general sort of way.
 
     foreach ($fields as $hash => $dict) {
       foreach ($dict as $key => $value) {
         if ($key == 'title') {
           // This has been handled above, and either assigned directly or
           // merged into the summary.
           continue;
         }
 
         if (is_array($value)) {
           // For array values, merge the arrays, appending the new values.
           // Examples are "Reviewers" and "Cc", where this produces a list of
           // all users specified as reviewers.
           $cur = idx($result, $key, array());
           $new = array_merge($cur, $value);
           $result[$key] = $new;
           continue;
         } else {
           if (!strlen(trim($value))) {
             // Ignore empty fields.
             continue;
           }
 
           // For string values, append the new field to the old field with
           // a blank line separating them. Examples are "Test Plan" and
           // "Summary".
           $cur = idx($result, $key, '');
           if (strlen($cur)) {
             $new = $cur."\n\n".$value;
           } else {
             $new = $value;
           }
           $result[$key] = $new;
         }
       }
     }
 
     return array($result, $notes, $included);
   }
 
   private function getDefaultUpdateMessage() {
     if ($this->isRawDiffSource()) {
       return null;
     }
 
     $repository_api = $this->getRepositoryAPI();
     if ($repository_api instanceof ArcanistGitAPI) {
       return $this->getGitUpdateMessage();
     }
 
     if ($repository_api instanceof ArcanistMercurialAPI) {
       return $this->getMercurialUpdateMessage();
     }
 
     return null;
   }
 
   /**
    * Retrieve the git messages between HEAD and the last update.
    *
    * @task message
    */
   private function getGitUpdateMessage() {
     $repository_api = $this->getRepositoryAPI();
 
     $parser = new ArcanistDiffParser();
     $commit_messages = $repository_api->getGitCommitLog();
     $commit_messages = $parser->parseDiff($commit_messages);
 
     if (count($commit_messages) == 1) {
       // If there's only one message, assume this is an amend-based workflow and
       // that using it to prefill doesn't make sense.
       return null;
     }
 
     // We have more than one message, so figure out which ones are new. We
     // do this by pulling the current diff and comparing commit hashes in the
     // working copy with attached commit hashes. It's not super important that
     // we always get this 100% right, we're just trying to do something
     // reasonable.
 
     $local = $this->loadActiveLocalCommitInfo();
     $hashes = ipull($local, null, 'commit');
 
     $usable = array();
     foreach ($commit_messages as $message) {
       $text = $message->getMetadata('message');
 
       $parsed = ArcanistDifferentialCommitMessage::newFromRawCorpus($text);
       if ($parsed->getRevisionID()) {
         // If this is an amended commit message with a revision ID, it's
         // certainly not new. Stop marking commits as usable and break out.
         break;
       }
 
       if (isset($hashes[$message->getCommitHash()])) {
         // If this commit is currently part of the diff, stop using commit
         // messages, since anything older than this isn't new.
         break;
       }
 
       // Otherwise, this looks new, so it's a usable commit message.
       $usable[] = $text;
     }
 
     if (!$usable) {
       // No new commit messages, so we don't have anywhere to start from.
       return null;
     }
 
     return $this->formatUsableLogs($usable);
   }
 
   /**
    * Retrieve the hg messages between tip and the last update.
    *
    * @task message
    */
   private function getMercurialUpdateMessage() {
     $repository_api = $this->getRepositoryAPI();
 
     $messages = $repository_api->getCommitMessageLog();
 
     $local = $this->loadActiveLocalCommitInfo();
     $hashes = ipull($local, null, 'commit');
 
     $usable = array();
     foreach ($messages as $rev => $message) {
       if (isset($hashes[$rev])) {
         // If this commit is currently part of the active diff on the revision,
         // stop using commit messages, since anything older than this isn't new.
         break;
       }
 
       // Otherwise, this looks new, so it's a usable commit message.
       $usable[] = $message;
     }
 
     if (!$usable) {
       // No new commit messages, so we don't have anywhere to start from.
       return null;
     }
 
     return $this->formatUsableLogs($usable);
   }
 
 
   /**
    * Format log messages to prefill a diff update.
    *
    * @task message
    */
   private function formatUsableLogs(array $usable) {
     // Flip messages so they'll read chronologically (oldest-first) in the
     // template, e.g.:
     //
     //   - Added foobar.
     //   - Fixed foobar bug.
     //   - Documented foobar.
 
     $usable = array_reverse($usable);
     $default = array();
     foreach ($usable as $message) {
       // Pick the first line out of each message.
       $text = trim($message);
       $text = head(explode("\n", $text));
       $default[] = '  - '.$text."\n";
     }
 
     return implode('', $default);
   }
 
   private function loadActiveLocalCommitInfo() {
     $current_diff = $this->getConduit()->callMethodSynchronous(
       'differential.getdiff',
       array(
         'revision_id' => $this->revisionID,
       ));
 
     $properties = idx($current_diff, 'properties', array());
     return idx($properties, 'local:commits', array());
   }
 
 
 /* -(  Diff Specification  )------------------------------------------------- */
 
 
   /**
    * @task diffspec
    */
   private function getLintStatus($lint_result) {
     $map = array(
       ArcanistLintWorkflow::RESULT_OKAY       => 'okay',
       ArcanistLintWorkflow::RESULT_ERRORS     => 'fail',
       ArcanistLintWorkflow::RESULT_WARNINGS   => 'warn',
       ArcanistLintWorkflow::RESULT_SKIP       => 'skip',
     );
     return idx($map, $lint_result, 'none');
   }
 
 
   /**
    * @task diffspec
    */
   private function getUnitStatus($unit_result) {
     $map = array(
       ArcanistUnitWorkflow::RESULT_OKAY       => 'okay',
       ArcanistUnitWorkflow::RESULT_FAIL       => 'fail',
       ArcanistUnitWorkflow::RESULT_UNSOUND    => 'warn',
       ArcanistUnitWorkflow::RESULT_SKIP       => 'skip',
       ArcanistUnitWorkflow::RESULT_POSTPONED  => 'postponed',
     );
     return idx($map, $unit_result, 'none');
   }
 
 
   /**
    * @task diffspec
    */
   private function buildDiffSpecification() {
 
     $base_revision  = null;
     $base_path      = null;
     $vcs            = null;
     $repo_uuid      = null;
     $parent         = null;
     $source_path    = null;
     $branch         = null;
 
     if (!$this->isRawDiffSource()) {
       $repository_api = $this->getRepositoryAPI();
 
       $base_revision  = $repository_api->getSourceControlBaseRevision();
       $base_path      = $repository_api->getSourceControlPath();
       $vcs            = $repository_api->getSourceControlSystemName();
       $source_path    = $repository_api->getPath();
       $branch         = $repository_api->getBranchName();
 
       if ($repository_api instanceof ArcanistGitAPI) {
         $info = $this->getGitParentLogInfo();
         if ($info['parent']) {
           $parent = $info['parent'];
         }
         if ($info['base_revision']) {
           $base_revision = $info['base_revision'];
         }
         if ($info['base_path']) {
           $base_path = $info['base_path'];
         }
         if ($info['uuid']) {
           $repo_uuid = $info['uuid'];
         }
       } else if ($repository_api instanceof ArcanistSubversionAPI) {
         $repo_uuid = $repository_api->getRepositorySVNUUID();
       } else if ($repository_api instanceof ArcanistMercurialAPI) {
         // TODO: Provide this information.
       } else {
         throw new Exception("Unsupported repository API!");
       }
     }
 
     $project_id = null;
     if ($this->requiresWorkingCopy()) {
       $project_id = $this->getWorkingCopy()->getProjectID();
     }
 
     return array(
       'sourceMachine'             => php_uname('n'),
       'sourcePath'                => $source_path,
       'branch'                    => $branch,
       'sourceControlSystem'       => $vcs,
       'sourceControlPath'         => $base_path,
       'sourceControlBaseRevision' => $base_revision,
       'parentRevisionID'          => $parent,
       'repositoryUUID'            => $repo_uuid,
       'creationMethod'            => 'arc',
       'arcanistProject'           => $project_id,
       'authorPHID'                => $this->getUserPHID(),
     );
   }
 
 
 /* -(  Diff Properties  )---------------------------------------------------- */
 
 
   /**
    * Update lint information for the diff.
    *
    * @return void
    *
    * @task diffprop
    */
   private function updateLintDiffProperty() {
     if (!$this->unresolvedLint) {
       return;
     }
 
     $data = array();
     foreach ($this->unresolvedLint as $message) {
       $data[] = array(
         'path'        => $message->getPath(),
         'line'        => $message->getLine(),
         'char'        => $message->getChar(),
         'code'        => $message->getCode(),
         'severity'    => $message->getSeverity(),
         'name'        => $message->getName(),
         'description' => $message->getDescription(),
       );
     }
 
     $this->updateDiffProperty('arc:lint', json_encode($data));
     if (strlen($this->lintExcuse)) {
       $this->updateDiffProperty('arc:lint-excuse',
         json_encode($this->lintExcuse));
     }
   }
 
 
   /**
    * Update unit test information for the diff.
    *
    * @return void
    *
    * @task diffprop
    */
   private function updateUnitDiffProperty() {
     if (!$this->testResults) {
       return;
     }
 
     $data = array();
     foreach ($this->testResults as $test) {
       $data[] = array(
         'name'      => $test->getName(),
         'result'    => $test->getResult(),
         'userdata'  => $test->getUserData(),
         'coverage'  => $test->getCoverage(),
       );
     }
 
     $this->updateDiffProperty('arc:unit', json_encode($data));
     if (strlen($this->unitExcuse)) {
       $this->updateDiffProperty('arc:unit-excuse',
         json_encode($this->unitExcuse));
     }
   }
 
 
   /**
    * Update local commit information for the diff.
    *
    * @task diffprop
    */
   private function updateLocalDiffProperty() {
     if ($this->isRawDiffSource()) {
       return;
     }
 
     $local_info = $this->getRepositoryAPI()->getLocalCommitInformation();
     if (!$local_info) {
       return;
     }
 
     $this->updateDiffProperty('local:commits', json_encode($local_info));
   }
 
 
   /**
    * Update an arbitrary diff property.
    *
    * @param string Diff property name.
    * @param string Diff property value.
    * @return void
    *
    * @task diffprop
    */
   private function updateDiffProperty($name, $data) {
     $this->getConduit()->callMethodSynchronous(
       'differential.setdiffproperty',
       array(
         'diff_id' => $this->getDiffID(),
         'name'    => $name,
         'data'    => $data,
       ));
   }
 
   private function dispatchWillBuildEvent(array $fields) {
     $event = new PhutilEvent(
       ArcanistEventType::TYPE_DIFF_WILLBUILDMESSAGE,
       array(
         'fields'      => $fields,
       ));
 
     PhutilEventEngine::dispatchEvent($event);
 
     return $event->getValue('fields');
   }
 
 }