diff --git a/src/applications/audit/editor/PhabricatorAuditEditor.php b/src/applications/audit/editor/PhabricatorAuditEditor.php
index 5d3bc3d881..74e460afdf 100644
--- a/src/applications/audit/editor/PhabricatorAuditEditor.php
+++ b/src/applications/audit/editor/PhabricatorAuditEditor.php
@@ -1,920 +1,920 @@
 <?php
 
 final class PhabricatorAuditEditor
   extends PhabricatorApplicationTransactionEditor {
 
   const MAX_FILES_SHOWN_IN_EMAIL = 1000;
 
   private $auditReasonMap = array();
   private $heraldEmailPHIDs = array();
   private $affectedFiles;
   private $rawPatch;
 
   public function addAuditReason($phid, $reason) {
     if (!isset($this->auditReasonMap[$phid])) {
       $this->auditReasonMap[$phid] = array();
     }
     $this->auditReasonMap[$phid][] = $reason;
     return $this;
   }
 
   private function getAuditReasons($phid) {
     if (isset($this->auditReasonMap[$phid])) {
       return $this->auditReasonMap[$phid];
     }
     if ($this->getIsHeraldEditor()) {
       $name = 'herald';
     } else {
       $name = $this->getActor()->getUsername();
     }
     return array('Added by '.$name.'.');
   }
 
   public function setRawPatch($patch) {
     $this->rawPatch = $patch;
     return $this;
   }
 
   public function getRawPatch() {
     return $this->rawPatch;
   }
 
   public function getEditorApplicationClass() {
     return 'PhabricatorAuditApplication';
   }
 
   public function getEditorObjectsDescription() {
     return pht('Audits');
   }
 
   public function getTransactionTypes() {
     $types = parent::getTransactionTypes();
 
     $types[] = PhabricatorTransactions::TYPE_COMMENT;
     $types[] = PhabricatorTransactions::TYPE_EDGE;
 
     $types[] = PhabricatorAuditTransaction::TYPE_COMMIT;
 
     // TODO: These will get modernized eventually, but that can happen one
     // at a time later on.
     $types[] = PhabricatorAuditActionConstants::ACTION;
     $types[] = PhabricatorAuditActionConstants::INLINE;
     $types[] = PhabricatorAuditActionConstants::ADD_AUDITORS;
 
     return $types;
   }
 
   protected function transactionHasEffect(
     PhabricatorLiskDAO $object,
     PhabricatorApplicationTransaction $xaction) {
 
     switch ($xaction->getTransactionType()) {
       case PhabricatorAuditActionConstants::INLINE:
         return $xaction->hasComment();
     }
 
     return parent::transactionHasEffect($object, $xaction);
   }
 
   protected function getCustomTransactionOldValue(
     PhabricatorLiskDAO $object,
     PhabricatorApplicationTransaction $xaction) {
     switch ($xaction->getTransactionType()) {
       case PhabricatorAuditActionConstants::ACTION:
       case PhabricatorAuditActionConstants::INLINE:
       case PhabricatorAuditTransaction::TYPE_COMMIT:
         return null;
       case PhabricatorAuditActionConstants::ADD_AUDITORS:
         // TODO: For now, just record the added PHIDs. Eventually, turn these
         // into real edge transactions, probably?
         return array();
     }
 
     return parent::getCustomTransactionOldValue($object, $xaction);
   }
 
   protected function getCustomTransactionNewValue(
     PhabricatorLiskDAO $object,
     PhabricatorApplicationTransaction $xaction) {
 
     switch ($xaction->getTransactionType()) {
       case PhabricatorAuditActionConstants::ACTION:
       case PhabricatorAuditActionConstants::INLINE:
       case PhabricatorAuditActionConstants::ADD_AUDITORS:
       case PhabricatorAuditTransaction::TYPE_COMMIT:
         return $xaction->getNewValue();
     }
 
     return parent::getCustomTransactionNewValue($object, $xaction);
   }
 
   protected function applyCustomInternalTransaction(
     PhabricatorLiskDAO $object,
     PhabricatorApplicationTransaction $xaction) {
 
     switch ($xaction->getTransactionType()) {
       case PhabricatorTransactions::TYPE_COMMENT:
       case PhabricatorTransactions::TYPE_SUBSCRIBERS:
       case PhabricatorTransactions::TYPE_EDGE:
       case PhabricatorAuditActionConstants::ACTION:
       case PhabricatorAuditActionConstants::INLINE:
       case PhabricatorAuditActionConstants::ADD_AUDITORS:
       case PhabricatorAuditTransaction::TYPE_COMMIT:
         return;
     }
 
     return parent::applyCustomInternalTransaction($object, $xaction);
   }
 
   protected function applyCustomExternalTransaction(
     PhabricatorLiskDAO $object,
     PhabricatorApplicationTransaction $xaction) {
 
     switch ($xaction->getTransactionType()) {
       case PhabricatorTransactions::TYPE_COMMENT:
       case PhabricatorTransactions::TYPE_SUBSCRIBERS:
       case PhabricatorTransactions::TYPE_EDGE:
       case PhabricatorAuditActionConstants::ACTION:
       case PhabricatorAuditActionConstants::INLINE:
       case PhabricatorAuditTransaction::TYPE_COMMIT:
         return;
       case PhabricatorAuditActionConstants::ADD_AUDITORS:
         $new = $xaction->getNewValue();
         if (!is_array($new)) {
           $new = array();
         }
 
         $old = $xaction->getOldValue();
         if (!is_array($old)) {
           $old = array();
         }
 
         $add = array_diff_key($new, $old);
 
         $actor = $this->requireActor();
 
         $requests = $object->getAudits();
         $requests = mpull($requests, null, 'getAuditorPHID');
         foreach ($add as $phid) {
           if (isset($requests[$phid])) {
             continue;
           }
 
           if ($this->getIsHeraldEditor()) {
             $audit_requested = $xaction->getMetadataValue('auditStatus');
             $audit_reason_map = $xaction->getMetadataValue('auditReasonMap');
             $audit_reason = $audit_reason_map[$phid];
           } else {
             $audit_requested = PhabricatorAuditStatusConstants::AUDIT_REQUESTED;
             $audit_reason = $this->getAuditReasons($phid);
           }
           $requests[] = id (new PhabricatorRepositoryAuditRequest())
             ->setCommitPHID($object->getPHID())
             ->setAuditorPHID($phid)
             ->setAuditStatus($audit_requested)
             ->setAuditReasons($audit_reason)
             ->save();
         }
 
         $object->attachAudits($requests);
         return;
     }
 
     return parent::applyCustomExternalTransaction($object, $xaction);
   }
 
   protected function applyFinalEffects(
     PhabricatorLiskDAO $object,
     array $xactions) {
 
     // Load auditors explicitly; we may not have them if the caller was a
     // generic piece of infrastructure.
 
     $commit = id(new DiffusionCommitQuery())
       ->setViewer($this->requireActor())
       ->withIDs(array($object->getID()))
       ->needAuditRequests(true)
       ->executeOne();
     if (!$commit) {
       throw new Exception(
         pht('Failed to load commit during transaction finalization!'));
     }
     $object->attachAudits($commit->getAudits());
 
     $status_concerned = PhabricatorAuditStatusConstants::CONCERNED;
     $status_closed = PhabricatorAuditStatusConstants::CLOSED;
     $status_resigned = PhabricatorAuditStatusConstants::RESIGNED;
     $status_accepted = PhabricatorAuditStatusConstants::ACCEPTED;
     $status_concerned = PhabricatorAuditStatusConstants::CONCERNED;
 
     $actor_phid = $this->getActingAsPHID();
     $actor_is_author = ($object->getAuthorPHID()) &&
       ($actor_phid == $object->getAuthorPHID());
 
     $import_status_flag = null;
     foreach ($xactions as $xaction) {
       switch ($xaction->getTransactionType()) {
         case PhabricatorAuditTransaction::TYPE_COMMIT:
           $import_status_flag = PhabricatorRepositoryCommit::IMPORTED_HERALD;
           break;
         case PhabricatorAuditActionConstants::ACTION:
           $new = $xaction->getNewValue();
           switch ($new) {
             case PhabricatorAuditActionConstants::CLOSE:
               // "Close" means wipe out all the concerns.
               $requests = $object->getAudits();
               foreach ($requests as $request) {
                 if ($request->getAuditStatus() == $status_concerned) {
                   $request
                     ->setAuditStatus($status_closed)
                     ->save();
                 }
               }
               break;
             case PhabricatorAuditActionConstants::RESIGN:
               $requests = $object->getAudits();
               $requests = mpull($requests, null, 'getAuditorPHID');
               $actor_request = idx($requests, $actor_phid);
 
               // If the actor doesn't currently have a relationship to the
               // commit, add one explicitly. For example, this allows members
               // of a project to resign from a commit and have it drop out of
               // their queue.
 
               if (!$actor_request) {
                 $actor_request = id(new PhabricatorRepositoryAuditRequest())
                   ->setCommitPHID($object->getPHID())
                   ->setAuditorPHID($actor_phid);
 
                 $requests[] = $actor_request;
                 $object->attachAudits($requests);
               }
 
               $actor_request
                 ->setAuditStatus($status_resigned)
                 ->save();
               break;
             case PhabricatorAuditActionConstants::ACCEPT:
             case PhabricatorAuditActionConstants::CONCERN:
               if ($new == PhabricatorAuditActionConstants::ACCEPT) {
                 $new_status = $status_accepted;
               } else {
                 $new_status = $status_concerned;
               }
 
               $requests = $object->getAudits();
               $requests = mpull($requests, null, 'getAuditorPHID');
 
               // Figure out which requests the actor has authority over: these
               // are user requests where they are the auditor, and packages
               // and projects they are a member of.
 
               if ($actor_is_author) {
                 // When modifying your own commits, you act only on behalf of
                 // yourself, not your packages/projects -- the idea being that
                 // you can't accept your own commits.
                 $authority_phids = array($actor_phid);
               } else {
                 $authority_phids =
                   PhabricatorAuditCommentEditor::loadAuditPHIDsForUser(
                     $this->requireActor());
               }
 
               $authority = array_select_keys(
                 $requests,
                 $authority_phids);
 
               if (!$authority) {
                 // If the actor has no authority over any existing requests,
                 // create a new request for them.
 
                 $actor_request = id(new PhabricatorRepositoryAuditRequest())
                   ->setCommitPHID($object->getPHID())
                   ->setAuditorPHID($actor_phid)
                   ->setAuditStatus($new_status)
                   ->save();
 
                 $requests[$actor_phid] = $actor_request;
                 $object->attachAudits($requests);
               } else {
                 // Otherwise, update the audit status of the existing requests.
                 foreach ($authority as $request) {
                   $request
                     ->setAuditStatus($new_status)
                     ->save();
                 }
               }
               break;
 
           }
           break;
       }
     }
 
     $requests = $object->getAudits();
     $object->updateAuditStatus($requests);
     $object->save();
 
     if ($import_status_flag) {
       $object->writeImportStatusFlag($import_status_flag);
     }
 
     return $xactions;
   }
 
   protected function expandTransaction(
     PhabricatorLiskDAO $object,
     PhabricatorApplicationTransaction $xaction) {
 
     $xactions = parent::expandTransaction($object, $xaction);
     switch ($xaction->getTransactionType()) {
       case PhabricatorAuditTransaction::TYPE_COMMIT:
         $request = $this->createAuditRequestTransactionFromCommitMessage(
           $object);
         if ($request) {
           $xactions[] = $request;
           $this->setUnmentionablePHIDMap($request->getNewValue());
         }
         break;
       default:
         break;
     }
     return $xactions;
   }
 
   private function createAuditRequestTransactionFromCommitMessage(
     PhabricatorRepositoryCommit $commit) {
 
     $data = $commit->getCommitData();
     $message = $data->getCommitMessage();
 
     $matches = null;
     if (!preg_match('/^Auditors:\s*(.*)$/im', $message, $matches)) {
       return array();
     }
 
     $phids = id(new PhabricatorObjectListQuery())
       ->setViewer($this->getActor())
       ->setAllowPartialResults(true)
       ->setAllowedTypes(
         array(
           PhabricatorPeopleUserPHIDType::TYPECONST,
           PhabricatorProjectProjectPHIDType::TYPECONST,
         ))
       ->setObjectList($matches[1])
       ->execute();
 
     if (!$phids) {
       return array();
     }
 
     foreach ($phids as $phid) {
       $this->addAuditReason($phid, 'Requested by Author');
     }
     return id(new PhabricatorAuditTransaction())
       ->setTransactionType(PhabricatorAuditActionConstants::ADD_AUDITORS)
       ->setNewValue(array_fuse($phids));
   }
 
   protected function sortTransactions(array $xactions) {
     $xactions = parent::sortTransactions($xactions);
 
     $head = array();
     $tail = array();
 
     foreach ($xactions as $xaction) {
       $type = $xaction->getTransactionType();
       if ($type == PhabricatorAuditActionConstants::INLINE) {
         $tail[] = $xaction;
       } else {
         $head[] = $xaction;
       }
     }
 
     return array_values(array_merge($head, $tail));
   }
 
   protected function validateTransaction(
     PhabricatorLiskDAO $object,
     $type,
     array $xactions) {
 
     $errors = parent::validateTransaction($object, $type, $xactions);
 
     foreach ($xactions as $xaction) {
       switch ($type) {
         case PhabricatorAuditActionConstants::ACTION:
           $error = $this->validateAuditAction(
             $object,
             $type,
             $xaction,
             $xaction->getNewValue());
           if ($error) {
             $errors[] = new PhabricatorApplicationTransactionValidationError(
               $type,
               pht('Invalid'),
               $error,
               $xaction);
           }
           break;
       }
     }
 
     return $errors;
   }
 
   private function validateAuditAction(
     PhabricatorLiskDAO $object,
     $type,
     PhabricatorAuditTransaction $xaction,
     $action) {
 
     $can_author_close_key = 'audit.can-author-close-audit';
     $can_author_close = PhabricatorEnv::getEnvConfig($can_author_close_key);
 
     $actor_is_author = ($object->getAuthorPHID()) &&
       ($object->getAuthorPHID() == $this->getActingAsPHID());
 
     switch ($action) {
       case PhabricatorAuditActionConstants::CLOSE:
         if (!$actor_is_author) {
           return pht(
             'You can not close this audit because you are not the author '.
             'of the commit.');
         }
 
         if (!$can_author_close) {
           return pht(
             'You can not close this audit because "%s" is disabled in '.
             'the Phabricator configuration.',
             $can_author_close_key);
         }
 
         break;
     }
 
     return null;
   }
 
 
   protected function supportsSearch() {
     return true;
   }
 
   protected function expandCustomRemarkupBlockTransactions(
     PhabricatorLiskDAO $object,
     array $xactions,
     $blocks,
     PhutilMarkupEngine $engine) {
 
     // we are only really trying to find unmentionable phids here...
     // don't bother with this outside initial commit (i.e. create)
     // transaction
     $is_commit = false;
     foreach ($xactions as $xaction) {
       switch ($xaction->getTransactionType()) {
         case PhabricatorAuditTransaction::TYPE_COMMIT:
           $is_commit = true;
           break;
       }
     }
 
     // "result" is always an array....
     $result = array();
     if (!$is_commit) {
       return $result;
     }
 
     $flat_blocks = array_mergev($blocks);
     $huge_block = implode("\n\n", $flat_blocks);
     $phid_map = array();
     $phid_map[] = $this->getUnmentionablePHIDMap();
     $monograms = array();
 
     $task_refs = id(new ManiphestCustomFieldStatusParser())
       ->parseCorpus($huge_block);
     foreach ($task_refs as $match) {
       foreach ($match['monograms'] as $monogram) {
         $monograms[] = $monogram;
       }
     }
 
     $rev_refs = id(new DifferentialCustomFieldDependsOnParser())
       ->parseCorpus($huge_block);
     foreach ($rev_refs as $match) {
       foreach ($match['monograms'] as $monogram) {
         $monograms[] = $monogram;
       }
     }
 
     $objects = id(new PhabricatorObjectQuery())
       ->setViewer($this->getActor())
       ->withNames($monograms)
       ->execute();
     $phid_map[] = mpull($objects, 'getPHID', 'getPHID');
     $phid_map = array_mergev($phid_map);
     $this->setUnmentionablePHIDMap($phid_map);
 
     return $result;
   }
 
 
   protected function shouldSendMail(
     PhabricatorLiskDAO $object,
     array $xactions) {
 
     // not every code path loads the repository so tread carefully
     if ($object->getRepository($assert_attached = false)) {
       $repository = $object->getRepository();
       if ($repository->isImporting()) {
         return false;
       }
     }
     return $this->isCommitMostlyImported($object);
   }
 
   protected function buildReplyHandler(PhabricatorLiskDAO $object) {
     $reply_handler = PhabricatorEnv::newObjectFromConfig(
       'metamta.diffusion.reply-handler');
     $reply_handler->setMailReceiver($object);
     return $reply_handler;
   }
 
   protected function getMailSubjectPrefix() {
     return PhabricatorEnv::getEnvConfig('metamta.diffusion.subject-prefix');
   }
 
   protected function getMailThreadID(PhabricatorLiskDAO $object) {
     // For backward compatibility, use this legacy thread ID.
     return 'diffusion-audit-'.$object->getPHID();
   }
 
   protected function buildMailTemplate(PhabricatorLiskDAO $object) {
     $identifier = $object->getCommitIdentifier();
     $repository = $object->getRepository();
     $monogram = $repository->getMonogram();
 
     $summary = $object->getSummary();
     $name = $repository->formatCommitName($identifier);
 
     $subject = "{$name}: {$summary}";
     $thread_topic = "Commit {$monogram}{$identifier}";
 
     $template = id(new PhabricatorMetaMTAMail())
       ->setSubject($subject)
       ->addHeader('Thread-Topic', $thread_topic);
 
     $this->attachPatch(
       $template,
       $object);
 
     return $template;
   }
 
   protected function getMailTo(PhabricatorLiskDAO $object) {
     $phids = array();
     if ($this->heraldEmailPHIDs) {
       $phids = $this->heraldEmailPHIDs;
     }
 
     if ($object->getAuthorPHID()) {
       $phids[] = $object->getAuthorPHID();
     }
 
     $status_resigned = PhabricatorAuditStatusConstants::RESIGNED;
     foreach ($object->getAudits() as $audit) {
       if ($audit->getAuditStatus() != $status_resigned) {
         $phids[] = $audit->getAuditorPHID();
       }
     }
 
     return $phids;
   }
 
   protected function buildMailBody(
     PhabricatorLiskDAO $object,
     array $xactions) {
 
     $body = parent::buildMailBody($object, $xactions);
 
     $type_inline = PhabricatorAuditActionConstants::INLINE;
     $type_push = PhabricatorAuditTransaction::TYPE_COMMIT;
 
     $is_commit = false;
     $inlines = array();
     foreach ($xactions as $xaction) {
       if ($xaction->getTransactionType() == $type_inline) {
         $inlines[] = $xaction;
       }
       if ($xaction->getTransactionType() == $type_push) {
         $is_commit = true;
       }
     }
 
     if ($inlines) {
       $body->addTextSection(
         pht('INLINE COMMENTS'),
         $this->renderInlineCommentsForMail($object, $inlines));
     }
 
     if ($is_commit) {
       $data = $object->getCommitData();
       $body->addTextSection(pht('AFFECTED FILES'), $this->affectedFiles);
       $this->inlinePatch(
         $body,
         $object);
     }
 
     // Reload the commit to pull commit data.
     $commit = id(new DiffusionCommitQuery())
       ->setViewer($this->requireActor())
       ->withIDs(array($object->getID()))
       ->needCommitData(true)
       ->executeOne();
     $data = $commit->getCommitData();
 
     $user_phids = array();
 
     $author_phid = $commit->getAuthorPHID();
     if ($author_phid) {
       $user_phids[$author_phid][] = pht('Author');
     }
 
     $committer_phid = $data->getCommitDetail('committerPHID');
     if ($committer_phid && ($committer_phid != $author_phid)) {
       $user_phids[$committer_phid][] = pht('Committer');
     }
 
     // we loaded this in applyFinalEffects
     $audit_requests = $object->getAudits();
     $auditor_phids = mpull($audit_requests, 'getAuditorPHID');
     foreach ($auditor_phids as $auditor_phid) {
       $user_phids[$auditor_phid][] = pht('Auditor');
     }
 
     // TODO: It would be nice to show pusher here too, but that information
     // is a little tricky to get at right now.
 
     if ($user_phids) {
       $handle_phids = array_keys($user_phids);
       $handles = id(new PhabricatorHandleQuery())
         ->setViewer($this->requireActor())
         ->withPHIDs($handle_phids)
         ->execute();
 
       $user_info = array();
       foreach ($user_phids as $phid => $roles) {
         $user_info[] = pht(
           '%s (%s)',
           $handles[$phid]->getName(),
           implode(', ', $roles));
       }
 
       $body->addTextSection(
         pht('USERS'),
         implode("\n", $user_info));
     }
 
     $monogram = $object->getRepository()->formatCommitName(
       $object->getCommitIdentifier());
 
-    $body->addTextSection(
+    $body->addLinkSection(
       pht('COMMIT'),
       PhabricatorEnv::getProductionURI('/'.$monogram));
 
     return $body;
   }
 
   private function attachPatch(
     PhabricatorMetaMTAMail $template,
     PhabricatorRepositoryCommit $commit) {
 
     if (!$this->getRawPatch()) {
       return;
     }
 
     $attach_key = 'metamta.diffusion.attach-patches';
     $attach_patches = PhabricatorEnv::getEnvConfig($attach_key);
     if (!$attach_patches) {
       return;
     }
 
     $repository = $commit->getRepository();
     $encoding = $repository->getDetail('encoding', 'UTF-8');
 
     $raw_patch = $this->getRawPatch();
     $commit_name = $repository->formatCommitName(
       $commit->getCommitIdentifier());
 
     $template->addAttachment(
       new PhabricatorMetaMTAAttachment(
         $raw_patch,
         $commit_name.'.patch',
         'text/x-patch; charset='.$encoding));
   }
 
   private function inlinePatch(
     PhabricatorMetaMTAMailBody $body,
     PhabricatorRepositoryCommit $commit) {
 
     if (!$this->getRawPatch()) {
         return;
     }
 
     $inline_key = 'metamta.diffusion.inline-patches';
     $inline_patches = PhabricatorEnv::getEnvConfig($inline_key);
     if (!$inline_patches) {
       return;
     }
 
     $repository = $commit->getRepository();
     $raw_patch = $this->getRawPatch();
     $result = null;
     $len = substr_count($raw_patch, "\n");
     if ($len <= $inline_patches) {
       // We send email as utf8, so we need to convert the text to utf8 if
       // we can.
       $encoding = $repository->getDetail('encoding', 'UTF-8');
       if ($encoding) {
         $raw_patch = phutil_utf8_convert($raw_patch, 'UTF-8', $encoding);
       }
       $result = phutil_utf8ize($raw_patch);
     }
 
     if ($result) {
       $result = "PATCH\n\n{$result}\n";
     }
     $body->addRawSection($result);
   }
 
   private function renderInlineCommentsForMail(
     PhabricatorLiskDAO $object,
     array $inline_xactions) {
 
     $inlines = mpull($inline_xactions, 'getComment');
 
     $block = array();
 
     $path_map = id(new DiffusionPathQuery())
       ->withPathIDs(mpull($inlines, 'getPathID'))
       ->execute();
     $path_map = ipull($path_map, 'path', 'id');
 
     foreach ($inlines as $inline) {
       $path = idx($path_map, $inline->getPathID());
       if ($path === null) {
         continue;
       }
 
       $start = $inline->getLineNumber();
       $len   = $inline->getLineLength();
       if ($len) {
         $range = $start.'-'.($start + $len);
       } else {
         $range = $start;
       }
 
       $content = $inline->getContent();
       $block[] = "{$path}:{$range} {$content}";
     }
 
     return implode("\n", $block);
   }
 
   public function getMailTagsMap() {
     return array(
       PhabricatorAuditTransaction::MAILTAG_COMMIT =>
         pht('A commit is created.'),
       PhabricatorAuditTransaction::MAILTAG_ACTION_CONCERN =>
         pht('A commit has a concerned raised against it.'),
       PhabricatorAuditTransaction::MAILTAG_ACTION_ACCEPT =>
         pht('A commit is accepted.'),
       PhabricatorAuditTransaction::MAILTAG_ACTION_RESIGN =>
         pht('A commit has an auditor resign.'),
       PhabricatorAuditTransaction::MAILTAG_ACTION_CLOSE =>
         pht('A commit is closed.'),
       PhabricatorAuditTransaction::MAILTAG_ADD_AUDITORS =>
         pht('A commit has auditors added.'),
       PhabricatorAuditTransaction::MAILTAG_ADD_CCS =>
         pht("A commit's subscribers change."),
       PhabricatorAuditTransaction::MAILTAG_PROJECTS =>
         pht("A commit's projects change."),
       PhabricatorAuditTransaction::MAILTAG_COMMENT =>
         pht('Someone comments on a commit.'),
       PhabricatorAuditTransaction::MAILTAG_OTHER =>
         pht('Other commit activity not listed above occurs.'),
     );
   }
 
 
 
   protected function shouldPublishFeedStory(
     PhabricatorLiskDAO $object,
     array $xactions) {
     return $this->shouldSendMail($object, $xactions);
   }
 
   protected function shouldApplyHeraldRules(
     PhabricatorLiskDAO $object,
     array $xactions) {
 
     foreach ($xactions as $xaction) {
       switch ($xaction->getTransactionType()) {
         case PhabricatorAuditTransaction::TYPE_COMMIT:
           $repository = $object->getRepository();
           if ($repository->isImporting()) {
             return false;
           }
           if ($repository->getDetail('herald-disabled')) {
             return false;
           }
           return true;
         default:
           break;
       }
     }
     return parent::shouldApplyHeraldRules($object, $xactions);
   }
 
   protected function buildHeraldAdapter(
     PhabricatorLiskDAO $object,
     array $xactions) {
 
     return id(new HeraldCommitAdapter())
       ->setCommit($object);
   }
 
   protected function didApplyHeraldRules(
     PhabricatorLiskDAO $object,
     HeraldAdapter $adapter,
     HeraldTranscript $transcript) {
 
     $xactions = array();
 
     $audit_phids = $adapter->getAuditMap();
     foreach ($audit_phids as $phid => $rule_ids) {
       foreach ($rule_ids as $rule_id) {
         $this->addAuditReason(
           $phid,
           pht(
             '%s Triggered Audit',
             "H{$rule_id}"));
       }
     }
     if ($audit_phids) {
       $xactions[] = id(new PhabricatorAuditTransaction())
         ->setTransactionType(PhabricatorAuditActionConstants::ADD_AUDITORS)
         ->setNewValue(array_fuse(array_keys($audit_phids)))
         ->setMetadataValue(
           'auditStatus',
           PhabricatorAuditStatusConstants::AUDIT_REQUIRED)
         ->setMetadataValue(
           'auditReasonMap', $this->auditReasonMap);
     }
 
     $cc_phids = $adapter->getAddCCMap();
     $add_ccs = array('+' => array());
     foreach ($cc_phids as $phid => $rule_ids) {
       $add_ccs['+'][$phid] = $phid;
     }
     $xactions[] = id(new PhabricatorAuditTransaction())
       ->setTransactionType(PhabricatorTransactions::TYPE_SUBSCRIBERS)
       ->setNewValue($add_ccs);
 
     $this->heraldEmailPHIDs = $adapter->getEmailPHIDs();
 
     HarbormasterBuildable::applyBuildPlans(
       $object->getPHID(),
       $object->getRepository()->getPHID(),
       $adapter->getBuildPlans());
 
     $limit = self::MAX_FILES_SHOWN_IN_EMAIL;
     $files = $adapter->loadAffectedPaths();
     sort($files);
     if (count($files) > $limit) {
       array_splice($files, $limit);
       $files[] = pht(
         '(This commit affected more than %d files. Only %d are shown here '.
         'and additional ones are truncated.)',
         $limit,
         $limit);
     }
     $this->affectedFiles = implode("\n", $files);
 
     return $xactions;
   }
 
   private function isCommitMostlyImported(PhabricatorLiskDAO $object) {
     $has_message = PhabricatorRepositoryCommit::IMPORTED_MESSAGE;
     $has_changes = PhabricatorRepositoryCommit::IMPORTED_CHANGE;
 
     // Don't publish feed stories or email about events which occur during
     // import. In particular, this affects tasks being attached when they are
     // closed by "Fixes Txxxx" in a commit message. See T5851.
 
     $mask = ($has_message | $has_changes);
 
     return $object->isPartiallyImported($mask);
   }
 
 }
diff --git a/src/applications/conpherence/editor/ConpherenceEditor.php b/src/applications/conpherence/editor/ConpherenceEditor.php
index 16ef622c79..d680472c9e 100644
--- a/src/applications/conpherence/editor/ConpherenceEditor.php
+++ b/src/applications/conpherence/editor/ConpherenceEditor.php
@@ -1,429 +1,429 @@
 <?php
 
 final class ConpherenceEditor extends PhabricatorApplicationTransactionEditor {
 
   const ERROR_EMPTY_PARTICIPANTS = 'error-empty-participants';
   const ERROR_EMPTY_MESSAGE = 'error-empty-message';
 
   public function getEditorApplicationClass() {
     return 'PhabricatorConpherenceApplication';
   }
 
   public function getEditorObjectsDescription() {
     return pht('Conpherence Threads');
   }
 
   public static function createConpherence(
     PhabricatorUser $creator,
     array $participant_phids,
     $title,
     $message,
     PhabricatorContentSource $source) {
 
     $conpherence = id(new ConpherenceThread())
       ->attachParticipants(array())
       ->attachFilePHIDs(array())
       ->setMessageCount(0);
     $files = array();
     $errors = array();
     if (empty($participant_phids)) {
       $errors[] = self::ERROR_EMPTY_PARTICIPANTS;
     } else {
       $participant_phids[] = $creator->getPHID();
       $participant_phids = array_unique($participant_phids);
       $conpherence->setRecentParticipantPHIDs(
         array_slice($participant_phids, 0, 10));
     }
 
     if (empty($message)) {
       $errors[] = self::ERROR_EMPTY_MESSAGE;
     }
 
     $file_phids = PhabricatorMarkupEngine::extractFilePHIDsFromEmbeddedFiles(
       $creator,
       array($message));
     if ($file_phids) {
       $files = id(new PhabricatorFileQuery())
         ->setViewer($creator)
         ->withPHIDs($file_phids)
         ->execute();
     }
 
     if (!$errors) {
       $xactions = array();
       $xactions[] = id(new ConpherenceTransaction())
         ->setTransactionType(ConpherenceTransactionType::TYPE_PARTICIPANTS)
         ->setNewValue(array('+' => $participant_phids));
       if ($files) {
         $xactions[] = id(new ConpherenceTransaction())
           ->setTransactionType(ConpherenceTransactionType::TYPE_FILES)
           ->setNewValue(array('+' => mpull($files, 'getPHID')));
       }
       if ($title) {
         $xactions[] = id(new ConpherenceTransaction())
           ->setTransactionType(ConpherenceTransactionType::TYPE_TITLE)
           ->setNewValue($title);
       }
       $xactions[] = id(new ConpherenceTransaction())
         ->setTransactionType(PhabricatorTransactions::TYPE_COMMENT)
         ->attachComment(
           id(new ConpherenceTransactionComment())
           ->setContent($message)
           ->setConpherencePHID($conpherence->getPHID()));
 
       id(new ConpherenceEditor())
         ->setContentSource($source)
         ->setContinueOnNoEffect(true)
         ->setActor($creator)
         ->applyTransactions($conpherence, $xactions);
 
     }
 
     return array($errors, $conpherence);
   }
 
   public function generateTransactionsFromText(
     PhabricatorUser $viewer,
     ConpherenceThread $conpherence,
     $text) {
 
     $files = array();
     $file_phids = PhabricatorMarkupEngine::extractFilePHIDsFromEmbeddedFiles(
       $viewer,
       array($text));
     // Since these are extracted from text, we might be re-including the
     // same file -- e.g. a mock under discussion. Filter files we
     // already have.
     $existing_file_phids = $conpherence->getFilePHIDs();
     $file_phids = array_diff($file_phids, $existing_file_phids);
     if ($file_phids) {
       $files = id(new PhabricatorFileQuery())
         ->setViewer($this->getActor())
         ->withPHIDs($file_phids)
         ->execute();
     }
     $xactions = array();
     if ($files) {
       $xactions[] = id(new ConpherenceTransaction())
         ->setTransactionType(ConpherenceTransactionType::TYPE_FILES)
         ->setNewValue(array('+' => mpull($files, 'getPHID')));
     }
     $xactions[] = id(new ConpherenceTransaction())
       ->setTransactionType(PhabricatorTransactions::TYPE_COMMENT)
       ->attachComment(
         id(new ConpherenceTransactionComment())
         ->setContent($text)
         ->setConpherencePHID($conpherence->getPHID()));
     return $xactions;
   }
 
   public function getTransactionTypes() {
     $types = parent::getTransactionTypes();
 
     $types[] = PhabricatorTransactions::TYPE_COMMENT;
 
     $types[] = ConpherenceTransactionType::TYPE_TITLE;
     $types[] = ConpherenceTransactionType::TYPE_PARTICIPANTS;
     $types[] = ConpherenceTransactionType::TYPE_FILES;
 
     return $types;
   }
 
   protected function getCustomTransactionOldValue(
     PhabricatorLiskDAO $object,
     PhabricatorApplicationTransaction $xaction) {
 
     switch ($xaction->getTransactionType()) {
       case ConpherenceTransactionType::TYPE_TITLE:
         return $object->getTitle();
       case ConpherenceTransactionType::TYPE_PARTICIPANTS:
         return $object->getParticipantPHIDs();
       case ConpherenceTransactionType::TYPE_FILES:
         return $object->getFilePHIDs();
     }
   }
 
   protected function getCustomTransactionNewValue(
     PhabricatorLiskDAO $object,
     PhabricatorApplicationTransaction $xaction) {
 
     switch ($xaction->getTransactionType()) {
       case ConpherenceTransactionType::TYPE_TITLE:
         return $xaction->getNewValue();
       case ConpherenceTransactionType::TYPE_PARTICIPANTS:
       case ConpherenceTransactionType::TYPE_FILES:
         return $this->getPHIDTransactionNewValue($xaction);
     }
   }
 
   /**
    * We really only need a read lock if we have a comment. In that case, we
    * must update the messagesCount field on the conpherence and
    * seenMessagesCount(s) for the participant(s).
    */
   protected function shouldReadLock(
     PhabricatorLiskDAO $object,
     PhabricatorApplicationTransaction $xaction) {
 
     $lock = false;
     switch ($xaction->getTransactionType()) {
       case PhabricatorTransactions::TYPE_COMMENT:
         $lock =  true;
         break;
     }
 
     return $lock;
   }
 
   /**
    * We need to apply initial effects IFF the conpherence is new. We must
    * save the conpherence first thing to make sure we have an id and a phid.
    */
   protected function shouldApplyInitialEffects(
     PhabricatorLiskDAO $object,
     array $xactions) {
 
     return !$object->getID();
   }
 
   protected function applyInitialEffects(
     PhabricatorLiskDAO $object,
     array $xactions) {
 
     $object->save();
   }
 
   protected function applyCustomInternalTransaction(
     PhabricatorLiskDAO $object,
     PhabricatorApplicationTransaction $xaction) {
     switch ($xaction->getTransactionType()) {
       case PhabricatorTransactions::TYPE_COMMENT:
         $object->setMessageCount((int)$object->getMessageCount() + 1);
         break;
       case ConpherenceTransactionType::TYPE_TITLE:
         $object->setTitle($xaction->getNewValue());
         break;
     }
     $this->updateRecentParticipantPHIDs($object, $xaction);
   }
 
   private function updateRecentParticipantPHIDs(
     PhabricatorLiskDAO $object,
     PhabricatorApplicationTransaction $xaction) {
 
     $participants = $object->getRecentParticipantPHIDs();
     array_unshift($participants, $xaction->getAuthorPHID());
     $participants = array_slice(array_unique($participants), 0, 10);
 
     $object->setRecentParticipantPHIDs($participants);
   }
 
   protected function applyCustomExternalTransaction(
     PhabricatorLiskDAO $object,
     PhabricatorApplicationTransaction $xaction) {
 
     switch ($xaction->getTransactionType()) {
       case ConpherenceTransactionType::TYPE_FILES:
         $editor = new PhabricatorEdgeEditor();
         $edge_type = PhabricatorEdgeConfig::TYPE_OBJECT_HAS_FILE;
         $old = array_fill_keys($xaction->getOldValue(), true);
         $new = array_fill_keys($xaction->getNewValue(), true);
         $add_edges = array_keys(array_diff_key($new, $old));
         $remove_edges = array_keys(array_diff_key($old, $new));
         foreach ($add_edges as $file_phid) {
           $editor->addEdge(
             $object->getPHID(),
             $edge_type,
             $file_phid);
         }
         foreach ($remove_edges as $file_phid) {
           $editor->removeEdge(
             $object->getPHID(),
             $edge_type,
             $file_phid);
         }
         $editor->save();
         break;
       case ConpherenceTransactionType::TYPE_PARTICIPANTS:
         $participants = $object->getParticipants();
 
         $old_map = array_fuse($xaction->getOldValue());
         $new_map = array_fuse($xaction->getNewValue());
 
         $remove = array_keys(array_diff_key($old_map, $new_map));
         foreach ($remove as $phid) {
           $remove_participant = $participants[$phid];
           $remove_participant->delete();
           unset($participants[$phid]);
         }
 
         $add = array_keys(array_diff_key($new_map, $old_map));
         foreach ($add as $phid) {
           if ($phid == $this->getActor()->getPHID()) {
             $status = ConpherenceParticipationStatus::UP_TO_DATE;
             $message_count = $object->getMessageCount();
           } else {
             $status = ConpherenceParticipationStatus::BEHIND;
             $message_count = 0;
           }
           $participants[$phid] =
             id(new ConpherenceParticipant())
             ->setConpherencePHID($object->getPHID())
             ->setParticipantPHID($phid)
             ->setParticipationStatus($status)
             ->setDateTouched(time())
             ->setBehindTransactionPHID($xaction->getPHID())
             ->setSeenMessageCount($message_count)
             ->save();
         }
         $object->attachParticipants($participants);
         break;
     }
   }
 
   protected function applyFinalEffects(
     PhabricatorLiskDAO $object,
     array $xactions) {
 
     // update everyone's participation status on the last xaction -only-
     $xaction = end($xactions);
     $xaction_phid = $xaction->getPHID();
     $behind = ConpherenceParticipationStatus::BEHIND;
     $up_to_date = ConpherenceParticipationStatus::UP_TO_DATE;
     $participants = $object->getParticipants();
     $user = $this->getActor();
     $time = time();
     foreach ($participants as $phid => $participant) {
       if ($phid != $user->getPHID()) {
         if ($participant->getParticipationStatus() != $behind) {
           $participant->setBehindTransactionPHID($xaction_phid);
           // decrement one as this is the message putting them behind!
           $participant->setSeenMessageCount($object->getMessageCount() - 1);
         }
         $participant->setParticipationStatus($behind);
         $participant->setDateTouched($time);
       } else {
         $participant->setSeenMessageCount($object->getMessageCount());
         $participant->setParticipationStatus($up_to_date);
         $participant->setDateTouched($time);
       }
       $participant->save();
     }
 
     if ($xactions) {
       $data = array(
         'type'        => 'message',
         'threadPHID'  => $object->getPHID(),
         'messageID'   => last($xactions)->getID(),
         'subscribers' => array($object->getPHID()),
       );
 
       PhabricatorNotificationClient::tryToPostMessage($data);
     }
 
     return $xactions;
   }
 
   protected function mergeTransactions(
     PhabricatorApplicationTransaction $u,
     PhabricatorApplicationTransaction $v) {
 
     $type = $u->getTransactionType();
     switch ($type) {
       case ConpherenceTransactionType::TYPE_TITLE:
         return $v;
       case ConpherenceTransactionType::TYPE_FILES:
       case ConpherenceTransactionType::TYPE_PARTICIPANTS:
         return $this->mergePHIDOrEdgeTransactions($u, $v);
     }
 
     return parent::mergeTransactions($u, $v);
   }
 
   protected function shouldSendMail(
     PhabricatorLiskDAO $object,
     array $xactions) {
     return true;
   }
 
   protected function buildReplyHandler(PhabricatorLiskDAO $object) {
     return id(new ConpherenceReplyHandler())
       ->setActor($this->getActor())
       ->setMailReceiver($object);
   }
 
   protected function buildMailTemplate(PhabricatorLiskDAO $object) {
     $id = $object->getID();
     $title = $object->getTitle();
     if (!$title) {
       $title = pht(
         '%s sent you a message.',
         $this->getActor()->getUserName());
     }
     $phid = $object->getPHID();
 
     return id(new PhabricatorMetaMTAMail())
       ->setSubject("E{$id}: {$title}")
       ->addHeader('Thread-Topic', "E{$id}: {$phid}");
   }
 
   protected function getMailTo(PhabricatorLiskDAO $object) {
     $to_phids = array();
     $participants = $object->getParticipants();
     if (empty($participants)) {
       return $to_phids;
     }
     $preferences = id(new PhabricatorUserPreferences())
       ->loadAllWhere('userPHID in (%Ls)', array_keys($participants));
     $preferences = mpull($preferences, null, 'getUserPHID');
     foreach ($participants as $phid => $participant) {
       $default = ConpherenceSettings::EMAIL_ALWAYS;
       $preference = idx($preferences, $phid);
       if ($preference) {
         $default = $preference->getPreference(
           PhabricatorUserPreferences::PREFERENCE_CONPH_NOTIFICATIONS,
           ConpherenceSettings::EMAIL_ALWAYS);
       }
       $settings = $participant->getSettings();
       $notifications = idx(
         $settings,
         'notifications',
         $default);
       if ($notifications == ConpherenceSettings::EMAIL_ALWAYS) {
         $to_phids[] = $phid;
       }
     }
     return $to_phids;
   }
 
   protected function getMailCC(PhabricatorLiskDAO $object) {
     return array();
   }
 
   protected function buildMailBody(
     PhabricatorLiskDAO $object,
     array $xactions) {
 
     $body = parent::buildMailBody($object, $xactions);
-    $body->addTextSection(
+    $body->addLinkSection(
       pht('CONPHERENCE DETAIL'),
       PhabricatorEnv::getProductionURI('/conpherence/'.$object->getID().'/'));
 
     return $body;
   }
 
   protected function getMailSubjectPrefix() {
     return PhabricatorEnv::getEnvConfig('metamta.conpherence.subject-prefix');
   }
 
   protected function shouldPublishFeedStory(
     PhabricatorLiskDAO $object,
     array $xactions) {
     return false;
   }
 
   protected function supportsSearch() {
     return false;
   }
 
 }
diff --git a/src/applications/differential/customfield/DifferentialChangesSinceLastUpdateField.php b/src/applications/differential/customfield/DifferentialChangesSinceLastUpdateField.php
index e2eef1788a..a7e3654d0d 100644
--- a/src/applications/differential/customfield/DifferentialChangesSinceLastUpdateField.php
+++ b/src/applications/differential/customfield/DifferentialChangesSinceLastUpdateField.php
@@ -1,60 +1,60 @@
 <?php
 
 final class DifferentialChangesSinceLastUpdateField
   extends DifferentialCustomField {
 
   public function getFieldKey() {
     return 'differential:changes-since-last-update';
   }
 
   public function getFieldName() {
     return pht('Changes Since Last Update');
   }
 
   public function getFieldDescription() {
     return pht('Links to changes since the last update in email.');
   }
 
   public function shouldAppearInTransactionMail() {
     return true;
   }
 
   public function updateTransactionMailBody(
     PhabricatorMetaMTAMailBody $body,
     PhabricatorApplicationTransactionEditor $editor,
     array $xactions) {
 
     if ($editor->getIsNewObject()) {
       return;
     }
 
     if ($editor->getIsCloseByCommit()) {
       return;
     }
 
     $xaction = $editor->getDiffUpdateTransaction($xactions);
     if (!$xaction) {
       return;
     }
 
     $original = id(new DifferentialDiffQuery())
       ->setViewer($this->getViewer())
       ->withPHIDs(array($xaction->getOldValue()))
       ->executeOne();
     if (!$original) {
       return;
     }
 
     $revision = $this->getObject();
     $current = $revision->getActiveDiff();
 
     $old_id = $original->getID();
     $new_id = $current->getID();
 
     $uri = '/'.$revision->getMonogram().'?vs='.$old_id.'&id='.$new_id;
     $uri = PhabricatorEnv::getProductionURI($uri);
 
-    $body->addTextSection(pht('CHANGES SINCE LAST UPDATE'), $uri);
+    $body->addLinkSection(pht('CHANGES SINCE LAST UPDATE'), $uri);
   }
 
 }
diff --git a/src/applications/differential/editor/DifferentialTransactionEditor.php b/src/applications/differential/editor/DifferentialTransactionEditor.php
index 85f68768df..dc0058b0f3 100644
--- a/src/applications/differential/editor/DifferentialTransactionEditor.php
+++ b/src/applications/differential/editor/DifferentialTransactionEditor.php
@@ -1,1851 +1,1851 @@
 <?php
 
 final class DifferentialTransactionEditor
   extends PhabricatorApplicationTransactionEditor {
 
   private $heraldEmailPHIDs;
   private $changedPriorToCommitURI;
   private $isCloseByCommit;
 
   public function getEditorApplicationClass() {
     return 'PhabricatorDifferentialApplication';
   }
 
   public function getEditorObjectsDescription() {
     return pht('Differential Revisions');
   }
 
   public function getDiffUpdateTransaction(array $xactions) {
     $type_update = DifferentialTransaction::TYPE_UPDATE;
 
     foreach ($xactions as $xaction) {
       if ($xaction->getTransactionType() == $type_update) {
         return $xaction;
       }
     }
 
     return null;
   }
 
   public function setIsCloseByCommit($is_close_by_commit) {
     $this->isCloseByCommit = $is_close_by_commit;
     return $this;
   }
 
   public function getIsCloseByCommit() {
     return $this->isCloseByCommit;
   }
 
   public function setChangedPriorToCommitURI($uri) {
     $this->changedPriorToCommitURI = $uri;
     return $this;
   }
 
   public function getChangedPriorToCommitURI() {
     return $this->changedPriorToCommitURI;
   }
 
   public function getTransactionTypes() {
     $types = parent::getTransactionTypes();
 
     $types[] = PhabricatorTransactions::TYPE_COMMENT;
     $types[] = PhabricatorTransactions::TYPE_EDGE;
     $types[] = PhabricatorTransactions::TYPE_VIEW_POLICY;
     $types[] = PhabricatorTransactions::TYPE_EDIT_POLICY;
 
     $types[] = DifferentialTransaction::TYPE_ACTION;
     $types[] = DifferentialTransaction::TYPE_INLINE;
     $types[] = DifferentialTransaction::TYPE_STATUS;
     $types[] = DifferentialTransaction::TYPE_UPDATE;
 
     return $types;
   }
 
   protected function getCustomTransactionOldValue(
     PhabricatorLiskDAO $object,
     PhabricatorApplicationTransaction $xaction) {
 
     switch ($xaction->getTransactionType()) {
       case PhabricatorTransactions::TYPE_VIEW_POLICY:
         return $object->getViewPolicy();
       case PhabricatorTransactions::TYPE_EDIT_POLICY:
         return $object->getEditPolicy();
       case DifferentialTransaction::TYPE_ACTION:
         return null;
       case DifferentialTransaction::TYPE_INLINE:
         return null;
       case DifferentialTransaction::TYPE_UPDATE:
         if ($this->getIsNewObject()) {
           return null;
         } else {
           return $object->getActiveDiff()->getPHID();
         }
     }
 
     return parent::getCustomTransactionOldValue($object, $xaction);
   }
 
   protected function getCustomTransactionNewValue(
     PhabricatorLiskDAO $object,
     PhabricatorApplicationTransaction $xaction) {
 
     switch ($xaction->getTransactionType()) {
       case PhabricatorTransactions::TYPE_VIEW_POLICY:
       case PhabricatorTransactions::TYPE_EDIT_POLICY:
       case DifferentialTransaction::TYPE_ACTION:
       case DifferentialTransaction::TYPE_UPDATE:
         return $xaction->getNewValue();
       case DifferentialTransaction::TYPE_INLINE:
         return null;
     }
 
     return parent::getCustomTransactionNewValue($object, $xaction);
   }
 
   protected function transactionHasEffect(
     PhabricatorLiskDAO $object,
     PhabricatorApplicationTransaction $xaction) {
 
     $actor_phid = $this->getActingAsPHID();
 
     switch ($xaction->getTransactionType()) {
       case DifferentialTransaction::TYPE_INLINE:
         return $xaction->hasComment();
       case DifferentialTransaction::TYPE_ACTION:
         $status_closed = ArcanistDifferentialRevisionStatus::CLOSED;
         $status_abandoned = ArcanistDifferentialRevisionStatus::ABANDONED;
         $status_review = ArcanistDifferentialRevisionStatus::NEEDS_REVIEW;
         $status_revision = ArcanistDifferentialRevisionStatus::NEEDS_REVISION;
         $status_plan = ArcanistDifferentialRevisionStatus::CHANGES_PLANNED;
 
         $action_type = $xaction->getNewValue();
         switch ($action_type) {
           case DifferentialAction::ACTION_ACCEPT:
           case DifferentialAction::ACTION_REJECT:
             if ($action_type == DifferentialAction::ACTION_ACCEPT) {
               $new_status = DifferentialReviewerStatus::STATUS_ACCEPTED;
             } else {
               $new_status = DifferentialReviewerStatus::STATUS_REJECTED;
             }
 
             $actor = $this->getActor();
 
             // These transactions can cause effects in two ways: by altering the
             // status of an existing reviewer; or by adding the actor as a new
             // reviewer.
 
             $will_add_reviewer = true;
             foreach ($object->getReviewerStatus() as $reviewer) {
               if ($reviewer->hasAuthority($actor)) {
                 if ($reviewer->getStatus() != $new_status) {
                   return true;
                 }
               }
               if ($reviewer->getReviewerPHID() == $actor_phid) {
                 $will_add_reviwer = false;
               }
             }
 
             return $will_add_reviewer;
           case DifferentialAction::ACTION_CLOSE:
             return ($object->getStatus() != $status_closed);
           case DifferentialAction::ACTION_ABANDON:
             return ($object->getStatus() != $status_abandoned);
           case DifferentialAction::ACTION_RECLAIM:
             return ($object->getStatus() == $status_abandoned);
           case DifferentialAction::ACTION_REOPEN:
             return ($object->getStatus() == $status_closed);
           case DifferentialAction::ACTION_RETHINK:
             return ($object->getStatus() != $status_plan);
           case DifferentialAction::ACTION_REQUEST:
             return ($object->getStatus() != $status_review);
           case DifferentialAction::ACTION_RESIGN:
             foreach ($object->getReviewerStatus() as $reviewer) {
               if ($reviewer->getReviewerPHID() == $actor_phid) {
                 return true;
               }
             }
             return false;
           case DifferentialAction::ACTION_CLAIM:
             return ($actor_phid != $object->getAuthorPHID());
         }
     }
 
     return parent::transactionHasEffect($object, $xaction);
   }
 
   protected function applyCustomInternalTransaction(
     PhabricatorLiskDAO $object,
     PhabricatorApplicationTransaction $xaction) {
 
     $status_review = ArcanistDifferentialRevisionStatus::NEEDS_REVIEW;
     $status_revision = ArcanistDifferentialRevisionStatus::NEEDS_REVISION;
     $status_plan = ArcanistDifferentialRevisionStatus::CHANGES_PLANNED;
 
     switch ($xaction->getTransactionType()) {
       case PhabricatorTransactions::TYPE_VIEW_POLICY:
         $object->setViewPolicy($xaction->getNewValue());
         return;
       case PhabricatorTransactions::TYPE_EDIT_POLICY:
         $object->setEditPolicy($xaction->getNewValue());
         return;
       case PhabricatorTransactions::TYPE_SUBSCRIBERS:
       case PhabricatorTransactions::TYPE_COMMENT:
       case DifferentialTransaction::TYPE_INLINE:
         return;
       case PhabricatorTransactions::TYPE_EDGE:
         return;
       case DifferentialTransaction::TYPE_UPDATE:
         if (!$this->getIsCloseByCommit() &&
             (($object->getStatus() == $status_revision) ||
              ($object->getStatus() == $status_plan))) {
           $object->setStatus($status_review);
         }
 
         $diff = $this->requireDiff($xaction->getNewValue());
 
         $object->setLineCount($diff->getLineCount());
         $object->setRepositoryPHID($diff->getRepositoryPHID());
         $object->setArcanistProjectPHID($diff->getArcanistProjectPHID());
         $object->attachActiveDiff($diff);
 
         // TODO: Update the `diffPHID` once we add that.
         return;
       case DifferentialTransaction::TYPE_ACTION:
         switch ($xaction->getNewValue()) {
           case DifferentialAction::ACTION_RESIGN:
           case DifferentialAction::ACTION_ACCEPT:
           case DifferentialAction::ACTION_REJECT:
             // These have no direct effects, and affect review status only
             // indirectly by altering reviewers with TYPE_EDGE transactions.
             return;
           case DifferentialAction::ACTION_ABANDON:
             $object->setStatus(ArcanistDifferentialRevisionStatus::ABANDONED);
             return;
           case DifferentialAction::ACTION_RETHINK:
             $object->setStatus($status_plan);
             return;
           case DifferentialAction::ACTION_RECLAIM:
             $object->setStatus($status_review);
             return;
           case DifferentialAction::ACTION_REOPEN:
             $object->setStatus($status_review);
             return;
           case DifferentialAction::ACTION_REQUEST:
             $object->setStatus($status_review);
             return;
           case DifferentialAction::ACTION_CLOSE:
             $object->setStatus(ArcanistDifferentialRevisionStatus::CLOSED);
             return;
           case DifferentialAction::ACTION_CLAIM:
             $object->setAuthorPHID($this->getActingAsPHID());
             return;
         }
         break;
     }
 
     return parent::applyCustomInternalTransaction($object, $xaction);
   }
 
   protected function expandTransaction(
     PhabricatorLiskDAO $object,
     PhabricatorApplicationTransaction $xaction) {
 
     $results = parent::expandTransaction($object, $xaction);
 
     $actor = $this->getActor();
     $actor_phid = $this->getActingAsPHID();
     $type_edge = PhabricatorTransactions::TYPE_EDGE;
 
     $status_plan = ArcanistDifferentialRevisionStatus::CHANGES_PLANNED;
 
     $edge_reviewer = PhabricatorEdgeConfig::TYPE_DREV_HAS_REVIEWER;
     $edge_ref_task = DifferentialRevisionHasTaskEdgeType::EDGECONST;
 
     $is_sticky_accept = PhabricatorEnv::getEnvConfig(
       'differential.sticky-accept');
 
     $downgrade_rejects = false;
     $downgrade_accepts = false;
     if ($this->getIsCloseByCommit()) {
       // Never downgrade reviewers when we're closing a revision after a
       // commit.
     } else {
       switch ($xaction->getTransactionType()) {
         case DifferentialTransaction::TYPE_UPDATE:
           $downgrade_rejects = true;
           if (!$is_sticky_accept) {
             // If "sticky accept" is disabled, also downgrade the accepts.
             $downgrade_accepts = true;
           }
           break;
         case DifferentialTransaction::TYPE_ACTION:
           switch ($xaction->getNewValue()) {
             case DifferentialAction::ACTION_REQUEST:
               $downgrade_rejects = true;
               if ((!$is_sticky_accept) ||
                   ($object->getStatus() != $status_plan)) {
                 // If the old state isn't "changes planned", downgrade the
                 // accepts. This exception allows an accepted revision to
                 // go through Plan Changes -> Request Review to return to
                 // "accepted" if the author didn't update the revision.
                 $downgrade_accepts = true;
               }
               break;
           }
           break;
       }
     }
 
     $new_accept = DifferentialReviewerStatus::STATUS_ACCEPTED;
     $new_reject = DifferentialReviewerStatus::STATUS_REJECTED;
     $old_accept = DifferentialReviewerStatus::STATUS_ACCEPTED_OLDER;
     $old_reject = DifferentialReviewerStatus::STATUS_REJECTED_OLDER;
 
     if ($downgrade_rejects || $downgrade_accepts) {
       // When a revision is updated, change all "reject" to "rejected older
       // revision". This means we won't immediately push the update back into
       // "needs review", but outstanding rejects will still block it from
       // moving to "accepted".
 
       // We also do this for "Request Review", even though the diff is not
       // updated directly. Essentially, this acts like an update which doesn't
       // actually change the diff text.
 
       $edits = array();
       foreach ($object->getReviewerStatus() as $reviewer) {
         if ($downgrade_rejects) {
           if ($reviewer->getStatus() == $new_reject) {
             $edits[$reviewer->getReviewerPHID()] = array(
               'data' => array(
                 'status' => $old_reject,
               ),
             );
           }
         }
 
         if ($downgrade_accepts) {
           if ($reviewer->getStatus() == $new_accept) {
             $edits[$reviewer->getReviewerPHID()] = array(
               'data' => array(
                 'status' => $old_accept,
               ),
             );
           }
         }
       }
 
       if ($edits) {
         $results[] = id(new DifferentialTransaction())
           ->setTransactionType($type_edge)
           ->setMetadataValue('edge:type', $edge_reviewer)
           ->setIgnoreOnNoEffect(true)
           ->setNewValue(array('+' => $edits));
       }
     }
 
     switch ($xaction->getTransactionType()) {
       case DifferentialTransaction::TYPE_UPDATE:
         if ($this->getIsCloseByCommit()) {
           // Don't bother with any of this if this update is a side effect of
           // commit detection.
           break;
         }
 
         // When a revision is updated and the diff comes from a branch named
         // "T123" or similar, automatically associate the commit with the
         // task that the branch names.
 
         $maniphest = 'PhabricatorManiphestApplication';
         if (PhabricatorApplication::isClassInstalled($maniphest)) {
           $diff = $this->requireDiff($xaction->getNewValue());
           $branch = $diff->getBranch();
 
           // No "$", to allow for branches like T123_demo.
           $match = null;
           if (preg_match('/^T(\d+)/i', $branch, $match)) {
             $task_id = $match[1];
             $tasks = id(new ManiphestTaskQuery())
               ->setViewer($this->getActor())
               ->withIDs(array($task_id))
               ->execute();
             if ($tasks) {
               $task = head($tasks);
               $task_phid = $task->getPHID();
 
               $results[] = id(new DifferentialTransaction())
                 ->setTransactionType($type_edge)
                 ->setMetadataValue('edge:type', $edge_ref_task)
                 ->setIgnoreOnNoEffect(true)
                 ->setNewValue(array('+' => array($task_phid => $task_phid)));
             }
           }
         }
         break;
 
       case PhabricatorTransactions::TYPE_COMMENT:
         // When a user leaves a comment, upgrade their reviewer status from
         // "added" to "commented" if they're also a reviewer. We may further
         // upgrade this based on other actions in the transaction group.
 
         $status_added = DifferentialReviewerStatus::STATUS_ADDED;
         $status_commented = DifferentialReviewerStatus::STATUS_COMMENTED;
 
         $data = array(
           'status' => $status_commented,
         );
 
         $edits = array();
         foreach ($object->getReviewerStatus() as $reviewer) {
           if ($reviewer->getReviewerPHID() == $actor_phid) {
             if ($reviewer->getStatus() == $status_added) {
               $edits[$actor_phid] = array(
                 'data' => $data,
               );
             }
           }
         }
 
         if ($edits) {
           $results[] = id(new DifferentialTransaction())
             ->setTransactionType($type_edge)
             ->setMetadataValue('edge:type', $edge_reviewer)
             ->setIgnoreOnNoEffect(true)
             ->setNewValue(array('+' => $edits));
         }
         break;
 
       case DifferentialTransaction::TYPE_ACTION:
         $action_type = $xaction->getNewValue();
 
         switch ($action_type) {
           case DifferentialAction::ACTION_ACCEPT:
           case DifferentialAction::ACTION_REJECT:
             if ($action_type == DifferentialAction::ACTION_ACCEPT) {
               $data = array(
                 'status' => DifferentialReviewerStatus::STATUS_ACCEPTED,
               );
             } else {
               $data = array(
                 'status' => DifferentialReviewerStatus::STATUS_REJECTED,
               );
             }
 
             $edits = array();
 
             foreach ($object->getReviewerStatus() as $reviewer) {
               if ($reviewer->hasAuthority($actor)) {
                 $edits[$reviewer->getReviewerPHID()] = array(
                   'data' => $data,
                 );
               }
             }
 
             // Also either update or add the actor themselves as a reviewer.
             $edits[$actor_phid] = array(
               'data' => $data,
             );
 
             $results[] = id(new DifferentialTransaction())
               ->setTransactionType($type_edge)
               ->setMetadataValue('edge:type', $edge_reviewer)
               ->setIgnoreOnNoEffect(true)
               ->setNewValue(array('+' => $edits));
             break;
 
           case DifferentialAction::ACTION_CLAIM:
             // If the user is commandeering, add the previous owner as a
             // reviewer and remove the actor.
 
             $edits = array(
               '-' => array(
                 $actor_phid => $actor_phid,
               ),
             );
 
             $owner_phid = $object->getAuthorPHID();
             if ($owner_phid) {
               $reviewer = new DifferentialReviewer(
                 $owner_phid,
                 array(
                   'status' => DifferentialReviewerStatus::STATUS_ADDED,
                 ));
 
               $edits['+'] = array(
                 $owner_phid => array(
                   'data' => $reviewer->getEdgeData(),
                 ),
               );
             }
 
             // NOTE: We're setting setIsCommandeerSideEffect() on this because
             // normally you can't add a revision's author as a reviewer, but
             // this action swaps them after validation executes.
 
             $results[] = id(new DifferentialTransaction())
               ->setTransactionType($type_edge)
               ->setMetadataValue('edge:type', $edge_reviewer)
               ->setIgnoreOnNoEffect(true)
               ->setIsCommandeerSideEffect(true)
               ->setNewValue($edits);
 
             break;
           case DifferentialAction::ACTION_RESIGN:
             // If the user is resigning, add a separate reviewer edit
             // transaction which removes them as a reviewer.
 
             $results[] = id(new DifferentialTransaction())
               ->setTransactionType($type_edge)
               ->setMetadataValue('edge:type', $edge_reviewer)
               ->setIgnoreOnNoEffect(true)
               ->setNewValue(
                 array(
                   '-' => array(
                     $actor_phid => $actor_phid,
                   ),
                 ));
 
             break;
         }
       break;
     }
 
     return $results;
   }
 
   protected function applyCustomExternalTransaction(
     PhabricatorLiskDAO $object,
     PhabricatorApplicationTransaction $xaction) {
 
     switch ($xaction->getTransactionType()) {
       case PhabricatorTransactions::TYPE_VIEW_POLICY:
       case PhabricatorTransactions::TYPE_EDIT_POLICY:
         return;
       case PhabricatorTransactions::TYPE_SUBSCRIBERS:
       case PhabricatorTransactions::TYPE_EDGE:
       case PhabricatorTransactions::TYPE_COMMENT:
       case DifferentialTransaction::TYPE_ACTION:
       case DifferentialTransaction::TYPE_INLINE:
         return;
       case DifferentialTransaction::TYPE_UPDATE:
         // Now that we're inside the transaction, do a final check.
         $diff = $this->requireDiff($xaction->getNewValue());
 
         // TODO: It would be slightly cleaner to just revalidate this
         // transaction somehow using the same validation code, but that's
         // not easy to do at the moment.
 
         $revision_id = $diff->getRevisionID();
         if ($revision_id && ($revision_id != $object->getID())) {
           throw new Exception(
             pht(
               'Diff is already attached to another revision. You lost '.
               'a race?'));
         }
 
         $diff->setRevisionID($object->getID());
         $diff->save();
         return;
     }
 
     return parent::applyCustomExternalTransaction($object, $xaction);
   }
 
   protected function mergeEdgeData($type, array $u, array $v) {
     $result = parent::mergeEdgeData($type, $u, $v);
 
     switch ($type) {
       case PhabricatorEdgeConfig::TYPE_DREV_HAS_REVIEWER:
         // When the same reviewer has their status updated by multiple
         // transactions, we want the strongest status to win. An example of
         // this is when a user adds a comment and also accepts a revision which
         // they are a reviewer on. The comment creates a "commented" status,
         // while the accept creates an "accepted" status. Since accept is
         // stronger, it should win and persist.
 
         $u_status = idx($u, 'status');
         $v_status = idx($v, 'status');
         $u_str = DifferentialReviewerStatus::getStatusStrength($u_status);
         $v_str = DifferentialReviewerStatus::getStatusStrength($v_status);
         if ($u_str > $v_str) {
           $result['status'] = $u_status;
         } else {
           $result['status'] = $v_status;
         }
         break;
     }
 
     return $result;
   }
 
   protected function applyFinalEffects(
     PhabricatorLiskDAO $object,
     array $xactions) {
 
     // Load the most up-to-date version of the revision and its reviewers,
     // so we don't need to try to deduce the state of reviewers by examining
     // all the changes made by the transactions. Then, update the reviewers
     // on the object to make sure we're acting on the current reviewer set
     // (and, for example, sending mail to the right people).
 
     $new_revision = id(new DifferentialRevisionQuery())
       ->setViewer($this->getActor())
       ->needReviewerStatus(true)
       ->needActiveDiffs(true)
       ->withIDs(array($object->getID()))
       ->executeOne();
     if (!$new_revision) {
       throw new Exception(
         pht('Failed to load revision from transaction finalization.'));
     }
 
     $object->attachReviewerStatus($new_revision->getReviewerStatus());
     $object->attachActiveDiff($new_revision->getActiveDiff());
     $object->attachRepository($new_revision->getRepository());
 
     foreach ($xactions as $xaction) {
       switch ($xaction->getTransactionType()) {
         case DifferentialTransaction::TYPE_UPDATE:
           $diff = $this->requireDiff($xaction->getNewValue(), true);
 
           // Update these denormalized index tables when we attach a new
           // diff to a revision.
 
           $this->updateRevisionHashTable($object, $diff);
           $this->updateAffectedPathTable($object, $diff);
           break;
       }
     }
 
     $status_accepted = ArcanistDifferentialRevisionStatus::ACCEPTED;
     $status_revision = ArcanistDifferentialRevisionStatus::NEEDS_REVISION;
     $status_review = ArcanistDifferentialRevisionStatus::NEEDS_REVIEW;
 
     $old_status = $object->getStatus();
     switch ($old_status) {
       case $status_accepted:
       case $status_revision:
       case $status_review:
         // Try to move a revision to "accepted". We look for:
         //
         //   - at least one accepting reviewer who is a user; and
         //   - no rejects; and
         //   - no rejects of older diffs; and
         //   - no blocking reviewers.
 
         $has_accepting_user = false;
         $has_rejecting_reviewer = false;
         $has_rejecting_older_reviewer = false;
         $has_blocking_reviewer = false;
         foreach ($object->getReviewerStatus() as $reviewer) {
           $reviewer_status = $reviewer->getStatus();
           switch ($reviewer_status) {
             case DifferentialReviewerStatus::STATUS_REJECTED:
               $has_rejecting_reviewer = true;
               break;
             case DifferentialReviewerStatus::STATUS_REJECTED_OLDER:
               $has_rejecting_older_reviewer = true;
               break;
             case DifferentialReviewerStatus::STATUS_BLOCKING:
               $has_blocking_reviewer = true;
               break;
             case DifferentialReviewerStatus::STATUS_ACCEPTED:
               if ($reviewer->isUser()) {
                 $has_accepting_user = true;
               }
               break;
           }
         }
 
         $new_status = null;
         if ($has_accepting_user &&
             !$has_rejecting_reviewer &&
             !$has_rejecting_older_reviewer &&
             !$has_blocking_reviewer) {
           $new_status = $status_accepted;
         } else if ($has_rejecting_reviewer) {
           // This isn't accepted, and there's at least one rejecting reviewer,
           // so the revision needs changes. This usually happens after a
           // "reject".
           $new_status = $status_revision;
         } else if ($old_status == $status_accepted) {
           // This revision was accepted, but it no longer satisfies the
           // conditions for acceptance. This usually happens after an accepting
           // reviewer resigns or is removed.
           $new_status = $status_review;
         }
 
         if ($new_status !== null && ($new_status != $old_status)) {
           $xaction = id(new DifferentialTransaction())
             ->setTransactionType(DifferentialTransaction::TYPE_STATUS)
             ->setOldValue($old_status)
             ->setNewValue($new_status);
 
           $xaction = $this->populateTransaction($object, $xaction)->save();
 
           $xactions[] = $xaction;
 
           $object->setStatus($new_status)->save();
         }
         break;
       default:
         // Revisions can't transition out of other statuses (like closed or
         // abandoned) as a side effect of reviewer status changes.
         break;
     }
 
     return $xactions;
   }
 
   protected function validateTransaction(
     PhabricatorLiskDAO $object,
     $type,
     array $xactions) {
 
     $errors = parent::validateTransaction($object, $type, $xactions);
 
     $config_self_accept_key = 'differential.allow-self-accept';
     $allow_self_accept = PhabricatorEnv::getEnvConfig($config_self_accept_key);
 
     foreach ($xactions as $xaction) {
       switch ($type) {
         case PhabricatorTransactions::TYPE_EDGE:
           switch ($xaction->getMetadataValue('edge:type')) {
             case PhabricatorEdgeConfig::TYPE_DREV_HAS_REVIEWER:
 
               // Prevent the author from becoming a reviewer.
 
               // NOTE: This is pretty gross, but this restriction is unusual.
               // If we end up with too much more of this, we should try to clean
               // this up -- maybe by moving validation to after transactions
               // are adjusted (so we can just examine the final value) or adding
               // a second phase there?
 
               $author_phid = $object->getAuthorPHID();
               $new = $xaction->getNewValue();
 
               $add = idx($new, '+', array());
               $eq = idx($new, '=', array());
               $phids = array_keys($add + $eq);
 
               foreach ($phids as $phid) {
                 if (($phid == $author_phid) &&
                     !$allow_self_accept &&
                     !$xaction->getIsCommandeerSideEffect()) {
                   $errors[] =
                     new PhabricatorApplicationTransactionValidationError(
                       $type,
                       pht('Invalid'),
                       pht('The author of a revision can not be a reviewer.'),
                       $xaction);
                 }
               }
               break;
           }
           break;
         case DifferentialTransaction::TYPE_UPDATE:
           $diff = $this->loadDiff($xaction->getNewValue());
           if (!$diff) {
             $errors[] = new PhabricatorApplicationTransactionValidationError(
               $type,
               pht('Invalid'),
               pht('The specified diff does not exist.'),
               $xaction);
           } else if (($diff->getRevisionID()) &&
             ($diff->getRevisionID() != $object->getID())) {
             $errors[] = new PhabricatorApplicationTransactionValidationError(
               $type,
               pht('Invalid'),
               pht(
                 'You can not update this revision to the specified diff, '.
                 'because the diff is already attached to another revision.'),
               $xaction);
           }
           break;
         case DifferentialTransaction::TYPE_ACTION:
           $error = $this->validateDifferentialAction(
             $object,
             $type,
             $xaction,
             $xaction->getNewValue());
           if ($error) {
             $errors[] = new PhabricatorApplicationTransactionValidationError(
               $type,
               pht('Invalid'),
               $error,
               $xaction);
           }
           break;
       }
     }
 
     return $errors;
   }
 
   private function validateDifferentialAction(
     DifferentialRevision $revision,
     $type,
     DifferentialTransaction $xaction,
     $action) {
 
     $author_phid = $revision->getAuthorPHID();
     $actor_phid = $this->getActingAsPHID();
     $actor_is_author = ($author_phid == $actor_phid);
 
     $config_abandon_key = 'differential.always-allow-abandon';
     $always_allow_abandon = PhabricatorEnv::getEnvConfig($config_abandon_key);
 
     $config_close_key = 'differential.always-allow-close';
     $always_allow_close = PhabricatorEnv::getEnvConfig($config_close_key);
 
     $config_reopen_key = 'differential.allow-reopen';
     $allow_reopen = PhabricatorEnv::getEnvConfig($config_reopen_key);
 
     $config_self_accept_key = 'differential.allow-self-accept';
     $allow_self_accept = PhabricatorEnv::getEnvConfig($config_self_accept_key);
 
     $revision_status = $revision->getStatus();
 
     $status_accepted = ArcanistDifferentialRevisionStatus::ACCEPTED;
     $status_abandoned = ArcanistDifferentialRevisionStatus::ABANDONED;
     $status_closed = ArcanistDifferentialRevisionStatus::CLOSED;
 
     switch ($action) {
       case DifferentialAction::ACTION_ACCEPT:
         if ($actor_is_author && !$allow_self_accept) {
           return pht(
             'You can not accept this revision because you are the owner.');
         }
 
         if ($revision_status == $status_abandoned) {
           return pht(
             'You can not accept this revision because it has been '.
             'abandoned.');
         }
 
         if ($revision_status == $status_closed) {
           return pht(
             'You can not accept this revision because it has already been '.
             'closed.');
         }
 
         // TODO: It would be nice to make this generic at some point.
         $signatures = DifferentialRequiredSignaturesField::loadForRevision(
           $revision);
         foreach ($signatures as $phid => $signed) {
           if (!$signed) {
             return pht(
               'You can not accept this revision because the author has '.
               'not signed all of the required legal documents.');
           }
         }
 
         break;
 
       case DifferentialAction::ACTION_REJECT:
         if ($actor_is_author) {
           return pht(
             'You can not request changes to your own revision.');
         }
 
         if ($revision_status == $status_abandoned) {
           return pht(
             'You can not request changes to this revision because it has been '.
             'abandoned.');
         }
 
         if ($revision_status == $status_closed) {
           return pht(
             'You can not request changes to this revision because it has '.
             'already been closed.');
         }
         break;
 
       case DifferentialAction::ACTION_RESIGN:
         // You can always resign from a revision if you're a reviewer. If you
         // aren't, this is a no-op rather than invalid.
         break;
 
       case DifferentialAction::ACTION_CLAIM:
         // You can claim a revision if you're not the owner. If you are, this
         // is a no-op rather than invalid.
 
         if ($revision_status == $status_closed) {
           return pht(
             'You can not commandeer this revision because it has already been '.
             'closed.');
         }
         break;
 
       case DifferentialAction::ACTION_ABANDON:
         if (!$actor_is_author && !$always_allow_abandon) {
           return pht(
             'You can not abandon this revision because you do not own it. '.
             'You can only abandon revisions you own.');
         }
 
         if ($revision_status == $status_closed) {
           return pht(
             'You can not abandon this revision because it has already been '.
             'closed.');
         }
 
         // NOTE: Abandons of already-abandoned revisions are treated as no-op
         // instead of invalid. Other abandons are OK.
 
         break;
 
       case DifferentialAction::ACTION_RECLAIM:
         if (!$actor_is_author) {
           return pht(
             'You can not reclaim this revision because you do not own '.
             'it. You can only reclaim revisions you own.');
         }
 
         if ($revision_status == $status_closed) {
           return pht(
             'You can not reclaim this revision because it has already been '.
             'closed.');
         }
 
         // NOTE: Reclaims of other non-abandoned revisions are treated as no-op
         // instead of invalid.
 
         break;
 
       case DifferentialAction::ACTION_REOPEN:
         if (!$allow_reopen) {
           return pht(
             'The reopen action is not enabled on this Phabricator install. '.
             'Adjust your configuration to enable it.');
         }
 
         // NOTE: If the revision is not closed, this is caught as a no-op
         // instead of an invalid transaction.
 
         break;
 
       case DifferentialAction::ACTION_RETHINK:
         if (!$actor_is_author) {
           return pht(
             'You can not plan changes to this revision because you do not '.
             'own it. To plan changes to a revision, you must be its owner.');
         }
 
         switch ($revision_status) {
           case ArcanistDifferentialRevisionStatus::ACCEPTED:
           case ArcanistDifferentialRevisionStatus::NEEDS_REVISION:
           case ArcanistDifferentialRevisionStatus::NEEDS_REVIEW:
             // These are OK.
             break;
           case ArcanistDifferentialRevisionStatus::CHANGES_PLANNED:
             // Let this through, it's a no-op.
             break;
           case ArcanistDifferentialRevisionStatus::ABANDONED:
             return pht(
               'You can not plan changes to this revision because it has '.
               'been abandoned.');
           case ArcanistDifferentialRevisionStatus::CLOSED:
             return pht(
               'You can not plan changes to this revision because it has '.
               'already been closed.');
           default:
             throw new Exception(
               pht(
                 'Encountered unexpected revision status ("%s") when '.
                 'validating "%s" action.',
                 $revision_status,
                 $action));
         }
         break;
 
       case DifferentialAction::ACTION_REQUEST:
         if (!$actor_is_author) {
           return pht(
             'You can not request review of this revision because you do '.
             'not own it. To request review of a revision, you must be its '.
             'owner.');
         }
 
         switch ($revision_status) {
           case ArcanistDifferentialRevisionStatus::ACCEPTED:
           case ArcanistDifferentialRevisionStatus::NEEDS_REVISION:
           case ArcanistDifferentialRevisionStatus::CHANGES_PLANNED:
             // These are OK.
             break;
           case ArcanistDifferentialRevisionStatus::NEEDS_REVIEW:
             // This will be caught as "no effect" later on.
             break;
           case ArcanistDifferentialRevisionStatus::ABANDONED:
             return pht(
               'You can not request review of this revision because it has '.
               'been abandoned. Instead, reclaim it.');
           case ArcanistDifferentialRevisionStatus::CLOSED:
             return pht(
               'You can not request review of this revision because it has '.
               'already been closed.');
           default:
             throw new Exception(
               pht(
                 'Encountered unexpected revision status ("%s") when '.
                 'validating "%s" action.',
                 $revision_status,
                 $action));
         }
         break;
 
       case DifferentialAction::ACTION_CLOSE:
         // We force revisions closed when we discover a corresponding commit.
         // In this case, revisions are allowed to transition to closed from
         // any state. This is an automated action taken by the daemons.
 
         if (!$this->getIsCloseByCommit()) {
           if (!$actor_is_author && !$always_allow_close) {
             return pht(
               'You can not close this revision because you do not own it. To '.
               'close a revision, you must be its owner.');
           }
 
           if ($revision_status != $status_accepted) {
             return pht(
               'You can not close this revision because it has not been '.
               'accepted. You can only close accepted revisions.');
           }
         }
         break;
     }
 
     return null;
   }
 
   protected function sortTransactions(array $xactions) {
     $xactions = parent::sortTransactions($xactions);
 
     $head = array();
     $tail = array();
 
     foreach ($xactions as $xaction) {
       $type = $xaction->getTransactionType();
       if ($type == DifferentialTransaction::TYPE_INLINE) {
         $tail[] = $xaction;
       } else {
         $head[] = $xaction;
       }
     }
 
     return array_values(array_merge($head, $tail));
   }
 
   protected function requireCapabilities(
     PhabricatorLiskDAO $object,
     PhabricatorApplicationTransaction $xaction) {
 
     switch ($xaction->getTransactionType()) {}
 
     return parent::requireCapabilities($object, $xaction);
   }
 
   protected function shouldPublishFeedStory(
     PhabricatorLiskDAO $object,
     array $xactions) {
     return true;
   }
 
   protected function shouldSendMail(
     PhabricatorLiskDAO $object,
     array $xactions) {
     return true;
   }
 
   protected function getMailTo(PhabricatorLiskDAO $object) {
     $phids = array();
     $phids[] = $object->getAuthorPHID();
     foreach ($object->getReviewerStatus() as $reviewer) {
       $phids[] = $reviewer->getReviewerPHID();
     }
     return $phids;
   }
 
   protected function getMailCC(PhabricatorLiskDAO $object) {
     $phids = parent::getMailCC($object);
 
     if ($this->heraldEmailPHIDs) {
       foreach ($this->heraldEmailPHIDs as $phid) {
         $phids[] = $phid;
       }
     }
 
     return $phids;
   }
 
   protected function getMailAction(
     PhabricatorLiskDAO $object,
     array $xactions) {
     $action = parent::getMailAction($object, $xactions);
 
     $strongest = $this->getStrongestAction($object, $xactions);
     switch ($strongest->getTransactionType()) {
       case DifferentialTransaction::TYPE_UPDATE:
         $count = new PhutilNumber($object->getLineCount());
         $action = pht('%s, %s line(s)', $action, $count);
         break;
     }
 
     return $action;
   }
 
   protected function getMailSubjectPrefix() {
     return PhabricatorEnv::getEnvConfig('metamta.differential.subject-prefix');
   }
 
   protected function getMailThreadID(PhabricatorLiskDAO $object) {
     // This is nonstandard, but retains threading with older messages.
     $phid = $object->getPHID();
     return "differential-rev-{$phid}-req";
   }
 
   protected function buildReplyHandler(PhabricatorLiskDAO $object) {
     return id(new DifferentialReplyHandler())
       ->setMailReceiver($object);
   }
 
   protected function buildMailTemplate(PhabricatorLiskDAO $object) {
     $id = $object->getID();
     $title = $object->getTitle();
 
     $original_title = $object->getOriginalTitle();
 
     $subject = "D{$id}: {$title}";
     $thread_topic = "D{$id}: {$original_title}";
 
     return id(new PhabricatorMetaMTAMail())
       ->setSubject($subject)
       ->addHeader('Thread-Topic', $thread_topic);
   }
 
   protected function buildMailBody(
     PhabricatorLiskDAO $object,
     array $xactions) {
 
     $body = parent::buildMailBody($object, $xactions);
 
     $type_inline = DifferentialTransaction::TYPE_INLINE;
 
     $inlines = array();
     foreach ($xactions as $xaction) {
       if ($xaction->getTransactionType() == $type_inline) {
         $inlines[] = $xaction;
       }
     }
 
     $changed_uri = $this->getChangedPriorToCommitURI();
     if ($changed_uri) {
-      $body->addTextSection(
+      $body->addLinkSection(
         pht('CHANGED PRIOR TO COMMIT'),
         $changed_uri);
     }
 
     if ($inlines) {
       $body->addTextSection(
         pht('INLINE COMMENTS'),
         $this->renderInlineCommentsForMail($object, $inlines));
     }
 
-    $body->addTextSection(
+    $body->addLinkSection(
       pht('REVISION DETAIL'),
       PhabricatorEnv::getProductionURI('/D'.$object->getID()));
 
     $update_xaction = null;
     foreach ($xactions as $xaction) {
       switch ($xaction->getTransactionType()) {
         case DifferentialTransaction::TYPE_UPDATE:
           $update_xaction = $xaction;
           break;
       }
     }
 
     if ($update_xaction) {
       $diff = $this->requireDiff($update_xaction->getNewValue(), true);
 
       $body->addTextSection(
         pht('AFFECTED FILES'),
         $this->renderAffectedFilesForMail($diff));
 
       $config_key_inline = 'metamta.differential.inline-patches';
       $config_inline = PhabricatorEnv::getEnvConfig($config_key_inline);
 
       $config_key_attach = 'metamta.differential.attach-patches';
       $config_attach = PhabricatorEnv::getEnvConfig($config_key_attach);
 
       if ($config_inline || $config_attach) {
         $patch_section = $this->renderPatchForMail($diff);
         $lines = count(phutil_split_lines($patch_section->getPlaintext()));
 
         if ($config_inline && ($lines <= $config_inline)) {
           $body->addTextSection(
             pht('CHANGE DETAILS'),
             $patch_section);
         }
 
         if ($config_attach) {
           $name = pht('D%s.%s.patch', $object->getID(), $diff->getID());
           $mime_type = 'text/x-patch; charset=utf-8';
           $body->addAttachment(
             new PhabricatorMetaMTAAttachment(
               $patch_section->getPlaintext(), $name, $mime_type));
         }
       }
     }
 
     return $body;
   }
 
   public function getMailTagsMap() {
     return array(
       MetaMTANotificationType::TYPE_DIFFERENTIAL_REVIEW_REQUEST =>
         pht('A revision is created.'),
       MetaMTANotificationType::TYPE_DIFFERENTIAL_UPDATED =>
         pht('A revision is updated.'),
       MetaMTANotificationType::TYPE_DIFFERENTIAL_COMMENT =>
         pht('Someone comments on a revision.'),
       MetaMTANotificationType::TYPE_DIFFERENTIAL_CLOSED =>
         pht('A revision is closed.'),
       MetaMTANotificationType::TYPE_DIFFERENTIAL_REVIEWERS =>
         pht("A revision's reviewers change."),
       MetaMTANotificationType::TYPE_DIFFERENTIAL_CC =>
         pht("A revision's CCs change."),
       MetaMTANotificationType::TYPE_DIFFERENTIAL_OTHER =>
         pht('Other revision activity not listed above occurs.'),
     );
   }
 
   protected function supportsSearch() {
     return true;
   }
 
   protected function extractFilePHIDsFromCustomTransaction(
     PhabricatorLiskDAO $object,
     PhabricatorApplicationTransaction $xaction) {
 
     switch ($xaction->getTransactionType()) {}
 
     return parent::extractFilePHIDsFromCustomTransaction($object, $xaction);
   }
 
   protected function expandCustomRemarkupBlockTransactions(
     PhabricatorLiskDAO $object,
     array $xactions,
     $blocks,
     PhutilMarkupEngine $engine) {
 
     $flat_blocks = array_mergev($blocks);
     $huge_block = implode("\n\n", $flat_blocks);
 
     $task_map = array();
     $task_refs = id(new ManiphestCustomFieldStatusParser())
       ->parseCorpus($huge_block);
     foreach ($task_refs as $match) {
       foreach ($match['monograms'] as $monogram) {
         $task_id = (int)trim($monogram, 'tT');
         $task_map[$task_id] = true;
       }
     }
 
     $rev_map = array();
     $rev_refs = id(new DifferentialCustomFieldDependsOnParser())
       ->parseCorpus($huge_block);
     foreach ($rev_refs as $match) {
       foreach ($match['monograms'] as $monogram) {
         $rev_id = (int)trim($monogram, 'dD');
         $rev_map[$rev_id] = true;
       }
     }
 
     $edges = array();
 
     if ($task_map) {
       $tasks = id(new ManiphestTaskQuery())
         ->setViewer($this->getActor())
         ->withIDs(array_keys($task_map))
         ->execute();
 
       if ($tasks) {
         $phid_map = mpull($tasks, 'getPHID', 'getPHID');
         $edge_related = DifferentialRevisionHasTaskEdgeType::EDGECONST;
         $edges[$edge_related] = $phid_map;
         $this->setUnmentionablePHIDMap($phid_map);
       }
     }
 
     if ($rev_map) {
       $revs = id(new DifferentialRevisionQuery())
         ->setViewer($this->getActor())
         ->withIDs(array_keys($rev_map))
         ->execute();
       $rev_phids = mpull($revs, 'getPHID', 'getPHID');
 
       // NOTE: Skip any write attempts if a user cleverly implies a revision
       // depends upon itself.
       unset($rev_phids[$object->getPHID()]);
 
       if ($revs) {
         $edge_depends = PhabricatorEdgeConfig::TYPE_DREV_DEPENDS_ON_DREV;
         $edges[$edge_depends] = $rev_phids;
       }
     }
 
     $result = array();
     foreach ($edges as $type => $specs) {
       $result[] = id(new DifferentialTransaction())
         ->setTransactionType(PhabricatorTransactions::TYPE_EDGE)
         ->setMetadataValue('edge:type', $type)
         ->setNewValue(array('+' => $specs));
     }
 
     return $result;
   }
 
   protected function indentForMail(array $lines) {
     $indented = array();
     foreach ($lines as $line) {
       $indented[] = '> '.$line;
     }
     return $indented;
   }
 
   protected function nestCommentHistory(
     DifferentialTransactionComment $comment, array $comments_by_line_number,
     array $users_by_phid) {
 
     $nested = array();
     $previous_comments = $comments_by_line_number[$comment->getChangesetID()]
                                                  [$comment->getLineNumber()];
     foreach ($previous_comments as $previous_comment) {
       if ($previous_comment->getID() >= $comment->getID())
         break;
       $nested = $this->indentForMail(
         array_merge(
           $nested,
           explode("\n", $previous_comment->getContent())));
       $user = idx($users_by_phid, $previous_comment->getAuthorPHID(), null);
       if ($user) {
         array_unshift($nested, pht('%s wrote:', $user->getUserName()));
       }
     }
 
     $nested = array_merge($nested, explode("\n", $comment->getContent()));
     return implode("\n", $nested);
   }
 
   private function renderInlineCommentsForMail(
     PhabricatorLiskDAO $object,
     array $inlines) {
 
     $context_key = 'metamta.differential.unified-comment-context';
     $show_context = PhabricatorEnv::getEnvConfig($context_key);
 
     $changeset_ids = array();
     $line_numbers_by_changeset = array();
     foreach ($inlines as $inline) {
       $id = $inline->getComment()->getChangesetID();
       $changeset_ids[$id] = $id;
       $line_numbers_by_changeset[$id][] =
         $inline->getComment()->getLineNumber();
     }
 
     $changesets = id(new DifferentialChangesetQuery())
       ->setViewer($this->getActor())
       ->withIDs($changeset_ids)
       ->needHunks(true)
       ->execute();
 
     $inline_groups = DifferentialTransactionComment::sortAndGroupInlines(
       $inlines,
       $changesets);
 
     if ($show_context) {
       $hunk_parser = new DifferentialHunkParser();
       $table = new DifferentialTransactionComment();
       $conn_r = $table->establishConnection('r');
       $queries = array();
       foreach ($line_numbers_by_changeset as $id => $line_numbers) {
         $queries[] = qsprintf(
           $conn_r,
           '(changesetID = %d AND lineNumber IN (%Ld))',
           $id, $line_numbers);
       }
       $all_comments = id(new DifferentialTransactionComment())->loadAllWhere(
         'transactionPHID IS NOT NULL AND (%Q)', implode(' OR ', $queries));
       $comments_by_line_number = array();
       foreach ($all_comments as $comment) {
         $comments_by_line_number
           [$comment->getChangesetID()]
           [$comment->getLineNumber()]
           [$comment->getID()] = $comment;
       }
       $author_phids = mpull($all_comments, 'getAuthorPHID');
       $authors = id(new PhabricatorPeopleQuery())
         ->setViewer($this->getActor())
         ->withPHIDs($author_phids)
         ->execute();
       $authors_by_phid = mpull($authors, null, 'getPHID');
     }
 
     $section = new PhabricatorMetaMTAMailSection();
     foreach ($inline_groups as $changeset_id => $group) {
       $changeset = idx($changesets, $changeset_id);
       if (!$changeset) {
         continue;
       }
 
       foreach ($group as $inline) {
         $comment = $inline->getComment();
         $file = $changeset->getFilename();
         $start = $comment->getLineNumber();
         $len = $comment->getLineLength();
         if ($len) {
           $range = $start.'-'.($start + $len);
         } else {
           $range = $start;
         }
 
         $inline_content = $comment->getContent();
 
         if (!$show_context) {
           $section->addFragment("{$file}:{$range} {$inline_content}");
         } else {
           $patch = $hunk_parser->makeContextDiff(
             $changeset->getHunks(),
             $comment->getIsNewFile(),
             $comment->getLineNumber(),
             $comment->getLineLength(),
             1);
           $nested_comments = $this->nestCommentHistory(
             $inline->getComment(), $comments_by_line_number, $authors_by_phid);
 
           $section->addFragment('================')
                   ->addFragment('Comment at: '.$file.':'.$range)
                   ->addPlaintextFragment($patch)
                   ->addHTMLFragment($this->renderPatchHTMLForMail($patch))
                   ->addFragment('----------------')
                   ->addFragment($nested_comments)
                   ->addFragment(null);
         }
       }
     }
 
     return $section;
   }
 
   private function loadDiff($phid, $need_changesets = false) {
     $query = id(new DifferentialDiffQuery())
       ->withPHIDs(array($phid))
       ->setViewer($this->getActor());
 
     if ($need_changesets) {
       $query->needChangesets(true);
     }
 
     return $query->executeOne();
   }
 
   private function requireDiff($phid, $need_changesets = false) {
     $diff = $this->loadDiff($phid, $need_changesets);
     if (!$diff) {
       throw new Exception(pht('Diff "%s" does not exist!', $phid));
     }
 
     return $diff;
   }
 
 /* -(  Herald Integration  )------------------------------------------------- */
 
   protected function shouldApplyHeraldRules(
     PhabricatorLiskDAO $object,
     array $xactions) {
 
     if ($this->getIsNewObject()) {
       return true;
     }
 
     foreach ($xactions as $xaction) {
       switch ($xaction->getTransactionType()) {
         case DifferentialTransaction::TYPE_UPDATE:
           if (!$this->getIsCloseByCommit()) {
             return true;
           }
           break;
         case DifferentialTransaction::TYPE_ACTION:
           switch ($xaction->getNewValue()) {
             case DifferentialAction::ACTION_CLAIM:
               // When users commandeer revisions, we may need to trigger
               // signatures or author-based rules.
               return true;
           }
           break;
       }
     }
 
     return parent::shouldApplyHeraldRules($object, $xactions);
   }
 
   protected function buildHeraldAdapter(
     PhabricatorLiskDAO $object,
     array $xactions) {
 
     $unsubscribed_phids = PhabricatorEdgeQuery::loadDestinationPHIDs(
       $object->getPHID(),
       PhabricatorEdgeConfig::TYPE_OBJECT_HAS_UNSUBSCRIBER);
 
     $subscribed_phids = PhabricatorSubscribersQuery::loadSubscribersForPHID(
       $object->getPHID());
 
     $revision = id(new DifferentialRevisionQuery())
       ->setViewer($this->getActor())
       ->withPHIDs(array($object->getPHID()))
       ->needActiveDiffs(true)
       ->needReviewerStatus(true)
       ->executeOne();
     if (!$revision) {
       throw new Exception(
         pht(
           'Failed to load revision for Herald adapter construction!'));
     }
 
     $adapter = HeraldDifferentialRevisionAdapter::newLegacyAdapter(
       $revision,
       $revision->getActiveDiff());
 
     $reviewers = $revision->getReviewerStatus();
     $reviewer_phids = mpull($reviewers, 'getReviewerPHID');
 
     $adapter->setExplicitCCs($subscribed_phids);
     $adapter->setExplicitReviewers($reviewer_phids);
     $adapter->setForbiddenCCs($unsubscribed_phids);
 
     $adapter->setIsNewObject($this->getIsNewObject());
 
     return $adapter;
   }
 
   protected function didApplyHeraldRules(
     PhabricatorLiskDAO $object,
     HeraldAdapter $adapter,
     HeraldTranscript $transcript) {
 
     $xactions = array();
 
     // Build a transaction to adjust CCs.
     $ccs = array(
       '+' => array_keys($adapter->getCCsAddedByHerald()),
       '-' => array_keys($adapter->getCCsRemovedByHerald()),
     );
     $value = array();
     foreach ($ccs as $type => $phids) {
       foreach ($phids as $phid) {
         $value[$type][$phid] = $phid;
       }
     }
 
     if ($value) {
       $xactions[] = id(new DifferentialTransaction())
         ->setTransactionType(PhabricatorTransactions::TYPE_SUBSCRIBERS)
         ->setNewValue($value);
     }
 
     // Build a transaction to adjust reviewers.
     $reviewers = array(
       DifferentialReviewerStatus::STATUS_ADDED =>
         array_keys($adapter->getReviewersAddedByHerald()),
       DifferentialReviewerStatus::STATUS_BLOCKING =>
         array_keys($adapter->getBlockingReviewersAddedByHerald()),
     );
 
     $old_reviewers = $object->getReviewerStatus();
     $old_reviewers = mpull($old_reviewers, null, 'getReviewerPHID');
 
     $value = array();
     foreach ($reviewers as $status => $phids) {
       foreach ($phids as $phid) {
         if ($phid == $object->getAuthorPHID()) {
           // Don't try to add the revision's author as a reviewer, since this
           // isn't valid and doesn't make sense.
           continue;
         }
 
         // If the target is already a reviewer, don't try to change anything
         // if their current status is at least as strong as the new status.
         // For example, don't downgrade an "Accepted" to a "Blocking Reviewer".
         $old_reviewer = idx($old_reviewers, $phid);
         if ($old_reviewer) {
           $old_status = $old_reviewer->getStatus();
 
           $old_strength = DifferentialReviewerStatus::getStatusStrength(
             $old_status);
           $new_strength = DifferentialReviewerStatus::getStatusStrength(
             $status);
 
           if ($new_strength <= $old_strength) {
             continue;
           }
         }
 
         $value['+'][$phid] = array(
           'data' => array(
             'status' => $status,
           ),
         );
       }
     }
 
     if ($value) {
       $edge_reviewer = PhabricatorEdgeConfig::TYPE_DREV_HAS_REVIEWER;
 
       $xactions[] = id(new DifferentialTransaction())
         ->setTransactionType(PhabricatorTransactions::TYPE_EDGE)
         ->setMetadataValue('edge:type', $edge_reviewer)
         ->setNewValue($value);
     }
 
     // Require legalpad document signatures.
     $legal_phids = $adapter->getRequiredSignatureDocumentPHIDs();
     if ($legal_phids) {
       // We only require signatures of documents which have not already
       // been signed. In general, this reduces the amount of churn that
       // signature rules cause.
 
       $signatures = id(new LegalpadDocumentSignatureQuery())
         ->setViewer(PhabricatorUser::getOmnipotentUser())
         ->withDocumentPHIDs($legal_phids)
         ->withSignerPHIDs(array($object->getAuthorPHID()))
         ->execute();
       $signed_phids = mpull($signatures, 'getDocumentPHID');
       $legal_phids = array_diff($legal_phids, $signed_phids);
 
       // If we still have something to trigger, add the edges.
       if ($legal_phids) {
         $edge_legal = PhabricatorEdgeConfig::TYPE_OBJECT_NEEDS_SIGNATURE;
         $xactions[] = id(new DifferentialTransaction())
           ->setTransactionType(PhabricatorTransactions::TYPE_EDGE)
           ->setMetadataValue('edge:type', $edge_legal)
           ->setNewValue(
             array(
               '+' => array_fuse($legal_phids),
             ));
       }
     }
 
     // Save extra email PHIDs for later.
     $email_phids = $adapter->getEmailPHIDsAddedByHerald();
     $this->heraldEmailPHIDs = array_keys($email_phids);
 
     // Apply build plans.
     HarbormasterBuildable::applyBuildPlans(
       $adapter->getDiff()->getPHID(),
       $adapter->getPHID(),
       $adapter->getBuildPlans());
 
     return $xactions;
   }
 
   /**
    * Update the table which links Differential revisions to paths they affect,
    * so Diffusion can efficiently find pending revisions for a given file.
    */
   private function updateAffectedPathTable(
     DifferentialRevision $revision,
     DifferentialDiff $diff) {
 
     $repository = $revision->getRepository();
     if (!$repository) {
       // The repository where the code lives is untracked.
       return;
     }
 
     $path_prefix = null;
 
     $local_root = $diff->getSourceControlPath();
     if ($local_root) {
       // We're in a working copy which supports subdirectory checkouts (e.g.,
       // SVN) so we need to figure out what prefix we should add to each path
       // (e.g., trunk/projects/example/) to get the absolute path from the
       // root of the repository. DVCS systems like Git and Mercurial are not
       // affected.
 
       // Normalize both paths and check if the repository root is a prefix of
       // the local root. If so, throw it away. Note that this correctly handles
       // the case where the remote path is "/".
       $local_root = id(new PhutilURI($local_root))->getPath();
       $local_root = rtrim($local_root, '/');
 
       $repo_root = id(new PhutilURI($repository->getRemoteURI()))->getPath();
       $repo_root = rtrim($repo_root, '/');
 
       if (!strncmp($repo_root, $local_root, strlen($repo_root))) {
         $path_prefix = substr($local_root, strlen($repo_root));
       }
     }
 
     $changesets = $diff->getChangesets();
     $paths = array();
     foreach ($changesets as $changeset) {
       $paths[] = $path_prefix.'/'.$changeset->getFilename();
     }
 
     // Mark this as also touching all parent paths, so you can see all pending
     // changes to any file within a directory.
     $all_paths = array();
     foreach ($paths as $local) {
       foreach (DiffusionPathIDQuery::expandPathToRoot($local) as $path) {
         $all_paths[$path] = true;
       }
     }
     $all_paths = array_keys($all_paths);
 
     $path_ids =
       PhabricatorRepositoryCommitChangeParserWorker::lookupOrCreatePaths(
         $all_paths);
 
     $table = new DifferentialAffectedPath();
     $conn_w = $table->establishConnection('w');
 
     $sql = array();
     foreach ($path_ids as $path_id) {
       $sql[] = qsprintf(
         $conn_w,
         '(%d, %d, %d, %d)',
         $repository->getID(),
         $path_id,
         time(),
         $revision->getID());
     }
 
     queryfx(
       $conn_w,
       'DELETE FROM %T WHERE revisionID = %d',
       $table->getTableName(),
       $revision->getID());
     foreach (array_chunk($sql, 256) as $chunk) {
       queryfx(
         $conn_w,
         'INSERT INTO %T (repositoryID, pathID, epoch, revisionID) VALUES %Q',
         $table->getTableName(),
         implode(', ', $chunk));
     }
   }
 
   /**
    * Update the table connecting revisions to DVCS local hashes, so we can
    * identify revisions by commit/tree hashes.
    */
   private function updateRevisionHashTable(
     DifferentialRevision $revision,
     DifferentialDiff $diff) {
 
     $vcs = $diff->getSourceControlSystem();
     if ($vcs == DifferentialRevisionControlSystem::SVN) {
       // Subversion has no local commit or tree hash information, so we don't
       // have to do anything.
       return;
     }
 
     $property = id(new DifferentialDiffProperty())->loadOneWhere(
       'diffID = %d AND name = %s',
       $diff->getID(),
       'local:commits');
     if (!$property) {
       return;
     }
 
     $hashes = array();
 
     $data = $property->getData();
     switch ($vcs) {
       case DifferentialRevisionControlSystem::GIT:
         foreach ($data as $commit) {
           $hashes[] = array(
             ArcanistDifferentialRevisionHash::HASH_GIT_COMMIT,
             $commit['commit'],
           );
           $hashes[] = array(
             ArcanistDifferentialRevisionHash::HASH_GIT_TREE,
             $commit['tree'],
           );
         }
         break;
       case DifferentialRevisionControlSystem::MERCURIAL:
         foreach ($data as $commit) {
           $hashes[] = array(
             ArcanistDifferentialRevisionHash::HASH_MERCURIAL_COMMIT,
             $commit['rev'],
           );
         }
         break;
     }
 
     $conn_w = $revision->establishConnection('w');
 
     $sql = array();
     foreach ($hashes as $info) {
       list($type, $hash) = $info;
       $sql[] = qsprintf(
         $conn_w,
         '(%d, %s, %s)',
         $revision->getID(),
         $type,
         $hash);
     }
 
     queryfx(
       $conn_w,
       'DELETE FROM %T WHERE revisionID = %d',
       ArcanistDifferentialRevisionHash::TABLE_NAME,
       $revision->getID());
 
     if ($sql) {
       queryfx(
         $conn_w,
         'INSERT INTO %T (revisionID, type, hash) VALUES %Q',
         ArcanistDifferentialRevisionHash::TABLE_NAME,
         implode(', ', $sql));
     }
   }
 
   private function renderAffectedFilesForMail(DifferentialDiff $diff) {
     $changesets = $diff->getChangesets();
 
     $filenames = mpull($changesets, 'getDisplayFilename');
     sort($filenames);
 
     $count = count($filenames);
     $max = 250;
     if ($count > $max) {
       $filenames = array_slice($filenames, 0, $max);
       $filenames[] = pht('(%d more files...)', ($count - $max));
     }
 
     return implode("\n", $filenames);
   }
 
   private function renderPatchHTMLForMail($patch) {
     return phutil_tag('pre',
       array('style' => 'font-family: monospace;'), $patch);
   }
 
   private function renderPatchForMail(DifferentialDiff $diff) {
     $format = PhabricatorEnv::getEnvConfig('metamta.differential.patch-format');
 
     $patch = id(new DifferentialRawDiffRenderer())
       ->setViewer($this->getActor())
       ->setFormat($format)
       ->setChangesets($diff->getChangesets())
       ->buildPatch();
 
     $section = new PhabricatorMetaMTAMailSection();
     $section->addHTMLFragment($this->renderPatchHTMLForMail($patch));
     $section->addPlaintextFragment($patch);
 
     return $section;
   }
 
 }
diff --git a/src/applications/fund/editor/FundInitiativeEditor.php b/src/applications/fund/editor/FundInitiativeEditor.php
index 72bede9069..05041ba119 100644
--- a/src/applications/fund/editor/FundInitiativeEditor.php
+++ b/src/applications/fund/editor/FundInitiativeEditor.php
@@ -1,300 +1,300 @@
 <?php
 
 final class FundInitiativeEditor
   extends PhabricatorApplicationTransactionEditor {
 
   public function getEditorApplicationClass() {
     return 'PhabricatorFundApplication';
   }
 
   public function getEditorObjectsDescription() {
     return pht('Fund Initiatives');
   }
 
   public function getTransactionTypes() {
     $types = parent::getTransactionTypes();
 
     $types[] = FundInitiativeTransaction::TYPE_NAME;
     $types[] = FundInitiativeTransaction::TYPE_DESCRIPTION;
     $types[] = FundInitiativeTransaction::TYPE_RISKS;
     $types[] = FundInitiativeTransaction::TYPE_STATUS;
     $types[] = FundInitiativeTransaction::TYPE_BACKER;
     $types[] = FundInitiativeTransaction::TYPE_REFUND;
     $types[] = FundInitiativeTransaction::TYPE_MERCHANT;
     $types[] = PhabricatorTransactions::TYPE_VIEW_POLICY;
     $types[] = PhabricatorTransactions::TYPE_EDIT_POLICY;
 
     return $types;
   }
 
   protected function getCustomTransactionOldValue(
     PhabricatorLiskDAO $object,
     PhabricatorApplicationTransaction $xaction) {
     switch ($xaction->getTransactionType()) {
       case FundInitiativeTransaction::TYPE_NAME:
         return $object->getName();
       case FundInitiativeTransaction::TYPE_DESCRIPTION:
         return $object->getDescription();
       case FundInitiativeTransaction::TYPE_RISKS:
         return $object->getRisks();
       case FundInitiativeTransaction::TYPE_STATUS:
         return $object->getStatus();
       case FundInitiativeTransaction::TYPE_BACKER:
       case FundInitiativeTransaction::TYPE_REFUND:
         return null;
       case FundInitiativeTransaction::TYPE_MERCHANT:
         return $object->getMerchantPHID();
     }
 
     return parent::getCustomTransactionOldValue($object, $xaction);
   }
 
   protected function getCustomTransactionNewValue(
     PhabricatorLiskDAO $object,
     PhabricatorApplicationTransaction $xaction) {
 
     switch ($xaction->getTransactionType()) {
       case FundInitiativeTransaction::TYPE_NAME:
       case FundInitiativeTransaction::TYPE_DESCRIPTION:
       case FundInitiativeTransaction::TYPE_RISKS:
       case FundInitiativeTransaction::TYPE_STATUS:
       case FundInitiativeTransaction::TYPE_BACKER:
       case FundInitiativeTransaction::TYPE_REFUND:
       case FundInitiativeTransaction::TYPE_MERCHANT:
         return $xaction->getNewValue();
     }
 
     return parent::getCustomTransactionNewValue($object, $xaction);
   }
 
   protected function applyCustomInternalTransaction(
     PhabricatorLiskDAO $object,
     PhabricatorApplicationTransaction $xaction) {
 
     $type = $xaction->getTransactionType();
     switch ($type) {
       case FundInitiativeTransaction::TYPE_NAME:
         $object->setName($xaction->getNewValue());
         return;
       case FundInitiativeTransaction::TYPE_DESCRIPTION:
         $object->setDescription($xaction->getNewValue());
         return;
       case FundInitiativeTransaction::TYPE_RISKS:
         $object->setRisks($xaction->getNewValue());
         return;
       case FundInitiativeTransaction::TYPE_MERCHANT:
         $object->setMerchantPHID($xaction->getNewValue());
         return;
       case FundInitiativeTransaction::TYPE_STATUS:
         $object->setStatus($xaction->getNewValue());
         return;
       case FundInitiativeTransaction::TYPE_BACKER:
       case FundInitiativeTransaction::TYPE_REFUND:
         $amount = $xaction->getMetadataValue(
           FundInitiativeTransaction::PROPERTY_AMOUNT);
         $amount = PhortuneCurrency::newFromString($amount);
 
         if ($type == FundInitiativeTransaction::TYPE_REFUND) {
           $total = $object->getTotalAsCurrency()->subtract($amount);
         } else {
           $total = $object->getTotalAsCurrency()->add($amount);
         }
 
         $object->setTotalAsCurrency($total);
         return;
       case PhabricatorTransactions::TYPE_SUBSCRIBERS:
       case PhabricatorTransactions::TYPE_EDGE:
       case PhabricatorTransactions::TYPE_VIEW_POLICY:
       case PhabricatorTransactions::TYPE_EDIT_POLICY:
         return;
     }
 
     return parent::applyCustomInternalTransaction($object, $xaction);
   }
 
   protected function applyCustomExternalTransaction(
     PhabricatorLiskDAO $object,
     PhabricatorApplicationTransaction $xaction) {
 
     $type = $xaction->getTransactionType();
     switch ($type) {
       case FundInitiativeTransaction::TYPE_NAME:
       case FundInitiativeTransaction::TYPE_DESCRIPTION:
       case FundInitiativeTransaction::TYPE_RISKS:
       case FundInitiativeTransaction::TYPE_STATUS:
       case FundInitiativeTransaction::TYPE_MERCHANT:
         return;
       case FundInitiativeTransaction::TYPE_BACKER:
       case FundInitiativeTransaction::TYPE_REFUND:
         $backer = id(new FundBackerQuery())
           ->setViewer($this->requireActor())
           ->withPHIDs(array($xaction->getNewValue()))
           ->executeOne();
         if (!$backer) {
           throw new Exception(pht('Unable to load FundBacker!'));
         }
 
         $subx = array();
 
         if ($type == FundInitiativeTransaction::TYPE_BACKER) {
           $subx[] = id(new FundBackerTransaction())
             ->setTransactionType(FundBackerTransaction::TYPE_STATUS)
             ->setNewValue(FundBacker::STATUS_PURCHASED);
         } else {
           $amount = $xaction->getMetadataValue(
             FundInitiativeTransaction::PROPERTY_AMOUNT);
           $subx[] = id(new FundBackerTransaction())
             ->setTransactionType(FundBackerTransaction::TYPE_STATUS)
             ->setNewValue($amount);
         }
 
         $editor = id(new FundBackerEditor())
           ->setActor($this->requireActor())
           ->setContentSource($this->getContentSource())
           ->setContinueOnMissingFields(true)
           ->setContinueOnNoEffect(true);
 
         $editor->applyTransactions($backer, $subx);
         return;
       case PhabricatorTransactions::TYPE_SUBSCRIBERS:
       case PhabricatorTransactions::TYPE_EDGE:
       case PhabricatorTransactions::TYPE_VIEW_POLICY:
       case PhabricatorTransactions::TYPE_EDIT_POLICY:
         return;
     }
 
     return parent::applyCustomExternalTransaction($object, $xaction);
   }
 
   protected function validateTransaction(
     PhabricatorLiskDAO $object,
     $type,
     array $xactions) {
 
     $errors = parent::validateTransaction($object, $type, $xactions);
 
     switch ($type) {
       case FundInitiativeTransaction::TYPE_NAME:
         $missing = $this->validateIsEmptyTextField(
           $object->getName(),
           $xactions);
 
         if ($missing) {
           $error = new PhabricatorApplicationTransactionValidationError(
             $type,
             pht('Required'),
             pht('Initiative name is required.'),
             nonempty(last($xactions), null));
 
           $error->setIsMissingFieldError(true);
           $errors[] = $error;
         }
         break;
       case FundInitiativeTransaction::TYPE_MERCHANT:
         $missing = $this->validateIsEmptyTextField(
           $object->getName(),
           $xactions);
         if ($missing) {
           $error = new PhabricatorApplicationTransactionValidationError(
             $type,
             pht('Required'),
             pht('Payable merchant is required.'),
             nonempty(last($xactions), null));
 
           $error->setIsMissingFieldError(true);
           $errors[] = $error;
         } else if ($xactions) {
           $merchant_phid = last($xactions)->getNewValue();
 
           // Make sure the actor has permission to edit the merchant they're
           // selecting. You aren't allowed to send payments to an account you
           // do not control.
           $merchants = id(new PhortuneMerchantQuery())
             ->setViewer($this->requireActor())
             ->withPHIDs(array($merchant_phid))
             ->requireCapabilities(
               array(
                 PhabricatorPolicyCapability::CAN_VIEW,
                 PhabricatorPolicyCapability::CAN_EDIT,
               ))
             ->execute();
           if (!$merchants) {
             $error = new PhabricatorApplicationTransactionValidationError(
               $type,
               pht('Invalid'),
               pht(
                 'You must specify a merchant account you control as the '.
                 'recipient of funds from this initiative.'),
               last($xactions));
             $errors[] = $error;
           }
         }
         break;
     }
 
     return $errors;
   }
 
   protected function shouldSendMail(
     PhabricatorLiskDAO $object,
     array $xactions) {
     return true;
   }
 
   public function getMailTagsMap() {
     return array(
       FundInitiativeTransaction::MAILTAG_BACKER =>
         pht('Someone backs an initiative.'),
       FundInitiativeTransaction::MAILTAG_STATUS =>
         pht("An initiative's status changes."),
       FundInitiativeTransaction::MAILTAG_OTHER =>
         pht('Other initiative activity not listed above occurs.'),
     );
   }
 
   protected function buildMailTemplate(PhabricatorLiskDAO $object) {
     $monogram = $object->getMonogram();
     $name = $object->getName();
 
     return id(new PhabricatorMetaMTAMail())
       ->setSubject("{$monogram}: {$name}")
       ->addHeader('Thread-Topic', $monogram);
   }
 
   protected function buildMailBody(
     PhabricatorLiskDAO $object,
     array $xactions) {
 
     $body = parent::buildMailBody($object, $xactions);
 
-    $body->addTextSection(
+    $body->addLinkSection(
       pht('INITIATIVE DETAIL'),
       PhabricatorEnv::getProductionURI('/'.$object->getMonogram()));
 
     return $body;
   }
 
   protected function getMailTo(PhabricatorLiskDAO $object) {
     return array($object->getOwnerPHID());
   }
 
   protected function getMailSubjectPrefix() {
     return 'Fund';
   }
 
   protected function buildReplyHandler(PhabricatorLiskDAO $object) {
     return id(new FundInitiativeReplyHandler())
       ->setMailReceiver($object);
   }
 
   protected function shouldPublishFeedStory(
     PhabricatorLiskDAO $object,
     array $xactions) {
     return true;
   }
 
   protected function supportsSearch() {
     return true;
   }
 
 }
diff --git a/src/applications/legalpad/editor/LegalpadDocumentEditor.php b/src/applications/legalpad/editor/LegalpadDocumentEditor.php
index 80dd262716..98104690d0 100644
--- a/src/applications/legalpad/editor/LegalpadDocumentEditor.php
+++ b/src/applications/legalpad/editor/LegalpadDocumentEditor.php
@@ -1,219 +1,219 @@
 <?php
 
 final class LegalpadDocumentEditor
   extends PhabricatorApplicationTransactionEditor {
 
   private $isContribution = false;
 
   public function getEditorApplicationClass() {
     return 'PhabricatorLegalpadApplication';
   }
 
   public function getEditorObjectsDescription() {
     return pht('Legalpad Documents');
   }
 
   private function setIsContribution($is_contribution) {
     $this->isContribution = $is_contribution;
   }
 
   private function isContribution() {
     return $this->isContribution;
   }
 
   public function getTransactionTypes() {
     $types = parent::getTransactionTypes();
 
     $types[] = PhabricatorTransactions::TYPE_COMMENT;
     $types[] = PhabricatorTransactions::TYPE_VIEW_POLICY;
     $types[] = PhabricatorTransactions::TYPE_EDIT_POLICY;
 
     $types[] = LegalpadTransactionType::TYPE_TITLE;
     $types[] = LegalpadTransactionType::TYPE_TEXT;
     $types[] = LegalpadTransactionType::TYPE_SIGNATURE_TYPE;
     $types[] = LegalpadTransactionType::TYPE_PREAMBLE;
 
     return $types;
   }
 
   protected function getCustomTransactionOldValue(
     PhabricatorLiskDAO $object,
     PhabricatorApplicationTransaction $xaction) {
 
     switch ($xaction->getTransactionType()) {
       case LegalpadTransactionType::TYPE_TITLE:
         return $object->getDocumentBody()->getTitle();
       case LegalpadTransactionType::TYPE_TEXT:
         return $object->getDocumentBody()->getText();
       case LegalpadTransactionType::TYPE_SIGNATURE_TYPE:
         return $object->getSignatureType();
       case LegalpadTransactionType::TYPE_PREAMBLE:
         return $object->getPreamble();
     }
   }
 
   protected function getCustomTransactionNewValue(
     PhabricatorLiskDAO $object,
     PhabricatorApplicationTransaction $xaction) {
 
     switch ($xaction->getTransactionType()) {
       case LegalpadTransactionType::TYPE_TITLE:
       case LegalpadTransactionType::TYPE_TEXT:
       case LegalpadTransactionType::TYPE_SIGNATURE_TYPE:
       case LegalpadTransactionType::TYPE_PREAMBLE:
         return $xaction->getNewValue();
     }
   }
 
   protected function applyCustomInternalTransaction(
     PhabricatorLiskDAO $object,
     PhabricatorApplicationTransaction $xaction) {
 
     switch ($xaction->getTransactionType()) {
       case LegalpadTransactionType::TYPE_TITLE:
         $object->setTitle($xaction->getNewValue());
         $body = $object->getDocumentBody();
         $body->setTitle($xaction->getNewValue());
         $this->setIsContribution(true);
         break;
       case LegalpadTransactionType::TYPE_TEXT:
         $body = $object->getDocumentBody();
         $body->setText($xaction->getNewValue());
         $this->setIsContribution(true);
         break;
       case LegalpadTransactionType::TYPE_SIGNATURE_TYPE:
         $object->setSignatureType($xaction->getNewValue());
         break;
       case LegalpadTransactionType::TYPE_PREAMBLE:
         $object->setPreamble($xaction->getNewValue());
         break;
     }
   }
 
   protected function applyCustomExternalTransaction(
     PhabricatorLiskDAO $object,
     PhabricatorApplicationTransaction $xaction) {
     return;
   }
 
   protected function applyFinalEffects(
     PhabricatorLiskDAO $object,
     array $xactions) {
 
     if ($this->isContribution()) {
       $object->setVersions($object->getVersions() + 1);
       $body = $object->getDocumentBody();
       $body->setVersion($object->getVersions());
       $body->setDocumentPHID($object->getPHID());
       $body->save();
 
       $object->setDocumentBodyPHID($body->getPHID());
 
       $actor = $this->getActor();
       $type = PhabricatorEdgeConfig::TYPE_CONTRIBUTED_TO_OBJECT;
       id(new PhabricatorEdgeEditor())
         ->addEdge($actor->getPHID(), $type, $object->getPHID())
         ->save();
 
       $type = PhabricatorEdgeConfig::TYPE_OBJECT_HAS_CONTRIBUTOR;
       $contributors = PhabricatorEdgeQuery::loadDestinationPHIDs(
         $object->getPHID(),
         $type);
       $object->setRecentContributorPHIDs(array_slice($contributors, 0, 3));
       $object->setContributorCount(count($contributors));
 
       $object->save();
     }
 
     return $xactions;
   }
 
   protected function mergeTransactions(
     PhabricatorApplicationTransaction $u,
     PhabricatorApplicationTransaction $v) {
 
     $type = $u->getTransactionType();
     switch ($type) {
       case LegalpadTransactionType::TYPE_TITLE:
       case LegalpadTransactionType::TYPE_TEXT:
       case LegalpadTransactionType::TYPE_SIGNATURE_TYPE:
       case LegalpadTransactionType::TYPE_PREAMBLE:
         return $v;
     }
 
     return parent::mergeTransactions($u, $v);
   }
 
 /* -(  Sending Mail  )------------------------------------------------------- */
 
   protected function shouldSendMail(
     PhabricatorLiskDAO $object,
     array $xactions) {
     return true;
   }
 
   protected function buildReplyHandler(PhabricatorLiskDAO $object) {
     return id(new LegalpadReplyHandler())
       ->setMailReceiver($object);
   }
 
   protected function buildMailTemplate(PhabricatorLiskDAO $object) {
     $id = $object->getID();
     $phid = $object->getPHID();
     $title = $object->getDocumentBody()->getTitle();
 
     return id(new PhabricatorMetaMTAMail())
       ->setSubject("L{$id}: {$title}")
       ->addHeader('Thread-Topic', "L{$id}: {$phid}");
   }
 
   protected function getMailTo(PhabricatorLiskDAO $object) {
     return array(
       $object->getCreatorPHID(),
       $this->requireActor()->getPHID(),
     );
   }
 
   protected function shouldImplyCC(
     PhabricatorLiskDAO $object,
     PhabricatorApplicationTransaction $xaction) {
 
     switch ($xaction->getTransactionType()) {
       case LegalpadTransactionType::TYPE_TEXT:
       case LegalpadTransactionType::TYPE_TITLE:
       case LegalpadTransactionType::TYPE_PREAMBLE:
         return true;
     }
 
     return parent::shouldImplyCC($object, $xaction);
   }
 
   protected function buildMailBody(
     PhabricatorLiskDAO $object,
     array $xactions) {
 
     $body = parent::buildMailBody($object, $xactions);
 
-    $body->addTextSection(
+    $body->addLinkSection(
       pht('DOCUMENT DETAIL'),
       PhabricatorEnv::getProductionURI('/legalpad/view/'.$object->getID().'/'));
 
     return $body;
   }
 
   protected function getMailSubjectPrefix() {
     return PhabricatorEnv::getEnvConfig('metamta.legalpad.subject-prefix');
   }
 
 
   protected function shouldPublishFeedStory(
     PhabricatorLiskDAO $object,
     array $xactions) {
     return false;
   }
 
   protected function supportsSearch() {
     return false;
   }
 
 }
diff --git a/src/applications/macro/editor/PhabricatorMacroEditor.php b/src/applications/macro/editor/PhabricatorMacroEditor.php
index 09d4c99fb4..fe5259a1d2 100644
--- a/src/applications/macro/editor/PhabricatorMacroEditor.php
+++ b/src/applications/macro/editor/PhabricatorMacroEditor.php
@@ -1,192 +1,192 @@
 <?php
 
 final class PhabricatorMacroEditor
   extends PhabricatorApplicationTransactionEditor {
 
   public function getEditorApplicationClass() {
     return 'PhabricatorMacroApplication';
   }
 
   public function getEditorObjectsDescription() {
     return pht('Macros');
   }
 
   public function getTransactionTypes() {
     $types = parent::getTransactionTypes();
 
     $types[] = PhabricatorTransactions::TYPE_COMMENT;
     $types[] = PhabricatorMacroTransactionType::TYPE_NAME;
     $types[] = PhabricatorMacroTransactionType::TYPE_DISABLED;
     $types[] = PhabricatorMacroTransactionType::TYPE_FILE;
     $types[] = PhabricatorMacroTransactionType::TYPE_AUDIO;
     $types[] = PhabricatorMacroTransactionType::TYPE_AUDIO_BEHAVIOR;
 
     return $types;
   }
 
   protected function getCustomTransactionOldValue(
     PhabricatorLiskDAO $object,
     PhabricatorApplicationTransaction $xaction) {
 
     switch ($xaction->getTransactionType()) {
       case PhabricatorMacroTransactionType::TYPE_NAME:
         return $object->getName();
       case PhabricatorMacroTransactionType::TYPE_DISABLED:
         return $object->getIsDisabled();
       case PhabricatorMacroTransactionType::TYPE_FILE:
         return $object->getFilePHID();
       case PhabricatorMacroTransactionType::TYPE_AUDIO:
         return $object->getAudioPHID();
       case PhabricatorMacroTransactionType::TYPE_AUDIO_BEHAVIOR:
         return $object->getAudioBehavior();
     }
   }
 
   protected function getCustomTransactionNewValue(
     PhabricatorLiskDAO $object,
     PhabricatorApplicationTransaction $xaction) {
 
     switch ($xaction->getTransactionType()) {
       case PhabricatorMacroTransactionType::TYPE_NAME:
       case PhabricatorMacroTransactionType::TYPE_DISABLED:
       case PhabricatorMacroTransactionType::TYPE_FILE:
       case PhabricatorMacroTransactionType::TYPE_AUDIO:
       case PhabricatorMacroTransactionType::TYPE_AUDIO_BEHAVIOR:
         return $xaction->getNewValue();
     }
   }
 
   protected function applyCustomInternalTransaction(
     PhabricatorLiskDAO $object,
     PhabricatorApplicationTransaction $xaction) {
 
     switch ($xaction->getTransactionType()) {
       case PhabricatorMacroTransactionType::TYPE_NAME:
         $object->setName($xaction->getNewValue());
         break;
       case PhabricatorMacroTransactionType::TYPE_DISABLED:
         $object->setIsDisabled($xaction->getNewValue());
         break;
       case PhabricatorMacroTransactionType::TYPE_FILE:
         $object->setFilePHID($xaction->getNewValue());
         break;
       case PhabricatorMacroTransactionType::TYPE_AUDIO:
         $object->setAudioPHID($xaction->getNewValue());
         break;
       case PhabricatorMacroTransactionType::TYPE_AUDIO_BEHAVIOR:
         $object->setAudioBehavior($xaction->getNewValue());
         break;
     }
   }
 
   protected function applyCustomExternalTransaction(
     PhabricatorLiskDAO $object,
     PhabricatorApplicationTransaction $xaction) {
 
     switch ($xaction->getTransactionType()) {
       case PhabricatorMacroTransactionType::TYPE_FILE:
       case PhabricatorMacroTransactionType::TYPE_AUDIO:
         // When changing a macro's image or audio, attach the underlying files
         // to the macro (and detach the old files).
         $old = $xaction->getOldValue();
         $new = $xaction->getNewValue();
         $all = array();
         if ($old) {
           $all[] = $old;
         }
         if ($new) {
           $all[] = $new;
         }
 
         $files = id(new PhabricatorFileQuery())
           ->setViewer($this->requireActor())
           ->withPHIDs($all)
           ->execute();
         $files = mpull($files, null, 'getPHID');
 
         $old_file = idx($files, $old);
         if ($old_file) {
           $old_file->detachFromObject($object->getPHID());
         }
 
         $new_file = idx($files, $new);
         if ($new_file) {
           $new_file->attachToObject($object->getPHID());
         }
         break;
     }
   }
 
   protected function mergeTransactions(
     PhabricatorApplicationTransaction $u,
     PhabricatorApplicationTransaction $v) {
 
     $type = $u->getTransactionType();
     switch ($type) {
       case PhabricatorMacroTransactionType::TYPE_NAME:
       case PhabricatorMacroTransactionType::TYPE_DISABLED:
       case PhabricatorMacroTransactionType::TYPE_FILE:
       case PhabricatorMacroTransactionType::TYPE_AUDIO:
       case PhabricatorMacroTransactionType::TYPE_AUDIO_BEHAVIOR:
         return $v;
     }
 
     return parent::mergeTransactions($u, $v);
   }
 
   protected function shouldSendMail(
     PhabricatorLiskDAO $object,
     array $xactions) {
     foreach ($xactions as $xaction) {
       switch ($xaction->getTransactionType()) {
         case PhabricatorMacroTransactionType::TYPE_NAME;
           return ($xaction->getOldValue() !== null);
         default:
           break;
       }
     }
     return true;
   }
 
   protected function buildReplyHandler(PhabricatorLiskDAO $object) {
     return id(new PhabricatorMacroReplyHandler())
       ->setMailReceiver($object);
   }
 
   protected function buildMailTemplate(PhabricatorLiskDAO $object) {
     $name = $object->getName();
     $name = 'Image Macro "'.$name.'"';
 
     return id(new PhabricatorMetaMTAMail())
       ->setSubject($name)
       ->addHeader('Thread-Topic', $name);
   }
 
   protected function getMailTo(PhabricatorLiskDAO $object) {
     return array(
       $this->requireActor()->getPHID(),
     );
   }
 
   protected function buildMailBody(
     PhabricatorLiskDAO $object,
     array $xactions) {
 
     $body = parent::buildMailBody($object, $xactions);
-    $body->addTextSection(
+    $body->addLinkSection(
       pht('MACRO DETAIL'),
       PhabricatorEnv::getProductionURI('/macro/view/'.$object->getID().'/'));
 
     return $body;
   }
 
   protected function getMailSubjectPrefix() {
     return PhabricatorEnv::getEnvConfig('metamta.macro.subject-prefix');
   }
 
   protected function shouldPublishFeedStory(
     PhabricatorLiskDAO $object,
     array $xactions) {
     return true;
   }
 }
diff --git a/src/applications/maniphest/editor/ManiphestTransactionEditor.php b/src/applications/maniphest/editor/ManiphestTransactionEditor.php
index c2cd4455c8..1fb7d2ec52 100644
--- a/src/applications/maniphest/editor/ManiphestTransactionEditor.php
+++ b/src/applications/maniphest/editor/ManiphestTransactionEditor.php
@@ -1,687 +1,687 @@
 <?php
 
 final class ManiphestTransactionEditor
   extends PhabricatorApplicationTransactionEditor {
 
   private $heraldEmailPHIDs = array();
 
   public function getEditorApplicationClass() {
     return 'PhabricatorManiphestApplication';
   }
 
   public function getEditorObjectsDescription() {
     return pht('Maniphest Tasks');
   }
 
   public function getTransactionTypes() {
     $types = parent::getTransactionTypes();
 
     $types[] = PhabricatorTransactions::TYPE_COMMENT;
     $types[] = PhabricatorTransactions::TYPE_EDGE;
     $types[] = ManiphestTransaction::TYPE_PRIORITY;
     $types[] = ManiphestTransaction::TYPE_STATUS;
     $types[] = ManiphestTransaction::TYPE_TITLE;
     $types[] = ManiphestTransaction::TYPE_DESCRIPTION;
     $types[] = ManiphestTransaction::TYPE_OWNER;
     $types[] = ManiphestTransaction::TYPE_CCS;
     $types[] = ManiphestTransaction::TYPE_SUBPRIORITY;
     $types[] = ManiphestTransaction::TYPE_PROJECT_COLUMN;
     $types[] = ManiphestTransaction::TYPE_MERGED_INTO;
     $types[] = ManiphestTransaction::TYPE_MERGED_FROM;
     $types[] = ManiphestTransaction::TYPE_UNBLOCK;
     $types[] = PhabricatorTransactions::TYPE_VIEW_POLICY;
     $types[] = PhabricatorTransactions::TYPE_EDIT_POLICY;
 
     return $types;
   }
 
   protected function getCustomTransactionOldValue(
     PhabricatorLiskDAO $object,
     PhabricatorApplicationTransaction $xaction) {
 
     switch ($xaction->getTransactionType()) {
       case ManiphestTransaction::TYPE_PRIORITY:
         if ($this->getIsNewObject()) {
           return null;
         }
         return (int)$object->getPriority();
       case ManiphestTransaction::TYPE_STATUS:
         if ($this->getIsNewObject()) {
           return null;
         }
         return $object->getStatus();
       case ManiphestTransaction::TYPE_TITLE:
         if ($this->getIsNewObject()) {
           return null;
         }
         return $object->getTitle();
       case ManiphestTransaction::TYPE_DESCRIPTION:
         if ($this->getIsNewObject()) {
           return null;
         }
         return $object->getDescription();
       case ManiphestTransaction::TYPE_OWNER:
         return nonempty($object->getOwnerPHID(), null);
       case ManiphestTransaction::TYPE_CCS:
         return array_values(array_unique($object->getCCPHIDs()));
       case ManiphestTransaction::TYPE_PROJECT_COLUMN:
         // These are pre-populated.
         return $xaction->getOldValue();
       case ManiphestTransaction::TYPE_SUBPRIORITY:
         return $object->getSubpriority();
       case ManiphestTransaction::TYPE_MERGED_INTO:
       case ManiphestTransaction::TYPE_MERGED_FROM:
         return null;
     }
   }
 
   protected function getCustomTransactionNewValue(
     PhabricatorLiskDAO $object,
     PhabricatorApplicationTransaction $xaction) {
 
     switch ($xaction->getTransactionType()) {
       case ManiphestTransaction::TYPE_PRIORITY:
         return (int)$xaction->getNewValue();
       case ManiphestTransaction::TYPE_CCS:
         return array_values(array_unique($xaction->getNewValue()));
       case ManiphestTransaction::TYPE_OWNER:
         return nonempty($xaction->getNewValue(), null);
       case ManiphestTransaction::TYPE_STATUS:
       case ManiphestTransaction::TYPE_TITLE:
       case ManiphestTransaction::TYPE_DESCRIPTION:
       case ManiphestTransaction::TYPE_SUBPRIORITY:
       case ManiphestTransaction::TYPE_PROJECT_COLUMN:
       case ManiphestTransaction::TYPE_MERGED_INTO:
       case ManiphestTransaction::TYPE_MERGED_FROM:
       case ManiphestTransaction::TYPE_UNBLOCK:
         return $xaction->getNewValue();
     }
   }
 
   protected function transactionHasEffect(
     PhabricatorLiskDAO $object,
     PhabricatorApplicationTransaction $xaction) {
 
     $old = $xaction->getOldValue();
     $new = $xaction->getNewValue();
 
     switch ($xaction->getTransactionType()) {
       case ManiphestTransaction::TYPE_CCS:
         sort($old);
         sort($new);
         return ($old !== $new);
       case ManiphestTransaction::TYPE_PROJECT_COLUMN:
         $new_column_phids = $new['columnPHIDs'];
         $old_column_phids = $old['columnPHIDs'];
         sort($new_column_phids);
         sort($old_column_phids);
         return ($old !== $new);
     }
 
     return parent::transactionHasEffect($object, $xaction);
   }
 
   protected function applyCustomInternalTransaction(
     PhabricatorLiskDAO $object,
     PhabricatorApplicationTransaction $xaction) {
 
     switch ($xaction->getTransactionType()) {
       case ManiphestTransaction::TYPE_PRIORITY:
         return $object->setPriority($xaction->getNewValue());
       case ManiphestTransaction::TYPE_STATUS:
         return $object->setStatus($xaction->getNewValue());
       case ManiphestTransaction::TYPE_TITLE:
         return $object->setTitle($xaction->getNewValue());
       case ManiphestTransaction::TYPE_DESCRIPTION:
         return $object->setDescription($xaction->getNewValue());
       case ManiphestTransaction::TYPE_OWNER:
         $phid = $xaction->getNewValue();
 
         // Update the "ownerOrdering" column to contain the full name of the
         // owner, if the task is assigned.
 
         $handle = null;
         if ($phid) {
           $handle = id(new PhabricatorHandleQuery())
             ->setViewer($this->getActor())
             ->withPHIDs(array($phid))
             ->executeOne();
         }
 
         if ($handle) {
           $object->setOwnerOrdering($handle->getName());
         } else {
           $object->setOwnerOrdering(null);
         }
 
         return $object->setOwnerPHID($phid);
       case ManiphestTransaction::TYPE_CCS:
         return $object->setCCPHIDs($xaction->getNewValue());
       case ManiphestTransaction::TYPE_SUBPRIORITY:
         $data = $xaction->getNewValue();
         $new_sub = $this->getNextSubpriority(
           $data['newPriority'],
           $data['newSubpriorityBase'],
           $data['direction']);
         $object->setSubpriority($new_sub);
         return;
       case ManiphestTransaction::TYPE_PROJECT_COLUMN:
         // these do external (edge) updates
         return;
       case ManiphestTransaction::TYPE_MERGED_INTO:
         $object->setStatus(ManiphestTaskStatus::getDuplicateStatus());
         return;
       case ManiphestTransaction::TYPE_MERGED_FROM:
         return;
     }
   }
 
   protected function expandTransaction(
     PhabricatorLiskDAO $object,
     PhabricatorApplicationTransaction $xaction) {
 
     $xactions = parent::expandTransaction($object, $xaction);
     switch ($xaction->getTransactionType()) {
       case ManiphestTransaction::TYPE_SUBPRIORITY:
         $data = $xaction->getNewValue();
         $new_pri = $data['newPriority'];
         if ($new_pri != $object->getPriority()) {
           $xactions[] = id(new ManiphestTransaction())
             ->setTransactionType(ManiphestTransaction::TYPE_PRIORITY)
             ->setNewValue($new_pri);
         }
         break;
       default:
         break;
     }
 
     return $xactions;
   }
 
   protected function applyCustomExternalTransaction(
     PhabricatorLiskDAO $object,
     PhabricatorApplicationTransaction $xaction) {
 
     switch ($xaction->getTransactionType()) {
       case ManiphestTransaction::TYPE_PROJECT_COLUMN:
         $board_phid = idx($xaction->getNewValue(), 'projectPHID');
         if (!$board_phid) {
           throw new Exception(
             pht("Expected 'projectPHID' in column transaction."));
         }
 
         $old_phids = idx($xaction->getOldValue(), 'columnPHIDs', array());
         $new_phids = idx($xaction->getNewValue(), 'columnPHIDs', array());
         if (count($new_phids) !== 1) {
           throw new Exception(
             pht("Expected exactly one 'columnPHIDs' in column transaction."));
         }
 
         $columns = id(new PhabricatorProjectColumnQuery())
           ->setViewer($this->requireActor())
           ->withPHIDs($new_phids)
           ->execute();
         $columns = mpull($columns, null, 'getPHID');
 
         $positions = id(new PhabricatorProjectColumnPositionQuery())
           ->setViewer($this->requireActor())
           ->withObjectPHIDs(array($object->getPHID()))
           ->withBoardPHIDs(array($board_phid))
           ->execute();
 
         $before_phid = idx($xaction->getNewValue(), 'beforePHID');
         $after_phid = idx($xaction->getNewValue(), 'afterPHID');
 
         if (!$before_phid && !$after_phid && ($old_phids == $new_phids)) {
           // If we are not moving the object between columns and also not
           // reordering the position, this is a move on some other order
           // (like priority). We can leave the positions untouched and just
           // bail, there's no work to be done.
           return;
         }
 
         // Otherwise, we're either moving between columns or adjusting the
         // object's position in the "natural" ordering, so we do need to update
         // some rows.
 
         // Remove all existing column positions on the board.
 
         foreach ($positions as $position) {
           $position->delete();
         }
 
         // Add the new column positions.
 
         foreach ($new_phids as $phid) {
           $column = idx($columns, $phid);
           if (!$column) {
             throw new Exception(
               pht('No such column "%s" exists!', $phid));
           }
 
           // Load the other object positions in the column. Note that we must
           // skip implicit column creation to avoid generating a new position
           // if the target column is a backlog column.
 
           $other_positions = id(new PhabricatorProjectColumnPositionQuery())
             ->setViewer($this->requireActor())
             ->withColumns(array($column))
             ->withBoardPHIDs(array($board_phid))
             ->setSkipImplicitCreate(true)
             ->execute();
           $other_positions = msort($other_positions, 'getOrderingKey');
 
           // Set up the new position object. We're going to figure out the
           // right sequence number and then persist this object with that
           // sequence number.
           $new_position = id(new PhabricatorProjectColumnPosition())
             ->setBoardPHID($board_phid)
             ->setColumnPHID($column->getPHID())
             ->setObjectPHID($object->getPHID());
 
           $updates = array();
           $sequence = 0;
 
           // If we're just dropping this into the column without any specific
           // position information, put it at the top.
           if (!$before_phid && !$after_phid) {
             $new_position->setSequence($sequence)->save();
             $sequence++;
           }
 
           foreach ($other_positions as $position) {
             $object_phid = $position->getObjectPHID();
 
             // If this is the object we're moving before and we haven't
             // saved yet, insert here.
             if (($before_phid == $object_phid) && !$new_position->getID()) {
               $new_position->setSequence($sequence)->save();
               $sequence++;
             }
 
             // This object goes here in the sequence; we might need to update
             // the row.
             if ($sequence != $position->getSequence()) {
               $updates[$position->getID()] = $sequence;
             }
             $sequence++;
 
             // If this is the object we're moving after and we haven't saved
             // yet, insert here.
             if (($after_phid == $object_phid) && !$new_position->getID()) {
               $new_position->setSequence($sequence)->save();
               $sequence++;
             }
           }
 
           // We should have found a place to put it.
           if (!$new_position->getID()) {
             throw new Exception(
               pht('Unable to find a place to insert object on column!'));
           }
 
           // If we changed other objects' column positions, bulk reorder them.
 
           if ($updates) {
             $position = new PhabricatorProjectColumnPosition();
             $conn_w = $position->establishConnection('w');
 
             $pairs = array();
             foreach ($updates as $id => $sequence) {
               // This is ugly because MySQL gets upset with us if it is
               // configured strictly and we attempt inserts which can't work.
               // We'll never actually do these inserts since they'll always
               // collide (triggering the ON DUPLICATE KEY logic), so we just
               // provide dummy values in order to get there.
 
               $pairs[] = qsprintf(
                 $conn_w,
                 '(%d, %d, "", "", "")',
                 $id,
                 $sequence);
             }
 
             queryfx(
               $conn_w,
               'INSERT INTO %T (id, sequence, boardPHID, columnPHID, objectPHID)
                 VALUES %Q ON DUPLICATE KEY UPDATE sequence = VALUES(sequence)',
               $position->getTableName(),
               implode(', ', $pairs));
           }
         }
         break;
       default:
         break;
     }
   }
 
   protected function applyFinalEffects(
     PhabricatorLiskDAO $object,
     array $xactions) {
 
     // When we change the status of a task, update tasks this tasks blocks
     // with a message to the effect of "alincoln resolved blocking task Txxx."
     $unblock_xaction = null;
     foreach ($xactions as $xaction) {
       switch ($xaction->getTransactionType()) {
         case ManiphestTransaction::TYPE_STATUS:
           $unblock_xaction = $xaction;
           break;
       }
     }
 
     if ($unblock_xaction !== null) {
       $blocked_phids = PhabricatorEdgeQuery::loadDestinationPHIDs(
         $object->getPHID(),
         PhabricatorEdgeConfig::TYPE_TASK_DEPENDED_ON_BY_TASK);
       if ($blocked_phids) {
         // In theory we could apply these through policies, but that seems a
         // little bit surprising. For now, use the actor's vision.
         $blocked_tasks = id(new ManiphestTaskQuery())
           ->setViewer($this->getActor())
           ->withPHIDs($blocked_phids)
           ->execute();
 
         $old = $unblock_xaction->getOldValue();
         $new = $unblock_xaction->getNewValue();
 
         foreach ($blocked_tasks as $blocked_task) {
           $unblock_xactions = array();
 
           $unblock_xactions[] = id(new ManiphestTransaction())
             ->setTransactionType(ManiphestTransaction::TYPE_UNBLOCK)
             ->setOldValue(array($object->getPHID() => $old))
             ->setNewValue(array($object->getPHID() => $new));
 
           id(new ManiphestTransactionEditor())
             ->setActor($this->getActor())
             ->setActingAsPHID($this->getActingAsPHID())
             ->setContentSource($this->getContentSource())
             ->setContinueOnNoEffect(true)
             ->setContinueOnMissingFields(true)
             ->applyTransactions($blocked_task, $unblock_xactions);
         }
       }
     }
 
     return $xactions;
   }
 
   protected function shouldSendMail(
     PhabricatorLiskDAO $object,
     array $xactions) {
 
     $xactions = mfilter($xactions, 'shouldHide', true);
     return $xactions;
   }
 
   protected function getMailSubjectPrefix() {
     return PhabricatorEnv::getEnvConfig('metamta.maniphest.subject-prefix');
   }
 
   protected function getMailThreadID(PhabricatorLiskDAO $object) {
     return 'maniphest-task-'.$object->getPHID();
   }
 
   protected function getMailTo(PhabricatorLiskDAO $object) {
     return array(
       $object->getOwnerPHID(),
       $this->getActingAsPHID(),
     );
   }
 
   protected function getMailCC(PhabricatorLiskDAO $object) {
     $phids = array();
 
     foreach ($object->getCCPHIDs() as $phid) {
       $phids[] = $phid;
     }
 
     foreach (parent::getMailCC($object) as $phid) {
       $phids[] = $phid;
     }
 
     foreach ($this->heraldEmailPHIDs as $phid) {
       $phids[] = $phid;
     }
 
     return $phids;
   }
 
   public function getMailTagsMap() {
     return array(
       ManiphestTransaction::MAILTAG_STATUS =>
         pht("A task's status changes."),
       ManiphestTransaction::MAILTAG_OWNER =>
         pht("A task's owner changes."),
       ManiphestTransaction::MAILTAG_PRIORITY =>
         pht("A task's priority changes."),
       ManiphestTransaction::MAILTAG_CC =>
         pht("A task's subscribers change."),
       ManiphestTransaction::MAILTAG_PROJECTS =>
         pht("A task's associated projects change."),
       ManiphestTransaction::MAILTAG_UNBLOCK =>
         pht('One of the tasks a task is blocked by changes status.'),
       ManiphestTransaction::MAILTAG_COLUMN =>
         pht('A task is moved between columns on a workboard.'),
       ManiphestTransaction::MAILTAG_COMMENT =>
         pht('Someone comments on a task.'),
       ManiphestTransaction::MAILTAG_OTHER =>
         pht('Other task activity not listed above occurs.'),
     );
   }
 
   protected function buildReplyHandler(PhabricatorLiskDAO $object) {
     return id(new ManiphestReplyHandler())
       ->setMailReceiver($object);
   }
 
   protected function buildMailTemplate(PhabricatorLiskDAO $object) {
     $id = $object->getID();
     $title = $object->getTitle();
 
     return id(new PhabricatorMetaMTAMail())
       ->setSubject("T{$id}: {$title}")
       ->addHeader('Thread-Topic', "T{$id}: ".$object->getOriginalTitle());
   }
 
   protected function buildMailBody(
     PhabricatorLiskDAO $object,
     array $xactions) {
 
     $body = parent::buildMailBody($object, $xactions);
 
     if ($this->getIsNewObject()) {
       $body->addTextSection(
         pht('TASK DESCRIPTION'),
         $object->getDescription());
     }
 
-    $body->addTextSection(
+    $body->addLinkSection(
       pht('TASK DETAIL'),
       PhabricatorEnv::getProductionURI('/T'.$object->getID()));
 
     return $body;
   }
 
   protected function shouldPublishFeedStory(
     PhabricatorLiskDAO $object,
     array $xactions) {
     return $this->shouldSendMail($object, $xactions);
   }
 
   protected function supportsSearch() {
     return true;
   }
 
   protected function shouldApplyHeraldRules(
     PhabricatorLiskDAO $object,
     array $xactions) {
     return true;
   }
 
   protected function buildHeraldAdapter(
     PhabricatorLiskDAO $object,
     array $xactions) {
 
     return id(new HeraldManiphestTaskAdapter())
       ->setTask($object);
   }
 
   protected function didApplyHeraldRules(
     PhabricatorLiskDAO $object,
     HeraldAdapter $adapter,
     HeraldTranscript $transcript) {
 
     // TODO: Convert these to transactions. The way Maniphest deals with these
     // transactions is currently unconventional and messy.
 
     $save_again = false;
     $cc_phids = $adapter->getCcPHIDs();
     if ($cc_phids) {
       $existing_cc = $object->getCCPHIDs();
       $new_cc = array_unique(array_merge($cc_phids, $existing_cc));
       $object->setCCPHIDs($new_cc);
       $object->save();
     }
 
     $this->heraldEmailPHIDs = $adapter->getEmailPHIDs();
 
     $xactions = array();
 
     $assign_phid = $adapter->getAssignPHID();
     if ($assign_phid) {
       $xactions[] = id(new ManiphestTransaction())
         ->setTransactionType(ManiphestTransaction::TYPE_OWNER)
         ->setNewValue($assign_phid);
     }
 
     $project_phids = $adapter->getProjectPHIDs();
     if ($project_phids) {
       $project_type = PhabricatorProjectObjectHasProjectEdgeType::EDGECONST;
       $xactions[] = id(new ManiphestTransaction())
         ->setTransactionType(PhabricatorTransactions::TYPE_EDGE)
         ->setMetadataValue('edge:type', $project_type)
         ->setNewValue(
           array(
             '+' => array_fuse($project_phids),
           ));
     }
 
     return $xactions;
   }
 
   protected function requireCapabilities(
     PhabricatorLiskDAO $object,
     PhabricatorApplicationTransaction $xaction) {
 
     parent::requireCapabilities($object, $xaction);
 
     $app_capability_map = array(
       ManiphestTransaction::TYPE_PRIORITY =>
         ManiphestEditPriorityCapability::CAPABILITY,
       ManiphestTransaction::TYPE_STATUS =>
         ManiphestEditStatusCapability::CAPABILITY,
       ManiphestTransaction::TYPE_OWNER =>
         ManiphestEditAssignCapability::CAPABILITY,
       PhabricatorTransactions::TYPE_EDIT_POLICY =>
         ManiphestEditPoliciesCapability::CAPABILITY,
       PhabricatorTransactions::TYPE_VIEW_POLICY =>
         ManiphestEditPoliciesCapability::CAPABILITY,
     );
 
 
     $transaction_type = $xaction->getTransactionType();
 
     $app_capability = null;
     if ($transaction_type == PhabricatorTransactions::TYPE_EDGE) {
       switch ($xaction->getMetadataValue('edge:type')) {
         case PhabricatorProjectObjectHasProjectEdgeType::EDGECONST:
           $app_capability = ManiphestEditProjectsCapability::CAPABILITY;
           break;
       }
     } else {
       $app_capability = idx($app_capability_map, $transaction_type);
     }
 
     if ($app_capability) {
       $app = id(new PhabricatorApplicationQuery())
         ->setViewer($this->getActor())
         ->withClasses(array('PhabricatorManiphestApplication'))
         ->executeOne();
       PhabricatorPolicyFilter::requireCapability(
         $this->getActor(),
         $app,
         $app_capability);
     }
   }
 
   protected function adjustObjectForPolicyChecks(
     PhabricatorLiskDAO $object,
     array $xactions) {
 
     $copy = parent::adjustObjectForPolicyChecks($object, $xactions);
     foreach ($xactions as $xaction) {
       switch ($xaction->getTransactionType()) {
         case ManiphestTransaction::TYPE_OWNER:
           $copy->setOwnerPHID($xaction->getNewValue());
           break;
         default:
           continue;
       }
     }
 
     return $copy;
   }
 
   private function getNextSubpriority($pri, $sub, $dir = '>') {
     switch ($dir) {
       case '>':
         $order = 'ASC';
         break;
       case '<':
         $order = 'DESC';
         break;
       default:
         throw new Exception('$dir must be ">" or "<".');
         break;
     }
 
     if ($sub === null) {
       $base = 0;
     } else {
       $base = $sub;
     }
 
     if ($sub === null) {
       $next = id(new ManiphestTask())->loadOneWhere(
         'priority = %d ORDER BY subpriority %Q LIMIT 1',
         $pri,
         $order);
       if ($next) {
         if ($dir == '>') {
           return $next->getSubpriority() - ((double)(2 << 16));
         } else {
           return $next->getSubpriority() + ((double)(2 << 16));
         }
       }
     } else {
       $next = id(new ManiphestTask())->loadOneWhere(
         'priority = %d AND subpriority %Q %f ORDER BY subpriority %Q LIMIT 1',
         $pri,
         $dir,
         $sub,
         $order);
       if ($next) {
         return ($sub + $next->getSubpriority()) / 2;
       }
     }
 
     if ($dir == '>') {
       return $base + (double)(2 << 32);
     } else {
       return $base - (double)(2 << 32);
     }
   }
 
 }
diff --git a/src/applications/metamta/view/PhabricatorMetaMTAMailBody.php b/src/applications/metamta/view/PhabricatorMetaMTAMailBody.php
index e52b5c52c0..389549da7b 100644
--- a/src/applications/metamta/view/PhabricatorMetaMTAMailBody.php
+++ b/src/applications/metamta/view/PhabricatorMetaMTAMailBody.php
@@ -1,184 +1,190 @@
 <?php
 
 /**
  * Render the body of an application email by building it up section-by-section.
  *
  * @task compose  Composition
  * @task render   Rendering
  */
 final class PhabricatorMetaMTAMailBody {
 
   private $sections = array();
   private $htmlSections = array();
   private $attachments = array();
 
 
 /* -(  Composition  )-------------------------------------------------------- */
 
 
   /**
    * Add a raw block of text to the email. This will be rendered as-is.
    *
    * @param string Block of text.
    * @return this
    * @task compose
    */
   public function addRawSection($text) {
     if (strlen($text)) {
       $text = rtrim($text);
       $this->sections[] = $text;
       $this->htmlSections[] = phutil_escape_html_newlines(
         phutil_tag('div', array(), $text));
     }
     return $this;
   }
 
   public function addRawPlaintextSection($text) {
     if (strlen($text)) {
       $text = rtrim($text);
       $this->sections[] = $text;
     }
     return $this;
   }
 
   public function addRawHTMLSection($html) {
     $this->htmlSections[] = phutil_safe_html($html);
     return $this;
   }
 
 
   /**
    * Add a block of text with a section header. This is rendered like this:
    *
    *    HEADER
    *      Text is indented.
    *
    * @param string Header text.
    * @param string Section text.
    * @return this
    * @task compose
    */
   public function addTextSection($header, $section) {
     if ($section instanceof PhabricatorMetaMTAMailSection) {
       $plaintext = $section->getPlaintext();
       $html = $section->getHTML();
     } else {
       $plaintext = $section;
       $html = phutil_escape_html_newlines(phutil_tag('div', array(), $section));
     }
 
     $this->addPlaintextSection($header, $plaintext);
     $this->addHTMLSection($header, $html);
     return $this;
   }
 
   public function addPlaintextSection($header, $text) {
     $this->sections[] = $header."\n".$this->indent($text);
     return $this;
   }
 
   public function addHTMLSection($header, $html_fragment) {
     $this->htmlSections[] = array(
       phutil_tag('div', array('style' => 'font-weight:800;'), $header),
       $html_fragment,
     );
+    return $this;
+  }
 
+  public function addLinkSection($header, $link) {
+    $html = phutil_tag('a', array('href' => $link), $link);
+    $this->addPlaintextSection($header, $link);
+    $this->addHTMLSection($header, $html);
     return $this;
   }
 
   /**
    * Add a Herald section with a rule management URI and a transcript URI.
    *
    * @param string URI to rule transcripts.
    * @return this
    * @task compose
    */
   public function addHeraldSection($xscript_uri) {
     if (!PhabricatorEnv::getEnvConfig('metamta.herald.show-hints')) {
       return $this;
     }
 
-    $this->addTextSection(
+    $this->addLinkSection(
       pht('WHY DID I GET THIS EMAIL?'),
       PhabricatorEnv::getProductionURI($xscript_uri));
 
     return $this;
   }
 
 
   /**
    * Add a section with reply handler instructions.
    *
    * @param string Reply handler instructions.
    * @return this
    * @task compose
    */
   public function addReplySection($instructions) {
     if (!PhabricatorEnv::getEnvConfig('metamta.reply.show-hints')) {
       return $this;
     }
     if (!strlen($instructions)) {
       return $this;
     }
 
     $this->addTextSection(pht('REPLY HANDLER ACTIONS'), $instructions);
 
     return $this;
   }
 
 
   /**
    * Add an attachment.
    *
    * @param PhabricatorMetaMTAAttachment Attachment.
    * @return this
    * @task compose
    */
   public function addAttachment(PhabricatorMetaMTAAttachment $attachment) {
     $this->attachments[] = $attachment;
     return $this;
   }
 
 
 /* -(  Rendering  )---------------------------------------------------------- */
 
 
   /**
    * Render the email body.
    *
    * @return string Rendered body.
    * @task render
    */
   public function render() {
     return implode("\n\n", $this->sections)."\n";
   }
 
   public function renderHTML() {
     $br = phutil_tag('br');
     $body = phutil_implode_html($br, $this->htmlSections);
     return (string)hsprintf('%s', array($body, $br));
   }
 
   /**
    * Retrieve attachments.
    *
    * @return list<PhabricatorMetaMTAAttachment> Attachments.
    * @task render
    */
   public function getAttachments() {
     return $this->attachments;
   }
 
 
   /**
    * Indent a block of text for rendering under a section heading.
    *
    * @param string Text to indent.
    * @return string Indented text.
    * @task render
    */
   private function indent($text) {
     return rtrim("  ".str_replace("\n", "\n  ", $text));
   }
 
 }
diff --git a/src/applications/metamta/view/PhabricatorMetaMTAMailSection.php b/src/applications/metamta/view/PhabricatorMetaMTAMailSection.php
index 811b4c3127..701511dda2 100644
--- a/src/applications/metamta/view/PhabricatorMetaMTAMailSection.php
+++ b/src/applications/metamta/view/PhabricatorMetaMTAMailSection.php
@@ -1,40 +1,39 @@
 <?php
 /**
  * Helper for building a rendered section.
  *
  * @task compose  Composition
  * @task render   Rendering
  * @group metamta
  */
 
 final class PhabricatorMetaMTAMailSection {
   private $plaintextFragments = array();
   private $htmlFragments = array();
 
   public function getHTML() {
     return $this->htmlFragments;
   }
 
   public function getPlaintext() {
     return implode("\n", $this->plaintextFragments);
   }
 
   public function addHTMLFragment($fragment) {
     $this->htmlFragments[] = $fragment;
     return $this;
-
   }
 
   public function addPlaintextFragment($fragment) {
     $this->plaintextFragments[] = $fragment;
     return $this;
   }
 
   public function addFragment($fragment) {
     $this->plaintextFragments[] = $fragment;
     $this->htmlFragments[] =
       phutil_escape_html_newlines(phutil_tag('div', array(), $fragment));
 
     return $this;
   }
 }
diff --git a/src/applications/paste/editor/PhabricatorPasteEditor.php b/src/applications/paste/editor/PhabricatorPasteEditor.php
index 26c79147f1..6e038fe11d 100644
--- a/src/applications/paste/editor/PhabricatorPasteEditor.php
+++ b/src/applications/paste/editor/PhabricatorPasteEditor.php
@@ -1,187 +1,187 @@
 <?php
 
 final class PhabricatorPasteEditor
   extends PhabricatorApplicationTransactionEditor {
 
   private $pasteFile;
 
   public function getEditorApplicationClass() {
     return 'PhabricatorPasteApplication';
   }
 
   public function getEditorObjectsDescription() {
     return pht('Pastes');
   }
 
   public static function initializeFileForPaste(
     PhabricatorUser $actor,
     $name,
     $data) {
 
     return PhabricatorFile::newFromFileData(
       $data,
       array(
         'name' => $name,
         'mime-type' => 'text/plain; charset=utf-8',
         'authorPHID' => $actor->getPHID(),
         'viewPolicy' => PhabricatorPolicies::POLICY_NOONE,
       ));
   }
 
   public function getTransactionTypes() {
     $types = parent::getTransactionTypes();
 
     $types[] = PhabricatorPasteTransaction::TYPE_CONTENT;
     $types[] = PhabricatorPasteTransaction::TYPE_TITLE;
     $types[] = PhabricatorPasteTransaction::TYPE_LANGUAGE;
     $types[] = PhabricatorTransactions::TYPE_VIEW_POLICY;
     $types[] = PhabricatorTransactions::TYPE_COMMENT;
 
     return $types;
   }
 
   protected function getCustomTransactionOldValue(
     PhabricatorLiskDAO $object,
     PhabricatorApplicationTransaction $xaction) {
 
     switch ($xaction->getTransactionType()) {
       case PhabricatorPasteTransaction::TYPE_CONTENT:
         return $object->getFilePHID();
       case PhabricatorPasteTransaction::TYPE_TITLE:
         return $object->getTitle();
       case PhabricatorPasteTransaction::TYPE_LANGUAGE:
         return $object->getLanguage();
     }
   }
 
   protected function getCustomTransactionNewValue(
     PhabricatorLiskDAO $object,
     PhabricatorApplicationTransaction $xaction) {
 
     switch ($xaction->getTransactionType()) {
       case PhabricatorPasteTransaction::TYPE_CONTENT:
       case PhabricatorPasteTransaction::TYPE_TITLE:
       case PhabricatorPasteTransaction::TYPE_LANGUAGE:
         return $xaction->getNewValue();
     }
   }
 
   protected function applyCustomInternalTransaction(
     PhabricatorLiskDAO $object,
     PhabricatorApplicationTransaction $xaction) {
 
     switch ($xaction->getTransactionType()) {
       case PhabricatorPasteTransaction::TYPE_CONTENT:
         $object->setFilePHID($xaction->getNewValue());
         return;
       case PhabricatorPasteTransaction::TYPE_TITLE:
         $object->setTitle($xaction->getNewValue());
         return;
       case PhabricatorPasteTransaction::TYPE_LANGUAGE:
         $object->setLanguage($xaction->getNewValue());
         return;
       case PhabricatorTransactions::TYPE_VIEW_POLICY:
         $object->setViewPolicy($xaction->getNewValue());
         return;
       case PhabricatorTransactions::TYPE_COMMENT:
       case PhabricatorTransactions::TYPE_SUBSCRIBERS:
       case PhabricatorTransactions::TYPE_EDGE:
         return;
     }
 
     return parent::applyCustomInternalTransaction($object, $xaction);
   }
 
   protected function applyCustomExternalTransaction(
     PhabricatorLiskDAO $object,
     PhabricatorApplicationTransaction $xaction) {
 
     switch ($xaction->getTransactionType()) {
       case PhabricatorPasteTransaction::TYPE_CONTENT:
       case PhabricatorPasteTransaction::TYPE_TITLE:
       case PhabricatorPasteTransaction::TYPE_LANGUAGE:
       case PhabricatorTransactions::TYPE_VIEW_POLICY:
       case PhabricatorTransactions::TYPE_COMMENT:
       case PhabricatorTransactions::TYPE_SUBSCRIBERS:
       case PhabricatorTransactions::TYPE_EDGE:
         return;
     }
 
     return parent::applyCustomExternalTransaction($object, $xaction);
   }
 
   protected function extractFilePHIDsFromCustomTransaction(
     PhabricatorLiskDAO $object,
     PhabricatorApplicationTransaction $xaction) {
 
     switch ($xaction->getTransactionType()) {
       case PhabricatorPasteTransaction::TYPE_CONTENT:
         return array($xaction->getNewValue());
     }
 
     return parent::extractFilePHIDsFromCustomTransaction($object, $xaction);
   }
 
   protected function shouldSendMail(
     PhabricatorLiskDAO $object,
     array $xactions) {
     foreach ($xactions as $xaction) {
       switch ($xaction->getTransactionType()) {
         case PhabricatorPasteTransaction::TYPE_CONTENT:
           return false;
         default:
           break;
       }
     }
     return true;
   }
 
   protected function getMailSubjectPrefix() {
     return PhabricatorEnv::getEnvConfig('metamta.paste.subject-prefix');
   }
 
   protected function getMailTo(PhabricatorLiskDAO $object) {
     return array(
       $object->getAuthorPHID(),
       $this->requireActor()->getPHID(),
     );
   }
 
   protected function buildReplyHandler(PhabricatorLiskDAO $object) {
     return id(new PasteReplyHandler())
       ->setMailReceiver($object);
   }
 
   protected function buildMailTemplate(PhabricatorLiskDAO $object) {
     $id = $object->getID();
     $name = $object->getTitle();
 
     return id(new PhabricatorMetaMTAMail())
       ->setSubject("P{$id}: {$name}")
       ->addHeader('Thread-Topic', "P{$id}");
   }
 
   protected function buildMailBody(
     PhabricatorLiskDAO $object,
     array $xactions) {
 
     $body = parent::buildMailBody($object, $xactions);
 
-    $body->addTextSection(
+    $body->addLinkSection(
       pht('PASTE DETAIL'),
       PhabricatorEnv::getProductionURI('/P'.$object->getID()));
 
     return $body;
   }
 
   protected function shouldPublishFeedStory(
     PhabricatorLiskDAO $object,
     array $xactions) {
     return true;
   }
 
   protected function supportsSearch() {
     return false;
   }
 
 }
diff --git a/src/applications/pholio/editor/PholioMockEditor.php b/src/applications/pholio/editor/PholioMockEditor.php
index 9c49e39d52..7ba95455b5 100644
--- a/src/applications/pholio/editor/PholioMockEditor.php
+++ b/src/applications/pholio/editor/PholioMockEditor.php
@@ -1,507 +1,507 @@
 <?php
 
 final class PholioMockEditor extends PhabricatorApplicationTransactionEditor {
 
   private $newImages = array();
 
   public function getEditorApplicationClass() {
     return 'PhabricatorPholioApplication';
   }
 
   public function getEditorObjectsDescription() {
     return pht('Pholio Mocks');
   }
 
   private function setNewImages(array $new_images) {
     assert_instances_of($new_images, 'PholioImage');
     $this->newImages = $new_images;
     return $this;
   }
   private function getNewImages() {
     return $this->newImages;
   }
 
   public function getTransactionTypes() {
     $types = parent::getTransactionTypes();
 
     $types[] = PhabricatorTransactions::TYPE_EDGE;
     $types[] = PhabricatorTransactions::TYPE_COMMENT;
     $types[] = PhabricatorTransactions::TYPE_VIEW_POLICY;
     $types[] = PhabricatorTransactions::TYPE_EDIT_POLICY;
 
     $types[] = PholioTransactionType::TYPE_NAME;
     $types[] = PholioTransactionType::TYPE_DESCRIPTION;
     $types[] = PholioTransactionType::TYPE_STATUS;
     $types[] = PholioTransactionType::TYPE_INLINE;
 
     $types[] = PholioTransactionType::TYPE_IMAGE_FILE;
     $types[] = PholioTransactionType::TYPE_IMAGE_NAME;
     $types[] = PholioTransactionType::TYPE_IMAGE_DESCRIPTION;
     $types[] = PholioTransactionType::TYPE_IMAGE_REPLACE;
     $types[] = PholioTransactionType::TYPE_IMAGE_SEQUENCE;
 
     return $types;
   }
 
   protected function getCustomTransactionOldValue(
     PhabricatorLiskDAO $object,
     PhabricatorApplicationTransaction $xaction) {
 
     switch ($xaction->getTransactionType()) {
       case PholioTransactionType::TYPE_NAME:
         return $object->getName();
       case PholioTransactionType::TYPE_DESCRIPTION:
         return $object->getDescription();
       case PholioTransactionType::TYPE_STATUS:
         return $object->getStatus();
       case PholioTransactionType::TYPE_IMAGE_FILE:
         $images = $object->getImages();
         return mpull($images, 'getPHID');
       case PholioTransactionType::TYPE_IMAGE_NAME:
         $name = null;
         $phid = null;
         $image = $this->getImageForXaction($object, $xaction);
         if ($image) {
           $name = $image->getName();
           $phid = $image->getPHID();
         }
         return array($phid => $name);
       case PholioTransactionType::TYPE_IMAGE_DESCRIPTION:
         $description = null;
         $phid = null;
         $image = $this->getImageForXaction($object, $xaction);
         if ($image) {
           $description = $image->getDescription();
           $phid = $image->getPHID();
         }
         return array($phid => $description);
       case PholioTransactionType::TYPE_IMAGE_REPLACE:
         $raw = $xaction->getNewValue();
         return $raw->getReplacesImagePHID();
       case PholioTransactionType::TYPE_IMAGE_SEQUENCE:
         $sequence = null;
         $phid = null;
         $image = $this->getImageForXaction($object, $xaction);
         if ($image) {
           $sequence = $image->getSequence();
           $phid = $image->getPHID();
         }
         return array($phid => $sequence);
     }
   }
 
   protected function getCustomTransactionNewValue(
     PhabricatorLiskDAO $object,
     PhabricatorApplicationTransaction $xaction) {
 
     switch ($xaction->getTransactionType()) {
       case PholioTransactionType::TYPE_NAME:
       case PholioTransactionType::TYPE_DESCRIPTION:
       case PholioTransactionType::TYPE_STATUS:
       case PholioTransactionType::TYPE_IMAGE_NAME:
       case PholioTransactionType::TYPE_IMAGE_DESCRIPTION:
       case PholioTransactionType::TYPE_IMAGE_SEQUENCE:
         return $xaction->getNewValue();
       case PholioTransactionType::TYPE_IMAGE_REPLACE:
         $raw = $xaction->getNewValue();
         return $raw->getPHID();
       case PholioTransactionType::TYPE_IMAGE_FILE:
         $raw_new_value = $xaction->getNewValue();
         $new_value = array();
         foreach ($raw_new_value as $key => $images) {
           $new_value[$key] = mpull($images, 'getPHID');
         }
         $xaction->setNewValue($new_value);
         return $this->getPHIDTransactionNewValue($xaction);
     }
   }
 
   protected function extractFilePHIDsFromCustomTransaction(
     PhabricatorLiskDAO $object,
     PhabricatorApplicationTransaction $xaction) {
 
     switch ($xaction->getTransactionType()) {
       case PholioTransactionType::TYPE_IMAGE_FILE:
         $new = $xaction->getNewValue();
         $phids = array();
         foreach ($new as $key => $images) {
           $phids[] = mpull($images, 'getFilePHID');
         }
         return array_mergev($phids);
       case PholioTransactionType::TYPE_IMAGE_REPLACE:
         return array($xaction->getNewValue()->getFilePHID());
     }
 
     return array();
   }
 
 
   protected function transactionHasEffect(
     PhabricatorLiskDAO $object,
     PhabricatorApplicationTransaction $xaction) {
 
     switch ($xaction->getTransactionType()) {
       case PholioTransactionType::TYPE_INLINE:
         return true;
     }
 
     return parent::transactionHasEffect($object, $xaction);
   }
 
   protected function shouldApplyInitialEffects(
     PhabricatorLiskDAO $object,
     array $xactions) {
 
     foreach ($xactions as $xaction) {
       switch ($xaction->getTransactionType()) {
         case PholioTransactionType::TYPE_IMAGE_FILE:
         case PholioTransactionType::TYPE_IMAGE_REPLACE:
           return true;
           break;
       }
     }
     return false;
   }
 
   protected function applyInitialEffects(
     PhabricatorLiskDAO $object,
     array $xactions) {
 
     $new_images = array();
     foreach ($xactions as $xaction) {
       switch ($xaction->getTransactionType()) {
         case PholioTransactionType::TYPE_IMAGE_FILE:
           $new_value = $xaction->getNewValue();
           foreach ($new_value as $key => $txn_images) {
             if ($key != '+') {
               continue;
             }
             foreach ($txn_images as $image) {
               $image->save();
               $new_images[] = $image;
             }
           }
           break;
         case PholioTransactionType::TYPE_IMAGE_REPLACE:
           $image = $xaction->getNewValue();
           $image->save();
           $new_images[] = $image;
           break;
       }
     }
     $this->setNewImages($new_images);
   }
 
   protected function applyCustomInternalTransaction(
     PhabricatorLiskDAO $object,
     PhabricatorApplicationTransaction $xaction) {
 
     switch ($xaction->getTransactionType()) {
       case PholioTransactionType::TYPE_NAME:
         $object->setName($xaction->getNewValue());
         if ($object->getOriginalName() === null) {
           $object->setOriginalName($xaction->getNewValue());
         }
         break;
       case PholioTransactionType::TYPE_DESCRIPTION:
         $object->setDescription($xaction->getNewValue());
         break;
       case PholioTransactionType::TYPE_STATUS:
         $object->setStatus($xaction->getNewValue());
         break;
       case PhabricatorTransactions::TYPE_EDGE:
         return;
     }
   }
 
   private function getImageForXaction(
     PholioMock $mock,
     PhabricatorApplicationTransaction $xaction) {
     $raw_new_value = $xaction->getNewValue();
     $image_phid = key($raw_new_value);
     $images = $mock->getImages();
     foreach ($images as $image) {
       if ($image->getPHID() == $image_phid) {
         return $image;
       }
     }
     return null;
   }
 
   protected function applyCustomExternalTransaction(
     PhabricatorLiskDAO $object,
     PhabricatorApplicationTransaction $xaction) {
 
     switch ($xaction->getTransactionType()) {
       case PholioTransactionType::TYPE_IMAGE_FILE:
         $old_map = array_fuse($xaction->getOldValue());
         $new_map = array_fuse($xaction->getNewValue());
 
         $obsolete_map = array_diff_key($old_map, $new_map);
         $images = $object->getImages();
         foreach ($images as $seq => $image) {
           if (isset($obsolete_map[$image->getPHID()])) {
             $image->setIsObsolete(1);
             $image->save();
             unset($images[$seq]);
           }
         }
         $object->attachImages($images);
         break;
       case PholioTransactionType::TYPE_IMAGE_REPLACE:
         $old = $xaction->getOldValue();
         $images = $object->getImages();
         foreach ($images as $seq => $image) {
           if ($image->getPHID() == $old) {
             $image->setIsObsolete(1);
             $image->save();
             unset($images[$seq]);
           }
         }
         $object->attachImages($images);
         break;
       case PholioTransactionType::TYPE_IMAGE_NAME:
         $image = $this->getImageForXaction($object, $xaction);
         $value = (string) head($xaction->getNewValue());
         $image->setName($value);
         $image->save();
         break;
       case PholioTransactionType::TYPE_IMAGE_DESCRIPTION:
         $image = $this->getImageForXaction($object, $xaction);
         $value = (string) head($xaction->getNewValue());
         $image->setDescription($value);
         $image->save();
         break;
       case PholioTransactionType::TYPE_IMAGE_SEQUENCE:
         $image = $this->getImageForXaction($object, $xaction);
         $value = (int) head($xaction->getNewValue());
         $image->setSequence($value);
         $image->save();
         break;
       case PhabricatorTransactions::TYPE_EDGE:
         return;
     }
   }
 
   protected function applyFinalEffects(
     PhabricatorLiskDAO $object,
     array $xactions) {
 
     $images = $this->getNewImages();
     foreach ($images as $image) {
       $image->setMockID($object->getID());
       $image->save();
     }
 
     return $xactions;
   }
 
   protected function mergeTransactions(
     PhabricatorApplicationTransaction $u,
     PhabricatorApplicationTransaction $v) {
 
     $type = $u->getTransactionType();
     switch ($type) {
       case PholioTransactionType::TYPE_NAME:
       case PholioTransactionType::TYPE_DESCRIPTION:
       case PholioTransactionType::TYPE_STATUS:
         return $v;
       case PholioTransactionType::TYPE_IMAGE_REPLACE:
         $u_img = $u->getNewValue();
         $v_img = $v->getNewValue();
         if ($u_img->getReplacesImagePHID() == $v_img->getReplacesImagePHID()) {
           return $v;
         }
         break;
       case PholioTransactionType::TYPE_IMAGE_FILE:
         return $this->mergePHIDOrEdgeTransactions($u, $v);
       case PholioTransactionType::TYPE_IMAGE_NAME:
       case PholioTransactionType::TYPE_IMAGE_DESCRIPTION:
       case PholioTransactionType::TYPE_IMAGE_SEQUENCE:
         $raw_new_value_u = $u->getNewValue();
         $raw_new_value_v = $v->getNewValue();
         $phid_u = key($raw_new_value_u);
         $phid_v = key($raw_new_value_v);
         if ($phid_u == $phid_v) {
           return $v;
         }
         break;
     }
 
     return parent::mergeTransactions($u, $v);
   }
 
   protected function shouldSendMail(
     PhabricatorLiskDAO $object,
     array $xactions) {
     return true;
   }
 
   protected function buildReplyHandler(PhabricatorLiskDAO $object) {
     return id(new PholioReplyHandler())
       ->setMailReceiver($object);
   }
 
   protected function buildMailTemplate(PhabricatorLiskDAO $object) {
     $id = $object->getID();
     $name = $object->getName();
     $original_name = $object->getOriginalName();
 
     return id(new PhabricatorMetaMTAMail())
       ->setSubject("M{$id}: {$name}")
       ->addHeader('Thread-Topic', "M{$id}: {$original_name}");
   }
 
   protected function getMailTo(PhabricatorLiskDAO $object) {
     return array(
       $object->getAuthorPHID(),
       $this->requireActor()->getPHID(),
     );
   }
 
   protected function buildMailBody(
     PhabricatorLiskDAO $object,
     array $xactions) {
 
     $body = new PhabricatorMetaMTAMailBody();
     $headers = array();
     $comments = array();
     $inline_comments = array();
 
     foreach ($xactions as $xaction) {
       if ($xaction->shouldHide()) {
         continue;
       }
       $comment = $xaction->getComment();
       switch ($xaction->getTransactionType()) {
         case PholioTransactionType::TYPE_INLINE:
           if ($comment && strlen($comment->getContent())) {
             $inline_comments[] = $comment;
           }
           break;
         case PhabricatorTransactions::TYPE_COMMENT:
           if ($comment && strlen($comment->getContent())) {
             $comments[] = $comment->getContent();
           }
         // fallthrough
         default:
           $headers[] = id(clone $xaction)
             ->setRenderingTarget('text')
             ->getTitle();
           break;
       }
     }
 
     $body->addRawSection(implode("\n", $headers));
 
     foreach ($comments as $comment) {
       $body->addRawSection($comment);
     }
 
     if ($inline_comments) {
       $body->addRawSection(pht('INLINE COMMENTS'));
       foreach ($inline_comments as $comment) {
         $text = pht(
           'Image %d: %s',
           $comment->getImageID(),
           $comment->getContent());
         $body->addRawSection($text);
       }
     }
 
-    $body->addTextSection(
+    $body->addLinkSection(
       pht('MOCK DETAIL'),
       PhabricatorEnv::getProductionURI('/M'.$object->getID()));
 
     return $body;
   }
 
   protected function getMailSubjectPrefix() {
     return PhabricatorEnv::getEnvConfig('metamta.pholio.subject-prefix');
   }
 
   public function getMailTagsMap() {
     return array(
       MetaMTANotificationType::TYPE_PHOLIO_STATUS =>
         pht("A mock's status changes."),
       MetaMTANotificationType::TYPE_PHOLIO_COMMENT =>
         pht('Someone comments on a mock.'),
       MetaMTANotificationType::TYPE_PHOLIO_UPDATED =>
         pht('Mock images or descriptions change.'),
       MetaMTANotificationType::TYPE_PHOLIO_OTHER =>
         pht('Other mock activity not listed above occurs.'),
     );
   }
 
   protected function shouldPublishFeedStory(
     PhabricatorLiskDAO $object,
     array $xactions) {
     return true;
   }
 
   protected function supportsSearch() {
     return true;
   }
 
   protected function shouldApplyHeraldRules(
     PhabricatorLiskDAO $object,
     array $xactions) {
     return true;
   }
 
   protected function buildHeraldAdapter(
     PhabricatorLiskDAO $object,
     array $xactions) {
 
     return id(new HeraldPholioMockAdapter())
       ->setMock($object);
   }
 
   protected function didApplyHeraldRules(
     PhabricatorLiskDAO $object,
     HeraldAdapter $adapter,
     HeraldTranscript $transcript) {
 
     $xactions = array();
 
     $cc_phids = $adapter->getCcPHIDs();
     if ($cc_phids) {
       $value = array_fuse($cc_phids);
       $xactions[] = id(new PholioTransaction())
         ->setTransactionType(PhabricatorTransactions::TYPE_SUBSCRIBERS)
         ->setNewValue(array('+' => $value));
     }
 
     return $xactions;
   }
 
   protected function sortTransactions(array $xactions) {
     $head = array();
     $tail = array();
 
     // Move inline comments to the end, so the comments precede them.
     foreach ($xactions as $xaction) {
       $type = $xaction->getTransactionType();
       if ($type == PholioTransactionType::TYPE_INLINE) {
         $tail[] = $xaction;
       } else {
         $head[] = $xaction;
       }
     }
 
     return array_values(array_merge($head, $tail));
   }
 
   protected function shouldImplyCC(
     PhabricatorLiskDAO $object,
     PhabricatorApplicationTransaction $xaction) {
 
     switch ($xaction->getTransactionType()) {
       case PholioTransactionType::TYPE_INLINE:
         return true;
     }
 
     return parent::shouldImplyCC($object, $xaction);
   }
 
 }
diff --git a/src/applications/phortune/editor/PhortuneCartEditor.php b/src/applications/phortune/editor/PhortuneCartEditor.php
index 716d00727c..fb39102624 100644
--- a/src/applications/phortune/editor/PhortuneCartEditor.php
+++ b/src/applications/phortune/editor/PhortuneCartEditor.php
@@ -1,167 +1,167 @@
 <?php
 
 final class PhortuneCartEditor
   extends PhabricatorApplicationTransactionEditor {
 
   public function getEditorApplicationClass() {
     return 'PhabricatorPhortuneApplication';
   }
 
   public function getEditorObjectsDescription() {
     return pht('Phortune Carts');
   }
 
   public function getTransactionTypes() {
     $types = parent::getTransactionTypes();
 
     $types[] = PhortuneCartTransaction::TYPE_CREATED;
     $types[] = PhortuneCartTransaction::TYPE_PURCHASED;
     $types[] = PhortuneCartTransaction::TYPE_HOLD;
     $types[] = PhortuneCartTransaction::TYPE_REVIEW;
     $types[] = PhortuneCartTransaction::TYPE_CANCEL;
     $types[] = PhortuneCartTransaction::TYPE_REFUND;
 
     return $types;
   }
 
   protected function getCustomTransactionOldValue(
     PhabricatorLiskDAO $object,
     PhabricatorApplicationTransaction $xaction) {
 
     switch ($xaction->getTransactionType()) {
       case PhortuneCartTransaction::TYPE_CREATED:
       case PhortuneCartTransaction::TYPE_PURCHASED:
       case PhortuneCartTransaction::TYPE_HOLD:
       case PhortuneCartTransaction::TYPE_REVIEW:
       case PhortuneCartTransaction::TYPE_CANCEL:
       case PhortuneCartTransaction::TYPE_REFUND:
         return null;
     }
 
     return parent::getCustomTransactionOldValue($object, $xaction);
   }
 
   protected function getCustomTransactionNewValue(
     PhabricatorLiskDAO $object,
     PhabricatorApplicationTransaction $xaction) {
 
     switch ($xaction->getTransactionType()) {
       case PhortuneCartTransaction::TYPE_CREATED:
       case PhortuneCartTransaction::TYPE_PURCHASED:
       case PhortuneCartTransaction::TYPE_HOLD:
       case PhortuneCartTransaction::TYPE_REVIEW:
       case PhortuneCartTransaction::TYPE_CANCEL:
       case PhortuneCartTransaction::TYPE_REFUND:
         return $xaction->getNewValue();
     }
 
     return parent::getCustomTransactionNewValue($object, $xaction);
   }
 
   protected function applyCustomInternalTransaction(
     PhabricatorLiskDAO $object,
     PhabricatorApplicationTransaction $xaction) {
 
     switch ($xaction->getTransactionType()) {
       case PhortuneCartTransaction::TYPE_CREATED:
       case PhortuneCartTransaction::TYPE_PURCHASED:
       case PhortuneCartTransaction::TYPE_HOLD:
       case PhortuneCartTransaction::TYPE_REVIEW:
       case PhortuneCartTransaction::TYPE_CANCEL:
       case PhortuneCartTransaction::TYPE_REFUND:
         return;
     }
 
     return parent::applyCustomInternalTransaction($object, $xaction);
   }
 
   protected function applyCustomExternalTransaction(
     PhabricatorLiskDAO $object,
     PhabricatorApplicationTransaction $xaction) {
 
     switch ($xaction->getTransactionType()) {
       case PhortuneCartTransaction::TYPE_CREATED:
       case PhortuneCartTransaction::TYPE_PURCHASED:
       case PhortuneCartTransaction::TYPE_HOLD:
       case PhortuneCartTransaction::TYPE_REVIEW:
       case PhortuneCartTransaction::TYPE_CANCEL:
       case PhortuneCartTransaction::TYPE_REFUND:
         return;
     }
 
     return parent::applyCustomExternalTransaction($object, $xaction);
   }
 
   protected function shouldSendMail(
     PhabricatorLiskDAO $object,
     array $xactions) {
     return true;
   }
 
   protected function buildMailTemplate(PhabricatorLiskDAO $object) {
     $id = $object->getID();
     $name = $object->getName();
 
     return id(new PhabricatorMetaMTAMail())
       ->setSubject(pht('Order %d: %s', $id, $name))
       ->addHeader('Thread-Topic', pht('Order %s', $id));
   }
 
   protected function buildMailBody(
     PhabricatorLiskDAO $object,
     array $xactions) {
 
     $body = parent::buildMailBody($object, $xactions);
 
     $items = array();
     foreach ($object->getPurchases() as $purchase) {
       $name = $purchase->getFullDisplayName();
       $price = $purchase->getTotalPriceAsCurrency()->formatForDisplay();
 
       $items[] = "{$name} {$price}";
     }
 
     $body->addTextSection(pht('ORDER CONTENTS'), implode("\n", $items));
 
-    $body->addTextSection(
+    $body->addLinkSection(
       pht('ORDER DETAIL'),
       PhabricatorEnv::getProductionURI('/phortune/cart/'.$object->getID().'/'));
 
     return $body;
   }
 
   protected function getMailTo(PhabricatorLiskDAO $object) {
     $phids = array();
 
     // Relaod the cart to pull merchant and account information, in case we
     // just created the object.
     $cart = id(new PhortuneCartQuery())
       ->setViewer($this->requireActor())
       ->withPHIDs(array($object->getPHID()))
       ->executeOne();
 
     foreach ($cart->getAccount()->getMemberPHIDs() as $account_member) {
       $phids[] = $account_member;
     }
 
     foreach ($cart->getMerchant()->getMemberPHIDs() as $merchant_member) {
       $phids[] = $merchant_member;
     }
 
     return $phids;
   }
 
   protected function getMailCC(PhabricatorLiskDAO $object) {
     return array();
   }
 
   protected function getMailSubjectPrefix() {
     return 'Order';
   }
 
   protected function buildReplyHandler(PhabricatorLiskDAO $object) {
     return id(new PhortuneCartReplyHandler())
       ->setMailReceiver($object);
   }
 
 }
diff --git a/src/applications/phriction/editor/PhrictionTransactionEditor.php b/src/applications/phriction/editor/PhrictionTransactionEditor.php
index c857ff979d..546abc3979 100644
--- a/src/applications/phriction/editor/PhrictionTransactionEditor.php
+++ b/src/applications/phriction/editor/PhrictionTransactionEditor.php
@@ -1,298 +1,298 @@
 <?php
 
 final class PhrictionTransactionEditor
   extends PhabricatorApplicationTransactionEditor {
 
   private $description;
   private $oldContent;
   private $newContent;
 
   public function setDescription($description) {
     $this->description = $description;
     return $this;
   }
 
   private function getDescription() {
     return $this->description;
   }
 
   private function setOldContent(PhrictionContent $content) {
     $this->oldContent = $content;
     return $this;
   }
 
   private function getOldContent() {
     return $this->oldContent;
   }
 
   private function setNewContent(PhrictionContent $content) {
     $this->newContent = $content;
     return $this;
   }
 
   private function getNewContent() {
     return $this->newContent;
   }
 
   public function getEditorApplicationClass() {
     return 'PhabricatorPhrictionApplication';
   }
 
   public function getEditorObjectsDescription() {
     return pht('Phriction Documents');
   }
 
   public function getTransactionTypes() {
     $types = parent::getTransactionTypes();
 
     $types[] = PhabricatorTransactions::TYPE_COMMENT;
     $types[] = PhrictionTransaction::TYPE_TITLE;
     $types[] = PhrictionTransaction::TYPE_CONTENT;
 
     /* TODO
     $types[] = PhabricatorTransactions::TYPE_VIEW_POLICY;
     $types[] = PhabricatorTransactions::TYPE_EDIT_POLICY;
      */
 
     return $types;
   }
 
   protected function getCustomTransactionOldValue(
     PhabricatorLiskDAO $object,
     PhabricatorApplicationTransaction $xaction) {
 
     switch ($xaction->getTransactionType()) {
       case PhrictionTransaction::TYPE_TITLE:
         if ($this->getIsNewObject()) {
           return null;
         }
         return $this->getOldContent()->getTitle();
       case PhrictionTransaction::TYPE_CONTENT:
         if ($this->getIsNewObject()) {
           return null;
         }
         return $this->getOldContent()->getContent();
     }
   }
 
   protected function getCustomTransactionNewValue(
     PhabricatorLiskDAO $object,
     PhabricatorApplicationTransaction $xaction) {
 
     switch ($xaction->getTransactionType()) {
       case PhrictionTransaction::TYPE_TITLE:
       case PhrictionTransaction::TYPE_CONTENT:
         return $xaction->getNewValue();
     }
   }
 
   protected function shouldApplyInitialEffects(
     PhabricatorLiskDAO $object,
     array $xactions) {
 
     foreach ($xactions as $xaction) {
       switch ($xaction->getTransactionType()) {
       case PhrictionTransaction::TYPE_TITLE:
       case PhrictionTransaction::TYPE_CONTENT:
         return true;
       }
     }
     return parent::shouldApplyInitialEffects($object, $xactions);
   }
 
   protected function applyInitialEffects(
     PhabricatorLiskDAO $object,
     array $xactions) {
 
     $this->setOldContent($object->getContent());
     $this->setNewContent($this->buildNewContentTemplate($object));
   }
 
   protected function applyCustomInternalTransaction(
     PhabricatorLiskDAO $object,
     PhabricatorApplicationTransaction $xaction) {
 
     switch ($xaction->getTransactionType()) {
       case PhrictionTransaction::TYPE_TITLE:
       case PhrictionTransaction::TYPE_CONTENT:
         $object->setStatus(PhrictionDocumentStatus::STATUS_EXISTS);
         return;
     }
   }
 
   protected function applyCustomExternalTransaction(
     PhabricatorLiskDAO $object,
     PhabricatorApplicationTransaction $xaction) {
 
     switch ($xaction->getTransactionType()) {
       case PhrictionTransaction::TYPE_TITLE:
         $this->getNewContent()->setTitle($xaction->getNewValue());
         break;
       case PhrictionTransaction::TYPE_CONTENT:
         $this->getNewContent()->setContent($xaction->getNewValue());
         break;
       default:
         break;
     }
   }
 
   protected function applyFinalEffects(
     PhabricatorLiskDAO $object,
     array $xactions) {
 
     $save_content = false;
     foreach ($xactions as $xaction) {
       switch ($xaction->getTransactionType()) {
         case PhrictionTransaction::TYPE_TITLE:
         case PhrictionTransaction::TYPE_CONTENT:
           $save_content = true;
           break;
         default:
           break;
       }
     }
 
     if ($save_content) {
       $content = $this->getNewContent();
       $content->setDocumentID($object->getID());
       $content->save();
 
       $object->setContentID($content->getID());
       $object->save();
       $object->attachContent($content);
     }
 
     if ($this->getIsNewObject()) {
       // Stub out empty parent documents if they don't exist
       $ancestral_slugs = PhabricatorSlug::getAncestry($object->getSlug());
       if ($ancestral_slugs) {
         $ancestors = id(new PhrictionDocument())->loadAllWhere(
           'slug IN (%Ls)',
           $ancestral_slugs);
         $ancestors = mpull($ancestors, null, 'getSlug');
         foreach ($ancestral_slugs as $slug) {
           // We check for change type to prevent near-infinite recursion
           if (!isset($ancestors[$slug]) &&
             $content->getChangeType() !=
             PhrictionChangeType::CHANGE_STUB) {
               id(PhrictionDocumentEditor::newForSlug($slug))
                 ->setActor($this->getActor())
                 ->setTitle(PhabricatorSlug::getDefaultTitle($slug))
                 ->setContent('')
                 ->setDescription(pht('Empty Parent Document'))
                 ->stub();
             }
         }
       }
     }
     return $xactions;
   }
 
   protected function shouldSendMail(
     PhabricatorLiskDAO $object,
     array $xactions) {
 
     $xactions = mfilter($xactions, 'shouldHide', true);
     return $xactions;
   }
 
   protected function getMailSubjectPrefix() {
     return '[Phriction]';
   }
 
   protected function getMailTo(PhabricatorLiskDAO $object) {
     return array(
       $object->getContent()->getAuthorPHID(),
       $this->getActingAsPHID(),
     );
   }
 
   public function getMailTagsMap() {
     return array(
       PhrictionTransaction::MAILTAG_TITLE =>
         pht("A document's title changes."),
       PhrictionTransaction::MAILTAG_CONTENT =>
         pht("A document's content changes."),
     );
   }
 
   protected function buildReplyHandler(PhabricatorLiskDAO $object) {
     return id(new PhrictionReplyHandler())
       ->setMailReceiver($object);
   }
 
   protected function buildMailTemplate(PhabricatorLiskDAO $object) {
     $id = $object->getID();
     $title = $object->getContent()->getTitle();
 
     return id(new PhabricatorMetaMTAMail())
       ->setSubject($title)
       ->addHeader('Thread-Topic', $object->getPHID());
   }
 
   protected function buildMailBody(
     PhabricatorLiskDAO $object,
     array $xactions) {
 
     $body = parent::buildMailBody($object, $xactions);
 
     if ($this->getIsNewObject()) {
       $body->addTextSection(
         pht('DOCUMENT CONTENT'),
         $object->getContent()->getContent());
     }
 
-    $body->addTextSection(
+    $body->addLinkSection(
       pht('DOCUMENT DETAIL'),
       PhabricatorEnv::getProductionURI(
         PhrictionDocument::getSlugURI($object->getSlug())));
 
     return $body;
   }
 
   protected function shouldPublishFeedStory(
     PhabricatorLiskDAO $object,
     array $xactions) {
     return $this->shouldSendMail($object, $xactions);
   }
 
   protected function getFeedRelatedPHIDs(
     PhabricatorLiskDAO $object,
     array $xactions) {
 
     $phids = parent::getFeedRelatedPHIDs($object, $xactions);
     // TODO - once the editor supports moves, we'll need to surface the
     // "from document phid" to related phids.
     return $phids;
   }
 
   protected function supportsSearch() {
     return true;
   }
 
   protected function shouldApplyHeraldRules(
     PhabricatorLiskDAO $object,
     array $xactions) {
     return false;
   }
 
   private function buildNewContentTemplate(
     PhrictionDocument $document) {
 
     $new_content = new PhrictionContent();
     $new_content->setSlug($document->getSlug());
     $new_content->setAuthorPHID($this->getActor()->getPHID());
     $new_content->setChangeType(PhrictionChangeType::CHANGE_EDIT);
 
     $new_content->setTitle($this->getOldContent()->getTitle());
     $new_content->setContent($this->getOldContent()->getContent());
 
     if (strlen($this->getDescription())) {
       $new_content->setDescription($this->getDescription());
     }
     $new_content->setVersion($this->getOldContent()->getVersion() + 1);
 
     return $new_content;
   }
 
 }
diff --git a/src/applications/ponder/editor/PonderAnswerEditor.php b/src/applications/ponder/editor/PonderAnswerEditor.php
index 9c2792efbf..69ee10f270 100644
--- a/src/applications/ponder/editor/PonderAnswerEditor.php
+++ b/src/applications/ponder/editor/PonderAnswerEditor.php
@@ -1,108 +1,108 @@
 <?php
 
 final class PonderAnswerEditor extends PonderEditor {
 
   public function getEditorObjectsDescription() {
     return pht('Ponder Answers');
   }
 
   public function getTransactionTypes() {
     $types = parent::getTransactionTypes();
 
     $types[] = PhabricatorTransactions::TYPE_COMMENT;
     $types[] = PonderAnswerTransaction::TYPE_CONTENT;
 
     return $types;
   }
 
   protected function getCustomTransactionOldValue(
     PhabricatorLiskDAO $object,
     PhabricatorApplicationTransaction $xaction) {
 
     switch ($xaction->getTransactionType()) {
       case PonderAnswerTransaction::TYPE_CONTENT:
         return $object->getContent();
     }
   }
 
   protected function getCustomTransactionNewValue(
     PhabricatorLiskDAO $object,
     PhabricatorApplicationTransaction $xaction) {
 
     switch ($xaction->getTransactionType()) {
       case PonderAnswerTransaction::TYPE_CONTENT:
         return $xaction->getNewValue();
     }
   }
 
   protected function applyCustomInternalTransaction(
     PhabricatorLiskDAO $object,
     PhabricatorApplicationTransaction $xaction) {
 
     switch ($xaction->getTransactionType()) {
       case PonderAnswerTransaction::TYPE_CONTENT:
         $object->setContent($xaction->getNewValue());
         break;
     }
   }
 
   protected function applyCustomExternalTransaction(
     PhabricatorLiskDAO $object,
     PhabricatorApplicationTransaction $xaction) {
     return;
   }
 
   protected function mergeTransactions(
     PhabricatorApplicationTransaction $u,
     PhabricatorApplicationTransaction $v) {
 
     $type = $u->getTransactionType();
     switch ($type) {
       case PonderAnswerTransaction::TYPE_CONTENT:
         return $v;
     }
 
     return parent::mergeTransactions($u, $v);
   }
 
   protected function shouldSendMail(
     PhabricatorLiskDAO $object,
     array $xactions) {
     return true;
   }
 
   protected function buildReplyHandler(PhabricatorLiskDAO $object) {
     $question = $object->getQuestion();
     return id(new PonderQuestionReplyHandler())
       ->setMailReceiver($question);
   }
 
   protected function buildMailTemplate(PhabricatorLiskDAO $object) {
     $question = $object->getQuestion();
     return parent::buildMailTemplate($question);
   }
 
 
   protected function buildMailBody(
     PhabricatorLiskDAO $object,
     array $xactions) {
 
     $body = parent::buildMailBody($object, $xactions);
 
     // If the user just gave the answer, add the answer text.
     foreach ($xactions as $xaction) {
       $type = $xaction->getTransactionType();
       $new = $xaction->getNewValue();
       if ($type == PonderAnswerTransaction::TYPE_CONTENT) {
         $body->addRawSection($new);
       }
     }
 
-    $body->addTextSection(
+    $body->addLinkSection(
       pht('ANSWER DETAIL'),
       PhabricatorEnv::getProductionURI($object->getURI()));
 
     return $body;
   }
 
 }
diff --git a/src/applications/ponder/editor/PonderQuestionEditor.php b/src/applications/ponder/editor/PonderQuestionEditor.php
index f7030dedce..5505e751de 100644
--- a/src/applications/ponder/editor/PonderQuestionEditor.php
+++ b/src/applications/ponder/editor/PonderQuestionEditor.php
@@ -1,253 +1,253 @@
 <?php
 
 final class PonderQuestionEditor
   extends PonderEditor {
 
   private $answer;
 
   public function getEditorObjectsDescription() {
     return pht('Ponder Questions');
   }
 
   /**
    * This is used internally on @{method:applyInitialEffects} if a transaction
    * of type PonderQuestionTransaction::TYPE_ANSWERS is in the mix. The value
    * is set to the //last// answer in the transactions. Practically, one
    * answer is given at a time in the application, though theoretically
    * this is buggy.
    *
    * The answer is used in emails to generate proper links.
    */
   private function setAnswer(PonderAnswer $answer) {
     $this->answer = $answer;
     return $this;
   }
   private function getAnswer() {
     return $this->answer;
   }
 
   protected function shouldApplyInitialEffects(
     PhabricatorLiskDAO $object,
     array $xactions) {
 
     foreach ($xactions as $xaction) {
       switch ($xaction->getTransactionType()) {
         case PonderQuestionTransaction::TYPE_ANSWERS:
           return true;
       }
     }
 
     return false;
   }
 
   protected function applyInitialEffects(
     PhabricatorLiskDAO $object,
     array $xactions) {
 
     foreach ($xactions as $xaction) {
       switch ($xaction->getTransactionType()) {
         case PonderQuestionTransaction::TYPE_ANSWERS:
           $new_value = $xaction->getNewValue();
           $new = idx($new_value, '+', array());
           foreach ($new as $new_answer) {
             $answer = idx($new_answer, 'answer');
             if (!$answer) {
               continue;
             }
             $answer->save();
             $this->setAnswer($answer);
           }
           break;
       }
     }
   }
 
   public function getTransactionTypes() {
     $types = parent::getTransactionTypes();
 
     $types[] = PhabricatorTransactions::TYPE_COMMENT;
     $types[] = PonderQuestionTransaction::TYPE_TITLE;
     $types[] = PonderQuestionTransaction::TYPE_CONTENT;
     $types[] = PonderQuestionTransaction::TYPE_ANSWERS;
     $types[] = PonderQuestionTransaction::TYPE_STATUS;
 
     return $types;
   }
 
   protected function getCustomTransactionOldValue(
     PhabricatorLiskDAO $object,
     PhabricatorApplicationTransaction $xaction) {
 
     switch ($xaction->getTransactionType()) {
       case PonderQuestionTransaction::TYPE_TITLE:
         return $object->getTitle();
       case PonderQuestionTransaction::TYPE_CONTENT:
         return $object->getContent();
       case PonderQuestionTransaction::TYPE_ANSWERS:
         return mpull($object->getAnswers(), 'getPHID');
       case PonderQuestionTransaction::TYPE_STATUS:
         return $object->getStatus();
     }
   }
 
   protected function getCustomTransactionNewValue(
     PhabricatorLiskDAO $object,
     PhabricatorApplicationTransaction $xaction) {
 
     switch ($xaction->getTransactionType()) {
       case PonderQuestionTransaction::TYPE_TITLE:
       case PonderQuestionTransaction::TYPE_CONTENT:
       case PonderQuestionTransaction::TYPE_STATUS:
         return $xaction->getNewValue();
       case PonderQuestionTransaction::TYPE_ANSWERS:
         $raw_new_value = $xaction->getNewValue();
         $new_value = array();
         foreach ($raw_new_value as $key => $answers) {
           $phids = array();
           foreach ($answers as $answer) {
             $obj = idx($answer, 'answer');
             if (!$answer) {
               continue;
             }
             $phids[] = $obj->getPHID();
           }
           $new_value[$key] = $phids;
         }
         $xaction->setNewValue($new_value);
         return $this->getPHIDTransactionNewValue($xaction);
     }
   }
 
   protected function applyCustomInternalTransaction(
     PhabricatorLiskDAO $object,
     PhabricatorApplicationTransaction $xaction) {
 
     switch ($xaction->getTransactionType()) {
       case PonderQuestionTransaction::TYPE_TITLE:
         $object->setTitle($xaction->getNewValue());
         break;
       case PonderQuestionTransaction::TYPE_CONTENT:
         $object->setContent($xaction->getNewValue());
         break;
       case PonderQuestionTransaction::TYPE_STATUS:
         $object->setStatus($xaction->getNewValue());
         break;
       case PonderQuestionTransaction::TYPE_ANSWERS:
         $old = $xaction->getOldValue();
         $new = $xaction->getNewValue();
 
         $add = array_diff_key($new, $old);
         $rem = array_diff_key($old, $new);
 
         $count = $object->getAnswerCount();
         $count += count($add);
         $count -= count($rem);
 
         $object->setAnswerCount($count);
         break;
       case PhabricatorTransactions::TYPE_EDGE:
         return;
     }
   }
 
   protected function applyCustomExternalTransaction(
     PhabricatorLiskDAO $object,
     PhabricatorApplicationTransaction $xaction) {
     return;
   }
 
   protected function mergeTransactions(
     PhabricatorApplicationTransaction $u,
     PhabricatorApplicationTransaction $v) {
 
     $type = $u->getTransactionType();
     switch ($type) {
       case PonderQuestionTransaction::TYPE_TITLE:
       case PonderQuestionTransaction::TYPE_CONTENT:
       case PonderQuestionTransaction::TYPE_STATUS:
         return $v;
     }
 
     return parent::mergeTransactions($u, $v);
   }
 
   protected function supportsSearch() {
     return true;
   }
 
   protected function getFeedStoryType() {
     return 'PonderTransactionFeedStory';
   }
 
   protected function getFeedStoryData(
     PhabricatorLiskDAO $object,
     array $xactions) {
 
     $data = parent::getFeedStoryData($object, $xactions);
     $answer = $this->getAnswer();
     if ($answer) {
       $data['answerPHID'] = $answer->getPHID();
     }
 
     return $data;
  }
 
   protected function shouldImplyCC(
     PhabricatorLiskDAO $object,
     PhabricatorApplicationTransaction $xaction) {
 
     switch ($xaction->getTransactionType()) {
       case PonderQuestionTransaction::TYPE_ANSWERS:
         return true;
     }
 
     return parent::shouldImplyCC($object, $xaction);
   }
 
   protected function shouldSendMail(
     PhabricatorLiskDAO $object,
     array $xactions) {
     return true;
   }
 
   protected function buildReplyHandler(PhabricatorLiskDAO $object) {
     return id(new PonderQuestionReplyHandler())
       ->setMailReceiver($object);
   }
 
   protected function buildMailBody(
     PhabricatorLiskDAO $object,
     array $xactions) {
 
     $body = parent::buildMailBody($object, $xactions);
 
     $header = pht('QUESTION DETAIL');
     $uri = '/Q'.$object->getID();
     foreach ($xactions as $xaction) {
       $type = $xaction->getTransactionType();
       $old = $xaction->getOldValue();
       $new = $xaction->getNewValue();
       // If the user just asked the question, add the question text.
       if ($type == PonderQuestionTransaction::TYPE_CONTENT) {
         if ($old === null) {
           $body->addRawSection($new);
         }
       }
       // If the user gave an answer, add the answer text. Also update
       // the header and uri to be more answer-specific.
       if ($type == PonderQuestionTransaction::TYPE_ANSWERS) {
         $answer = $this->getAnswer();
         $body->addRawSection($answer->getContent());
         $header = pht('ANSWER DETAIL');
         $uri = $answer->getURI();
       }
     }
 
-    $body->addTextSection(
+    $body->addLinkSection(
       $header,
       PhabricatorEnv::getProductionURI($uri));
 
     return $body;
   }
 
 }
diff --git a/src/applications/repository/worker/PhabricatorRepositoryPushMailWorker.php b/src/applications/repository/worker/PhabricatorRepositoryPushMailWorker.php
index 883e547e58..23582d63eb 100644
--- a/src/applications/repository/worker/PhabricatorRepositoryPushMailWorker.php
+++ b/src/applications/repository/worker/PhabricatorRepositoryPushMailWorker.php
@@ -1,225 +1,225 @@
 <?php
 
 final class PhabricatorRepositoryPushMailWorker
   extends PhabricatorWorker {
 
   public function doWork() {
     $viewer = PhabricatorUser::getOmnipotentUser();
 
     $task_data = $this->getTaskData();
 
     $email_phids = idx($task_data, 'emailPHIDs');
     if (!$email_phids) {
       // If we don't have any email targets, don't send any email.
       return;
     }
 
     $event_phid = idx($task_data, 'eventPHID');
     $event = id(new PhabricatorRepositoryPushEventQuery())
       ->setViewer($viewer)
       ->withPHIDs(array($event_phid))
       ->needLogs(true)
       ->executeOne();
 
     $repository = $event->getRepository();
     if ($repository->isImporting()) {
       // If the repository is still importing, don't send email.
       return;
     }
 
     if ($repository->getDetail('herald-disabled')) {
       // If publishing is disabled, don't send email.
       return;
     }
 
     $logs = $event->getLogs();
 
     list($ref_lines, $ref_list) = $this->renderRefs($logs);
     list($commit_lines, $subject_line) = $this->renderCommits(
       $repository,
       $logs,
       idx($task_data, 'info', array()));
 
     $ref_count = count($ref_lines);
     $commit_count = count($commit_lines);
 
     $handles = id(new PhabricatorHandleQuery())
       ->setViewer($viewer)
       ->withPHIDs(array($event->getPusherPHID()))
       ->execute();
 
     $pusher_name = $handles[$event->getPusherPHID()]->getName();
     $repo_name = $repository->getMonogram();
 
     if ($commit_count) {
       $overview = pht(
         '%s pushed %d commit(s) to %s.',
         $pusher_name,
         $commit_count,
         $repo_name);
     } else {
       $overview = pht(
         '%s pushed to %s.',
         $pusher_name,
         $repo_name);
     }
 
     $details_uri = PhabricatorEnv::getProductionURI(
       '/diffusion/pushlog/view/'.$event->getID().'/');
 
     $body = new PhabricatorMetaMTAMailBody();
     $body->addRawSection($overview);
 
-    $body->addTextSection(pht('DETAILS'), $details_uri);
+    $body->addLinkSection(pht('DETAILS'), $details_uri);
 
     if ($commit_lines) {
       $body->addTextSection(pht('COMMITS'), implode("\n", $commit_lines));
     }
 
     if ($ref_lines) {
       $body->addTextSection(pht('REFERENCES'), implode("\n", $ref_lines));
     }
 
     $prefix = PhabricatorEnv::getEnvConfig('metamta.diffusion.subject-prefix');
 
     $parts = array();
     if ($commit_count) {
       $parts[] = pht('%s commit(s)', $commit_count);
     }
     if ($ref_count) {
       $parts[] = implode(', ', $ref_list);
     }
     $parts = implode(', ', $parts);
 
     if ($subject_line) {
       $subject = pht('(%s) %s', $parts, $subject_line);
     } else {
       $subject = pht('(%s)', $parts);
     }
 
     $mail = id(new PhabricatorMetaMTAMail())
       ->setRelatedPHID($event->getPHID())
       ->setSubjectPrefix($prefix)
       ->setVarySubjectPrefix(pht('[Push]'))
       ->setSubject($subject)
       ->setFrom($event->getPusherPHID())
       ->setBody($body->render())
       ->setThreadID($event->getPHID(), $is_new = true)
       ->addHeader('Thread-Topic', $subject)
       ->setIsBulk(true);
 
     $to_handles = id(new PhabricatorHandleQuery())
       ->setViewer($viewer)
       ->withPHIDs($email_phids)
       ->execute();
 
     $reply_handler = new PhabricatorRepositoryPushReplyHandler();
     $mails = $reply_handler->multiplexMail(
       $mail,
       $to_handles,
       array());
 
     foreach ($mails as $mail) {
       $mail->saveAndSend();
     }
   }
 
   public function renderForDisplay(PhabricatorUser $viewer) {
     // This data has some sensitive stuff, so don't show it.
     return null;
   }
 
   private function renderRefs(array $logs) {
     $ref_lines = array();
     $ref_list = array();
 
     foreach ($logs as $log) {
       $type_name = null;
       $type_prefix = null;
       switch ($log->getRefType()) {
         case PhabricatorRepositoryPushLog::REFTYPE_BRANCH:
           $type_name = pht('branch');
           break;
         case PhabricatorRepositoryPushLog::REFTYPE_TAG:
           $type_name = pht('tag');
           $type_prefix = pht('tag:');
           break;
         case PhabricatorRepositoryPushLog::REFTYPE_BOOKMARK:
           $type_name = pht('bookmark');
           $type_prefix = pht('bookmark:');
           break;
         case PhabricatorRepositoryPushLog::REFTYPE_COMMIT:
         default:
           break;
       }
 
       if ($type_name === null) {
         continue;
       }
 
       $flags = $log->getChangeFlags();
       if ($flags & PhabricatorRepositoryPushLog::CHANGEFLAG_DANGEROUS) {
         $action = '!';
       } else if ($flags & PhabricatorRepositoryPushLog::CHANGEFLAG_DELETE) {
         $action = '-';
       } else if ($flags & PhabricatorRepositoryPushLog::CHANGEFLAG_REWRITE) {
         $action = '~';
       } else if ($flags & PhabricatorRepositoryPushLog::CHANGEFLAG_APPEND) {
         $action = ' ';
       } else if ($flags & PhabricatorRepositoryPushLog::CHANGEFLAG_ADD) {
         $action = '+';
       } else {
         $action = '?';
       }
 
       $old = nonempty($log->getRefOldShort(), pht('<null>'));
       $new = nonempty($log->getRefNewShort(), pht('<null>'));
 
       $name = $log->getRefName();
 
       $ref_lines[] = "{$action} {$type_name} {$name} {$old} > {$new}";
       $ref_list[] = $type_prefix.$name;
     }
 
     return array(
       $ref_lines,
       array_unique($ref_list),
     );
   }
 
   private function renderCommits(
     PhabricatorRepository $repository,
     array $logs,
     array $info) {
 
     $commit_lines = array();
     $subject_line = null;
     foreach ($logs as $log) {
       if ($log->getRefType() != PhabricatorRepositoryPushLog::REFTYPE_COMMIT) {
         continue;
       }
 
       $commit_info = idx($info, $log->getRefNew(), array());
 
       $name = $repository->formatCommitName($log->getRefNew());
 
       $branches = null;
       if (idx($commit_info, 'branches')) {
         $branches = ' ('.implode(', ', $commit_info['branches']).')';
       }
 
       $summary = null;
       if (strlen(idx($commit_info, 'summary'))) {
         $summary = ' '.$commit_info['summary'];
       }
 
       $commit_lines[] = "{$name}{$branches}{$summary}";
       if ($subject_line === null) {
         $subject_line = "{$name}{$summary}";
       }
     }
 
     return array($commit_lines, $subject_line);
   }
 
 }