diff --git a/resources/sql/patches/threadtopic.sql b/resources/sql/patches/threadtopic.sql
new file mode 100644
index 000000000..cce2ff80f
--- /dev/null
+++ b/resources/sql/patches/threadtopic.sql
@@ -0,0 +1,14 @@
+ALTER TABLE {$NAMESPACE}_differential.differential_revision
+  ADD originalTitle varchar(255) NOT NULL AFTER title;
+UPDATE {$NAMESPACE}_differential.differential_revision SET
+  originalTitle = title;
+
+ALTER TABLE {$NAMESPACE}_owners.owners_package
+  ADD originalName varchar(255) NOT NULL AFTER name;
+UPDATE {$NAMESPACE}_owners.owners_package SET
+  originalName = name;
+
+ALTER TABLE {$NAMESPACE}_maniphest.maniphest_task
+  ADD originalTitle text NOT NULL AFTER title;
+UPDATE {$NAMESPACE}_maniphest.maniphest_task SET
+  originalTitle = title;
diff --git a/src/applications/audit/editor/PhabricatorAuditCommentEditor.php b/src/applications/audit/editor/PhabricatorAuditCommentEditor.php
index 4b06aa03b..53f76bec3 100644
--- a/src/applications/audit/editor/PhabricatorAuditCommentEditor.php
+++ b/src/applications/audit/editor/PhabricatorAuditCommentEditor.php
@@ -1,530 +1,535 @@
 <?php
 
 /*
  * Copyright 2012 Facebook, Inc.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
  *
  *   http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
 
 final class PhabricatorAuditCommentEditor {
 
   private $commit;
   private $user;
 
   private $attachInlineComments;
   private $auditors = array();
   private $ccs = array();
 
   public function __construct(PhabricatorRepositoryCommit $commit) {
     $this->commit = $commit;
     return $this;
   }
 
   public function setUser(PhabricatorUser $user) {
     $this->user = $user;
     return $this;
   }
 
   public function addAuditors(array $auditor_phids) {
     $this->auditors = array_merge($this->auditors, $auditor_phids);
     return $this;
   }
 
   public function addCCs(array $cc_phids) {
     $this->ccs = array_merge($this->ccs, $cc_phids);
     return $this;
   }
 
   public function setAttachInlineComments($attach_inline_comments) {
     $this->attachInlineComments = $attach_inline_comments;
     return $this;
   }
 
   public function addComment(PhabricatorAuditComment $comment) {
 
     $commit = $this->commit;
     $user = $this->user;
 
     $other_comments = id(new PhabricatorAuditComment())->loadAllWhere(
       'targetPHID = %s',
       $commit->getPHID());
 
     $inline_comments = array();
     if ($this->attachInlineComments) {
       $inline_comments = id(new PhabricatorAuditInlineComment())->loadAllWhere(
         'authorPHID = %s AND commitPHID = %s
           AND auditCommentID IS NULL',
         $user->getPHID(),
         $commit->getPHID());
     }
 
     $comment
       ->setActorPHID($user->getPHID())
       ->setTargetPHID($commit->getPHID())
       ->save();
 
     $content_blocks = array($comment->getContent());
 
     if ($inline_comments) {
       foreach ($inline_comments as $inline) {
         $inline->setAuditCommentID($comment->getID());
         $inline->save();
         $content_blocks[] = $inline->getContent();
       }
     }
 
     $ccs = $this->ccs;
     $auditors = $this->auditors;
 
     $metadata = $comment->getMetadata();
     $metacc = array();
 
     // Find any "@mentions" in the content blocks.
     $mention_ccs = PhabricatorMarkupEngine::extractPHIDsFromMentions(
       $content_blocks);
     if ($mention_ccs) {
       $metacc = idx(
         $metadata,
         PhabricatorAuditComment::METADATA_ADDED_CCS,
         array());
       foreach ($mention_ccs as $cc_phid) {
         $metacc[] = $cc_phid;
       }
     }
 
     if ($metacc) {
       $ccs = array_merge($ccs, $metacc);
     }
 
     // When a user submits an audit comment, we update all the audit requests
     // they have authority over to reflect the most recent status. The general
     // idea here is that if audit has triggered for, e.g., several packages, but
     // a user owns all of them, they can clear the audit requirement in one go
     // without auditing the commit for each trigger.
 
     $audit_phids = self::loadAuditPHIDsForUser($this->user);
     $audit_phids = array_fill_keys($audit_phids, true);
 
     $requests = id(new PhabricatorRepositoryAuditRequest())
       ->loadAllWhere(
         'commitPHID = %s',
         $commit->getPHID());
 
     $action = $comment->getAction();
 
 
     // TODO: We should validate the action, currently we allow anyone to, e.g.,
     // close an audit if they muck with form parameters. I'll followup with this
     // and handle the no-effect cases (e.g., closing and already-closed audit).
 
 
     $user_is_author = ($user->getPHID() == $commit->getAuthorPHID());
 
     if ($action == PhabricatorAuditActionConstants::CLOSE) {
       // "Close" means wipe out all the concerns.
       $concerned_status = PhabricatorAuditStatusConstants::CONCERNED;
       foreach ($requests as $request) {
         if ($request->getAuditStatus() == $concerned_status) {
           $request->setAuditStatus(PhabricatorAuditStatusConstants::CLOSED);
           $request->save();
         }
       }
     } else if ($action == PhabricatorAuditActionConstants::RESIGN) {
       // "Resign" has unusual rules for writing user rows, only affects the
       // user row (never package/project rows), and always affects the user
       // row (other actions don't, if they were able to affect a package/project
       // row).
       $user_request = null;
       foreach ($requests as $request) {
         if ($request->getAuditorPHID() == $user->getPHID()) {
           $user_request = $request;
           break;
         }
       }
       if (!$user_request) {
         $user_request = id(new PhabricatorRepositoryAuditRequest())
           ->setCommitPHID($commit->getPHID())
           ->setAuditorPHID($user->getPHID())
           ->setAuditReasons(array("Resigned"));
       }
 
       $user_request
         ->setAuditStatus(PhabricatorAuditStatusConstants::RESIGNED)
         ->save();
 
       $requests[] = $user_request;
     } else {
       $have_any_requests = false;
       foreach ($requests as $request) {
         if (empty($audit_phids[$request->getAuditorPHID()])) {
           continue;
         }
 
         $request_is_for_user = ($request->getAuditorPHID() == $user->getPHID());
 
         $have_any_requests = true;
         $new_status = null;
         switch ($action) {
           case PhabricatorAuditActionConstants::COMMENT:
           case PhabricatorAuditActionConstants::ADD_CCS:
           case PhabricatorAuditActionConstants::ADD_AUDITORS:
             // Commenting or adding cc's/auditors doesn't change status.
             break;
           case PhabricatorAuditActionConstants::ACCEPT:
             if (!$user_is_author || $request_is_for_user) {
               // 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.
               $new_status = PhabricatorAuditStatusConstants::ACCEPTED;
             }
             break;
           case PhabricatorAuditActionConstants::CONCERN:
             if (!$user_is_author || $request_is_for_user) {
               // See above.
               $new_status = PhabricatorAuditStatusConstants::CONCERNED;
             }
             break;
           default:
             throw new Exception("Unknown action '{$action}'!");
         }
         if ($new_status !== null) {
           $request->setAuditStatus($new_status);
           $request->save();
         }
       }
 
       // If the user has no current authority over any audit trigger, make a
       // new one to represent their audit state.
       if (!$have_any_requests) {
         $new_status = null;
         switch ($action) {
           case PhabricatorAuditActionConstants::COMMENT:
           case PhabricatorAuditActionConstants::ADD_CCS:
           case PhabricatorAuditActionConstants::ADD_AUDITORS:
             $new_status = PhabricatorAuditStatusConstants::AUDIT_NOT_REQUIRED;
             break;
           case PhabricatorAuditActionConstants::ACCEPT:
             $new_status = PhabricatorAuditStatusConstants::ACCEPTED;
             break;
           case PhabricatorAuditActionConstants::CONCERN:
             $new_status = PhabricatorAuditStatusConstants::CONCERNED;
             break;
           case PhabricatorAuditActionConstants::CLOSE:
             // Impossible to reach this block with 'close'.
           default:
             throw new Exception("Unknown or invalid action '{$action}'!");
         }
 
         $request = id(new PhabricatorRepositoryAuditRequest())
           ->setCommitPHID($commit->getPHID())
           ->setAuditorPHID($user->getPHID())
           ->setAuditStatus($new_status)
           ->setAuditReasons(array("Voluntary Participant"))
           ->save();
         $requests[] = $request;
       }
     }
 
     $requests_by_auditor = mpull($requests, null, 'getAuditorPHID');
     $requests_phids = array_keys($requests_by_auditor);
 
     $ccs = array_diff($ccs, $requests_phids);
     $auditors = array_diff($auditors, $requests_phids);
 
     if ($action == PhabricatorAuditActionConstants::ADD_CCS) {
       if ($ccs) {
         $metadata[PhabricatorAuditComment::METADATA_ADDED_CCS] = $ccs;
         $comment->setMetaData($metadata);
       } else {
         $comment->setAction(PhabricatorAuditActionConstants::COMMENT);
       }
     }
 
     if ($action == PhabricatorAuditActionConstants::ADD_AUDITORS) {
       if ($auditors) {
         $metadata[PhabricatorAuditComment::METADATA_ADDED_AUDITORS]
           = $auditors;
         $comment->setMetaData($metadata);
       } else {
         $comment->setAction(PhabricatorAuditActionConstants::COMMENT);
       }
     }
 
     $comment->save();
 
     if ($auditors) {
       foreach ($auditors as $auditor_phid) {
         $audit_requested = PhabricatorAuditStatusConstants::AUDIT_REQUESTED;
         $requests[] = id (new PhabricatorRepositoryAuditRequest())
           ->setCommitPHID($commit->getPHID())
           ->setAuditorPHID($auditor_phid)
           ->setAuditStatus($audit_requested)
           ->setAuditReasons(
             array('Added by ' . $user->getUsername()))
           ->save();
       }
     }
 
     if ($ccs) {
       foreach ($ccs as $cc_phid) {
         $audit_cc = PhabricatorAuditStatusConstants::CC;
         $requests[] = id (new PhabricatorRepositoryAuditRequest())
           ->setCommitPHID($commit->getPHID())
           ->setAuditorPHID($cc_phid)
           ->setAuditStatus($audit_cc)
           ->setAuditReasons(
             array('Added by ' . $user->getUsername()))
           ->save();
       }
     }
 
     $commit->updateAuditStatus($requests);
     $commit->save();
 
     $this->publishFeedStory($comment, array_keys($audit_phids));
     PhabricatorSearchCommitIndexer::indexCommit($commit);
     $this->sendMail($comment, $other_comments, $inline_comments, $requests);
   }
 
 
   /**
    * Load the PHIDs for all objects the user has the authority to act as an
    * audit for. This includes themselves, and any packages they are an owner
    * of.
    */
   public static function loadAuditPHIDsForUser(PhabricatorUser $user) {
     $phids = array();
 
     // The user can audit on their own behalf.
     $phids[$user->getPHID()] = true;
 
     // The user can audit on behalf of all packages they own.
     $owned_packages = PhabricatorOwnersOwner::loadAffiliatedPackages(
       $user->getPHID());
 
     if ($owned_packages) {
       $packages = id(new PhabricatorOwnersPackage())->loadAllWhere(
         'id IN (%Ld)',
         mpull($owned_packages, 'getPackageID'));
       foreach (mpull($packages, 'getPHID') as $phid) {
         $phids[$phid] = true;
       }
     }
 
     // The user can audit on behalf of all projects they are a member of.
     $query = new PhabricatorProjectQuery();
     $query->setMembers(array($user->getPHID()));
     $projects = $query->execute();
     foreach ($projects as $project) {
       $phids[$project->getPHID()] = true;
     }
 
     return array_keys($phids);
   }
 
   private function publishFeedStory(
     PhabricatorAuditComment $comment,
     array $more_phids) {
 
     $commit = $this->commit;
     $user = $this->user;
 
     $related_phids = array_merge(
       array(
         $user->getPHID(),
         $commit->getPHID(),
       ),
       $more_phids);
 
     id(new PhabricatorFeedStoryPublisher())
       ->setRelatedPHIDs($related_phids)
       ->setStoryAuthorPHID($user->getPHID())
       ->setStoryTime(time())
       ->setStoryType(PhabricatorFeedStoryTypeConstants::STORY_AUDIT)
       ->setStoryData(
         array(
           'commitPHID'    => $commit->getPHID(),
           'action'        => $comment->getAction(),
           'content'       => $comment->getContent(),
         ))
       ->publish();
   }
 
   private function sendMail(
     PhabricatorAuditComment $comment,
     array $other_comments,
     array $inline_comments,
     array $requests) {
 
     assert_instances_of($other_comments, 'PhabricatorAuditComment');
     assert_instances_of($inline_comments, 'PhabricatorInlineCommentInterface');
 
     $commit = $this->commit;
 
     $data = $commit->loadCommitData();
     $summary = $data->getSummary();
 
     $commit_phid = $commit->getPHID();
     $phids = array($commit_phid);
     $handles = id(new PhabricatorObjectHandleData($phids))->loadHandles();
     $handle = $handles[$commit_phid];
 
     $name = $handle->getName();
 
     $map = array(
       PhabricatorAuditActionConstants::CONCERN  => 'Raised Concern',
       PhabricatorAuditActionConstants::ACCEPT   => 'Accepted',
       PhabricatorAuditActionConstants::RESIGN   => 'Resigned',
       PhabricatorAuditActionConstants::CLOSE    => 'Closed',
       PhabricatorAuditActionConstants::ADD_CCS => 'Added CCs',
       PhabricatorAuditActionConstants::ADD_AUDITORS => 'Added Auditors',
     );
     $verb = idx($map, $comment->getAction(), 'Commented On');
 
     $reply_handler = self::newReplyHandlerForCommit($commit);
 
     $prefix = PhabricatorEnv::getEnvConfig('metamta.diffusion.subject-prefix');
 
-    $threading = self::getMailThreading($commit->getPHID());
+    $repository = id(new PhabricatorRepository())
+      ->load($commit->getRepositoryID());
+    $threading = self::getMailThreading($repository, $commit);
     list($thread_id, $thread_topic) = $threading;
 
     $body       = $this->renderMailBody(
       $comment,
       "{$name}: {$summary}",
       $handle,
       $reply_handler,
       $inline_comments);
 
     $email_to = array();
     $email_cc = array();
 
     $author_phid = $data->getCommitDetail('authorPHID');
     if ($author_phid) {
       $email_to[] = $author_phid;
     }
 
     $email_cc = array();
     foreach ($other_comments as $other_comment) {
       $email_cc[] = $other_comment->getActorPHID();
     }
 
     foreach ($requests as $request) {
       if ($request->getAuditStatus() == PhabricatorAuditStatusConstants::CC) {
         $email_cc[] = $request->getAuditorPHID();
       }
     }
 
     $phids = array_merge($email_to, $email_cc);
     $handles = id(new PhabricatorObjectHandleData($phids))->loadHandles();
 
     // NOTE: Always set $is_new to false, because the "first" mail in the
     // thread is the Herald notification of the commit.
     $is_new = false;
 
     $template = id(new PhabricatorMetaMTAMail())
       ->setSubject("{$name}: {$summary}")
       ->setSubjectPrefix($prefix)
       ->setVarySubjectPrefix("[{$verb}]")
       ->setFrom($comment->getActorPHID())
       ->setThreadID($thread_id, $is_new)
       ->addHeader('Thread-Topic', $thread_topic)
       ->setRelatedPHID($commit->getPHID())
       ->setIsBulk(true)
       ->setBody($body);
 
     $mails = $reply_handler->multiplexMail(
       $template,
       array_select_keys($handles, $email_to),
       array_select_keys($handles, $email_cc));
 
     foreach ($mails as $mail) {
       $mail->saveAndSend();
     }
   }
 
-  public static function getMailThreading($phid) {
+  public static function getMailThreading(
+    PhabricatorRepository $repository,
+    PhabricatorRepositoryCommit $commit) {
+
     return array(
-      'diffusion-audit-'.$phid,
-      'Diffusion Audit '.$phid,
+      'diffusion-audit-'.$commit->getPHID(),
+      'Commit r'.$repository->getCallsign().$commit->getCommitIdentifier(),
     );
   }
 
   public static function newReplyHandlerForCommit($commit) {
     $reply_handler = PhabricatorEnv::newObjectFromConfig(
       'metamta.diffusion.reply-handler');
     $reply_handler->setMailReceiver($commit);
     return $reply_handler;
   }
 
   private function renderMailBody(
     PhabricatorAuditComment $comment,
     $cname,
     PhabricatorObjectHandle $handle,
     PhabricatorMailReplyHandler $reply_handler,
     array $inline_comments) {
     assert_instances_of($inline_comments, 'PhabricatorInlineCommentInterface');
 
     $commit = $this->commit;
     $user = $this->user;
     $name = $user->getUsername();
 
     $verb = PhabricatorAuditActionConstants::getActionPastTenseVerb(
       $comment->getAction());
 
     $body = array();
     $body[] = "{$name} {$verb} commit {$cname}.";
 
     if ($comment->getContent()) {
       $body[] = $comment->getContent();
     }
 
     if ($inline_comments) {
       $block = array();
 
       $path_map = id(new DiffusionPathQuery())
         ->withPathIDs(mpull($inline_comments, 'getPathID'))
         ->execute();
       $path_map = ipull($path_map, 'path', 'id');
 
       foreach ($inline_comments 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}";
       }
       $body[] = "INLINE COMMENTS\n  ".implode("\n  ", $block);
     }
 
     $body[] = "COMMIT\n  ".PhabricatorEnv::getProductionURI($handle->getURI());
 
 
     $reply_instructions = $reply_handler->getReplyHandlerInstructions();
     if ($reply_instructions) {
       $body[] = "REPLY HANDLER ACTIONS\n  ".$reply_instructions;
     }
 
     return implode("\n\n", $body)."\n";
   }
 
 }
diff --git a/src/applications/differential/mail/DifferentialMail.php b/src/applications/differential/mail/DifferentialMail.php
index 7014e2743..2d1628f02 100644
--- a/src/applications/differential/mail/DifferentialMail.php
+++ b/src/applications/differential/mail/DifferentialMail.php
@@ -1,426 +1,427 @@
 <?php
 
 /*
  * Copyright 2012 Facebook, Inc.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
  *
  *   http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
 
 abstract class DifferentialMail {
 
   protected $to = array();
   protected $cc = array();
 
   protected $actorHandle;
 
   protected $revision;
   protected $comment;
   protected $changesets;
   protected $inlineComments;
   protected $isFirstMailAboutRevision;
   protected $isFirstMailToRecipients;
   protected $heraldTranscriptURI;
   protected $heraldRulesHeader;
   protected $replyHandler;
   protected $parentMessageID;
 
   protected function renderSubject() {
     $revision = $this->getRevision();
     $title = $revision->getTitle();
     $id = $revision->getID();
     return "D{$id}: {$title}";
   }
 
   abstract protected function renderVaryPrefix();
   abstract protected function renderBody();
 
   public function setActorHandle($actor_handle) {
     $this->actorHandle = $actor_handle;
     return $this;
   }
 
   public function getActorHandle() {
     return $this->actorHandle;
   }
 
   protected function getActorName() {
     $handle = $this->getActorHandle();
     if ($handle) {
       return $handle->getName();
     }
     return '???';
   }
 
   public function setParentMessageID($parent_message_id) {
     $this->parentMessageID = $parent_message_id;
     return $this;
   }
 
   public function setXHeraldRulesHeader($header) {
     $this->heraldRulesHeader = $header;
     return $this;
   }
 
   public function send() {
     $to_phids = $this->getToPHIDs();
     if (!$to_phids) {
       throw new Exception('No "To:" users provided!');
     }
 
     $cc_phids     = $this->getCCPHIDs();
     $body         = $this->buildBody();
     $attachments  = $this->buildAttachments();
 
     $template = new PhabricatorMetaMTAMail();
     $actor_handle = $this->getActorHandle();
     $reply_handler = $this->getReplyHandler();
 
     if ($actor_handle) {
       $template->setFrom($actor_handle->getPHID());
     }
 
     $template
       ->setSubject($this->renderSubject())
       ->setSubjectPrefix($this->getSubjectPrefix())
       ->setVarySubjectPrefix($this->renderVaryPrefix())
       ->setBody($body)
       ->setIsHTML($this->shouldMarkMailAsHTML())
       ->setParentMessageID($this->parentMessageID)
       ->addHeader('Thread-Topic', $this->getThreadTopic());
 
     $template->setAttachments($attachments);
 
     $template->setThreadID(
       $this->getThreadID(),
       $this->isFirstMailAboutRevision());
 
     if ($this->heraldRulesHeader) {
       $template->addHeader('X-Herald-Rules', $this->heraldRulesHeader);
     }
 
     $revision = $this->revision;
     if ($revision) {
       if ($revision->getAuthorPHID()) {
         $template->addHeader(
           'X-Differential-Author',
           '<'.$revision->getAuthorPHID().'>');
       }
       if ($revision->getReviewers()) {
         $template->addHeader(
           'X-Differential-Reviewers',
           '<'.implode('>, <', $revision->getReviewers()).'>');
       }
       if ($revision->getCCPHIDs()) {
         $template->addHeader(
           'X-Differential-CCs',
           '<'.implode('>, <', $revision->getCCPHIDs()).'>');
 
         // Determine explicit CCs (those added by humans) and put them in a
         // header so users can differentiate between Herald CCs and human CCs.
 
         $relation_subscribed = DifferentialRevision::RELATION_SUBSCRIBED;
         $raw = $revision->getRawRelations($relation_subscribed);
 
         $reason_phids = ipull($raw, 'reasonPHID');
         $reason_handles = id(new PhabricatorObjectHandleData($reason_phids))
           ->loadHandles();
 
         $explicit_cc = array();
         foreach ($raw as $relation) {
           if (!$relation['reasonPHID']) {
             continue;
           }
           $type = $reason_handles[$relation['reasonPHID']]->getType();
           if ($type == PhabricatorPHIDConstants::PHID_TYPE_USER) {
             $explicit_cc[] = $relation['objectPHID'];
           }
         }
 
         if ($explicit_cc) {
           $template->addHeader(
             'X-Differential-Explicit-CCs',
             '<'.implode('>, <', $explicit_cc).'>');
         }
       }
     }
 
     $template->setIsBulk(true);
     $template->setRelatedPHID($this->getRevision()->getPHID());
 
     $mailtags = $this->getMailTags();
     if ($mailtags) {
       $template->setMailTags($mailtags);
     }
 
     $phids = array();
     foreach ($to_phids as $phid) {
       $phids[$phid] = true;
     }
     foreach ($cc_phids as $phid) {
       $phids[$phid] = true;
     }
     $phids = array_keys($phids);
 
     $handles = id(new PhabricatorObjectHandleData($phids))->loadHandles();
 
     $event = new PhabricatorEvent(
       PhabricatorEventType::TYPE_DIFFERENTIAL_WILLSENDMAIL,
       array(
         'mail' => $template,
       )
     );
     PhutilEventEngine::dispatchEvent($event);
 
     $template = $event->getValue('mail');
 
     $mails = $reply_handler->multiplexMail(
       $template,
       array_select_keys($handles, $to_phids),
       array_select_keys($handles, $cc_phids));
 
     foreach ($mails as $mail) {
       $mail->saveAndSend();
     }
   }
 
   protected function getMailTags() {
     return array();
   }
 
   protected function getSubjectPrefix() {
     return PhabricatorEnv::getEnvConfig('metamta.differential.subject-prefix');
   }
 
   protected function shouldMarkMailAsHTML() {
     return false;
   }
 
   protected function buildBody() {
 
     $body = $this->renderBody();
 
     $reply_handler = $this->getReplyHandler();
     $reply_instructions = $reply_handler->getReplyHandlerInstructions();
     if ($reply_instructions) {
       $body .=
         "\nREPLY HANDLER ACTIONS\n".
         "  {$reply_instructions}\n";
     }
 
     if ($this->getHeraldTranscriptURI() && $this->isFirstMailToRecipients()) {
       $manage_uri = PhabricatorEnv::getProductionURI(
         '/herald/view/differential/');
 
       $xscript_uri = $this->getHeraldTranscriptURI();
       $body .= <<<EOTEXT
 
 MANAGE HERALD DIFFERENTIAL RULES
   {$manage_uri}
 
 WHY DID I GET THIS EMAIL?
   {$xscript_uri}
 
 EOTEXT;
     }
 
     return $body;
   }
 
   /**
    * You can override this method in a subclass and return array of attachments
    * to be sent with the email.  Each attachment is an instance of
    * PhabricatorMetaMTAAttachment.
    */
   protected function buildAttachments() {
     return array();
   }
 
   public function getReplyHandler() {
     if (!$this->replyHandler) {
       $this->replyHandler =
         self::newReplyHandlerForRevision($this->getRevision());
     }
 
     return $this->replyHandler;
   }
 
   public static function newReplyHandlerForRevision(
     DifferentialRevision $revision) {
 
     $reply_handler = PhabricatorEnv::newObjectFromConfig(
       'metamta.differential.reply-handler');
     $reply_handler->setMailReceiver($revision);
 
     return $reply_handler;
   }
 
 
   protected function formatText($text) {
     $text = explode("\n", rtrim($text));
     foreach ($text as &$line) {
       $line = rtrim('  '.$line);
     }
     unset($line);
     return implode("\n", $text);
   }
 
   public function setToPHIDs(array $to) {
     $this->to = $this->filterContactPHIDs($to);
     return $this;
   }
 
   public function setCCPHIDs(array $cc) {
     $this->cc = $this->filterContactPHIDs($cc);
     return $this;
   }
 
   protected function filterContactPHIDs(array $phids) {
     return $phids;
 
     // TODO: actually do this?
 
     // Differential revisions use Subscriptions for CCs, so any arbitrary
     // PHID can end up CC'd to them. Only try to actually send email PHIDs
     // which have ToolsHandle types that are marked emailable. If we don't
     // filter here, sending the email will fail.
 /*
     $handles = array();
     prep(new ToolsHandleData($phids, $handles));
     foreach ($handles as $phid => $handle) {
       if (!$handle->isEmailable()) {
         unset($handles[$phid]);
       }
     }
     return array_keys($handles);
 */
   }
 
   protected function getToPHIDs() {
     return $this->to;
   }
 
   protected function getCCPHIDs() {
     return $this->cc;
   }
 
   public function setRevision($revision) {
     $this->revision = $revision;
     return $this;
   }
 
   public function getRevision() {
     return $this->revision;
   }
 
   protected function getThreadID() {
     $phid = $this->getRevision()->getPHID();
     return "differential-rev-{$phid}-req";
   }
 
   protected function getThreadTopic() {
-    $phid = $this->getRevision()->getPHID();
-    return "Differential Revision {$phid}";
+    $id = $this->getRevision()->getID();
+    $title = $this->getRevision()->getOriginalTitle();
+    return "D{$id}: {$title}";
   }
 
   public function setComment($comment) {
     $this->comment = $comment;
     return $this;
   }
 
   public function getComment() {
     return $this->comment;
   }
 
   public function setChangesets($changesets) {
     $this->changesets = $changesets;
     return $this;
   }
 
   public function getChangesets() {
     return $this->changesets;
   }
 
   public function setInlineComments(array $inline_comments) {
     assert_instances_of($inline_comments, 'PhabricatorInlineCommentInterface');
     $this->inlineComments = $inline_comments;
     return $this;
   }
 
   public function getInlineComments() {
     return $this->inlineComments;
   }
 
   protected function renderAuxFields($phase) {
     $selector = DifferentialFieldSelector::newSelector();
     $aux_fields = $selector->sortFieldsForMail(
       $selector->getFieldSpecifications());
 
     $body = array();
     foreach ($aux_fields as $field) {
       $field->setRevision($this->getRevision());
       $text = $field->renderValueForMail($phase);
       if ($text !== null) {
         $body[] = $text;
         $body[] = null;
       }
     }
 
     return implode("\n", $body);
   }
 
   public function renderRevisionDetailLink() {
     $uri = $this->getRevisionURI();
     return "REVISION DETAIL\n  {$uri}";
   }
 
   public function getRevisionURI() {
     return PhabricatorEnv::getProductionURI('/D'.$this->getRevision()->getID());
   }
 
   public function setIsFirstMailToRecipients($first) {
     $this->isFirstMailToRecipients = $first;
     return $this;
   }
 
   public function isFirstMailToRecipients() {
     return $this->isFirstMailToRecipients;
   }
 
   public function setIsFirstMailAboutRevision($first) {
     $this->isFirstMailAboutRevision = $first;
     return $this;
   }
 
   public function isFirstMailAboutRevision() {
     return $this->isFirstMailAboutRevision;
   }
 
   public function setHeraldTranscriptURI($herald_transcript_uri) {
     $this->heraldTranscriptURI = $herald_transcript_uri;
     return $this;
   }
 
   public function getHeraldTranscriptURI() {
     return $this->heraldTranscriptURI;
   }
 
   protected function renderHandleList(array $handles, array $phids) {
     assert_instances_of($handles, 'PhabricatorObjectHandle');
     $names = array();
     foreach ($phids as $phid) {
       $names[] = $handles[$phid]->getName();
     }
     return implode(', ', $names);
   }
 
 }
diff --git a/src/applications/differential/storage/DifferentialRevision.php b/src/applications/differential/storage/DifferentialRevision.php
index 218470b65..44a19ae68 100644
--- a/src/applications/differential/storage/DifferentialRevision.php
+++ b/src/applications/differential/storage/DifferentialRevision.php
@@ -1,236 +1,245 @@
 <?php
 
 /*
  * Copyright 2012 Facebook, Inc.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
  *
  *   http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
 
 final class DifferentialRevision extends DifferentialDAO {
 
   protected $title;
+  protected $originalTitle;
   protected $status;
 
   protected $summary;
   protected $testPlan;
 
   protected $phid;
   protected $authorPHID;
   protected $lastReviewerPHID;
 
   protected $dateCommitted;
 
   protected $lineCount;
   protected $attached = array();
   protected $unsubscribed = array();
 
   protected $mailKey;
   protected $branchName;
   protected $arcanistProjectPHID;
 
   private $relationships;
   private $commits;
   private $activeDiff = false;
   private $diffIDs;
 
 
   const RELATIONSHIP_TABLE    = 'differential_relationship';
   const TABLE_COMMIT          = 'differential_commit';
 
   const RELATION_REVIEWER     = 'revw';
   const RELATION_SUBSCRIBED   = 'subd';
 
   public function getConfiguration() {
     return array(
       self::CONFIG_AUX_PHID => true,
       self::CONFIG_SERIALIZATION => array(
         'attached'      => self::SERIALIZATION_JSON,
         'unsubscribed'  => self::SERIALIZATION_JSON,
       ),
     ) + parent::getConfiguration();
   }
 
+  public function setTitle($title) {
+    $this->title = $title;
+    if (!$this->getID()) {
+      $this->originalTitle = $title;
+    }
+    return $this;
+  }
+
   public function loadCommitPHIDs() {
     if (!$this->getID()) {
       return ($this->commits = array());
     }
 
     $commits = queryfx_all(
       $this->establishConnection('r'),
       'SELECT commitPHID FROM %T WHERE revisionID = %d',
       self::TABLE_COMMIT,
       $this->getID());
     $commits = ipull($commits, 'commitPHID');
 
     return ($this->commits = $commits);
   }
 
   public function getCommitPHIDs() {
     if ($this->commits === null) {
       throw new Exception("Must attach commits first!");
     }
     return $this->commits;
   }
 
   public function getActiveDiff() {
     // TODO: Because it's currently technically possible to create a revision
     // without an associated diff, we allow an attached-but-null active diff.
     // It would be good to get rid of this once we make diff-attaching
     // transactional.
 
     if ($this->activeDiff === false) {
       throw new Exception("Must attach active diff first!");
     }
     return $this->activeDiff;
   }
 
   public function attachActiveDiff($diff) {
     $this->activeDiff = $diff;
     return $this;
   }
 
   public function getDiffIDs() {
     if ($this->diffIDs === null) {
       throw new Exception("Must attach diff IDs first!");
     }
     return $this->diffIDs;
   }
 
   public function attachDiffIDs(array $ids) {
     rsort($ids);
     $this->diffIDs = array_values($ids);
     return $this;
   }
 
   public function attachCommitPHIDs(array $phids) {
     $this->commits = array_values($phids);
     return $this;
   }
 
   public function getAttachedPHIDs($type) {
     return array_keys(idx($this->attached, $type, array()));
   }
 
   public function setAttachedPHIDs($type, array $phids) {
     $this->attached[$type] = array_fill_keys($phids, array());
     return $this;
   }
 
   public function generatePHID() {
     return PhabricatorPHID::generateNewPHID(
       PhabricatorPHIDConstants::PHID_TYPE_DREV);
   }
 
   public function loadDiffs() {
     if (!$this->getID()) {
       return array();
     }
     return id(new DifferentialDiff())->loadAllWhere(
       'revisionID = %d',
       $this->getID());
   }
 
   public function loadComments() {
     if (!$this->getID()) {
       return array();
     }
     return id(new DifferentialComment())->loadAllWhere(
       'revisionID = %d',
       $this->getID());
   }
 
   public function loadActiveDiff() {
     return id(new DifferentialDiff())->loadOneWhere(
       'revisionID = %d ORDER BY id DESC LIMIT 1',
       $this->getID());
   }
 
   public function save() {
     if (!$this->getMailKey()) {
       $this->mailKey = Filesystem::readRandomCharacters(40);
     }
     return parent::save();
   }
 
   public function loadRelationships() {
     if (!$this->getID()) {
       $this->relationships = array();
       return;
     }
 
     $data = queryfx_all(
       $this->establishConnection('r'),
       'SELECT * FROM %T WHERE revisionID = %d ORDER BY sequence',
       self::RELATIONSHIP_TABLE,
       $this->getID());
 
     return $this->attachRelationships($data);
   }
 
   public function attachRelationships(array $relationships) {
     $this->relationships = igroup($relationships, 'relation');
     return $this;
   }
 
   public function getReviewers() {
     return $this->getRelatedPHIDs(self::RELATION_REVIEWER);
   }
 
   public function getCCPHIDs() {
     return $this->getRelatedPHIDs(self::RELATION_SUBSCRIBED);
   }
 
   private function getRelatedPHIDs($relation) {
     if ($this->relationships === null) {
       throw new Exception("Must load relationships!");
     }
 
     return ipull($this->getRawRelations($relation), 'objectPHID');
   }
 
   public function getRawRelations($relation) {
     return idx($this->relationships, $relation, array());
   }
 
   public function getUnsubscribedPHIDs() {
     return array_keys($this->getUnsubscribed());
   }
 
   public function getPrimaryReviewer() {
     if (!$this->lastReviewerPHID) {
       return head($this->getReviewers());
     }
     return $this->lastReviewerPHID;
   }
 
   public function loadReviewedBy() {
     $reviewer = null;
 
     if ($this->status == ArcanistDifferentialRevisionStatus::ACCEPTED ||
         $this->status == ArcanistDifferentialRevisionStatus::CLOSED) {
       $comments = $this->loadComments();
       foreach ($comments as $comment) {
         $action = $comment->getAction();
         if ($action == DifferentialAction::ACTION_ACCEPT) {
           $reviewer = $comment->getAuthorPHID();
         } else if ($action == DifferentialAction::ACTION_REJECT ||
                    $action == DifferentialAction::ACTION_ABANDON ||
                    $action == DifferentialAction::ACTION_RETHINK) {
           $reviewer = null;
         }
       }
     }
 
     return $reviewer;
   }
 }
diff --git a/src/applications/maniphest/editor/ManiphestTransactionEditor.php b/src/applications/maniphest/editor/ManiphestTransactionEditor.php
index d9307b3aa..ec6f4518e 100644
--- a/src/applications/maniphest/editor/ManiphestTransactionEditor.php
+++ b/src/applications/maniphest/editor/ManiphestTransactionEditor.php
@@ -1,440 +1,440 @@
 <?php
 
 /*
  * Copyright 2012 Facebook, Inc.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
  *
  *   http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
 
 /**
  * @group maniphest
  */
 final class ManiphestTransactionEditor {
 
   private $parentMessageID;
   private $auxiliaryFields = array();
 
   public function setAuxiliaryFields(array $fields) {
     assert_instances_of($fields, 'ManiphestAuxiliaryFieldSpecification');
     $this->auxiliaryFields = $fields;
     return $this;
   }
 
   public function setParentMessageID($parent_message_id) {
     $this->parentMessageID = $parent_message_id;
     return $this;
   }
 
   public function applyTransactions(ManiphestTask $task, array $transactions) {
     assert_instances_of($transactions, 'ManiphestTransaction');
 
     $email_cc = $task->getCCPHIDs();
 
     $email_to = array();
     $email_to[] = $task->getOwnerPHID();
 
     $pri_changed = $this->isCreate($transactions);
 
     foreach ($transactions as $key => $transaction) {
       $type = $transaction->getTransactionType();
       $new = $transaction->getNewValue();
       $email_to[] = $transaction->getAuthorPHID();
 
       $value_is_phid_set = false;
 
       switch ($type) {
         case ManiphestTransactionType::TYPE_NONE:
           $old = null;
           break;
         case ManiphestTransactionType::TYPE_STATUS:
           $old = $task->getStatus();
           break;
         case ManiphestTransactionType::TYPE_OWNER:
           $old = $task->getOwnerPHID();
           break;
         case ManiphestTransactionType::TYPE_CCS:
           $old = $task->getCCPHIDs();
           $value_is_phid_set = true;
           break;
         case ManiphestTransactionType::TYPE_PRIORITY:
           $old = $task->getPriority();
           break;
         case ManiphestTransactionType::TYPE_ATTACH:
           $old = $task->getAttached();
           break;
         case ManiphestTransactionType::TYPE_TITLE:
           $old = $task->getTitle();
           break;
         case ManiphestTransactionType::TYPE_DESCRIPTION:
           $old = $task->getDescription();
           break;
         case ManiphestTransactionType::TYPE_PROJECTS:
           $old = $task->getProjectPHIDs();
           $value_is_phid_set = true;
           break;
         case ManiphestTransactionType::TYPE_AUXILIARY:
           $aux_key = $transaction->getMetadataValue('aux:key');
           if (!$aux_key) {
             throw new Exception(
               "Expected 'aux:key' metadata on TYPE_AUXILIARY transaction.");
           }
           $old = $task->getAuxiliaryAttribute($aux_key);
           break;
         default:
           throw new Exception('Unknown action type.');
       }
 
       $old_cmp = $old;
       $new_cmp = $new;
       if ($value_is_phid_set) {
 
         // Normalize the old and new values if they are PHID sets so we don't
         // get any no-op transactions where the values differ only by keys,
         // order, duplicates, etc.
 
         if (is_array($old)) {
           $old = array_filter($old);
           $old = array_unique($old);
           sort($old);
           $old = array_values($old);
           $old_cmp = $old;
         }
 
         if (is_array($new)) {
           $new = array_filter($new);
           $new = array_unique($new);
           $transaction->setNewValue($new);
 
           $new_cmp = $new;
           sort($new_cmp);
           $new_cmp = array_values($new_cmp);
         }
       }
 
       if (($old !== null) && ($old_cmp == $new_cmp)) {
         if (count($transactions) > 1 && !$transaction->hasComments()) {
           // If we have at least one other transaction and this one isn't
           // doing anything and doesn't have any comments, just throw it
           // away.
           unset($transactions[$key]);
           continue;
         } else {
           $transaction->setOldValue(null);
           $transaction->setNewValue(null);
           $transaction->setTransactionType(ManiphestTransactionType::TYPE_NONE);
         }
       } else {
         switch ($type) {
           case ManiphestTransactionType::TYPE_NONE:
             break;
           case ManiphestTransactionType::TYPE_STATUS:
             $task->setStatus($new);
             break;
           case ManiphestTransactionType::TYPE_OWNER:
             if ($new) {
               $handles = id(new PhabricatorObjectHandleData(array($new)))
                 ->loadHandles();
               $task->setOwnerOrdering($handles[$new]->getName());
             } else {
               $task->setOwnerOrdering(null);
             }
             $task->setOwnerPHID($new);
             break;
           case ManiphestTransactionType::TYPE_CCS:
             $task->setCCPHIDs($new);
             break;
           case ManiphestTransactionType::TYPE_PRIORITY:
             $task->setPriority($new);
             $pri_changed = true;
             break;
           case ManiphestTransactionType::TYPE_ATTACH:
             $task->setAttached($new);
             break;
           case ManiphestTransactionType::TYPE_TITLE:
             $task->setTitle($new);
             break;
           case ManiphestTransactionType::TYPE_DESCRIPTION:
             $task->setDescription($new);
             break;
           case ManiphestTransactionType::TYPE_PROJECTS:
             $task->setProjectPHIDs($new);
             break;
           case ManiphestTransactionType::TYPE_AUXILIARY:
             $aux_key = $transaction->getMetadataValue('aux:key');
             $task->setAuxiliaryAttribute($aux_key, $new);
             break;
           default:
             throw new Exception('Unknown action type.');
         }
 
         $transaction->setOldValue($old);
         $transaction->setNewValue($new);
       }
 
     }
 
     if ($pri_changed) {
       $subpriority = ManiphestTransactionEditor::getNextSubpriority(
         $task->getPriority(),
         null);
       $task->setSubpriority($subpriority);
     }
 
     $task->save();
     foreach ($transactions as $transaction) {
       $transaction->setTaskID($task->getID());
       $transaction->save();
     }
 
     $email_to[] = $task->getOwnerPHID();
     $email_cc = array_merge(
       $email_cc,
       $task->getCCPHIDs());
 
     $this->publishFeedStory($task, $transactions);
 
     // TODO: Do this offline via timeline
     PhabricatorSearchManiphestIndexer::indexTask($task);
 
     $this->sendEmail($task, $transactions, $email_to, $email_cc);
   }
 
   protected function getSubjectPrefix() {
     return PhabricatorEnv::getEnvConfig('metamta.maniphest.subject-prefix');
   }
 
   private function sendEmail($task, $transactions, $email_to, $email_cc) {
     $email_to = array_filter(array_unique($email_to));
     $email_cc = array_filter(array_unique($email_cc));
 
     $phids = array();
     foreach ($transactions as $transaction) {
       foreach ($transaction->extractPHIDs() as $phid) {
         $phids[$phid] = true;
       }
     }
     foreach ($email_to as $phid) {
       $phids[$phid] = true;
     }
     foreach ($email_cc as $phid) {
       $phids[$phid] = true;
     }
     $phids = array_keys($phids);
 
     $handles = id(new PhabricatorObjectHandleData($phids))
       ->loadHandles();
 
     $view = new ManiphestTransactionDetailView();
     $view->setTransactionGroup($transactions);
     $view->setHandles($handles);
     $view->setAuxiliaryFields($this->auxiliaryFields);
     list($action, $body) = $view->renderForEmail($with_date = false);
 
     $is_create = $this->isCreate($transactions);
 
     $task_uri = PhabricatorEnv::getURI('/T'.$task->getID());
 
     $reply_handler = $this->buildReplyHandler($task);
 
     if ($is_create) {
       $body .=
         "\n\n".
         "TASK DESCRIPTION\n".
         "  ".$task->getDescription();
     }
 
     $body .=
       "\n\n".
       "TASK DETAIL\n".
       "  ".$task_uri."\n";
 
     $reply_instructions = $reply_handler->getReplyHandlerInstructions();
     if ($reply_instructions) {
       $body .=
         "\n".
         "REPLY HANDLER ACTIONS\n".
         "  ".$reply_instructions."\n";
     }
 
     $thread_id = 'maniphest-task-'.$task->getPHID();
     $task_id = $task->getID();
     $title = $task->getTitle();
 
     $mailtags = $this->getMailTags($transactions);
 
     $template = id(new PhabricatorMetaMTAMail())
       ->setSubject("T{$task_id}: {$title}")
       ->setSubjectPrefix($this->getSubjectPrefix())
       ->setVarySubjectPrefix("[{$action}]")
       ->setFrom($transaction->getAuthorPHID())
       ->setParentMessageID($this->parentMessageID)
-      ->addHeader('Thread-Topic', 'Maniphest Task '.$task->getPHID())
+      ->addHeader('Thread-Topic', "T{$task_id}: ".$task->getOriginalTitle())
       ->setThreadID($thread_id, $is_create)
       ->setRelatedPHID($task->getPHID())
       ->setIsBulk(true)
       ->setMailTags($mailtags)
       ->setBody($body);
 
     $mails = $reply_handler->multiplexMail(
       $template,
       array_select_keys($handles, $email_to),
       array_select_keys($handles, $email_cc));
 
     foreach ($mails as $mail) {
       $mail->saveAndSend();
     }
   }
 
   public function buildReplyHandler(ManiphestTask $task) {
     $handler_object = PhabricatorEnv::newObjectFromConfig(
       'metamta.maniphest.reply-handler');
     $handler_object->setMailReceiver($task);
 
     return $handler_object;
   }
 
   private function publishFeedStory(ManiphestTask $task, array $transactions) {
     assert_instances_of($transactions, 'ManiphestTransaction');
 
     $actions = array(ManiphestAction::ACTION_UPDATE);
     $comments = null;
     foreach ($transactions as $transaction) {
       if ($transaction->hasComments()) {
         $comments = $transaction->getComments();
       }
       $type = $transaction->getTransactionType();
       switch ($type) {
         case ManiphestTransactionType::TYPE_OWNER:
           $actions[] = ManiphestAction::ACTION_ASSIGN;
           break;
         case ManiphestTransactionType::TYPE_STATUS:
           if ($task->getStatus() != ManiphestTaskStatus::STATUS_OPEN) {
             $actions[] = ManiphestAction::ACTION_CLOSE;
           } else if ($this->isCreate($transactions)) {
             $actions[] = ManiphestAction::ACTION_CREATE;
           } else {
             $actions[] = ManiphestAction::ACTION_REOPEN;
           }
           break;
         default:
           $actions[] = $type;
           break;
       }
     }
 
     $action_type = ManiphestAction::selectStrongestAction($actions);
     $owner_phid = $task->getOwnerPHID();
     $actor_phid = head($transactions)->getAuthorPHID();
     $author_phid = $task->getAuthorPHID();
 
 
     id(new PhabricatorFeedStoryPublisher())
       ->setStoryType(PhabricatorFeedStoryTypeConstants::STORY_MANIPHEST)
       ->setStoryData(array(
         'taskPHID'        => $task->getPHID(),
         'transactionIDs'  => mpull($transactions, 'getID'),
         'ownerPHID'       => $owner_phid,
         'action'          => $action_type,
         'comments'        => $comments,
         'description'     => $task->getDescription(),
       ))
       ->setStoryTime(time())
       ->setStoryAuthorPHID($actor_phid)
       ->setRelatedPHIDs(
         array_merge(
           array_filter(
             array(
               $task->getPHID(),
               $author_phid,
               $actor_phid,
               $owner_phid,
             )),
           $task->getProjectPHIDs()))
       ->setPrimaryObjectPHID($task->getPHID())
       ->setSubscribedPHIDs(
         array_merge(
           array_filter(
             array(
               $author_phid,
               $owner_phid,
               $actor_phid)),
           $task->getCCPHIDs()))
       ->publish();
   }
 
   private function isCreate(array $transactions) {
     assert_instances_of($transactions, 'ManiphestTransaction');
     $is_create = false;
     foreach ($transactions as $transaction) {
       $type = $transaction->getTransactionType();
       if (($type == ManiphestTransactionType::TYPE_STATUS) &&
           ($transaction->getOldValue() === null) &&
           ($transaction->getNewValue() == ManiphestTaskStatus::STATUS_OPEN)) {
         $is_create = true;
       }
     }
     return $is_create;
   }
 
   private function getMailTags(array $transactions) {
     assert_instances_of($transactions, 'ManiphestTransaction');
 
     $tags = array();
     foreach ($transactions as $xaction) {
       switch ($xaction->getTransactionType()) {
         case ManiphestTransactionType::TYPE_CCS:
           $tags[] = MetaMTANotificationType::TYPE_MANIPHEST_CC;
           break;
         case ManiphestTransactionType::TYPE_PROJECTS:
           $tags[] = MetaMTANotificationType::TYPE_MANIPHEST_PROJECTS;
           break;
         case ManiphestTransactionType::TYPE_PRIORITY:
           $tags[] = MetaMTANotificationType::TYPE_MANIPHEST_PRIORITY;
           break;
         default:
           $tags[] = MetaMTANotificationType::TYPE_MANIPHEST_OTHER;
           break;
       }
 
       if ($xaction->hasComments()) {
         $tags[] = MetaMTANotificationType::TYPE_MANIPHEST_COMMENT;
       }
     }
 
     return array_unique($tags);
   }
 
   public static function getNextSubpriority($pri, $sub) {
 
     if ($sub === null) {
       $next = id(new ManiphestTask())->loadOneWhere(
         'priority = %d ORDER BY subpriority ASC LIMIT 1',
         $pri);
       if ($next) {
         return $next->getSubpriority() - ((double)(2 << 16));
       }
     } else {
       $next = id(new ManiphestTask())->loadOneWhere(
         'priority = %d AND subpriority > %s ORDER BY subpriority ASC LIMIT 1',
         $pri,
         $sub);
       if ($next) {
         return ($sub + $next->getSubpriority()) / 2;
       }
     }
 
     return (double)(2 << 32);
   }
 
 
 }
diff --git a/src/applications/maniphest/storage/ManiphestTask.php b/src/applications/maniphest/storage/ManiphestTask.php
index d95084896..cf0d88d77 100644
--- a/src/applications/maniphest/storage/ManiphestTask.php
+++ b/src/applications/maniphest/storage/ManiphestTask.php
@@ -1,208 +1,217 @@
 <?php
 
 /*
  * Copyright 2012 Facebook, Inc.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
  *
  *   http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
 
 /**
  * @group maniphest
  */
 final class ManiphestTask extends ManiphestDAO {
 
   protected $phid;
   protected $authorPHID;
   protected $ownerPHID;
   protected $ccPHIDs = array();
 
   protected $status;
   protected $priority;
   protected $subpriority;
 
   protected $title;
+  protected $originalTitle;
   protected $description;
   protected $originalEmailSource;
   protected $mailKey;
 
   protected $attached = array();
   protected $projectPHIDs = array();
   private $projectsNeedUpdate;
   private $subscribersNeedUpdate;
 
   protected $ownerOrdering;
 
   private $auxiliaryAttributes;
   private $auxiliaryDirty = array();
 
   public function getConfiguration() {
     return array(
       self::CONFIG_AUX_PHID => true,
       self::CONFIG_SERIALIZATION => array(
         'ccPHIDs' => self::SERIALIZATION_JSON,
         'attached' => self::SERIALIZATION_JSON,
         'projectPHIDs' => self::SERIALIZATION_JSON,
       ),
     ) + parent::getConfiguration();
   }
 
   public function getAttachedPHIDs($type) {
     return array_keys(idx($this->attached, $type, array()));
   }
 
   public function generatePHID() {
     return PhabricatorPHID::generateNewPHID(
       PhabricatorPHIDConstants::PHID_TYPE_TASK);
   }
 
   public function getCCPHIDs() {
     return array_values(nonempty($this->ccPHIDs, array()));
   }
 
   public function setProjectPHIDs(array $phids) {
     $this->projectPHIDs = array_values($phids);
     $this->projectsNeedUpdate = true;
     return $this;
   }
 
   public function getProjectPHIDs() {
     return array_values(nonempty($this->projectPHIDs, array()));
   }
 
   public function setCCPHIDs(array $phids) {
     $this->ccPHIDs = array_values($phids);
     $this->subscribersNeedUpdate = true;
     return $this;
   }
 
   public function setOwnerPHID($phid) {
     $this->ownerPHID = $phid;
     $this->subscribersNeedUpdate = true;
     return $this;
   }
 
   public function getAuxiliaryAttribute($key, $default = null) {
     if ($this->auxiliaryAttributes === null) {
       throw new Exception("Attach auxiliary attributes before getting them!");
     }
     return idx($this->auxiliaryAttributes, $key, $default);
   }
 
   public function setAuxiliaryAttribute($key, $val) {
     if ($this->auxiliaryAttributes === null) {
       throw new Exception("Attach auxiliary attributes before setting them!");
     }
     $this->auxiliaryAttributes[$key] = $val;
     $this->auxiliaryDirty[$key] = true;
     return $this;
   }
 
+  public function setTitle($title) {
+    $this->title = $title;
+    if (!$this->getID()) {
+      $this->originalTitle = $title;
+    }
+    return $this;
+  }
+
   public function attachAuxiliaryAttributes(array $attrs) {
     if ($this->auxiliaryDirty) {
       throw new Exception(
         "This object has dirty attributes, you can not attach new attributes ".
         "without writing or discarding the dirty attributes.");
     }
     $this->auxiliaryAttributes = $attrs;
     return $this;
   }
 
   public function loadAndAttachAuxiliaryAttributes() {
     if (!$this->getPHID()) {
       $this->auxiliaryAttributes = array();
       return $this;
     }
 
     $storage = id(new ManiphestTaskAuxiliaryStorage())->loadAllWhere(
       'taskPHID = %s',
       $this->getPHID());
 
     $this->auxiliaryAttributes = mpull($storage, 'getValue', 'getName');
 
     return $this;
   }
 
 
   public function save() {
     if (!$this->mailKey) {
       $this->mailKey = Filesystem::readRandomCharacters(20);
     }
 
     $result = parent::save();
 
     if ($this->projectsNeedUpdate) {
       // If we've changed the project PHIDs for this task, update the link
       // table.
       ManiphestTaskProject::updateTaskProjects($this);
       $this->projectsNeedUpdate = false;
     }
 
     if ($this->subscribersNeedUpdate) {
       // If we've changed the subscriber PHIDs for this task, update the link
       // table.
       ManiphestTaskSubscriber::updateTaskSubscribers($this);
       $this->subscribersNeedUpdate = false;
     }
 
     if ($this->auxiliaryDirty) {
       $this->writeAuxiliaryUpdates();
       $this->auxiliaryDirty = array();
     }
 
     return $result;
   }
 
   private function writeAuxiliaryUpdates() {
     $table = new ManiphestTaskAuxiliaryStorage();
     $conn_w = $table->establishConnection('w');
     $update = array();
     $remove = array();
 
     foreach ($this->auxiliaryDirty as $key => $dirty) {
       $value = $this->getAuxiliaryAttribute($key);
       if ($value === null) {
         $remove[$key] = true;
       } else {
         $update[$key] = $value;
       }
     }
 
     if ($remove) {
       queryfx(
         $conn_w,
         'DELETE FROM %T WHERE taskPHID = %s AND name IN (%Ls)',
         $table->getTableName(),
         $this->getPHID(),
         array_keys($remove));
     }
 
     if ($update) {
       $sql = array();
       foreach ($update as $key => $val) {
         $sql[] = qsprintf(
           $conn_w,
           '(%s, %s, %s)',
           $this->getPHID(),
           $key,
           $val);
       }
       queryfx(
         $conn_w,
         'INSERT INTO %T (taskPHID, name, value) VALUES %Q
           ON DUPLICATE KEY UPDATE value = VALUES(value)',
         $table->getTableName(),
         implode(', ', $sql));
     }
   }
 
 }
diff --git a/src/applications/owners/mail/PackageMail.php b/src/applications/owners/mail/PackageMail.php
index 6be89d2df..700f83843 100644
--- a/src/applications/owners/mail/PackageMail.php
+++ b/src/applications/owners/mail/PackageMail.php
@@ -1,220 +1,220 @@
 <?php
 
 /*
  * Copyright 2012 Facebook, Inc.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
  *
  *   http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
 
 abstract class PackageMail {
 
   protected $package;
   protected $handles;
   protected $owners;
   protected $paths;
   protected $mailTo;
 
-  public function __construct($package) {
+  public function __construct(PhabricatorOwnersPackage $package) {
     $this->package = $package;
   }
 
   abstract protected function getVerb();
 
   abstract protected function isNewThread();
 
   final protected function getPackage() {
     return $this->package;
   }
 
   final protected function getHandles() {
     return $this->handles;
   }
 
   final protected function getOwners() {
     return $this->owners;
   }
 
   final protected function getPaths() {
     return $this->paths;
   }
 
   final protected function getMailTo() {
     return $this->mailTo;
   }
 
   final protected function renderPackageTitle() {
     return $this->getPackage()->getName();
   }
 
   final protected function renderRepoSubSection($repository_phid, $paths) {
     $handles = $this->getHandles();
     $section = array();
     $section[] = '  In repository '.$handles[$repository_phid]->getName().
       ' - '. PhabricatorEnv::getProductionURI($handles[$repository_phid]
       ->getURI());
     foreach ($paths as $path => $ignored) {
       $section[] = '    '.$path;
     }
 
     return implode("\n", $section);
   }
 
   protected function needSend() {
     return true;
   }
 
   protected function loadData() {
     $package = $this->getPackage();
     $owners = $package->loadOwners();
     $this->owners = $owners;
 
     $owner_phids = mpull($owners, 'getUserPHID');
     $primary_owner_phid = $package->getPrimaryOwnerPHID();
     $mail_to = $owner_phids;
     if (!in_array($primary_owner_phid, $owner_phids)) {
       $mail_to[] = $primary_owner_phid;
     }
     $this->mailTo = $mail_to;
 
     $paths = $package->loadPaths();
     $this->paths = mgroup($paths, 'getRepositoryPHID', 'getPath');
 
     $phids = array_merge(
       $this->mailTo,
       array($package->getActorPHID()),
       array_keys($this->paths));
     $this->handles = id(new PhabricatorObjectHandleData($phids))->loadHandles();
   }
 
   final protected function renderSummarySection() {
     $package = $this->getPackage();
     $handles = $this->getHandles();
     $section = array();
     $section[] = $handles[$package->getActorPHID()]->getName().' '.
       strtolower($this->getVerb()).' '.$this->renderPackageTitle().'.';
     $section[] = '';
 
     $section[] = 'PACKAGE DETAIL';
     $section[] = '  '.PhabricatorEnv::getProductionURI(
       '/owners/package/'.$package->getID().'/');
 
     return implode("\n", $section);
   }
 
   protected function renderDescriptionSection() {
     return "PACKAGE DESCRIPTION\n".
       '  '.$this->getPackage()->getDescription();
   }
 
   protected function renderPrimaryOwnerSection() {
     $handles = $this->getHandles();
     return "PRIMARY OWNER\n".
       '  '.$handles[$this->getPackage()->getPrimaryOwnerPHID()]->getName();
   }
 
   protected function renderOwnersSection() {
     $handles = $this->getHandles();
     $owners = $this->getOwners();
     if (!$owners) {
       return null;
     }
 
     $owners = mpull($owners, 'getUserPHID');
     $owners = array_select_keys($handles, $owners);
     $owners = mpull($owners, 'getName');
     return "OWNERS\n".
       '  '.implode(', ', $owners);
   }
 
   protected function renderAuditingEnabledSection() {
     return "AUDITING ENABLED STATUS\n".
       '  '.($this->getPackage()->getAuditingEnabled() ? 'Enabled' : 'Disabled');
   }
 
   protected function renderPathsSection() {
     $section = array();
     $section[] = 'PATHS';
     foreach ($this->paths as $repository_phid => $paths) {
       $section[] = $this->renderRepoSubSection($repository_phid, $paths);
     }
 
     return implode("\n", $section);
   }
 
   final protected function renderBody() {
     $body = array();
     $body[] = $this->renderSummarySection();
     $body[] = $this->renderDescriptionSection();
     $body[] = $this->renderPrimaryOwnerSection();
     $body[] = $this->renderOwnersSection();
     $body[] = $this->renderAuditingEnabledSection();
     $body[] = $this->renderPathsSection();
     $body = array_filter($body);
     return implode("\n\n", $body);
   }
 
   final public function send() {
     $mails = $this->prepareMails();
 
     foreach ($mails as $mail) {
       $mail->saveAndSend();
     }
   }
 
   final public function prepareMails() {
     if (!$this->needSend()) {
       return array();
     }
 
     $this->loadData();
 
     $package = $this->getPackage();
     $prefix = PhabricatorEnv::getEnvConfig('metamta.package.subject-prefix');
     $verb = $this->getVerb();
     $threading = $this->getMailThreading();
     list($thread_id, $thread_topic) = $threading;
 
     $template = id(new PhabricatorMetaMTAMail())
       ->setSubject($this->renderPackageTitle())
       ->setSubjectPrefix($prefix)
       ->setVarySubjectPrefix("[{$verb}]")
       ->setFrom($package->getActorPHID())
       ->setThreadID($thread_id, $this->isNewThread())
       ->addHeader('Thread-Topic', $thread_topic)
       ->setRelatedPHID($package->getPHID())
       ->setIsBulk(true)
       ->setBody($this->renderBody());
 
     $reply_handler = $this->newReplyHandler();
     $mails = $reply_handler->multiplexMail(
       $template,
       array_select_keys($this->getHandles(), $this->getMailTo()),
       array());
     return $mails;
   }
 
   private function getMailThreading() {
     return array(
       'package-'.$this->getPackage()->getPHID(),
-      'package '.$this->getPackage()->getPHID(),
+      'Package '.$this->getPackage()->getOriginalName(),
     );
   }
 
   private function newReplyHandler() {
     $reply_handler = PhabricatorEnv::newObjectFromConfig(
       'metamta.package.reply-handler');
     $reply_handler->setMailReceiver($this->getPackage());
     return $reply_handler;
   }
 
 }
diff --git a/src/applications/owners/storage/PhabricatorOwnersPackage.php b/src/applications/owners/storage/PhabricatorOwnersPackage.php
index 39f45c14c..82e2deae3 100644
--- a/src/applications/owners/storage/PhabricatorOwnersPackage.php
+++ b/src/applications/owners/storage/PhabricatorOwnersPackage.php
@@ -1,335 +1,344 @@
 <?php
 
 /*
  * Copyright 2012 Facebook, Inc.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
  *
  *   http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
 
 final class PhabricatorOwnersPackage extends PhabricatorOwnersDAO {
 
   protected $phid;
   protected $name;
+  protected $originalName;
   protected $auditingEnabled;
   protected $description;
   protected $primaryOwnerPHID;
 
   private $unsavedOwners;
   private $unsavedPaths;
   private $actorPHID;
   private $oldPrimaryOwnerPHID;
   private $oldAuditingEnabled;
 
   public function getConfiguration() {
     return array(
       // This information is better available from the history table.
       self::CONFIG_TIMESTAMPS => false,
       self::CONFIG_AUX_PHID   => true,
     ) + parent::getConfiguration();
   }
 
   public function generatePHID() {
     return PhabricatorPHID::generateNewPHID('OPKG');
   }
 
   public function attachUnsavedOwners(array $owners) {
     $this->unsavedOwners = $owners;
     return $this;
   }
 
   public function attachUnsavedPaths(array $paths) {
     $this->unsavedPaths = $paths;
     return $this;
   }
 
   public function attachActorPHID($actor_phid) {
     $this->actorPHID = $actor_phid;
     return $this;
   }
 
   public function getActorPHID() {
     return $this->actorPHID;
   }
 
   public function attachOldPrimaryOwnerPHID($old_primary) {
     $this->oldPrimaryOwnerPHID = $old_primary;
     return $this;
   }
 
   public function getOldPrimaryOwnerPHID() {
     return $this->oldPrimaryOwnerPHID;
   }
 
   public function attachOldAuditingEnabled($auditing_enabled) {
     $this->oldAuditingEnabled = $auditing_enabled;
     return $this;
   }
 
   public function getOldAuditingEnabled() {
     return $this->oldAuditingEnabled;
   }
 
+  public function setName($name) {
+    $this->name = $name;
+    if (!$this->getID()) {
+      $this->originalName = $name;
+    }
+    return $this;
+  }
+
   public function loadOwners() {
     if (!$this->getID()) {
       return array();
     }
     return id(new PhabricatorOwnersOwner())->loadAllWhere(
       'packageID = %d',
       $this->getID());
   }
 
   public function loadPaths() {
     if (!$this->getID()) {
       return array();
     }
     return id(new PhabricatorOwnersPath())->loadAllWhere(
       'packageID = %d',
       $this->getID());
   }
 
   public static function loadAffectedPackages(
     PhabricatorRepository $repository,
     array $paths) {
 
     if (!$paths) {
       return array();
     }
 
     $fragments = array(
       '/' => true,
     );
 
     foreach ($paths as $path) {
       $fragments += self::splitPath($path);
     }
 
     return self::loadPackagesForPaths($repository, array_keys($fragments));
  }
 
  public static function loadOwningPackages($repository, $path) {
     if (empty($path)) {
       return array();
     }
 
     $fragments = self::splitPath($path);
     return self::loadPackagesForPaths($repository, array_keys($fragments), 1);
  }
 
   private static function loadPackagesForPaths(
     PhabricatorRepository $repository,
     array $paths,
     $limit = 0) {
     $package = new PhabricatorOwnersPackage();
     $path = new PhabricatorOwnersPath();
     $conn = $package->establishConnection('r');
 
     $repository_clause = qsprintf($conn, 'AND p.repositoryPHID = %s',
       $repository->getPHID());
 
     $limit_clause = '';
     if (!empty($limit)) {
       $limit_clause = qsprintf($conn, 'LIMIT %d', $limit);
     }
 
     $data = queryfx_all(
       $conn,
       'SELECT pkg.id FROM %T pkg JOIN %T p ON p.packageID = pkg.id
         WHERE p.path IN (%Ls) %Q ORDER BY LENGTH(p.path) DESC %Q',
       $package->getTableName(),
       $path->getTableName(),
       $paths,
       $repository_clause,
       $limit_clause);
 
     $ids = ipull($data, 'id');
 
     if (empty($ids)) {
       return array();
     }
 
     $order = array();
     foreach ($ids as $id) {
       if (empty($order[$id])) {
         $order[$id] = true;
       }
     }
 
     $packages = $package->loadAllWhere('id in (%Ld)', array_keys($order));
 
     $packages = array_select_keys($packages, array_keys($order));
 
     return $packages;
   }
 
   public function save() {
 
     if ($this->getID()) {
       $is_new = false;
     } else {
       $is_new = true;
     }
 
     $this->openTransaction();
 
     $ret = parent::save();
 
     $add_owners = array();
     $remove_owners = array();
     $all_owners = array();
     if ($this->unsavedOwners) {
       $new_owners = array_fill_keys($this->unsavedOwners, true);
       $cur_owners = array();
       foreach ($this->loadOwners() as $owner) {
         if (empty($new_owners[$owner->getUserPHID()])) {
           $remove_owners[$owner->getUserPHID()] = true;
           $owner->delete();
           continue;
         }
         $cur_owners[$owner->getUserPHID()] = true;
       }
 
       $add_owners = array_diff_key($new_owners, $cur_owners);
       $all_owners = array_merge(
         array($this->getPrimaryOwnerPHID() => true),
         $new_owners,
         $remove_owners);
       foreach ($add_owners as $phid => $ignored) {
         $owner = new PhabricatorOwnersOwner();
         $owner->setPackageID($this->getID());
         $owner->setUserPHID($phid);
         $owner->save();
       }
       unset($this->unsavedOwners);
     }
 
     $add_paths = array();
     $remove_paths = array();
     $touched_repos = array();
     if ($this->unsavedPaths) {
       $new_paths = igroup($this->unsavedPaths, 'repositoryPHID', 'path');
       $cur_paths = $this->loadPaths();
       foreach ($cur_paths as $key => $path) {
         if (empty($new_paths[$path->getRepositoryPHID()][$path->getPath()])) {
           $touched_repos[$path->getRepositoryPHID()] = true;
           $remove_paths[$path->getRepositoryPHID()][$path->getPath()] = true;
           $path->delete();
           unset($cur_paths[$key]);
         }
       }
 
       $cur_paths = mgroup($cur_paths, 'getRepositoryPHID', 'getPath');
       foreach ($new_paths as $repository_phid => $paths) {
         // get repository object for path validation
         $repository = id(new PhabricatorRepository())->loadOneWhere(
           'phid = %s',
           $repository_phid);
         if (!$repository) {
           continue;
         }
         foreach ($paths as $path => $ignored) {
           $path = ltrim($path, '/');
           // build query to validate path
           $drequest = DiffusionRequest::newFromDictionary(
             array(
               'repository'  => $repository,
               'path'        => $path,
             ));
           $query = DiffusionBrowseQuery::newFromDiffusionRequest($drequest);
           $query->needValidityOnly(true);
           $valid = $query->loadPaths();
           $is_directory = true;
           if (!$valid) {
             switch ($query->getReasonForEmptyResultSet()) {
               case DiffusionBrowseQuery::REASON_IS_FILE:
                 $valid = true;
                 $is_directory = false;
                 break;
               case DiffusionBrowseQuery::REASON_IS_EMPTY:
                 $valid = true;
                 break;
             }
           }
           if ($is_directory && substr($path, -1) != '/') {
             $path .= '/';
           }
           if (substr($path, 0, 1) != '/') {
             $path = '/'.$path;
           }
           if (empty($cur_paths[$repository_phid][$path]) && $valid) {
             $touched_repos[$repository_phid] = true;
             $add_paths[$repository_phid][$path] = true;
             $obj = new PhabricatorOwnersPath();
             $obj->setPackageID($this->getID());
             $obj->setRepositoryPHID($repository_phid);
             $obj->setPath($path);
             $obj->save();
           }
         }
       }
       unset($this->unsavedPaths);
     }
 
     $this->saveTransaction();
 
     if ($is_new) {
       $mail = new PackageCreateMail($this);
     } else {
       $mail = new PackageModifyMail(
         $this,
         array_keys($add_owners),
         array_keys($remove_owners),
         array_keys($all_owners),
         array_keys($touched_repos),
         $add_paths,
         $remove_paths);
     }
     $mail->send();
 
     return $ret;
   }
 
   public function delete() {
     $mails = id(new PackageDeleteMail($this))->prepareMails();
 
     $this->openTransaction();
     foreach ($this->loadOwners() as $owner) {
       $owner->delete();
     }
     foreach ($this->loadPaths() as $path) {
       $path->delete();
     }
 
     $ret = parent::delete();
 
     $this->saveTransaction();
 
     foreach ($mails as $mail) {
       $mail->saveAndSend();
     }
 
     return $ret;
   }
 
   private static function splitPath($path) {
     $result = array();
     $trailing_slash = preg_match('@/$@', $path) ? '/' : '';
     $path = trim($path, '/');
     $parts = explode('/', $path);
     while (count($parts)) {
       $result['/'.implode('/', $parts).$trailing_slash] = true;
       $trailing_slash = '/';
       array_pop($parts);
     }
     return $result;
   }
 }
diff --git a/src/applications/repository/worker/PhabricatorRepositoryCommitHeraldWorker.php b/src/applications/repository/worker/PhabricatorRepositoryCommitHeraldWorker.php
index bcc0b658b..d6f58b5a6 100644
--- a/src/applications/repository/worker/PhabricatorRepositoryCommitHeraldWorker.php
+++ b/src/applications/repository/worker/PhabricatorRepositoryCommitHeraldWorker.php
@@ -1,275 +1,276 @@
 <?php
 
 /*
  * Copyright 2012 Facebook, Inc.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
  *
  *   http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
 
 final class PhabricatorRepositoryCommitHeraldWorker
   extends PhabricatorRepositoryCommitParserWorker {
 
   public function parseCommit(
     PhabricatorRepository $repository,
     PhabricatorRepositoryCommit $commit) {
 
     $data = id(new PhabricatorRepositoryCommitData())->loadOneWhere(
       'commitID = %d',
       $commit->getID());
 
     if (!$data) {
       // TODO: Permanent failure.
       return;
     }
 
     $rules = HeraldRule::loadAllByContentTypeWithFullData(
       HeraldContentTypeConfig::CONTENT_TYPE_COMMIT,
       $commit->getPHID());
 
     $adapter = new HeraldCommitAdapter(
       $repository,
       $commit,
       $data);
     $engine = new HeraldEngine();
 
     $effects = $engine->applyRules($rules, $adapter);
     $engine->applyEffects($effects, $adapter, $rules);
 
     $audit_phids = $adapter->getAuditMap();
     if ($audit_phids) {
       $this->createAudits($commit, $audit_phids, $rules);
     }
 
     $this->createAuditsFromCommitMessage($commit, $data);
 
     $email_phids = $adapter->getEmailPHIDs();
     if (!$email_phids) {
       return;
     }
 
     if ($repository->getDetail('herald-disabled')) {
       // This just means "disable email"; audits are (mostly) idempotent.
       return;
     }
 
     $xscript = $engine->getTranscript();
 
     $revision = $adapter->loadDifferentialRevision();
     if ($revision) {
       $name = $revision->getTitle();
     } else {
       $name = $data->getSummary();
     }
 
     $author_phid = $data->getCommitDetail('authorPHID');
     $reviewer_phid = $data->getCommitDetail('reviewerPHID');
 
     $phids = array_filter(
       array(
         $author_phid,
         $reviewer_phid,
         $commit->getPHID(),
       ));
 
     $handles = id(new PhabricatorObjectHandleData($phids))->loadHandles();
 
     $commit_handle = $handles[$commit->getPHID()];
     $commit_name = $commit_handle->getName();
 
     if ($author_phid) {
       $author_name = $handles[$author_phid]->getName();
     } else {
       $author_name = $data->getAuthorName();
     }
 
     if ($reviewer_phid) {
       $reviewer_name = $handles[$reviewer_phid]->getName();
     } else {
       $reviewer_name = null;
     }
 
     $who = implode(', ', array_filter(array($author_name, $reviewer_name)));
 
     $description = $data->getCommitMessage();
 
     $commit_uri = PhabricatorEnv::getProductionURI($commit_handle->getURI());
     $differential = $revision
       ? PhabricatorEnv::getProductionURI('/D'.$revision->getID())
       : 'No revision.';
 
     $files = $adapter->loadAffectedPaths();
     sort($files);
     $files = implode("\n  ", $files);
 
     $xscript_id = $xscript->getID();
 
     $manage_uri = PhabricatorEnv::getProductionURI('/herald/view/commits/');
     $why_uri = PhabricatorEnv::getProductionURI(
       '/herald/transcript/'.$xscript_id.'/');
 
     $reply_handler = PhabricatorAuditCommentEditor::newReplyHandlerForCommit(
       $commit);
 
     $reply_instructions = $reply_handler->getReplyHandlerInstructions();
     if ($reply_instructions) {
       $reply_instructions =
         "\n".
         "REPLY HANDLER ACTIONS\n".
         "  ".$reply_instructions."\n";
     }
 
 
     $body = <<<EOBODY
 DESCRIPTION
 {$description}
 
 DETAILS
   {$commit_uri}
 
 DIFFERENTIAL REVISION
   {$differential}
 
 AFFECTED FILES
   {$files}
 {$reply_instructions}
 MANAGE HERALD COMMIT RULES
   {$manage_uri}
 
 WHY DID I GET THIS EMAIL?
   {$why_uri}
 
 EOBODY;
 
     $prefix = PhabricatorEnv::getEnvConfig('metamta.diffusion.subject-prefix');
 
     $threading = PhabricatorAuditCommentEditor::getMailThreading(
-      $commit->getPHID());
+      $repository,
+      $commit);
     list($thread_id, $thread_topic) = $threading;
 
     $template = new PhabricatorMetaMTAMail();
     $template->setRelatedPHID($commit->getPHID());
     $template->setSubject("{$commit_name}: {$name}");
     $template->setSubjectPrefix($prefix);
     $template->setVarySubjectPrefix("[Commit]");
     $template->setBody($body);
     $template->setThreadID($thread_id, $is_new = true);
     $template->addHeader('Thread-Topic', $thread_topic);
     $template->setIsBulk(true);
 
     $template->addHeader('X-Herald-Rules', $xscript->getXHeraldRulesHeader());
     if ($author_phid) {
       $template->setFrom($author_phid);
     }
 
     $mails = $reply_handler->multiplexMail(
       $template,
       id(new PhabricatorObjectHandleData($email_phids))->loadHandles(),
       array());
 
     foreach ($mails as $mail) {
       $mail->saveAndSend();
     }
   }
 
   private function createAudits(
     PhabricatorRepositoryCommit $commit,
     array $map,
     array $rules) {
     assert_instances_of($rules, 'HeraldRule');
 
     $requests = id(new PhabricatorRepositoryAuditRequest())->loadAllWhere(
       'commitPHID = %s',
       $commit->getPHID());
     $requests = mpull($requests, null, 'getAuditorPHID');
 
     $rules = mpull($rules, null, 'getID');
     foreach ($map as $phid => $rule_ids) {
       $request = idx($requests, $phid);
       if ($request) {
         continue;
       }
       $reasons = array();
       foreach ($rule_ids as $id) {
         $rule_name = '?';
         if ($rules[$id]) {
           $rule_name = $rules[$id]->getName();
         }
         $reasons[] = 'Herald Rule #'.$id.' "'.$rule_name.'" Triggered Audit';
       }
 
       $request = new PhabricatorRepositoryAuditRequest();
       $request->setCommitPHID($commit->getPHID());
       $request->setAuditorPHID($phid);
       $request->setAuditStatus(PhabricatorAuditStatusConstants::AUDIT_REQUIRED);
       $request->setAuditReasons($reasons);
       $request->save();
     }
 
     $commit->updateAuditStatus($requests);
     $commit->save();
   }
 
 
   /**
    * Find audit requests in the "Auditors" field if it is present and trigger
    * explicit audit requests.
    */
   private function createAuditsFromCommitMessage(
     PhabricatorRepositoryCommit $commit,
     PhabricatorRepositoryCommitData $data) {
 
     $message = $data->getCommitMessage();
 
     $matches = null;
     if (!preg_match('/^Auditors:\s*(.*)$/im', $message, $matches)) {
       return;
     }
 
     $phids = DifferentialFieldSpecification::parseCommitMessageObjectList(
       $matches[1],
       $include_mailables = false,
       $allow_partial = true);
 
     if (!$phids) {
       return;
     }
 
     $requests = id(new PhabricatorRepositoryAuditRequest())->loadAllWhere(
       'commitPHID = %s',
       $commit->getPHID());
     $requests = mpull($requests, null, 'getAuditorPHID');
 
     foreach ($phids as $phid) {
       if (isset($requests[$phid])) {
         continue;
       }
 
       $request = new PhabricatorRepositoryAuditRequest();
       $request->setCommitPHID($commit->getPHID());
       $request->setAuditorPHID($phid);
       $request->setAuditStatus(
         PhabricatorAuditStatusConstants::AUDIT_REQUESTED);
       $request->setAuditReasons(
         array(
           'Requested by Author',
         ));
       $request->save();
 
       $requests[$phid] = $request;
     }
 
     $commit->updateAuditStatus($requests);
     $commit->save();
   }
 
 }
diff --git a/src/infrastructure/setup/sql/PhabricatorBuiltinPatchList.php b/src/infrastructure/setup/sql/PhabricatorBuiltinPatchList.php
index ac48990cf..5c3c66459 100644
--- a/src/infrastructure/setup/sql/PhabricatorBuiltinPatchList.php
+++ b/src/infrastructure/setup/sql/PhabricatorBuiltinPatchList.php
@@ -1,893 +1,897 @@
 <?php
 
 /*
  * Copyright 2012 Facebook, Inc.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
  *
  *   http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
 
 final class PhabricatorBuiltinPatchList extends PhabricatorSQLPatchList {
 
   public function getNamespace() {
     return 'phabricator';
   }
 
   private function getPatchPath($file) {
     $root = dirname(phutil_get_library_root('phabricator'));
     $path = $root.'/resources/sql/patches/'.$file;
 
     // Make sure it exists.
     Filesystem::readFile($path);
 
     return $path;
   }
 
   public function getPatches() {
     return array(
       'db.audit' => array(
         'type'  => 'db',
         'name'  => 'audit',
         'after' => array( /* First Patch */ ),
       ),
       'db.calendar' => array(
         'type'  => 'db',
         'name'  => 'calendar',
       ),
       'db.chatlog' => array(
         'type'  => 'db',
         'name'  => 'chatlog',
       ),
       'db.conduit' => array(
         'type'  => 'db',
         'name'  => 'conduit',
       ),
       'db.countdown' => array(
         'type'  => 'db',
         'name'  => 'countdown',
       ),
       'db.daemon' => array(
         'type'  => 'db',
         'name'  => 'daemon',
       ),
       'db.differential' => array(
         'type'  => 'db',
         'name'  => 'differential',
       ),
       'db.draft' => array(
         'type'  => 'db',
         'name'  => 'draft',
       ),
       'db.drydock' => array(
         'type'  => 'db',
         'name'  => 'drydock',
       ),
       'db.feed' => array(
         'type'  => 'db',
         'name'  => 'feed',
       ),
       'db.file' => array(
         'type'  => 'db',
         'name'  => 'file',
       ),
       'db.flag' => array(
         'type'  => 'db',
         'name'  => 'flag',
       ),
       'db.harbormaster' => array(
         'type'  => 'db',
         'name'  => 'harbormaster',
       ),
       'db.herald' => array(
         'type'  => 'db',
         'name'  => 'herald',
       ),
       'db.maniphest' => array(
         'type'  => 'db',
         'name'  => 'maniphest',
       ),
       'db.meta_data' => array(
         'type'  => 'db',
         'name'  => 'meta_data',
       ),
       'db.metamta' => array(
         'type'  => 'db',
         'name'  => 'metamta',
       ),
       'db.oauth_server' => array(
         'type'  => 'db',
         'name'  => 'oauth_server',
       ),
       'db.owners' => array(
         'type'  => 'db',
         'name'  => 'owners',
       ),
       'db.pastebin' => array(
         'type'  => 'db',
         'name'  => 'pastebin',
       ),
       'db.phame' => array(
         'type'  => 'db',
         'name'  => 'phame',
       ),
       'db.phriction' => array(
         'type'  => 'db',
         'name'  => 'phriction',
       ),
       'db.project' => array(
         'type'  => 'db',
         'name'  => 'project',
       ),
       'db.repository' => array(
         'type'  => 'db',
         'name'  => 'repository',
       ),
       'db.search' => array(
         'type'  => 'db',
         'name'  => 'search',
       ),
       'db.slowvote' => array(
         'type'  => 'db',
         'name'  => 'slowvote',
       ),
       'db.timeline' => array(
         'type'  => 'db',
         'name'  => 'timeline',
       ),
       'db.user' => array(
         'type'  => 'db',
         'name'  => 'user',
       ),
       'db.worker' => array(
         'type'  => 'db',
         'name'  => 'worker',
       ),
       'db.xhpastview' => array(
         'type'  => 'db',
         'name'  => 'xhpastview',
       ),
       '0000.legacy.sql' => array(
         'type'    => 'sql',
         'name'    => $this->getPatchPath('0000.legacy.sql'),
         'legacy'  => 0,
       ),
       '000.project.sql' => array(
         'type'    => 'sql',
         'name'    => $this->getPatchPath('000.project.sql'),
         'legacy'  => 0,
       ),
       '001.maniphest_projects.sql' => array(
         'type'    => 'sql',
         'name'    => $this->getPatchPath('001.maniphest_projects.sql'),
         'legacy'  => 1,
       ),
       '002.oauth.sql' => array(
         'type'    => 'sql',
         'name'    => $this->getPatchPath('002.oauth.sql'),
         'legacy'  => 2,
       ),
       '003.more_oauth.sql' => array(
         'type'    => 'sql',
         'name'    => $this->getPatchPath('003.more_oauth.sql'),
         'legacy'  => 3,
       ),
       '004.daemonrepos.sql' => array(
         'type'    => 'sql',
         'name'    => $this->getPatchPath('004.daemonrepos.sql'),
         'legacy'  => 4,
       ),
       '005.workers.sql' => array(
         'type'    => 'sql',
         'name'    => $this->getPatchPath('005.workers.sql'),
         'legacy'  => 5,
       ),
       '006.repository.sql' => array(
         'type'    => 'sql',
         'name'    => $this->getPatchPath('006.repository.sql'),
         'legacy'  => 6,
       ),
       '007.daemonlog.sql' => array(
         'type'    => 'sql',
         'name'    => $this->getPatchPath('007.daemonlog.sql'),
         'legacy'  => 7,
       ),
       '008.repoopt.sql' => array(
         'type'    => 'sql',
         'name'    => $this->getPatchPath('008.repoopt.sql'),
         'legacy'  => 8,
       ),
       '009.repo_summary.sql' => array(
         'type'    => 'sql',
         'name'    => $this->getPatchPath('009.repo_summary.sql'),
         'legacy'  => 9,
       ),
       '010.herald.sql' => array(
         'type'    => 'sql',
         'name'    => $this->getPatchPath('010.herald.sql'),
         'legacy'  => 10,
       ),
       '011.badcommit.sql' => array(
         'type'    => 'sql',
         'name'    => $this->getPatchPath('011.badcommit.sql'),
         'legacy'  => 11,
       ),
       '012.dropphidtype.sql' => array(
         'type'    => 'sql',
         'name'    => $this->getPatchPath('012.dropphidtype.sql'),
         'legacy'  => 12,
       ),
       '013.commitdetail.sql' => array(
         'type'    => 'sql',
         'name'    => $this->getPatchPath('013.commitdetail.sql'),
         'legacy'  => 13,
       ),
       '014.shortcuts.sql' => array(
         'type'    => 'sql',
         'name'    => $this->getPatchPath('014.shortcuts.sql'),
         'legacy'  => 14,
       ),
       '015.preferences.sql' => array(
         'type'    => 'sql',
         'name'    => $this->getPatchPath('015.preferences.sql'),
         'legacy'  => 15,
       ),
       '016.userrealnameindex.sql' => array(
         'type'    => 'sql',
         'name'    => $this->getPatchPath('016.userrealnameindex.sql'),
         'legacy'  => 16,
       ),
       '017.sessionkeys.sql' => array(
         'type'    => 'sql',
         'name'    => $this->getPatchPath('017.sessionkeys.sql'),
         'legacy'  => 17,
       ),
       '018.owners.sql' => array(
         'type'    => 'sql',
         'name'    => $this->getPatchPath('018.owners.sql'),
         'legacy'  => 18,
       ),
       '019.arcprojects.sql' => array(
         'type'    => 'sql',
         'name'    => $this->getPatchPath('019.arcprojects.sql'),
         'legacy'  => 19,
       ),
       '020.pathcapital.sql' => array(
         'type'    => 'sql',
         'name'    => $this->getPatchPath('020.pathcapital.sql'),
         'legacy'  => 20,
       ),
       '021.xhpastview.sql' => array(
         'type'    => 'sql',
         'name'    => $this->getPatchPath('021.xhpastview.sql'),
         'legacy'  => 21,
       ),
       '022.differentialcommit.sql' => array(
         'type'    => 'sql',
         'name'    => $this->getPatchPath('022.differentialcommit.sql'),
         'legacy'  => 22,
       ),
       '023.dxkeys.sql' => array(
         'type'    => 'sql',
         'name'    => $this->getPatchPath('023.dxkeys.sql'),
         'legacy'  => 23,
       ),
       '024.mlistkeys.sql' => array(
         'type'    => 'sql',
         'name'    => $this->getPatchPath('024.mlistkeys.sql'),
         'legacy'  => 24,
       ),
       '025.commentopt.sql' => array(
         'type'    => 'sql',
         'name'    => $this->getPatchPath('025.commentopt.sql'),
         'legacy'  => 25,
       ),
       '026.diffpropkey.sql' => array(
         'type'    => 'sql',
         'name'    => $this->getPatchPath('026.diffpropkey.sql'),
         'legacy'  => 26,
       ),
       '027.metamtakeys.sql' => array(
         'type'    => 'sql',
         'name'    => $this->getPatchPath('027.metamtakeys.sql'),
         'legacy'  => 27,
       ),
       '028.systemagent.sql' => array(
         'type'    => 'sql',
         'name'    => $this->getPatchPath('028.systemagent.sql'),
         'legacy'  => 28,
       ),
       '029.cursors.sql' => array(
         'type'    => 'sql',
         'name'    => $this->getPatchPath('029.cursors.sql'),
         'legacy'  => 29,
       ),
       '030.imagemacro.sql' => array(
         'type'    => 'sql',
         'name'    => $this->getPatchPath('030.imagemacro.sql'),
         'legacy'  => 30,
       ),
       '031.workerrace.sql' => array(
         'type'    => 'sql',
         'name'    => $this->getPatchPath('031.workerrace.sql'),
         'legacy'  => 31,
       ),
       '032.viewtime.sql' => array(
         'type'    => 'sql',
         'name'    => $this->getPatchPath('032.viewtime.sql'),
         'legacy'  => 32,
       ),
       '033.privtest.sql' => array(
         'type'    => 'sql',
         'name'    => $this->getPatchPath('033.privtest.sql'),
         'legacy'  => 33,
       ),
       '034.savedheader.sql' => array(
         'type'    => 'sql',
         'name'    => $this->getPatchPath('034.savedheader.sql'),
         'legacy'  => 34,
       ),
       '035.proxyimage.sql' => array(
         'type'    => 'sql',
         'name'    => $this->getPatchPath('035.proxyimage.sql'),
         'legacy'  => 35,
       ),
       '036.mailkey.sql' => array(
         'type'    => 'sql',
         'name'    => $this->getPatchPath('036.mailkey.sql'),
         'legacy'  => 36,
       ),
       '037.setuptest.sql' => array(
         'type'    => 'sql',
         'name'    => $this->getPatchPath('037.setuptest.sql'),
         'legacy'  => 37,
       ),
       '038.admin.sql' => array(
         'type'    => 'sql',
         'name'    => $this->getPatchPath('038.admin.sql'),
         'legacy'  => 38,
       ),
       '039.userlog.sql' => array(
         'type'    => 'sql',
         'name'    => $this->getPatchPath('039.userlog.sql'),
         'legacy'  => 39,
       ),
       '040.transform.sql' => array(
         'type'    => 'sql',
         'name'    => $this->getPatchPath('040.transform.sql'),
         'legacy'  => 40,
       ),
       '041.heraldrepetition.sql' => array(
         'type'    => 'sql',
         'name'    => $this->getPatchPath('041.heraldrepetition.sql'),
         'legacy'  => 41,
       ),
       '042.commentmetadata.sql' => array(
         'type'    => 'sql',
         'name'    => $this->getPatchPath('042.commentmetadata.sql'),
         'legacy'  => 42,
       ),
       '043.pastebin.sql' => array(
         'type'    => 'sql',
         'name'    => $this->getPatchPath('043.pastebin.sql'),
         'legacy'  => 43,
       ),
       '044.countdown.sql' => array(
         'type'    => 'sql',
         'name'    => $this->getPatchPath('044.countdown.sql'),
         'legacy'  => 44,
       ),
       '045.timezone.sql' => array(
         'type'    => 'sql',
         'name'    => $this->getPatchPath('045.timezone.sql'),
         'legacy'  => 45,
       ),
       '046.conduittoken.sql' => array(
         'type'    => 'sql',
         'name'    => $this->getPatchPath('046.conduittoken.sql'),
         'legacy'  => 46,
       ),
       '047.projectstatus.sql' => array(
         'type'    => 'sql',
         'name'    => $this->getPatchPath('047.projectstatus.sql'),
         'legacy'  => 47,
       ),
       '048.relationshipkeys.sql' => array(
         'type'    => 'sql',
         'name'    => $this->getPatchPath('048.relationshipkeys.sql'),
         'legacy'  => 48,
       ),
       '049.projectowner.sql' => array(
         'type'    => 'sql',
         'name'    => $this->getPatchPath('049.projectowner.sql'),
         'legacy'  => 49,
       ),
       '050.taskdenormal.sql' => array(
         'type'    => 'sql',
         'name'    => $this->getPatchPath('050.taskdenormal.sql'),
         'legacy'  => 50,
       ),
       '051.projectfilter.sql' => array(
         'type'    => 'sql',
         'name'    => $this->getPatchPath('051.projectfilter.sql'),
         'legacy'  => 51,
       ),
       '052.pastelanguage.sql' => array(
         'type'    => 'sql',
         'name'    => $this->getPatchPath('052.pastelanguage.sql'),
         'legacy'  => 52,
       ),
       '053.feed.sql' => array(
         'type'    => 'sql',
         'name'    => $this->getPatchPath('053.feed.sql'),
         'legacy'  => 53,
       ),
       '054.subscribers.sql' => array(
         'type'    => 'sql',
         'name'    => $this->getPatchPath('054.subscribers.sql'),
         'legacy'  => 54,
       ),
       '055.add_author_to_files.sql' => array(
         'type'    => 'sql',
         'name'    => $this->getPatchPath('055.add_author_to_files.sql'),
         'legacy'  => 55,
       ),
       '056.slowvote.sql' => array(
         'type'    => 'sql',
         'name'    => $this->getPatchPath('056.slowvote.sql'),
         'legacy'  => 56,
       ),
       '057.parsecache.sql' => array(
         'type'    => 'sql',
         'name'    => $this->getPatchPath('057.parsecache.sql'),
         'legacy'  => 57,
       ),
       '058.missingkeys.sql' => array(
         'type'    => 'sql',
         'name'    => $this->getPatchPath('058.missingkeys.sql'),
         'legacy'  => 58,
       ),
       '059.engines.php' => array(
         'type'    => 'php',
         'name'    => $this->getPatchPath('059.engines.php'),
         'legacy'  => 59,
       ),
       '060.phriction.sql' => array(
         'type'    => 'sql',
         'name'    => $this->getPatchPath('060.phriction.sql'),
         'legacy'  => 60,
       ),
       '061.phrictioncontent.sql' => array(
         'type'    => 'sql',
         'name'    => $this->getPatchPath('061.phrictioncontent.sql'),
         'legacy'  => 61,
       ),
       '062.phrictionmenu.sql' => array(
         'type'    => 'sql',
         'name'    => $this->getPatchPath('062.phrictionmenu.sql'),
         'legacy'  => 62,
       ),
       '063.pasteforks.sql' => array(
         'type'    => 'sql',
         'name'    => $this->getPatchPath('063.pasteforks.sql'),
         'legacy'  => 63,
       ),
       '064.subprojects.sql' => array(
         'type'    => 'sql',
         'name'    => $this->getPatchPath('064.subprojects.sql'),
         'legacy'  => 64,
       ),
       '065.sshkeys.sql' => array(
         'type'    => 'sql',
         'name'    => $this->getPatchPath('065.sshkeys.sql'),
         'legacy'  => 65,
       ),
       '066.phrictioncontent.sql' => array(
         'type'    => 'sql',
         'name'    => $this->getPatchPath('066.phrictioncontent.sql'),
         'legacy'  => 66,
       ),
       '067.preferences.sql' => array(
         'type'    => 'sql',
         'name'    => $this->getPatchPath('067.preferences.sql'),
         'legacy'  => 67,
       ),
       '068.maniphestauxiliarystorage.sql' => array(
         'type'    => 'sql',
         'name'    => $this->getPatchPath('068.maniphestauxiliarystorage.sql'),
         'legacy'  => 68,
       ),
       '069.heraldxscript.sql' => array(
         'type'    => 'sql',
         'name'    => $this->getPatchPath('069.heraldxscript.sql'),
         'legacy'  => 69,
       ),
       '070.differentialaux.sql' => array(
         'type'    => 'sql',
         'name'    => $this->getPatchPath('070.differentialaux.sql'),
         'legacy'  => 70,
       ),
       '071.contentsource.sql' => array(
         'type'    => 'sql',
         'name'    => $this->getPatchPath('071.contentsource.sql'),
         'legacy'  => 71,
       ),
       '072.blamerevert.sql' => array(
         'type'    => 'sql',
         'name'    => $this->getPatchPath('072.blamerevert.sql'),
         'legacy'  => 72,
       ),
       '073.reposymbols.sql' => array(
         'type'    => 'sql',
         'name'    => $this->getPatchPath('073.reposymbols.sql'),
         'legacy'  => 73,
       ),
       '074.affectedpath.sql' => array(
         'type'    => 'sql',
         'name'    => $this->getPatchPath('074.affectedpath.sql'),
         'legacy'  => 74,
       ),
       '075.revisionhash.sql' => array(
         'type'    => 'sql',
         'name'    => $this->getPatchPath('075.revisionhash.sql'),
         'legacy'  => 75,
       ),
       '076.indexedlanguages.sql' => array(
         'type'    => 'sql',
         'name'    => $this->getPatchPath('076.indexedlanguages.sql'),
         'legacy'  => 76,
       ),
       '077.originalemail.sql' => array(
         'type'    => 'sql',
         'name'    => $this->getPatchPath('077.originalemail.sql'),
         'legacy'  => 77,
       ),
       '078.nametoken.sql' => array(
         'type'    => 'sql',
         'name'    => $this->getPatchPath('078.nametoken.sql'),
         'legacy'  => 78,
       ),
       '079.nametokenindex.php' => array(
         'type'    => 'php',
         'name'    => $this->getPatchPath('079.nametokenindex.php'),
         'legacy'  => 79,
       ),
       '080.filekeys.sql' => array(
         'type'    => 'sql',
         'name'    => $this->getPatchPath('080.filekeys.sql'),
         'legacy'  => 80,
       ),
       '081.filekeys.php' => array(
         'type'    => 'php',
         'name'    => $this->getPatchPath('081.filekeys.php'),
         'legacy'  => 81,
       ),
       '082.xactionkey.sql' => array(
         'type'    => 'sql',
         'name'    => $this->getPatchPath('082.xactionkey.sql'),
         'legacy'  => 82,
       ),
       '083.dxviewtime.sql' => array(
         'type'    => 'sql',
         'name'    => $this->getPatchPath('083.dxviewtime.sql'),
         'legacy'  => 83,
       ),
       '084.pasteauthorkey.sql' => array(
         'type'    => 'sql',
         'name'    => $this->getPatchPath('084.pasteauthorkey.sql'),
         'legacy'  => 84,
       ),
       '085.packagecommitrelationship.sql' => array(
         'type'    => 'sql',
         'name'    => $this->getPatchPath('085.packagecommitrelationship.sql'),
         'legacy'  => 85,
       ),
       '086.formeraffil.sql' => array(
         'type'    => 'sql',
         'name'    => $this->getPatchPath('086.formeraffil.sql'),
         'legacy'  => 86,
       ),
       '087.phrictiondelete.sql' => array(
         'type'    => 'sql',
         'name'    => $this->getPatchPath('087.phrictiondelete.sql'),
         'legacy'  => 87,
       ),
       '088.audit.sql' => array(
         'type'    => 'sql',
         'name'    => $this->getPatchPath('088.audit.sql'),
         'legacy'  => 88,
       ),
       '089.projectwiki.sql' => array(
         'type'    => 'sql',
         'name'    => $this->getPatchPath('089.projectwiki.sql'),
         'legacy'  => 89,
       ),
       '090.forceuniqueprojectnames.php' => array(
         'type'    => 'php',
         'name'    => $this->getPatchPath('090.forceuniqueprojectnames.php'),
         'legacy'  => 90,
       ),
       '091.uniqueslugkey.sql' => array(
         'type'    => 'sql',
         'name'    => $this->getPatchPath('091.uniqueslugkey.sql'),
         'legacy'  => 91,
       ),
       '092.dropgithubnotification.sql' => array(
         'type'    => 'sql',
         'name'    => $this->getPatchPath('092.dropgithubnotification.sql'),
         'legacy'  => 92,
       ),
       '093.gitremotes.php' => array(
         'type'    => 'php',
         'name'    => $this->getPatchPath('093.gitremotes.php'),
         'legacy'  => 93,
       ),
       '094.phrictioncolumn.sql' => array(
         'type'    => 'sql',
         'name'    => $this->getPatchPath('094.phrictioncolumn.sql'),
         'legacy'  => 94,
       ),
       '095.directory.sql' => array(
         'type'    => 'sql',
         'name'    => $this->getPatchPath('095.directory.sql'),
         'legacy'  => 95,
       ),
       '096.filename.sql' => array(
         'type'    => 'sql',
         'name'    => $this->getPatchPath('096.filename.sql'),
         'legacy'  => 96,
       ),
       '097.heraldruletypes.sql' => array(
         'type'    => 'sql',
         'name'    => $this->getPatchPath('097.heraldruletypes.sql'),
         'legacy'  => 97,
       ),
       '098.heraldruletypemigration.php' => array(
         'type'    => 'php',
         'name'    => $this->getPatchPath('098.heraldruletypemigration.php'),
         'legacy'  => 98,
       ),
       '099.drydock.sql' => array(
         'type'    => 'sql',
         'name'    => $this->getPatchPath('099.drydock.sql'),
         'legacy'  => 99,
       ),
       '100.projectxaction.sql' => array(
         'type'    => 'sql',
         'name'    => $this->getPatchPath('100.projectxaction.sql'),
         'legacy'  => 100,
       ),
       '101.heraldruleapplied.sql' => array(
         'type'    => 'sql',
         'name'    => $this->getPatchPath('101.heraldruleapplied.sql'),
         'legacy'  => 101,
       ),
       '102.heraldcleanup.php' => array(
         'type'    => 'php',
         'name'    => $this->getPatchPath('102.heraldcleanup.php'),
         'legacy'  => 102,
       ),
       '103.heraldedithistory.sql' => array(
         'type'    => 'sql',
         'name'    => $this->getPatchPath('103.heraldedithistory.sql'),
         'legacy'  => 103,
       ),
       '104.searchkey.sql' => array(
         'type'    => 'sql',
         'name'    => $this->getPatchPath('104.searchkey.sql'),
         'legacy'  => 104,
       ),
       '105.mimetype.sql' => array(
         'type'    => 'sql',
         'name'    => $this->getPatchPath('105.mimetype.sql'),
         'legacy'  => 105,
       ),
       '106.chatlog.sql' => array(
         'type'    => 'sql',
         'name'    => $this->getPatchPath('106.chatlog.sql'),
         'legacy'  => 106,
       ),
       '107.oauthserver.sql' => array(
         'type'    => 'sql',
         'name'    => $this->getPatchPath('107.oauthserver.sql'),
         'legacy'  => 107,
       ),
       '108.oauthscope.sql' => array(
         'type'    => 'sql',
         'name'    => $this->getPatchPath('108.oauthscope.sql'),
         'legacy'  => 108,
       ),
       '109.oauthclientphidkey.sql' => array(
         'type'    => 'sql',
         'name'    => $this->getPatchPath('109.oauthclientphidkey.sql'),
         'legacy'  => 109,
       ),
       '110.commitaudit.sql' => array(
         'type'    => 'sql',
         'name'    => $this->getPatchPath('110.commitaudit.sql'),
         'legacy'  => 110,
       ),
       '111.commitauditmigration.php' => array(
         'type'    => 'php',
         'name'    => $this->getPatchPath('111.commitauditmigration.php'),
         'legacy'  => 111,
       ),
       '112.oauthaccesscoderedirecturi.sql' => array(
         'type'    => 'sql',
         'name'    => $this->getPatchPath('112.oauthaccesscoderedirecturi.sql'),
         'legacy'  => 112,
       ),
       '113.lastreviewer.sql' => array(
         'type'    => 'sql',
         'name'    => $this->getPatchPath('113.lastreviewer.sql'),
         'legacy'  => 113,
       ),
       '114.auditrequest.sql' => array(
         'type'    => 'sql',
         'name'    => $this->getPatchPath('114.auditrequest.sql'),
         'legacy'  => 114,
       ),
       '115.prepareutf8.sql' => array(
         'type'    => 'sql',
         'name'    => $this->getPatchPath('115.prepareutf8.sql'),
         'legacy'  => 115,
       ),
       '116.utf8-backup-first-expect-wait.sql' => array(
         'type'    => 'sql',
         'name'    =>
           $this->getPatchPath('116.utf8-backup-first-expect-wait.sql'),
         'legacy'  => 116,
       ),
       '117.repositorydescription.php' => array(
         'type'    => 'php',
         'name'    => $this->getPatchPath('117.repositorydescription.php'),
         'legacy'  => 117,
       ),
       '118.auditinline.sql' => array(
         'type'    => 'sql',
         'name'    => $this->getPatchPath('118.auditinline.sql'),
         'legacy'  => 118,
       ),
       '119.filehash.sql' => array(
         'type'    => 'sql',
         'name'    => $this->getPatchPath('119.filehash.sql'),
         'legacy'  => 119,
       ),
       '120.noop.sql' => array(
         'type'    => 'sql',
         'name'    => $this->getPatchPath('120.noop.sql'),
         'legacy'  => 120,
       ),
       '121.drydocklog.sql' => array(
         'type'    => 'sql',
         'name'    => $this->getPatchPath('121.drydocklog.sql'),
         'legacy'  => 121,
       ),
       '122.flag.sql' => array(
         'type'    => 'sql',
         'name'    => $this->getPatchPath('122.flag.sql'),
         'legacy'  => 122,
       ),
       '123.heraldrulelog.sql' => array(
         'type'    => 'sql',
         'name'    => $this->getPatchPath('123.heraldrulelog.sql'),
         'legacy'  => 123,
       ),
       '124.subpriority.sql' => array(
         'type'    => 'sql',
         'name'    => $this->getPatchPath('124.subpriority.sql'),
         'legacy'  => 124,
       ),
       '125.ipv6.sql' => array(
         'type'    => 'sql',
         'name'    => $this->getPatchPath('125.ipv6.sql'),
         'legacy'  => 125,
       ),
       '126.edges.sql' => array(
         'type'    => 'sql',
         'name'    => $this->getPatchPath('126.edges.sql'),
         'legacy'  => 126,
       ),
       '127.userkeybody.sql' => array(
         'type'    => 'sql',
         'name'    => $this->getPatchPath('127.userkeybody.sql'),
         'legacy'  => 127,
       ),
       '128.phabricatorcom.sql' => array(
         'type'    => 'sql',
         'name'    => $this->getPatchPath('128.phabricatorcom.sql'),
         'legacy'  => 128,
       ),
       '129.savedquery.sql' => array(
         'type'    => 'sql',
         'name'    => $this->getPatchPath('129.savedquery.sql'),
         'legacy'  => 129,
       ),
       '130.denormalrevisionquery.sql' => array(
         'type'    => 'sql',
         'name'    => $this->getPatchPath('130.denormalrevisionquery.sql'),
         'legacy'  => 130,
       ),
       '131.migraterevisionquery.php' => array(
         'type'    => 'php',
         'name'    => $this->getPatchPath('131.migraterevisionquery.php'),
         'legacy'  => 131,
       ),
       '132.phame.sql' => array(
         'type'    => 'sql',
         'name'    => $this->getPatchPath('132.phame.sql'),
         'legacy'  => 132,
       ),
       '133.imagemacro.sql' => array(
         'type'    => 'sql',
         'name'    => $this->getPatchPath('133.imagemacro.sql'),
         'legacy'  => 133,
       ),
       '134.emptysearch.sql' => array(
         'type'    => 'sql',
         'name'    => $this->getPatchPath('134.emptysearch.sql'),
         'legacy'  => 134,
       ),
       '135.datecommitted.sql' => array(
         'type'    => 'sql',
         'name'    => $this->getPatchPath('135.datecommitted.sql'),
         'legacy'  => 135,
       ),
       '136.sex.sql' => array(
         'type'    => 'sql',
         'name'    => $this->getPatchPath('136.sex.sql'),
         'legacy'  => 136,
       ),
       '137.auditmetadata.sql' => array(
         'type'    => 'sql',
         'name'    => $this->getPatchPath('137.auditmetadata.sql'),
         'legacy'  => 137,
       ),
       '138.notification.sql' => array(
         'type'    => 'sql',
         'name'    => $this->getPatchPath('138.notification.sql'),
       ),
       'holidays.sql' => array(
         'type'    => 'sql',
         'name'    => $this->getPatchPath('holidays.sql'),
       ),
       'userstatus.sql' => array(
         'type'    => 'sql',
         'name'    => $this->getPatchPath('userstatus.sql'),
       ),
       'emailtable.sql' => array(
         'type'    => 'sql',
         'name'    => $this->getPatchPath('emailtable.sql'),
       ),
       'emailtableport.sql' => array(
         'type'    => 'php',
         'name'    => $this->getPatchPath('emailtableport.php'),
       ),
       'emailtableremove.sql' => array(
         'type'    => 'sql',
         'name'    => $this->getPatchPath('emailtableremove.sql'),
       ),
       'phiddrop.sql' => array(
         'type'    => 'sql',
         'name'    => $this->getPatchPath('phiddrop.sql'),
       ),
       'testdatabase.sql' => array(
         'type'    => 'sql',
         'name'    => $this->getPatchPath('testdatabase.sql'),
       ),
       'ldapinfo.sql' => array(
         'type'    => 'sql',
         'name'    => $this->getPatchPath('ldapinfo.sql'),
       ),
+      'threadtopic.sql' => array(
+        'type'    => 'sql',
+        'name'    => $this->getPatchPath('threadtopic.sql'),
+      ),
     );
   }
 
 }