diff --git a/conf/default.conf.php b/conf/default.conf.php
index 655640695..8d2218557 100644
--- a/conf/default.conf.php
+++ b/conf/default.conf.php
@@ -1,882 +1,921 @@
 <?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.
  */
 
 return array(
 
   // The root URI which Phabricator is installed on.
   // Example: "http://phabricator.example.com/"
   'phabricator.base-uri'        => null,
 
   // If you have multiple environments, provide the production environment URI
   // here so that emails, etc., generated in development/sandbox environments
   // contain the right links.
   'phabricator.production-uri'  => null,
 
   // Setting this to 'true' will invoke a special setup mode which helps guide
   // you through setting up Phabricator.
   'phabricator.setup'           => false,
 
   // The default PHID for users who haven't uploaded a profile image. It should
   // be 50x50px.
   'user.default-profile-image-phid' => 'PHID-FILE-4d61229816cfe6f2b2a3',
 
 // -- IMPORTANT! Security! -------------------------------------------------- //
 
   // IMPORTANT: By default, Phabricator serves files from the same domain the
   // application lives on. This is convenient but not secure: it creates a large
   // class of vulnerabilities which can not be generally mitigated.
   //
   // To avoid this, you should configure a second domain in the same way you
   // have the primary domain configured (e.g., point it at the same machine and
   // set up the same vhost rules) and provide it here. For instance, if your
   // primary install is on "http://www.phabricator-example.com/", you could
   // configure "http://www.phabricator-files.com/" and specify the entire
   // domain (with protocol) here. This will enforce that files are
   // served only from the alternate domain. Ideally, you should use a
   // completely separate domain name rather than just a different subdomain.
   //
   // It is STRONGLY RECOMMENDED that you configure this. Your install is NOT
   // SECURE unless you do so.
   'security.alternate-file-domain'  => null,
 
   // Default key for HMAC digests where the key is not important (i.e., the
   // hash itself is secret). You can change this if you want (to any other
   // string), but doing so will break existing sessions and CSRF tokens.
   'security.hmac-key' => '[D\t~Y7eNmnQGJ;rnH6aF;m2!vJ8@v8C=Cs:aQS\.Qw',
 
 
 // -- Customization --------------------------------------------------------- //
 
   // If you want to use a custom logo (e.g., for your company or organization),
   // copy 'webroot/rsrc/image/custom/example_template.png' to
   // 'webroot/rsrc/image/custom/custom.png' and set this to the URI you want it
   // to link to (like http://www.yourcompany.com/).
   'phabricator.custom.logo'   => null,
 
 
 // -- DarkConsole ----------------------------------------------------------- //
 
   // DarkConsole is a administrative debugging/profiling tool built into
   // Phabricator. You can leave it disabled unless you're developing against
   // Phabricator.
 
   // Determines whether or not DarkConsole is available. DarkConsole exposes
   // some data like queries and stack traces, so you should be careful about
   // turning it on in production (although users can not normally see it, even
   // if the deployment configuration enables it).
   'darkconsole.enabled'         => false,
 
   // Always enable DarkConsole, even for logged out users. This potentially
   // exposes sensitive information to users, so make sure untrusted users can
   // not access an install running in this mode. You should definitely leave
   // this off in production. It is only really useful for using DarkConsole
   // utilities to debug or profile logged-out pages. You must set
   // 'darkconsole.enabled' to use this option.
   'darkconsole.always-on'       => false,
 
 
   // Allows you to mask certain configuration values from appearing in the
   // "Config" tab of DarkConsole.
   'darkconsole.config-mask'     => array(
     'mysql.pass',
     'amazon-ses.secret-key',
     'recaptcha.private-key',
     'phabricator.csrf-key',
     'facebook.application-secret',
     'github.application-secret',
     'phabricator.mail-key',
     'security.hmac-key',
   ),
 
 
 // --  MySQL  --------------------------------------------------------------- //
 
   // Class providing database configuration. It must implement
   // DatabaseConfigurationProvider.
   'mysql.configuration-provider' => 'DefaultDatabaseConfigurationProvider',
 
   // The username to use when connecting to MySQL.
   'mysql.user' => 'root',
 
   // The password to use when connecting to MySQL.
   'mysql.pass' => '',
 
   // The MySQL server to connect to. If you want to connect to a different
   // port than the default (which is 3306), specify it in the hostname
   // (e.g., db.example.com:1234).
   'mysql.host' => 'localhost',
 
   // The number of times to try reconnecting to the MySQL database
   'mysql.connection-retries' => 3,
 
   // Phabricator supports PHP extensions MySQL and MySQLi. It is possible to
   // implement also other access mechanism (e.g. PDO_MySQL). The class must
   // extend AphrontMySQLDatabaseConnectionBase.
   'mysql.implementation' => 'AphrontMySQLDatabaseConnection',
 
 
 // -- Email ----------------------------------------------------------------- //
 
   // Some Phabricator tools send email notifications, e.g. when Differential
   // revisions are updated or Maniphest tasks are changed. These options allow
   // you to configure how email is delivered.
 
   // You can test your mail setup by going to "MetaMTA" in the web interface,
   // clicking "Send New Message", and then composing a message.
 
   // Default address to send mail "From".
   'metamta.default-address'     => 'noreply@example.com',
 
   // Domain used to generate Message-IDs.
   'metamta.domain'              => 'example.com',
 
+  // When a message is sent to multiple recipients (for example, several
+  // reviewers on a code review), Phabricator can either deliver one email to
+  // everyone (e.g., "To: alincoln, usgrant, htaft") or separate emails to each
+  // user (e.g., "To: alincoln", "To: usgrant", "To: htaft"). The major
+  // advantages and disadvantages of each approach are:
+  //
+  //   - One mail to everyone:
+  //     - Recipients can see To/Cc at a glance.
+  //     - If you use mailing lists, you won't get duplicate mail if you're
+  //       a normal recipient and also Cc'd on a mailing list.
+  //     - Getting threading to work properly is harder, and probably requires
+  //       making mail less useful by turning off options.
+  //     - Sometimes people will "Reply All" and everyone will get two mails,
+  //       one from the user and one from Phabricator turning their mail into
+  //       a comment.
+  //     - Not supported with a private reply-to address.
+  //   - One mail to each user:
+  //     - Recipients need to look in the mail body to see To/Cc.
+  //     - If you use mailing lists, recipients may sometimes get duplicate
+  //       mail.
+  //     - Getting threading to work properly is easier, and threading settings
+  //       can be customzied by each user.
+  //     - "Reply All" no longer spams all other users.
+  //     - Required if private reply-to addresses are configured.
+  //
+  // In the code, splitting one outbound email into one-per-recipient is
+  // sometimes referred to as "multiplexing".
+  'metamta.one-mail-per-recipient'  => true,
+
   // When a user takes an action which generates an email notification (like
   // commenting on a Differential revision), Phabricator can either send that
   // mail "From" the user's email address (like "alincoln@logcabin.com") or
   // "From" the 'metamta.default-address' address. The user experience is
   // generally better if Phabricator uses the user's real address as the "From"
   // since the messages are easier to organize when they appear in mail clients,
   // but this will only work if the server is authorized to send email on behalf
   // of the "From" domain. Practically, this means:
   //    - If you are doing an install for Example Corp and all the users will
   //      have corporate @corp.example.com addresses and any hosts Phabricator
   //      is running on are authorized to send email from corp.example.com,
   //      you can enable this to make the user experience a little better.
   //    - If you are doing an install for an open source project and your
   //      users will be registering via Facebook and using personal email
   //      addresses, you MUST NOT enable this or virtually all of your outgoing
   //      email will vanish into SFP blackholes.
   //    - If your install is anything else, you're much safer leaving this
   //      off since the risk in turning it on is that your outgoing mail will
   //      mostly never arrive.
   'metamta.can-send-as-user'    => false,
 
+
   // Adapter class to use to transmit mail to the MTA. The default uses
   // PHPMailerLite, which will invoke "sendmail". This is appropriate
   // if sendmail actually works on your host, but if you haven't configured mail
   // it may not be so great. You can also use Amazon SES, by changing this to
   // 'PhabricatorMailImplementationAmazonSESAdapter', signing up for SES, and
   // filling in your 'amazon-ses.access-key' and 'amazon-ses.secret-key' below.
   'metamta.mail-adapter'        =>
     'PhabricatorMailImplementationPHPMailerLiteAdapter',
 
   // When email is sent, try to hand it off to the MTA immediately. This may
   // be worth disabling if your MTA infrastructure is slow or unreliable. If you
   // disable this option, you must run the 'metamta_mta.php' daemon or mail
   // won't be handed off to the MTA. If you're using Amazon SES it can be a
   // little slugish sometimes so it may be worth disabling this and moving to
   // the daemon after you've got your install up and running. If you have a
   // properly configured local MTA it should not be necessary to disable this.
   'metamta.send-immediately'    => true,
 
   // If you're using Amazon SES to send email, provide your AWS access key
   // and AWS secret key here. To set up Amazon SES with Phabricator, you need
   // to:
   //  - Make sure 'metamta.mail-adapter' is set to:
   //    "PhabricatorMailImplementationAmazonSESAdapter"
   //  - Make sure 'metamta.can-send-as-user' is false.
   //  - Make sure 'metamta.default-address' is configured to something sensible.
   //  - Make sure 'metamta.default-address' is a validated SES "From" address.
   'amazon-ses.access-key'       =>  null,
   'amazon-ses.secret-key'       =>  null,
 
   // If you're using Sendgrid to send email, provide your access credentials
   // here. This will use the REST API. You can also use Sendgrid as a normal
   // SMTP service.
   'sendgrid.api-user'           => null,
   'sendgrid.api-key'            => null,
 
   // You can configure a reply handler domain so that email sent from Maniphest
   // will have a special "Reply To" address like "T123+82+af19f@example.com"
   // that allows recipients to reply by email and interact with tasks. For
   // instructions on configurating reply handlers, see the article
   // "Configuring Inbound Email" in the Phabricator documentation. By default,
   // this is set to 'null' and Phabricator will use a generic 'noreply@' address
   // or the address of the acting user instead of a special reply handler
   // address (see 'metamta.default-address'). If you set a domain here,
   // Phabricator will begin generating private reply handler addresses. See
   // also 'metamta.maniphest.reply-handler' to further configure behavior.
   // This key should be set to the domain part after the @, like "example.com".
   'metamta.maniphest.reply-handler-domain' => null,
 
   // You can follow the instructions in "Configuring Inbound Email" in the
   // Phabricator documentation and set 'metamta.maniphest.reply-handler-domain'
   // to support updating Maniphest tasks by email. If you want more advanced
   // customization than this provides, you can override the reply handler
   // class with an implementation of your own. This will allow you to do things
   // like have a single public reply handler or change how private reply
   // handlers are generated and validated.
   // This key should be set to a loadable subclass of
   // PhabricatorMailReplyHandler (and possibly of ManiphestReplyHandler).
   'metamta.maniphest.reply-handler' => 'ManiphestReplyHandler',
 
   // If you don't want phabricator to take up an entire domain
   // (or subdomain for that matter), you can use this and set a common
   // prefix for mail sent by phabricator. It will make use of the fact that
   // a mail-address such as phabricator+D123+1hjk213h@example.com will be
   // delivered to the phabricator users mailbox.
   // Set this to the left part of the email address and it well get
   // prepended to all outgoing mail. If you want to use e.g.
   // 'phabricator@example.com' this should be set to 'phabricator'.
   'metamta.single-reply-handler-prefix' => null,
 
   // Prefix prepended to mail sent by Maniphest. You can change this to
   // distinguish between testing and development installs, for example.
   'metamta.maniphest.subject-prefix' => '[Maniphest]',
 
   // See 'metamta.maniphest.reply-handler-domain'. This does the same thing,
   // but allows email replies via Differential.
   'metamta.differential.reply-handler-domain' => null,
 
   // See 'metamta.maniphest.reply-handler'. This does the same thing, but
   // affects Differential.
   'metamta.differential.reply-handler' => 'DifferentialReplyHandler',
 
   // Prefix prepended to mail sent by Differential.
   'metamta.differential.subject-prefix' => '[Differential]',
 
   // Set this to true if you want patches to be attached to mail from
   // Differential. This won't work if you are using SendGrid as your mail
   // adapter.
   'metamta.differential.attach-patches' => false,
 
   // To include patches in email bodies, set this to a positive integer. Patches
   // will be inlined if they are at most that many lines. For instance, a value
   // of 100 means "inline patches if they are no longer than 100 lines". By
   // default, patches are not inlined.
   'metamta.differential.inline-patches' => 0,
 
   // If you enable either of the options above, you can choose what format
   // patches are sent in. Valid options are 'unified' (like diff -u) or 'git'.
   'metamta.differential.patch-format'   => 'unified',
 
   // Prefix prepended to mail sent by Diffusion.
   'metamta.diffusion.subject-prefix' => '[Diffusion]',
 
   // See 'metamta.maniphest.reply-handler-domain'. This does the same thing,
   // but allows email replies via Diffusion.
   'metamta.diffusion.reply-handler-domain' => null,
 
   // See 'metamta.maniphest.reply-handler'. This does the same thing, but
   // affects Diffusion.
   'metamta.diffusion.reply-handler' => 'PhabricatorAuditReplyHandler',
 
   // By default, Phabricator generates unique reply-to addresses and sends a
   // separate email to each recipient when you enable reply handling. This is
   // more secure than using "From" to establish user identity, but can mean
   // users may receive multiple emails when they are on mailing lists. Instead,
   // you can use a single, non-unique reply to address and authenticate users
   // based on the "From" address by setting this to 'true'. This trades away
   // a little bit of security for convenience, but it's reasonable in many
   // installs. Object interactions are still protected using hashes in the
   // single public email address, so objects can not be replied to blindly.
   'metamta.public-replies' => false,
 
   // You can configure an email address like "bugs@phabricator.example.com"
   // which will automatically create Maniphest tasks when users send email
   // to it. This relies on the "From" address to authenticate users, so it is
   // is not completely secure. To set this up, enter a complete email
   // address like "bugs@phabricator.example.com" and then configure mail to
   // that address so it routed to Phabricator (if you've already configured
   // reply handlers, you're probably already done). See "Configuring Inbound
   // Email" in the documentation for more information.
   'metamta.maniphest.public-create-email' => null,
 
   // If you enable 'metamta.public-replies', Phabricator uses "From" to
   // authenticate users. You can additionally enable this setting to try to
   // authenticate with 'Reply-To'. Note that this is completely spoofable and
   // insecure (any user can set any 'Reply-To' address) but depending on the
   // nature of your install or other deliverability conditions this might be
   // okay. Generally, you can't do much more by spoofing Reply-To than be
   // annoying (you can write but not read content). But, you know, this is
   // still **COMPLETELY INSECURE**.
   'metamta.insecure-auth-with-reply-to' => false,
 
   // If you enable 'metamta.maniphest.public-create-email' and create an
   // email address like "bugs@phabricator.example.com", it will default to
   // rejecting mail which doesn't come from a known user. However, you might
   // want to let anyone send email to this address; to do so, set a default
   // author here (a Phabricator username). A typical use of this might be to
   // create a "System Agent" user called "bugs" and use that name here. If you
   // specify a valid username, mail will always be accepted and used to create
   // a task, even if the sender is not a system user. The original email
   // address will be stored in an 'From Email' field on the task.
   'metamta.maniphest.default-public-author' => null,
 
   // If this option is enabled, Phabricator will add a "Precedence: bulk"
   // header to transactional mail (e.g., Differential, Maniphest and Herald
   // notifications). This may improve the behavior of some auto-responder
   // software and prevent it from replying. However, it may also cause
   // deliverability issues -- notably, you currently can not send this header
   // via Amazon SES, and enabling this option with SES will prevent delivery
   // of any affected mail.
   'metamta.precedence-bulk' => false,
 
   // Mail.app on OS X Lion won't respect threading headers unless the subject
   // is prefixed with "Re:". If you enable this option, Phabricator will add
-  // "Re:" to the subject line of all mail which is expected to thread.
+  // "Re:" to the subject line of all mail which is expected to thread. If
+  // you've set 'metamta.one-mail-per-recipient', users can override this
+  // setting in their preferences.
   'metamta.re-prefix' => false,
 
+  // If true, allow MetaMTA to change mail subjects to put text like
+  // '[Accepted]' and '[Commented]' in them. This makes subjects more useful,
+  // but might break threading on some clients. If you've set
+  // 'metamta.one-mail-per-recipient', users can override this setting in their
+  // preferences.
+  'metamta.vary-subjects' => true,
+
 
 // -- Auth ------------------------------------------------------------------ //
 
   // Can users login with a username/password, or by following the link from
   // a password reset email? You can disable this and configure one or more
   // OAuth providers instead.
   'auth.password-auth-enabled'  => true,
 
   // Maximum number of simultaneous web sessions each user is permitted to have.
   // Setting this to "1" will prevent a user from logging in on more than one
   // browser at the same time.
   'auth.sessions.web'           => 5,
 
   // Maximum number of simultaneous Conduit sessions each user is permitted
   // to have.
   'auth.sessions.conduit'       => 5,
 
   // Set this true to enable the Settings -> SSH Public Keys panel, which will
   // allow users to associated SSH public keys with their accounts. This is only
   // really useful if you're setting up services over SSH and want to use
   // Phabricator for authentication; in most situations you can leave this
   // disabled.
   'auth.sshkeys.enabled'        => false,
 
 
 // -- Accounts -------------------------------------------------------------- //
 
   // Is basic account information (email, real name, profile picture) editable?
   // If you set up Phabricator to automatically synchronize account information
   // from some other authoritative system, you can disable this to ensure
   // information remains consistent across both systems.
   'account.editable'            => true,
 
   // When users set or reset a password, it must have at least this many
   // characters.
   'account.minimum-password-length'  => 8,
 
 
 // -- Facebook OAuth -------------------------------------------------------- //
 
   // Can users use Facebook credentials to login to Phabricator?
   'facebook.auth-enabled'       => false,
 
   // Can users use Facebook credentials to create new Phabricator accounts?
   'facebook.registration-enabled' => true,
 
   // Are Facebook accounts permanently linked to Phabricator accounts, or can
   // the user unlink them?
   'facebook.auth-permanent'     => false,
 
   // The Facebook "Application ID" to use for Facebook API access.
   'facebook.application-id'     => null,
 
   // The Facebook "Application Secret" to use for Facebook API access.
   'facebook.application-secret' => null,
 
 
 // -- GitHub OAuth ---------------------------------------------------------- //
 
   // Can users use GitHub credentials to login to Phabricator?
   'github.auth-enabled'         => false,
 
   // Can users use GitHub credentials to create new Phabricator accounts?
   'github.registration-enabled' => true,
 
   // Are GitHub accounts permanently linked to Phabricator accounts, or can
   // the user unlink them?
   'github.auth-permanent'       => false,
 
   // The GitHub "Client ID" to use for GitHub API access.
   'github.application-id'       => null,
 
   // The GitHub "Secret" to use for GitHub API access.
   'github.application-secret'   => null,
 
 
 // -- Google OAuth ---------------------------------------------------------- //
 
   // Can users use Google credentials to login to Phabricator?
   'google.auth-enabled'         => false,
 
   // Can users use Google credentials to create new Phabricator accounts?
   'google.registration-enabled' => true,
 
   // Are Google accounts permanently linked to Phabricator accounts, or can
   // the user unlink them?
   'google.auth-permanent'       => false,
 
   // The Google "Client ID" to use for Google API access.
   'google.application-id'       => null,
 
   // The Google "Client Secret" to use for Google API access.
   'google.application-secret'   => null,
 
 // -- Phabricator OAuth ----------------------------------------------------- //
 
   // Meta-town -- Phabricator is itself an OAuth Provider
   // TODO -- T887 -- make this support multiple Phabricator instances!
 
   // The URI of the Phabricator instance to use as an OAuth server.
   'phabricator.oauth-uri'            => null,
 
   // Can users use Phabricator credentials to login to Phabricator?
   'phabricator.auth-enabled'         => false,
 
   // Can users use Phabricator credentials to create new Phabricator accounts?
   'phabricator.registration-enabled' => true,
 
   // Are Phabricator accounts permanently linked to Phabricator accounts, or can
   // the user unlink them?
   'phabricator.auth-permanent'       => false,
 
   // The Phabricator "Client ID" to use for Phabricator API access.
   'phabricator.application-id'       => null,
 
   // The Phabricator "Client Secret" to use for Phabricator API access.
   'phabricator.application-secret'   => null,
 
 // -- Recaptcha ------------------------------------------------------------- //
 
   // Is Recaptcha enabled? If disabled, captchas will not appear. You should
   // enable Recaptcha if your install is public-facing, as it hinders
   // brute-force attacks.
   'recaptcha.enabled'           => false,
 
   // Your Recaptcha public key, obtained from Recaptcha.
   'recaptcha.public-key'        => null,
 
   // Your Recaptcha private key, obtained from Recaptcha.
   'recaptcha.private-key'       => null,
 
 
 // -- Misc ------------------------------------------------------------------ //
 
   // This is hashed with other inputs to generate CSRF tokens. If you want, you
   // can change it to some other string which is unique to your install. This
   // will make your install more secure in a vague, mostly theoretical way. But
   // it will take you like 3 seconds of mashing on your keyboard to set it up so
   // you might as well.
   'phabricator.csrf-key'        => '0b7ec0592e0a2829d8b71df2fa269b2c6172eca3',
 
   // This is hashed with other inputs to generate mail tokens. If you want, you
   // can change it to some other string which is unique to your install. In
   // particular, you will want to do this if you accidentally send a bunch of
   // mail somewhere you shouldn't have, to invalidate all old reply-to
   // addresses.
   'phabricator.mail-key'        => '5ce3e7e8787f6e40dfae861da315a5cdf1018f12',
 
   // Version string displayed in the footer. You probably should leave this
   // alone.
   'phabricator.version'         => 'UNSTABLE',
 
   // PHP requires that you set a timezone in your php.ini before using date
   // functions, or it will emit a warning. If this isn't possible (for instance,
   // because you are using HPHP) you can set some valid constant for
   // date_default_timezone_set() here and Phabricator will set it on your
   // behalf, silencing the warning.
   'phabricator.timezone'        => null,
 
   // When unhandled exceptions occur, stack traces are hidden by default.
   // You can enable traces for development to make it easier to debug problems.
   'phabricator.show-stack-traces' => false,
 
   // Shows an error callout if a page generated PHP errors, warnings or notices.
   // This makes it harder to miss problems while developing Phabricator.
   'phabricator.show-error-callout' => false,
 
   // When users write comments which have URIs, they'll be automatically linked
   // if the protocol appears in this set. This whitelist is primarily to prevent
   // security issues like javascript:// URIs.
   'uri.allowed-protocols' => array(
     'http'  => true,
     'https' => true,
   ),
 
   // Tokenizers are UI controls which let the user select other users, email
   // addresses, project names, etc., by typing the first few letters and having
   // the control autocomplete from a list. They can load their data in two ways:
   // either in a big chunk up front, or as the user types. By default, the data
   // is loaded in a big chunk. This is simpler and performs better for small
   // datasets. However, if you have a very large number of users or projects,
   // (in the ballpark of more than a thousand), loading all that data may become
   // slow enough that it's worthwhile to query on demand instead. This makes
   // the typeahead slightly less responsive but overall performance will be much
   // better if you have a ton of stuff. You can figure out which setting is
   // best for your install by changing this setting and then playing with a
   // user tokenizer (like the user selectors in Maniphest or Differential) and
   // seeing which setting loads faster and feels better.
   'tokenizer.ondemand'          => false,
 
   // By default, Phabricator includes some silly nonsense in the UI, such as
   // a submit button called "Clowncopterize" in Differential and a call to
   // "Leap Into Action". If you'd prefer more traditional UI strings like
   // "Submit", you can set this flag to disable most of the jokes and easter
   // eggs.
   'phabricator.serious-business' => false,
 
 
 // -- Files ----------------------------------------------------------------- //
 
   // Lists which uploaded file types may be viewed in the browser. If a file
   // has a mime type which does not appear in this list, it will always be
   // downloaded instead of displayed. This is mainly a usability
   // consideration, since browsers tend to freak out when viewing enormous
   // binary files.
   //
   // The keys in this array are viewable mime types; the values are the mime
   // types they will be delivered as when they are viewed in the browser.
   //
   // IMPORTANT: Configure 'security.alternate-file-domain' above! Your install
   // is NOT safe if it is left unconfigured.
   'files.viewable-mime-types' => array(
     'image/jpeg'  => 'image/jpeg',
     'image/jpg'   => 'image/jpg',
     'image/png'   => 'image/png',
     'image/gif'   => 'image/gif',
     'text/plain'  => 'text/plain; charset=utf-8',
 
     // ".ico" favicon files, which have mime type diversity. See:
     // http://en.wikipedia.org/wiki/ICO_(file_format)#MIME_type
     'image/x-ico'               => 'image/x-icon',
     'image/x-icon'              => 'image/x-icon',
     'image/vnd.microsoft.icon'  => 'image/x-icon',
   ),
 
   // List of mime types which can be used as the source for an <img /> tag.
   // This should be a subset of 'files.viewable-mime-types' and exclude files
   // like text.
   'files.image-mime-types' => array(
     'image/jpeg'                => true,
     'image/jpg'                 => true,
     'image/png'                 => true,
     'image/gif'                 => true,
     'image/x-ico'               => true,
     'image/x-icon'              => true,
     'image/vnd.microsoft.icon'  => true,
   ),
 
   // Phabricator can proxy images from other servers so you can paste the URI
   // to a funny picture of a cat into the comment box and have it show up as an
   // image. However, this means the webserver Phabricator is running on will
   // make HTTP requests to arbitrary URIs. If the server has access to internal
   // resources, this could be a security risk. You should only enable it if you
   // are installed entirely a VPN and VPN access is required to access
   // Phabricator, or if the webserver has no special access to anything. If
   // unsure, it is safer to leave this disabled.
   'files.enable-proxy' => false,
 
 
 // -- Storage --------------------------------------------------------------- //
 
   // Phabricator allows users to upload files, and can keep them in various
   // storage engines. This section allows you to configure which engines
   // Phabricator will use, and how it will use them.
 
   // The largest filesize Phabricator will store in the MySQL BLOB storage
   // engine, which just uses a database table to store files. While this isn't a
   // best practice, it's really easy to set up. This is hard-limited by the
   // value of 'max_allowed_packet' in MySQL (since this often defaults to 1MB,
   // the default here is slightly smaller than 1MB). Set this to 0 to disable
   // use of the MySQL blob engine.
   'storage.mysql-engine.max-size' => 1000000,
 
   // Phabricator provides a local disk storage engine, which just writes files
   // to some directory on local disk. The webserver must have read/write
   // permissions on this directory. This is straightforward and suitable for
   // most installs, but will not scale past one web frontend unless the path
   // is actually an NFS mount, since you'll end up with some of the files
   // written to each web frontend and no way for them to share. To use the
   // local disk storage engine, specify the path to a directory here. To
   // disable it, specify null.
   'storage.local-disk.path'       => null,
 
   // If you want to store files in Amazon S3, specify an AWS access and secret
   // key here and a bucket name below.
   'amazon-s3.access-key'          =>  null,
   'amazon-s3.secret-key'          =>  null,
 
   // Set this to a valid Amazon S3 bucket to store files there. You must also
   // configure S3 access keys above.
   'storage.s3.bucket'             => null,
 
   // Phabricator uses a storage engine selector to choose which storage engine
   // to use when writing file data. If you add new storage engines or want to
   // provide very custom rules (e.g., write images to one storage engine and
   // other files to a different one), you can provide an alternate
   // implementation here. The default engine will use choose MySQL, Local Disk,
   // and S3, in that order, if they have valid configurations above and a file
   // fits within configured limits.
   'storage.engine-selector' => 'PhabricatorDefaultFileStorageEngineSelector',
 
 
 // -- Search ---------------------------------------------------------------- //
 
   // Phabricator uses a search engine selector to choose which search engine
   // to use when indexing and reconstructing documents, and when executing
   // queries. You can override the engine selector to provide a new selector
   // class which can select some custom engine you implement, if you want to
   // store your documents in some search engine which does not have default
   // support.
   'search.engine-selector'  => 'PhabricatorDefaultSearchEngineSelector',
 
 
 // -- Differential ---------------------------------------------------------- //
 
   'differential.revision-custom-detail-renderer'  => null,
 
   // Array for custom remarkup rules. The array should have a list of
   // class names of classes that extend PhutilRemarkupRule
   'differential.custom-remarkup-rules' => null,
 
   // Array for custom remarkup block rules. The array should have a list of
   // class names of classes that extend PhutilRemarkupEngineBlockRule
   'differential.custom-remarkup-block-rules' => null,
 
   // Set display word-wrap widths for Differential. Specify a dictionary of
   // regular expressions mapping to column widths. The filename will be matched
   // against each regexp in order until one matches. The default configuration
   // uses a width of 100 for Java and 80 for other languages. Note that 80 is
   // the greatest column width of all time. Changes here will not be immediately
   // reflected in old revisions unless you purge the changeset render cache
   // (with `./scripts/util/purge_cache.php --changesets`).
   'differential.wordwrap' => array(
     '/\.java$/' => 100,
     '/.*/'      => 80,
   ),
 
   // List of file regexps were whitespace is meaningful and should not
   // use 'ignore-all' by default
   'differential.whitespace-matters' => array(
     '/\.py$/',
     '/\.l?hs$/',
   ),
 
   'differential.field-selector' => 'DifferentialDefaultFieldSelector',
 
   // Differential can show "Host" and "Path" fields on revisions, with
   // information about the machine and working directory where the
   // change came from. These fields are disabled by default because they may
   // occasionally have sensitive information; you can set this to true to
   // enable them.
   'differential.show-host-field'  => false,
 
   // Differential has a required "Test Plan" field by default, which requires
   // authors to fill out information about how they verified the correctness of
   // their changes when sending code for review. If you'd prefer not to use
   // this field, you can disable it here. You can also make it optional
   // (instead of required) below.
   'differential.show-test-plan-field' => true,
 
   // Differential has a required "Test Plan" field by default. You can make it
   // optional by setting this to false. You can also completely remove it above,
   // if you prefer.
   'differential.require-test-plan-field' => true,
 
   // If you set this to true, users can "!accept" revisions via email (normally,
   // they can take other actions but can not "!accept"). This action is disabled
   // by default because email authentication can be configured to be very weak,
   // and, socially, email "!accept" is kind of sketchy and implies revisions may
   // not actually be receiving thorough review.
   'differential.enable-email-accept' => false,
 
   // If you set this to true, users won't need to login to view differential
   // revisions.  Anonymous users will have read-only access and won't be able to
   // interact with the revisions.
   'differential.anonymous-access' => false,
 
   // List of file regexps that should be treated as if they are generated by
   // an automatic process, and thus get hidden by default in differential
   'differential.generated-paths' => array(
     // '/config\.h$/',
     // '#/autobuilt/#',
   ),
 
 
 // -- Maniphest ------------------------------------------------------------- //
 
   'maniphest.enabled' => true,
 
   // Array of custom fields for Maniphest tasks. For details on adding custom
   // fields to Maniphest, see "Maniphest User Guide: Adding Custom Fields".
   'maniphest.custom-fields' => array(),
 
   // Class which drives custom field construction. See "Maniphest User Guide:
   // Adding Custom Fields" in the documentation for more information.
   'maniphest.custom-task-extensions-class' => 'ManiphestDefaultTaskExtensions',
 
 // -- Phriction ------------------------------------------------------------- //
 
   'phriction.enabled' => true,
 
 // -- Remarkup -------------------------------------------------------------- //
 
   // If you enable this, linked YouTube videos will be embeded inline. This has
   // mild security implications (you'll leak referrers to YouTube) and is pretty
   // silly (but sort of awesome).
   'remarkup.enable-embedded-youtube' => false,
 
 
 // -- Garbage Collection ---------------------------------------------------- //
 
   // Phabricator generates various logs and caches in the database which can
   // be garbage collected after a while to make the total data size more
   // manageable. To run garbage collection, launch a
   // PhabricatorGarbageCollector daemon.
 
   // Since the GC daemon can issue large writes and table scans, you may want to
   // run it only during off hours or make sure it is scheduled so it doesn't
   // overlap with backups. This determines when the daemon can start running
   // each day.
   'gcdaemon.run-at'    => '12 AM',
 
   // How many seconds after 'gcdaemon.run-at' the daemon may collect garbage
   // for. By default it runs continuously, but you can set it to run for a
   // limited period of time. For instance, if you do backups at 3 AM, you might
   // run garbage collection for an hour beforehand. This is not a high-precision
   // limit so you may want to leave some room for the GC to actually stop, and
   // if you set it to something like 3 seconds you're on your own.
   'gcdaemon.run-for'   => 24 * 60 * 60,
 
   // These 'ttl' keys configure how much old data the GC daemon keeps around.
   // Objects older than the ttl will be collected. Set any value to 0 to store
   // data indefinitely.
 
   'gcdaemon.ttl.herald-transcripts'         => 30 * (24 * 60 * 60),
   'gcdaemon.ttl.daemon-logs'                =>  7 * (24 * 60 * 60),
   'gcdaemon.ttl.differential-parse-cache'   => 14 * (24 * 60 * 60),
 
 
 // -- Feed ------------------------------------------------------------------ //
 
   // If you set this to true, you can embed Phabricator activity feeds in other
   // pages using iframes. These feeds are completely public, and a login is not
   // required to view them! This is intended for things like open source
   // projects that want to expose an activity feed on the project homepage.
   'feed.public' => false,
 
 
 // -- Drydock --------------------------------------------------------------- //
 
   // If you want to use Drydock's builtin EC2 Blueprints, configure your AWS
   // EC2 credentials here.
   'amazon-ec2.access-key'   => null,
   'amazon-ec2.secret-key'   => null,
 
 // -- Customization --------------------------------------------------------- //
 
   // Paths to additional phutil libraries to load.
   'load-libraries' => array(),
 
   'aphront.default-application-configuration-class' =>
     'AphrontDefaultApplicationConfiguration',
 
   'controller.oauth-registration' =>
     'PhabricatorOAuthDefaultRegistrationController',
 
 
   // Directory that phd (the Phabricator daemon control script) should use to
   // track running daemons.
   'phd.pid-directory' => '/var/tmp/phd',
 
   // This value is an input to the hash function when building resource hashes.
   // It has no security value, but if you accidentally poison user caches (by
   // pushing a bad patch or having something go wrong with a CDN, e.g.) you can
   // change this to something else and rebuild the Celerity map to break user
   // caches. Unless you are doing Celerity development, it is exceptionally
   // unlikely that you need to modify this.
   'celerity.resource-hash' => 'd9455ea150622ee044f7931dabfa52aa',
 
   // In a development environment, it is desirable to force static resources
   // (CSS and JS) to be read from disk on every request, so that edits to them
   // appear when you reload the page even if you haven't updated the resource
   // maps. This setting ensures requests will be verified against the state on
   // disk. Generally, you should leave this off in production (caching behavior
   // and performance improve with it off) but turn it on in development. (These
   // settings are the defaults.)
   'celerity.force-disk-reads' => false,
 
   // Minify static resources by removing whitespace and comments. You should
   // enable this in production, but disable it in development.
   'celerity.minify' => false,
 
   // You can respond to various application events by installing listeners,
   // which will receive callbacks when interesting things occur. Specify a list
   // of classes which extend PhabricatorEventListener here.
   'events.listeners'  => array(),
 
 // -- Pygments -------------------------------------------------------------- //
 
   // Phabricator can highlight PHP by default, but if you want syntax
   // highlighting for other languages you should install the python package
   // 'Pygments', make sure the 'pygmentize' script is available in the
   // $PATH of the webserver, and then enable this.
   'pygments.enabled'            => false,
 
   // In places that we display a dropdown to syntax-highlight code,
   // this is where that list is defined.
   // Syntax is 'lexer-name' => 'Display Name',
   'pygments.dropdown-choices' => array(
     'apacheconf' => 'Apache Configuration',
     'bash' => 'Bash Scripting',
     'brainfuck' => 'Brainf*ck',
     'c' => 'C',
     'cpp' => 'C++',
     'css' => 'CSS',
     'diff' => 'Diff',
     'django' => 'Django Templating',
     'erb' => 'Embedded Ruby/ERB',
     'erlang' => 'Erlang',
     'html' => 'HTML',
     'infer' => 'Infer from title (extension)',
     'java' => 'Java',
     'js' => 'Javascript',
     'mysql' => 'MySQL',
     'perl' => 'Perl',
     'php' => 'PHP',
     'text' => 'Plain Text',
     'python' => 'Python',
     'rainbow' => 'Rainbow',
     'remarkup' => 'Remarkup',
     'ruby' => 'Ruby',
     'xml' => 'XML',
   ),
 
   'pygments.dropdown-default' => 'infer',
 
   // This is an override list of regular expressions which allows you to choose
   // what language files are highlighted as. If your projects have certain rules
   // about filenames or use unusual or ambiguous language extensions, you can
   // create a mapping here. This is an ordered dictionary of regular expressions
   // which will be tested against the filename. They should map to either an
   // explicit language as a string value, or a numeric index into the captured
   // groups as an integer.
   'syntax.filemap' => array(
     // Example: Treat all '*.xyz' files as PHP.
     // '@\\.xyz$@' => 'php',
 
     // Example: Treat 'httpd.conf' as 'apacheconf'.
     // '@/httpd\\.conf$@' => 'apacheconf',
 
     // Example: Treat all '*.x.bak' file as '.x'. NOTE: we map to capturing
     // group 1 by specifying the mapping as "1".
     // '@\\.([^.]+)\\.bak$@' => 1,
 
     '@\.arcconfig$@' => 'js',
   ),
 
 );
diff --git a/src/applications/audit/editor/comment/PhabricatorAuditCommentEditor.php b/src/applications/audit/editor/comment/PhabricatorAuditCommentEditor.php
index 4b27424ff..4dd7ee371 100644
--- a/src/applications/audit/editor/comment/PhabricatorAuditCommentEditor.php
+++ b/src/applications/audit/editor/comment/PhabricatorAuditCommentEditor.php
@@ -1,408 +1,413 @@
 <?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;
 
   public function __construct(PhabricatorRepositoryCommit $commit) {
     $this->commit = $commit;
     return $this;
   }
 
   public function setUser(PhabricatorUser $user) {
     $this->user = $user;
     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();
 
     if ($inline_comments) {
       foreach ($inline_comments as $inline) {
         $inline->setAuditCommentID($comment->getID());
         $inline->save();
       }
     }
 
     // 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 {
       $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:
             // Comments don't change audit statuses.
             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;
           case PhabricatorAuditActionConstants::RESIGN:
             // NOTE: Resigning resigns ONLY your user request, not the requests
             // of any projects or packages you are a member of.
             if ($request_is_for_user) {
               $new_status = PhabricatorAuditStatusConstants::RESIGNED;
             }
             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:
             $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::RESIGN:
             // If you're on an audit because of a package, we write an explicit
             // resign row to remove it from your queue.
             $new_status = PhabricatorAuditStatusConstants::RESIGNED;
             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;
       }
     }
 
     $commit->updateAuditStatus($requests);
     $commit->save();
 
     $this->publishFeedStory($comment, array_keys($audit_phids));
     PhabricatorSearchCommitIndexer::indexCommit($commit);
     $this->sendMail($comment, $other_comments, $inline_comments);
   }
 
 
   /**
    * 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) {
     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',
     );
     $verb = idx($map, $comment->getAction(), 'Commented On');
 
     $reply_handler = self::newReplyHandlerForCommit($commit);
 
     $prefix = PhabricatorEnv::getEnvConfig('metamta.diffusion.subject-prefix');
-    $subject = "{$prefix} [{$verb}] {$name}: {$summary}";
+    $subject = "{$prefix} {$name}: {$summary}";
+    $vary_subject = "{$prefix} [{$verb}] {$name}: {$summary}";
 
     $threading = self::getMailThreading($commit->getPHID());
     list($thread_id, $thread_topic) = $threading;
 
-    $is_new     = !count($other_comments);
     $body       = $this->renderMailBody(
       $comment,
       "{$name}: {$summary}",
       $handle,
       $reply_handler,
       $inline_comments);
 
     $email_to = 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();
     }
 
     $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($subject)
+      ->setVarySubject($subject)
       ->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) {
     return array(
-      '<diffusion-audit-'.$phid.'>',
+      'diffusion-audit-'.$phid,
       'Diffusion Audit '.$phid,
     );
   }
 
   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/base/DifferentialMail.php b/src/applications/differential/mail/base/DifferentialMail.php
index 686eecbc4..9694306ef 100644
--- a/src/applications/differential/mail/base/DifferentialMail.php
+++ b/src/applications/differential/mail/base/DifferentialMail.php
@@ -1,400 +1,412 @@
 <?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;
 
-  abstract protected function renderSubject();
+  protected function renderSubject() {
+    $revision = $this->getRevision();
+    $title = $revision->getTitle();
+    $id = $revision->getID();
+    return "D{$id}: {$title}";
+  }
+
+  abstract protected function renderVarySubject();
   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();
-    $subject     = $this->buildSubject();
-    $body        = $this->buildBody();
-    $attachments = $this->buildAttachments();
+    $cc_phids     = $this->getCCPHIDs();
+    $subject      = $this->buildSubject();
+    $vary_subject = $this->buildVarySubject();
+    $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($subject)
+      ->setVarySubject($vary_subject)
       ->setBody($body)
       ->setIsHTML($this->shouldMarkMailAsHTML())
       ->setParentMessageID($this->parentMessageID)
       ->addHeader('Thread-Topic', $this->getRevision()->getTitle());
 
     $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 buildSubject() {
     return trim($this->getSubjectPrefix().' '.$this->renderSubject());
   }
 
+  protected function buildVarySubject() {
+    return trim($this->getSubjectPrefix().' '.$this->renderVarySubject());
+  }
+
   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", $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();
-    $domain = PhabricatorEnv::getEnvConfig('metamta.domain');
-    return "<differential-rev-{$phid}-req@{$domain}>";
+    return "differential-rev-{$phid}-req";
   }
 
   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;
   }
 
   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/mail/ccwelcome/DifferentialCCWelcomeMail.php b/src/applications/differential/mail/ccwelcome/DifferentialCCWelcomeMail.php
index a7db4f6ce..85776461d 100644
--- a/src/applications/differential/mail/ccwelcome/DifferentialCCWelcomeMail.php
+++ b/src/applications/differential/mail/ccwelcome/DifferentialCCWelcomeMail.php
@@ -1,40 +1,39 @@
 <?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 DifferentialCCWelcomeMail extends DifferentialReviewRequestMail {
 
-  protected function renderSubject() {
-    $revision = $this->getRevision();
-    return 'Added to CC: '.$revision->getTitle();
+  protected function renderVarySubject() {
+    return '[Added to CC] '.$this->renderSubject();
   }
 
   protected function renderBody() {
 
     $actor = $this->getActorName();
     $name  = $this->getRevision()->getTitle();
     $body = array();
 
     $body[] = "{$actor} added you to the CC list for the revision \"{$name}\".";
     $body[] = $this->renderReviewersLine();
     $body[] = null;
 
     $body[] = $this->renderReviewRequestBody();
 
     return implode("\n", $body);
   }
 }
diff --git a/src/applications/differential/mail/comment/DifferentialCommentMail.php b/src/applications/differential/mail/comment/DifferentialCommentMail.php
index 03973d33a..fb78849b5 100644
--- a/src/applications/differential/mail/comment/DifferentialCommentMail.php
+++ b/src/applications/differential/mail/comment/DifferentialCommentMail.php
@@ -1,208 +1,204 @@
 <?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 DifferentialCommentMail extends DifferentialMail {
 
   protected $changedByCommit;
 
   public function setChangedByCommit($changed_by_commit) {
     $this->changedByCommit = $changed_by_commit;
     return $this;
   }
 
   public function getChangedByCommit() {
     return $this->changedByCommit;
   }
 
   public function __construct(
     DifferentialRevision $revision,
     PhabricatorObjectHandle $actor,
     DifferentialComment $comment,
     array $changesets,
     array $inline_comments) {
     assert_instances_of($changesets, 'DifferentialChangeset');
     assert_instances_of($inline_comments, 'PhabricatorInlineCommentInterface');
 
     $this->setRevision($revision);
     $this->setActorHandle($actor);
     $this->setComment($comment);
     $this->setChangesets($changesets);
     $this->setInlineComments($inline_comments);
 
   }
 
   protected function getMailTags() {
     $comment = $this->getComment();
     $action = $comment->getAction();
 
     $tags = array();
     switch ($action) {
       case DifferentialAction::ACTION_ADDCCS:
         $tags[] = MetaMTANotificationType::TYPE_DIFFERENTIAL_CC;
         break;
       case DifferentialAction::ACTION_COMMIT:
         $tags[] = MetaMTANotificationType::TYPE_DIFFERENTIAL_COMMITTED;
         break;
     }
 
     if (strlen(trim($comment->getContent()))) {
       switch ($action) {
         case DifferentialAction::ACTION_COMMIT:
           // Commit comments are auto-generated and not especially interesting,
           // so don't tag them as having a comment.
           break;
         default:
           $tags[] = MetaMTANotificationType::TYPE_DIFFERENTIAL_COMMENT;
           break;
       }
     }
 
     return $tags;
   }
 
-  protected function renderSubject() {
+  protected function renderVarySubject() {
     $verb = ucwords($this->getVerb());
-    $revision = $this->getRevision();
-    $title = $revision->getTitle();
-    $id = $revision->getID();
-    $subject = "[{$verb}] D{$id}: {$title}";
-    return $subject;
+    return "[{$verb}] ".$this->renderSubject();
   }
 
   protected function getVerb() {
     $comment = $this->getComment();
     $action = $comment->getAction();
     $verb = DifferentialAction::getActionPastTenseVerb($action);
     return $verb;
   }
 
   protected function renderBody() {
 
     $comment = $this->getComment();
 
     $actor = $this->getActorName();
     $name  = $this->getRevision()->getTitle();
     $verb  = $this->getVerb();
 
     $body  = array();
 
     $body[] = "{$actor} has {$verb} the revision \"{$name}\".";
 
     // If the commented added reviewers or CCs, list them explicitly.
     $meta = $comment->getMetadata();
     $m_reviewers = idx(
       $meta,
       DifferentialComment::METADATA_ADDED_REVIEWERS,
       array());
     $m_cc = idx(
       $meta,
       DifferentialComment::METADATA_ADDED_CCS,
       array());
     $load = array_merge($m_reviewers, $m_cc);
     if ($load) {
       $handles = id(new PhabricatorObjectHandleData($load))->loadHandles();
       if ($m_reviewers) {
         $body[] = 'Added Reviewers: '.$this->renderHandleList(
           $handles,
           $m_reviewers);
       }
       if ($m_cc) {
         $body[] = 'Added CCs: '.$this->renderHandleList(
           $handles,
           $m_cc);
       }
     }
 
     $body[] = null;
 
     $content = $comment->getContent();
     if (strlen($content)) {
       $body[] = $this->formatText($content);
       $body[] = null;
     }
 
     if ($this->getChangedByCommit()) {
       $body[] = 'CHANGED PRIOR TO COMMIT';
       $body[] = '  This revision was updated prior to commit.';
       $body[] = null;
     }
 
     $inlines = $this->getInlineComments();
     if ($inlines) {
       $body[] = 'INLINE COMMENTS';
       $changesets = $this->getChangesets();
       foreach ($inlines as $inline) {
         $changeset = $changesets[$inline->getChangesetID()];
         if (!$changeset) {
           throw new Exception('Changeset missing!');
         }
         $file = $changeset->getFilename();
         $start = $inline->getLineNumber();
         $len = $inline->getLineLength();
         if ($len) {
           $range = $start.'-'.($start + $len);
         } else {
           $range = $start;
         }
         $content = $inline->getContent();
         $body[] = $this->formatText("{$file}:{$range} {$content}");
       }
       $body[] = null;
     }
 
     $body[] = $this->renderRevisionDetailLink();
     $body[] = null;
 
     $revision = $this->getRevision();
     $status = $revision->getStatus();
 
     if ($status == ArcanistDifferentialRevisionStatus::NEEDS_REVISION ||
         $status == ArcanistDifferentialRevisionStatus::ACCEPTED) {
       $diff = $revision->loadActiveDiff();
       if ($diff) {
         $branch = $diff->getBranch();
         if ($branch) {
           $body[] = "BRANCH\n  $branch";
           $body[] = null;
         }
       }
     }
 
     if ($status == ArcanistDifferentialRevisionStatus::COMMITTED) {
       $phids = $revision->loadCommitPHIDs();
       if ($phids) {
         $handles = id(new PhabricatorObjectHandleData($phids))->loadHandles();
         if (count($handles) == 1) {
           $body[] = "COMMIT";
         } else {
           // This is unlikely to ever happen since we'll send this mail the
           // first time we discover a commit, but it's not impossible if data
           // was migrated, etc.
           $body[] = "COMMITS";
         }
 
         foreach ($handles as $handle) {
           $body[] = '  '.PhabricatorEnv::getProductionURI($handle->getURI());
         }
         $body[] = null;
       }
     }
 
     return implode("\n", $body);
   }
 }
diff --git a/src/applications/differential/mail/diffcontent/DifferentialDiffContentMail.php b/src/applications/differential/mail/diffcontent/DifferentialDiffContentMail.php
index f021ae4d2..110c98117 100644
--- a/src/applications/differential/mail/diffcontent/DifferentialDiffContentMail.php
+++ b/src/applications/differential/mail/diffcontent/DifferentialDiffContentMail.php
@@ -1,35 +1,35 @@
 <?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 DifferentialDiffContentMail extends DifferentialMail {
 
   protected $content;
 
   public function __construct(DifferentialRevision $revision, $content) {
     $this->setRevision($revision);
     $this->content = $content;
   }
 
-  protected function renderSubject() {
-    return "Content: ".$this->getRevision()->getTitle();
+  protected function renderVarySubject() {
+    return '[Content] '.$this->renderSubject();
   }
 
   protected function renderBody() {
     return $this->content;
   }
 }
diff --git a/src/applications/differential/mail/exception/DifferentialExceptionMail.php b/src/applications/differential/mail/exception/DifferentialExceptionMail.php
index a0484c7f5..ef11cf9e6 100644
--- a/src/applications/differential/mail/exception/DifferentialExceptionMail.php
+++ b/src/applications/differential/mail/exception/DifferentialExceptionMail.php
@@ -1,62 +1,66 @@
 <?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 DifferentialExceptionMail extends DifferentialMail {
 
   public function __construct(
     DifferentialRevision $revision,
     Exception $exception,
     $original_body) {
 
     $this->revision = $revision;
     $this->exception = $exception;
     $this->originalBody = $original_body;
   }
 
   protected function renderBody() {
     // Never called since buildBody() is overridden.
   }
 
   protected function renderSubject() {
     return "Exception: unable to process your mail request.";
   }
 
+  protected function renderVarySubject() {
+    return $this->renderSubject();
+  }
+
   protected function buildBody() {
     $exception = $this->exception;
     $original_body = $this->originalBody;
 
     $message = $exception->getMessage();
     $trace   = $exception->getTraceAsString();
 
     return <<<EOBODY
 Your request failed because an exception was encoutered while processing it:
 
 EXCEPTION: {$message}
 
 {$trace}
 
 -- Original Body --------------------------
 
 {$original_body}
 
 EOBODY;
   }
 
 }
 
 
diff --git a/src/applications/differential/mail/newdiff/DifferentialNewDiffMail.php b/src/applications/differential/mail/newdiff/DifferentialNewDiffMail.php
index b1d1b4618..f3167caa6 100644
--- a/src/applications/differential/mail/newdiff/DifferentialNewDiffMail.php
+++ b/src/applications/differential/mail/newdiff/DifferentialNewDiffMail.php
@@ -1,68 +1,54 @@
 <?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 DifferentialNewDiffMail extends DifferentialReviewRequestMail {
 
-  protected function renderSubject() {
+  protected function renderVarySubject() {
     $revision = $this->getRevision();
     $line_count = $revision->getLineCount();
     $lines = ($line_count == 1 ? "1 line" : "{$line_count} lines");
 
     if ($this->isFirstMailToRecipients()) {
       $verb = 'Request';
     } else {
       $verb = 'Updated';
     }
 
-    $revision_id = $revision->getID();
-    $revision_title = $revision->getTitle();
-
-    return "[{$verb}, {$lines}] D{$revision_id}: {$revision_title}";
-  }
-
-  protected function buildSubject() {
-    if (!$this->isFirstMailToRecipients()) {
-      return parent::buildSubject();
-    }
-
-    $prefix = $this->getSubjectPrefix();
-    $subject = $this->renderSubject();
-
-    return trim("{$prefix} {$subject}");
+    return "[{$verb}, {$lines}] ".$this->renderSubject();
   }
 
   protected function renderBody() {
     $actor = $this->getActorName();
 
     $name  = $this->getRevision()->getTitle();
 
     $body = array();
 
     if ($this->isFirstMailToRecipients()) {
       $body[] = "{$actor} requested code review of \"{$name}\".";
     } else {
       $body[] = "{$actor} updated the revision \"{$name}\".";
     }
     $body[] = $this->renderReviewersLine();
     $body[] = null;
 
     $body[] = $this->renderReviewRequestBody();
 
     return implode("\n", $body);
   }
 }
diff --git a/src/applications/maniphest/editor/transaction/ManiphestTransactionEditor.php b/src/applications/maniphest/editor/transaction/ManiphestTransactionEditor.php
index ac22b5ee5..94dfa2eee 100644
--- a/src/applications/maniphest/editor/transaction/ManiphestTransactionEditor.php
+++ b/src/applications/maniphest/editor/transaction/ManiphestTransactionEditor.php
@@ -1,426 +1,428 @@
 <?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().'>';
+    $thread_id = 'maniphest-task-'.$task->getPHID();
     $task_id = $task->getID();
     $title = $task->getTitle();
     $prefix = $this->getSubjectPrefix();
-    $subject = trim("{$prefix} [{$action}] T{$task_id}: {$title}");
+    $subject = trim("{$prefix} T{$task_id}: {$title}");
+    $vary_subject = trim("{$prefix} [{$action}] T{$task_id}: {$title}");
 
     $mailtags = $this->getMailTags($transactions);
 
     $template = id(new PhabricatorMetaMTAMail())
       ->setSubject($subject)
+      ->setVarySubject($vary_subject)
       ->setFrom($transaction->getAuthorPHID())
       ->setParentMessageID($this->parentMessageID)
       ->addHeader('Thread-Topic', 'Maniphest Task '.$task->getID())
       ->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();
       }
       switch ($transaction->getTransactionType()) {
         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;
           }
           break;
         default:
           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()))
       ->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/metamta/replyhandler/base/PhabricatorMailReplyHandler.php b/src/applications/metamta/replyhandler/base/PhabricatorMailReplyHandler.php
index c4d7afa79..57ffee38d 100644
--- a/src/applications/metamta/replyhandler/base/PhabricatorMailReplyHandler.php
+++ b/src/applications/metamta/replyhandler/base/PhabricatorMailReplyHandler.php
@@ -1,208 +1,212 @@
 <?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 PhabricatorMailReplyHandler {
 
   private $mailReceiver;
   private $actor;
 
   final public function setMailReceiver($mail_receiver) {
     $this->validateMailReceiver($mail_receiver);
     $this->mailReceiver = $mail_receiver;
     return $this;
   }
 
   final public function getMailReceiver() {
     return $this->mailReceiver;
   }
 
   final public function setActor(PhabricatorUser $actor) {
     $this->actor = $actor;
     return $this;
   }
 
   final public function getActor() {
     return $this->actor;
   }
 
   abstract public function validateMailReceiver($mail_receiver);
   abstract public function getPrivateReplyHandlerEmailAddress(
     PhabricatorObjectHandle $handle);
   abstract public function getReplyHandlerDomain();
   abstract public function getReplyHandlerInstructions();
   abstract public function receiveEmail(PhabricatorMetaMTAReceivedMail $mail);
 
   public function supportsPrivateReplies() {
     return (bool)$this->getReplyHandlerDomain() &&
            !$this->supportsPublicReplies();
   }
 
   public function supportsPublicReplies() {
     if (!PhabricatorEnv::getEnvConfig('metamta.public-replies')) {
       return false;
     }
     if (!$this->getReplyHandlerDomain()) {
       return false;
     }
     return (bool)$this->getPublicReplyHandlerEmailAddress();
   }
 
   final public function supportsReplies() {
     return $this->supportsPrivateReplies() ||
            $this->supportsPublicReplies();
   }
 
   public function getPublicReplyHandlerEmailAddress() {
     return null;
   }
 
   final public function multiplexMail(
     PhabricatorMetaMTAMail $mail_template,
     array $to_handles,
     array $cc_handles) {
     assert_instances_of($to_handles, 'PhabricatorObjectHandle');
     assert_instances_of($cc_handles, 'PhabricatorObjectHandle');
 
     $result = array();
 
-    // If private replies are not supported, simply send one email to all
-    // recipients and CCs. This covers cases where we have no reply handler,
-    // or we have a public reply handler.
-    if (!$this->supportsPrivateReplies()) {
-      $mail = clone $mail_template;
-      $mail->addTos(mpull($to_handles, 'getPHID'));
-      $mail->addCCs(mpull($cc_handles, 'getPHID'));
-
-      if ($this->supportsPublicReplies()) {
-        $reply_to = $this->getPublicReplyHandlerEmailAddress();
-        $mail->setReplyTo($reply_to);
+    // If MetaMTA is configured to always multiplex, skip the single-email
+    // case.
+    if (!PhabricatorMetaMTAMail::shouldMultiplexAllMail()) {
+      // If private replies are not supported, simply send one email to all
+      // recipients and CCs. This covers cases where we have no reply handler,
+      // or we have a public reply handler.
+      if (!$this->supportsPrivateReplies()) {
+        $mail = clone $mail_template;
+        $mail->addTos(mpull($to_handles, 'getPHID'));
+        $mail->addCCs(mpull($cc_handles, 'getPHID'));
+
+        if ($this->supportsPublicReplies()) {
+          $reply_to = $this->getPublicReplyHandlerEmailAddress();
+          $mail->setReplyTo($reply_to);
+        }
+
+        $result[] = $mail;
+
+        return $result;
       }
-
-      $result[] = $mail;
-
-      return $result;
     }
 
     // Merge all the recipients together. TODO: We could keep the CCs as real
     // CCs and send to a "noreply@domain.com" type address, but keep it simple
     // for now.
     $recipients = mpull($to_handles, null, 'getPHID') +
                   mpull($cc_handles, null, 'getPHID');
 
     // This grouping is just so we can use the public reply-to for any
     // recipients without a private reply-to, e.g. mailing lists.
     $groups = array();
     foreach ($recipients as $recipient) {
       $private = $this->getPrivateReplyHandlerEmailAddress($recipient);
       $groups[$private][] = $recipient;
     }
 
     // When multiplexing mail, explicitly include To/Cc information in the
     // message body and headers.
     $add_headers = array();
 
     $body = $mail_template->getBody();
     $body .= "\n";
     if ($to_handles) {
       $body .= "To: ".implode(', ', mpull($to_handles, 'getName'))."\n";
       $add_headers['X-Phabricator-To'] = $this->formatPHIDList($to_handles);
     }
     if ($cc_handles) {
       $body .= "Cc: ".implode(', ', mpull($cc_handles, 'getName'))."\n";
       $add_headers['X-Phabricator-Cc'] = $this->formatPHIDList($cc_handles);
     }
 
     foreach ($groups as $reply_to => $group) {
       $mail = clone $mail_template;
       $mail->addTos(mpull($group, 'getPHID'));
 
       $mail->setBody($body);
       foreach ($add_headers as $header => $value) {
         $mail->addHeader($header, $value);
       }
 
       if (!$reply_to && $this->supportsPublicReplies()) {
         $reply_to = $this->getPublicReplyHandlerEmailAddress();
       }
 
       if ($reply_to) {
         $mail->setReplyTo($reply_to);
       }
 
       $result[] = $mail;
     }
 
     return $result;
   }
 
   protected function formatPHIDList(array $handles) {
     assert_instances_of($handles, 'PhabricatorObjectHandle');
     $list = array();
     foreach ($handles as $handle) {
       $list[] = '<'.$handle->getPHID().'>';
     }
     return implode(', ', $list);
   }
 
   protected function getDefaultPublicReplyHandlerEmailAddress($prefix) {
 
     $receiver = $this->getMailReceiver();
     $receiver_id = $receiver->getID();
     $domain = $this->getReplyHandlerDomain();
 
     // We compute a hash using the object's own PHID to prevent an attacker
     // from blindly interacting with objects that they haven't ever received
     // mail about by just sending to D1@, D2@, etc...
     $hash = PhabricatorMetaMTAReceivedMail::computeMailHash(
       $receiver->getMailKey(),
       $receiver->getPHID());
 
     $address = "{$prefix}{$receiver_id}+public+{$hash}@{$domain}";
     return $this->getSingleReplyHandlerPrefix($address);
   }
 
   protected function getSingleReplyHandlerPrefix($address) {
     $single_handle_prefix = PhabricatorEnv::getEnvConfig(
       'metamta.single-reply-handler-prefix');
     return ($single_handle_prefix)
       ? $single_handle_prefix . '+' . $address
       : $address;
   }
 
   protected function getDefaultPrivateReplyHandlerEmailAddress(
     PhabricatorObjectHandle $handle,
     $prefix) {
 
     if ($handle->getType() != PhabricatorPHIDConstants::PHID_TYPE_USER) {
       // You must be a real user to get a private reply handler address.
       return null;
     }
 
     $receiver = $this->getMailReceiver();
     $receiver_id = $receiver->getID();
     $user_id = $handle->getAlternateID();
     $hash = PhabricatorMetaMTAReceivedMail::computeMailHash(
       $receiver->getMailKey(),
       $handle->getPHID());
     $domain = $this->getReplyHandlerDomain();
 
     $address = "{$prefix}{$receiver_id}+{$user_id}+{$hash}@{$domain}";
     return $this->getSingleReplyHandlerPrefix($address);
   }
 
 }
diff --git a/src/applications/metamta/replyhandler/base/__init__.php b/src/applications/metamta/replyhandler/base/__init__.php
index 145c5f6fd..02f6d6d33 100644
--- a/src/applications/metamta/replyhandler/base/__init__.php
+++ b/src/applications/metamta/replyhandler/base/__init__.php
@@ -1,16 +1,17 @@
 <?php
 /**
  * This file is automatically generated. Lint this module to rebuild it.
  * @generated
  */
 
 
 
+phutil_require_module('phabricator', 'applications/metamta/storage/mail');
 phutil_require_module('phabricator', 'applications/metamta/storage/receivedmail');
 phutil_require_module('phabricator', 'applications/phid/constants');
 phutil_require_module('phabricator', 'infrastructure/env');
 
 phutil_require_module('phutil', 'utils');
 
 
 phutil_require_source('PhabricatorMailReplyHandler.php');
diff --git a/src/applications/metamta/storage/mail/PhabricatorMetaMTAMail.php b/src/applications/metamta/storage/mail/PhabricatorMetaMTAMail.php
index 458c7545c..3240ad2e7 100644
--- a/src/applications/metamta/storage/mail/PhabricatorMetaMTAMail.php
+++ b/src/applications/metamta/storage/mail/PhabricatorMetaMTAMail.php
@@ -1,637 +1,678 @@
 <?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.
  */
 
 /**
  * See #394445 for an explanation of why this thing even exists.
  */
 final class PhabricatorMetaMTAMail extends PhabricatorMetaMTADAO {
 
   const STATUS_QUEUE = 'queued';
   const STATUS_SENT  = 'sent';
   const STATUS_FAIL  = 'fail';
   const STATUS_VOID  = 'void';
 
   const MAX_RETRIES   = 250;
   const RETRY_DELAY   = 5;
 
   protected $parameters;
   protected $status;
   protected $message;
   protected $retryCount;
   protected $nextRetry;
   protected $relatedPHID;
 
   public function __construct() {
 
     $this->status     = self::STATUS_QUEUE;
     $this->retryCount = 0;
     $this->nextRetry  = time();
     $this->parameters = array();
 
     parent::__construct();
   }
 
   public function getConfiguration() {
     return array(
       self::CONFIG_SERIALIZATION => array(
         'parameters'  => self::SERIALIZATION_JSON,
       ),
     ) + parent::getConfiguration();
   }
 
   protected function setParam($param, $value) {
     $this->parameters[$param] = $value;
     return $this;
   }
 
   protected function getParam($param) {
     return idx($this->parameters, $param);
   }
 
   /**
    * Set tags (@{class:MetaMTANotificationType} constants) which identify the
    * content of this mail in a general way. These tags are used to allow users
    * to opt out of receiving certain types of mail, like updates when a task's
    * projects change.
    *
    * @param list<const> List of @{class:MetaMTANotificationType} constants.
    * @return this
    */
   public function setMailTags(array $tags) {
     $this->setParam('mailtags', $tags);
     return $this;
   }
 
   /**
    * In Gmail, conversations will be broken if you reply to a thread and the
    * server sends back a response without referencing your Message-ID, even if
    * it references a Message-ID earlier in the thread. To avoid this, use the
    * parent email's message ID explicitly if it's available. This overwrites the
    * "In-Reply-To" and "References" headers we would otherwise generate. This
    * needs to be set whenever an action is triggered by an email message. See
    * T251 for more details.
    *
    * @param   string The "Message-ID" of the email which precedes this one.
    * @return  this
    */
   public function setParentMessageID($id) {
     $this->setParam('parent-message-id', $id);
     return $this;
   }
 
   public function getParentMessageID() {
     return $this->getParam('parent-message-id');
   }
 
   public function getSubject() {
     return $this->getParam('subject');
   }
 
   public function addTos(array $phids) {
     $phids = array_unique($phids);
     $this->setParam('to', $phids);
     return $this;
   }
 
   public function addCCs(array $phids) {
     $phids = array_unique($phids);
     $this->setParam('cc', $phids);
     return $this;
   }
 
   public function addHeader($name, $value) {
     $this->parameters['headers'][$name] = $value;
     return $this;
   }
 
   public function addAttachment(PhabricatorMetaMTAAttachment $attachment) {
     $this->parameters['attachments'][] = $attachment;
     return $this;
   }
 
   public function getAttachments() {
     return $this->getParam('attachments');
   }
 
   public function setAttachments(array $attachments) {
     assert_instances_of($attachments, 'PhabricatorMetaMTAAttachment');
     $this->setParam('attachments', $attachments);
     return $this;
   }
 
   public function setFrom($from) {
     $this->setParam('from', $from);
     return $this;
   }
 
   public function setReplyTo($reply_to) {
     $this->setParam('reply-to', $reply_to);
     return $this;
   }
 
   public function setSubject($subject) {
     $this->setParam('subject', $subject);
     return $this;
   }
 
+  public function setVarySubject($subject) {
+    $this->setParam('vary-subject', $subject);
+    return $this;
+  }
+
   public function setBody($body) {
     $this->setParam('body', $body);
     return $this;
   }
 
   public function getBody() {
     return $this->getParam('body');
   }
 
   public function setIsHTML($html) {
     $this->setParam('is-html', $html);
     return $this;
   }
 
   public function getSimulatedFailureCount() {
     return nonempty($this->getParam('simulated-failures'), 0);
   }
 
   public function setSimulatedFailureCount($count) {
     $this->setParam('simulated-failures', $count);
     return $this;
   }
 
   public function getWorkerTaskID() {
     return $this->getParam('worker-task');
   }
 
   public function setWorkerTaskID($id) {
     $this->setParam('worker-task', $id);
     return $this;
   }
 
   /**
    * Flag that this is an auto-generated bulk message and should have bulk
    * headers added to it if appropriate. Broadly, this means some flavor of
    * "Precedence: bulk" or similar, but is implementation and configuration
    * dependent.
    *
    * @param bool  True if the mail is automated bulk mail.
    * @return this
    */
   public function setIsBulk($is_bulk) {
     $this->setParam('is-bulk', $is_bulk);
     return $this;
   }
 
   /**
    * Use this method to set an ID used for message threading. MetaMTA will
    * set appropriate headers (Message-ID, In-Reply-To, References and
    * Thread-Index) based on the capabilities of the underlying mailer.
    *
    * @param string  Unique identifier, appropriate for use in a Message-ID,
    *                In-Reply-To or References headers.
    * @param bool    If true, indicates this is the first message in the thread.
    * @return this
    */
   public function setThreadID($thread_id, $is_first_message = false) {
     $this->setParam('thread-id', $thread_id);
     $this->setParam('is-first-message', $is_first_message);
     return $this;
   }
 
   /**
    * Save a newly created mail to the database and attempt to send it
    * immediately if the server is configured for immediate sends. When
    * applications generate new mail they should generally use this method to
    * deliver it. If the server doesn't use immediate sends, this has the same
    * effect as calling save(): the mail will eventually be delivered by the
    * MetaMTA daemon.
    *
    * @return this
    */
   public function saveAndSend() {
     $ret = null;
 
     if (PhabricatorEnv::getEnvConfig('metamta.send-immediately')) {
       $ret = $this->sendNow();
     } else {
       $ret = $this->save();
     }
 
     return $ret;
   }
 
   protected function didWriteData() {
     parent::didWriteData();
 
     if (!$this->getWorkerTaskID()) {
       $mailer_task = new PhabricatorWorkerTask();
       $mailer_task->setTaskClass('PhabricatorMetaMTAWorker');
       $mailer_task->setData($this->getID());
       $mailer_task->save();
       $this->setWorkerTaskID($mailer_task->getID());
       $this->save();
     }
   }
 
 
   public function buildDefaultMailer() {
     return PhabricatorEnv::newObjectFromConfig('metamta.mail-adapter');
   }
 
   /**
    * Attempt to deliver an email immediately, in this process.
    *
    * @param bool  Try to deliver this email even if it has already been
    *              delivered or is in backoff after a failed delivery attempt.
    * @param PhabricatorMailImplementationAdapter Use a specific mail adapter,
    *              instead of the default.
    *
    * @return void
    */
   public function sendNow(
     $force_send = false,
     PhabricatorMailImplementationAdapter $mailer = null) {
 
     if ($mailer === null) {
       $mailer = $this->buildDefaultMailer();
     }
 
     if (!$force_send) {
       if ($this->getStatus() != self::STATUS_QUEUE) {
         throw new Exception("Trying to send an already-sent mail!");
       }
 
       if (time() < $this->getNextRetry()) {
         throw new Exception("Trying to send an email before next retry!");
       }
     }
 
     try {
       $parameters = $this->parameters;
       $phids = array();
       foreach ($parameters as $key => $value) {
         switch ($key) {
           case 'from':
           case 'to':
           case 'cc':
             if (!is_array($value)) {
               $value = array($value);
             }
             foreach (array_filter($value) as $phid) {
               $phids[] = $phid;
             }
             break;
         }
       }
 
       $handles = id(new PhabricatorObjectHandleData($phids))
         ->loadHandles();
 
       $exclude = array();
 
       $params = $this->parameters;
       $default = PhabricatorEnv::getEnvConfig('metamta.default-address');
       if (empty($params['from'])) {
         $mailer->setFrom($default);
       } else {
         $from = $params['from'];
 
         // If the user has set their preferences to not send them email about
         // things they do, exclude them from being on To or Cc.
         $from_user = id(new PhabricatorUser())->loadOneWhere(
           'phid = %s',
           $from);
         if ($from_user) {
           $pref_key = PhabricatorUserPreferences::PREFERENCE_NO_SELF_MAIL;
           $exclude_self = $from_user
             ->loadPreferences()
             ->getPreference($pref_key);
           if ($exclude_self) {
             $exclude[$from] = true;
           }
         }
 
         if (!PhabricatorEnv::getEnvConfig('metamta.can-send-as-user')) {
           $handle = $handles[$from];
           if (empty($params['reply-to'])) {
             $params['reply-to'] = $handle->getEmail();
             $params['reply-to-name'] = $handle->getFullName();
           }
           $mailer->setFrom(
             $default,
             $handle->getFullName());
           unset($params['from']);
         }
       }
 
       $is_first = idx($params, 'is-first-message');
       unset($params['is-first-message']);
 
       $is_threaded = (bool)idx($params, 'thread-id');
 
       $reply_to_name = idx($params, 'reply-to-name', '');
       unset($params['reply-to-name']);
 
       $add_cc = array();
       $add_to = array();
 
       foreach ($params as $key => $value) {
         switch ($key) {
           case 'from':
             $mailer->setFrom($handles[$value]->getEmail());
             break;
           case 'reply-to':
             $mailer->addReplyTo($value, $reply_to_name);
             break;
           case 'to':
             $emails = $this->getDeliverableEmailsFromHandles(
               $value,
               $handles,
               $exclude);
             if ($emails) {
               $add_to = $emails;
             }
             break;
           case 'cc':
             $emails = $this->getDeliverableEmailsFromHandles(
               $value,
               $handles,
               $exclude);
             if ($emails) {
               $add_cc = $emails;
             }
             break;
           case 'headers':
             foreach ($value as $header_key => $header_value) {
               // NOTE: If we have \n in a header, SES rejects the email.
               $header_value = str_replace("\n", " ", $header_value);
 
               $mailer->addHeader($header_key, $header_value);
             }
             break;
           case 'attachments':
             foreach ($value as $attachment) {
               $mailer->addAttachment(
                 $attachment->getData(),
                 $attachment->getFilename(),
                 $attachment->getMimeType()
               );
             }
             break;
           case 'body':
             $mailer->setBody($value);
             break;
           case 'subject':
+            // Only try to use preferences if everything is multiplexed, so we
+            // get consistent behavior.
+            $use_prefs = self::shouldMultiplexAllMail();
+
+            $prefs = null;
+            if ($use_prefs) {
+              $to = idx($params, 'to', array());
+              $user = id(new PhabricatorUser())->loadOneWhere(
+                'phid = %s',
+                head($to));
+              if ($user) {
+                $prefs = $user->loadPreferences();
+              }
+            }
+
+            $alt_subject = idx($params, 'vary-subject');
+            if ($alt_subject) {
+              $use_subject = PhabricatorEnv::getEnvConfig(
+                'metamta.vary-subjects');
+
+              if ($prefs) {
+                $use_subject = $prefs->getPreference(
+                  PhabricatorUserPreferences::PREFERENCE_VARY_SUBJECT,
+                  $use_subject);
+              }
+
+              if ($use_subject) {
+                $value = $alt_subject;
+              }
+            }
+
             if ($is_threaded) {
               $add_re = PhabricatorEnv::getEnvConfig('metamta.re-prefix');
 
-              // If this message has a single recipient, respect their "Re:"
-              // preference. Otherwise, use the global setting.
-
-              $to = idx($params, 'to', array());
-              $cc = idx($params, 'cc', array());
-              if (count($to) == 1 && count($cc) == 0) {
-                $user = id(new PhabricatorUser())->loadOneWhere(
-                  'phid = %s',
-                  head($to));
-                if ($user) {
-                  $prefs = $user->loadPreferences();
-                  $pref_key = PhabricatorUserPreferences::PREFERENCE_RE_PREFIX;
-                  $add_re = $prefs->getPreference($pref_key, $add_re);
-                }
+              if ($prefs) {
+                $add_re = $prefs->getPreference(
+                  PhabricatorUserPreferences::PREFERENCE_RE_PREFIX,
+                  $add_re);
               }
 
               if ($add_re) {
                 $value = 'Re: '.$value;
               }
             }
 
             $mailer->setSubject($value);
             break;
           case 'is-html':
             if ($value) {
               $mailer->setIsHTML(true);
             }
             break;
           case 'is-bulk':
             if ($value) {
               if (PhabricatorEnv::getEnvConfig('metamta.precedence-bulk')) {
                 $mailer->addHeader('Precedence', 'bulk');
               }
             }
             break;
           case 'thread-id':
+
+            // NOTE: Gmail freaks out about In-Reply-To and References which
+            // aren't in the form "<string@domain.tld>"; this is also required
+            // by RFC 2822, although some clients are more liberal in what they
+            // accept.
+            $domain = PhabricatorEnv::getEnvConfig('metamta.domain');
+            $value = '<'.$value.'@'.$domain.'>';
+
             if ($is_first && $mailer->supportsMessageIDHeader()) {
               $mailer->addHeader('Message-ID',  $value);
             } else {
               $in_reply_to = $value;
               $references = array($value);
               $parent_id = $this->getParentMessageID();
               if ($parent_id) {
                 $in_reply_to = $parent_id;
                 // By RFC 2822, the most immediate parent should appear last
                 // in the "References" header, so this order is intentional.
                 $references[] = $parent_id;
               }
               $references = implode(' ', $references);
               $mailer->addHeader('In-Reply-To', $in_reply_to);
               $mailer->addHeader('References',  $references);
             }
             $thread_index = $this->generateThreadIndex($value, $is_first);
             $mailer->addHeader('Thread-Index', $thread_index);
             break;
           case 'mailtags':
             // Handled below.
             break;
+          case 'vary-subject':
+            // Handled above.
+            break;
           default:
             // Just discard.
         }
       }
 
       $mailer->addHeader('X-Phabricator-Sent-This-Message', 'Yes');
       $mailer->addHeader('X-Mail-Transport-Agent', 'MetaMTA');
 
       // If the message has mailtags, filter out any recipients who don't want
       // to receive this type of mail.
       $mailtags = $this->getParam('mailtags');
       if ($mailtags && ($add_to || $add_cc)) {
 
         $tag_header = array();
         foreach ($mailtags as $mailtag) {
           $tag_header[] = '<'.$mailtag.'>';
         }
         $tag_header = implode(', ', $tag_header);
         $mailer->addHeader('X-Phabricator-Mail-Tags', $tag_header);
 
         $exclude = array();
 
         $all_recipients = array_merge(
           array_keys($add_to),
           array_keys($add_cc));
 
         $all_prefs = id(new PhabricatorUserPreferences())->loadAllWhere(
           'userPHID in (%Ls)',
           $all_recipients);
         $all_prefs = mpull($all_prefs, null, 'getUserPHID');
 
         foreach ($all_recipients as $recipient) {
           $prefs = idx($all_prefs, $recipient);
           if (!$prefs) {
             continue;
           }
 
           $user_mailtags = $prefs->getPreference(
             PhabricatorUserPreferences::PREFERENCE_MAILTAGS,
             array());
 
           // The user must have elected to receive mail for at least one
           // of the mailtags.
           $send = false;
           foreach ($mailtags as $tag) {
             if (idx($user_mailtags, $tag, true)) {
               $send = true;
               break;
             }
           }
 
           if (!$send) {
             $exclude[$recipient] = true;
           }
         }
 
         $add_to = array_diff_key($add_to, $exclude);
         $add_cc = array_diff_key($add_cc, $exclude);
       }
 
 
       if ($add_to) {
         $mailer->addTos($add_to);
         if ($add_cc) {
           $mailer->addCCs($add_cc);
         }
       } else if ($add_cc) {
         // If we have CC addresses but no "to" address, promote the CCs to
         // "to".
         $mailer->addTos($add_cc);
       } else {
         $this->setStatus(self::STATUS_VOID);
         $this->setMessage(
           "Message has no valid recipients: all To/CC are disabled or ".
           "configured not to receive this mail.");
         return $this->save();
       }
 
     } catch (Exception $ex) {
       $this->setStatus(self::STATUS_FAIL);
       $this->setMessage($ex->getMessage());
       return $this->save();
     }
 
     if ($this->getRetryCount() < $this->getSimulatedFailureCount()) {
       $ok = false;
       $error = 'Simulated failure.';
     } else {
       try {
         $ok = $mailer->send();
         $error = null;
       } catch (Exception $ex) {
         $ok = false;
         $error = $ex->getMessage()."\n".$ex->getTraceAsString();
       }
     }
 
     if (!$ok) {
       $this->setMessage($error);
       if ($this->getRetryCount() > self::MAX_RETRIES) {
         $this->setStatus(self::STATUS_FAIL);
       } else {
         $this->setRetryCount($this->getRetryCount() + 1);
         $next_retry = time() + ($this->getRetryCount() * self::RETRY_DELAY);
         $this->setNextRetry($next_retry);
       }
     } else {
       $this->setStatus(self::STATUS_SENT);
     }
 
     return $this->save();
   }
 
   public static function getReadableStatus($status_code) {
     static $readable = array(
       self::STATUS_QUEUE => "Queued for Delivery",
       self::STATUS_FAIL  => "Delivery Failed",
       self::STATUS_SENT  => "Sent",
       self::STATUS_VOID  => "Void",
     );
     $status_code = coalesce($status_code, '?');
     return idx($readable, $status_code, $status_code);
   }
 
   private function generateThreadIndex($seed, $is_first_mail) {
     // When threading, Outlook ignores the 'References' and 'In-Reply-To'
     // headers that most clients use. Instead, it uses a custom 'Thread-Index'
     // header. The format of this header is something like this (from
     // camel-exchange-folder.c in Evolution Exchange):
 
     /* A new post to a folder gets a 27-byte-long thread index. (The value
      * is apparently unique but meaningless.) Each reply to a post gets a
      * 32-byte-long thread index whose first 27 bytes are the same as the
      * parent's thread index. Each reply to any of those gets a
      * 37-byte-long thread index, etc. The Thread-Index header contains a
      * base64 representation of this value.
      */
 
     // The specific implementation uses a 27-byte header for the first email
     // a recipient receives, and a random 5-byte suffix (32 bytes total)
     // thereafter. This means that all the replies are (incorrectly) siblings,
     // but it would be very difficult to keep track of the entire tree and this
     // gets us reasonable client behavior.
 
     $base = substr(md5($seed), 0, 27);
     if (!$is_first_mail) {
       // Not totally sure, but it seems like outlook orders replies by
       // thread-index rather than timestamp, so to get these to show up in the
       // right order we use the time as the last 4 bytes.
       $base .= ' '.pack('N', time());
     }
 
     return base64_encode($base);
   }
 
   private function getDeliverableEmailsFromHandles(
     array $phids,
     array $handles,
     array $exclude) {
     assert_instances_of($handles, 'PhabricatorObjectHandle');
 
     $emails = array();
     foreach ($phids as $phid) {
       if ($handles[$phid]->isDisabled()) {
         continue;
       }
       if (!$handles[$phid]->isComplete()) {
         continue;
       }
       if (isset($exclude[$phid])) {
         continue;
       }
       $emails[$phid] = $handles[$phid]->getEmail();
     }
 
     return $emails;
   }
 
+  public static function shouldMultiplexAllMail() {
+    return PhabricatorEnv::getEnvConfig('metamta.one-mail-per-recipient');
+  }
+
 }
diff --git a/src/applications/people/controller/settings/panels/emailpref/PhabricatorUserEmailPreferenceSettingsPanelController.php b/src/applications/people/controller/settings/panels/emailpref/PhabricatorUserEmailPreferenceSettingsPanelController.php
index 8b7e5c73d..d8d3b73dc 100644
--- a/src/applications/people/controller/settings/panels/emailpref/PhabricatorUserEmailPreferenceSettingsPanelController.php
+++ b/src/applications/people/controller/settings/panels/emailpref/PhabricatorUserEmailPreferenceSettingsPanelController.php
@@ -1,212 +1,253 @@
 <?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 PhabricatorUserEmailPreferenceSettingsPanelController
   extends PhabricatorUserSettingsPanelController {
 
   public function processRequest() {
     $request = $this->getRequest();
     $user = $request->getUser();
 
     $preferences = $user->loadPreferences();
 
     $pref_re_prefix = PhabricatorUserPreferences::PREFERENCE_RE_PREFIX;
+    $pref_vary = PhabricatorUserPreferences::PREFERENCE_VARY_SUBJECT;
     $pref_no_self_mail = PhabricatorUserPreferences::PREFERENCE_NO_SELF_MAIL;
 
     $errors = array();
     if ($request->isFormPost()) {
 
-      if ($request->getStr($pref_re_prefix) == 'default') {
-        $preferences->unsetPreference($pref_re_prefix);
-      } else {
-        $preferences->setPreference(
-          $pref_re_prefix,
-          $request->getBool($pref_re_prefix));
+      if (PhabricatorMetaMTAMail::shouldMultiplexAllMail()) {
+        if ($request->getStr($pref_re_prefix) == 'default') {
+          $preferences->unsetPreference($pref_re_prefix);
+        } else {
+          $preferences->setPreference(
+            $pref_re_prefix,
+            $request->getBool($pref_re_prefix));
+        }
+
+        if ($request->getStr($pref_vary) == 'default') {
+          $preferences->unsetPreference($pref_vary);
+        } else {
+          $preferences->setPreference(
+            $pref_vary,
+            $request->getBool($pref_vary));
+        }
       }
 
       $preferences->setPreference(
         $pref_no_self_mail,
         $request->getStr($pref_no_self_mail));
 
-
       $new_tags = $request->getArr('mailtags');
       $mailtags = $preferences->getPreference('mailtags', array());
       foreach ($this->getMailTags() as $key => $label) {
         $mailtags[$key] = (bool)idx($new_tags, $key, false);
       }
       $preferences->setPreference('mailtags', $mailtags);
 
       $preferences->save();
 
       return id(new AphrontRedirectResponse())
         ->setURI('/settings/page/emailpref/?saved=true');
     }
 
     $notice = null;
     if (!$errors) {
       if ($request->getStr('saved')) {
         $notice = new AphrontErrorView();
         $notice->setSeverity(AphrontErrorView::SEVERITY_NOTICE);
         $notice->setTitle('Changes Saved');
         $notice->appendChild('<p>Your changes have been saved.</p>');
       }
     } else {
       $notice = new AphrontErrorView();
       $notice->setTitle('Form Errors');
       $notice->setErrors($errors);
     }
 
     $re_prefix_default = PhabricatorEnv::getEnvConfig('metamta.re-prefix')
       ? 'Enabled'
       : 'Disabled';
 
+    $vary_default = PhabricatorEnv::getEnvConfig('metamta.vary-subjects')
+      ? 'Vary'
+      : 'Do Not Vary';
+
     $re_prefix_value = $preferences->getPreference($pref_re_prefix);
     if ($re_prefix_value === null) {
-      $re_prefix_value = 'defualt';
+      $re_prefix_value = 'default';
     } else {
       $re_prefix_value = $re_prefix_value
         ? 'true'
         : 'false';
     }
 
+    $vary_value = $preferences->getPreference($pref_vary);
+    if ($vary_value === null) {
+      $vary_value = 'default';
+    } else {
+      $vary_value = $vary_value
+        ? 'true'
+        : 'false';
+    }
+
     $form = new AphrontFormView();
     $form
       ->setUser($user)
       ->appendChild(
         id(new AphrontFormSelectControl())
           ->setLabel('Self Actions')
           ->setName($pref_no_self_mail)
           ->setOptions(
             array(
               '0' => 'Send me an email when I take an action',
               '1' => 'Do not send me an email when I take an action',
             ))
           ->setCaption('You can disable email about your own actions.')
-          ->setValue($preferences->getPreference($pref_no_self_mail, 0)))
-      ->appendChild(
-        id(new AphrontFormSelectControl())
-          ->setLabel('Add "Re:" Prefix')
-          ->setName($pref_re_prefix)
-          ->setCaption(
-            'Enable this option to fix threading in Mail.app on OS X Lion, '.
-            'or if you like "Re:" in your email subjects.')
-          ->setOptions(
-            array(
-              'default'   => 'Use Server Default ('.$re_prefix_default.')',
-              'true'      => 'Enable "Re:" prefix',
-              'false'     => 'Disable "Re:" prefix',
-            ))
-          ->setValue($re_prefix_value));
+          ->setValue($preferences->getPreference($pref_no_self_mail, 0)));
+
+    if (PhabricatorMetaMTAMail::shouldMultiplexAllMail()) {
+      $form
+        ->appendChild(
+          id(new AphrontFormSelectControl())
+            ->setLabel('Add "Re:" Prefix')
+            ->setName($pref_re_prefix)
+            ->setCaption(
+              'Enable this option to fix threading in Mail.app on OS X Lion, '.
+              'or if you like "Re:" in your email subjects.')
+            ->setOptions(
+              array(
+                'default'   => 'Use Server Default ('.$re_prefix_default.')',
+                'true'      => 'Enable "Re:" prefix',
+                'false'     => 'Disable "Re:" prefix',
+              ))
+            ->setValue($re_prefix_value))
+        ->appendChild(
+          id(new AphrontFormSelectControl())
+            ->setLabel('Vary Subjects')
+            ->setName($pref_vary)
+            ->setCaption(
+              'This option adds more information email subjects, but may '.
+              'break threading in some clients.')
+            ->setOptions(
+              array(
+                'default'   => 'Use Server Default ('.$vary_default.')',
+                'true'      => 'Vary Subjects',
+                'false'     => 'Do Not Vary Subjects',
+              ))
+            ->setValue($vary_value));
+    }
 
     $form
       ->appendChild(
         '<br />'.
         '<p class="aphront-form-instructions">'.
           'You can customize what mail you receive from Phabricator here.'.
         '</p>'.
         '<p class="aphront-form-instructions">'.
           '<strong>NOTE:</strong> If an update makes several changes (like '.
           'adding CCs to a task, closing it, and adding a comment) you will '.
           'still receive an email as long as at least one of the changes '.
           'is set to notify you.'.
         '</p>'
         );
 
     $mailtags = $preferences->getPreference('mailtags', array());
 
     $form
       ->appendChild(
         $this->buildMailTagCheckboxes(
           $this->getDifferentialMailTags(),
           $mailtags)
           ->setLabel('Differential'))
       ->appendChild(
         $this->buildMailTagCheckboxes(
           $this->getManiphestMailTags(),
           $mailtags)
           ->setLabel('Maniphest'));
 
     $form
       ->appendChild(
         id(new AphrontFormSubmitControl())
           ->setValue('Save Preferences'));
 
     $panel = new AphrontPanelView();
     $panel->setHeader('Email Preferences');
     $panel->setWidth(AphrontPanelView::WIDTH_FORM);
     $panel->appendChild($form);
 
     return id(new AphrontNullView())
       ->appendChild(
         array(
           $notice,
           $panel,
         ));
   }
 
   private function getMailTags() {
     return array(
       MetaMTANotificationType::TYPE_DIFFERENTIAL_CC =>
         "Send me email when a revision's CCs change.",
       MetaMTANotificationType::TYPE_DIFFERENTIAL_COMMITTED =>
         "Send me email when a revision is committed.",
       MetaMTANotificationType::TYPE_MANIPHEST_PROJECTS =>
         "Send me email when a task's associated projects change.",
       MetaMTANotificationType::TYPE_MANIPHEST_PRIORITY =>
         "Send me email when a task's priority changes.",
       MetaMTANotificationType::TYPE_MANIPHEST_CC =>
         "Send me email when a task's CCs change.",
     );
   }
 
   private function getManiphestMailTags() {
     return array_select_keys(
       $this->getMailTags(),
       array(
         MetaMTANotificationType::TYPE_MANIPHEST_PROJECTS,
         MetaMTANotificationType::TYPE_MANIPHEST_PRIORITY,
         MetaMTANotificationType::TYPE_MANIPHEST_CC,
       ));
   }
 
   private function getDifferentialMailTags() {
     return array_select_keys(
       $this->getMailTags(),
       array(
         MetaMTANotificationType::TYPE_DIFFERENTIAL_CC,
         MetaMTANotificationType::TYPE_DIFFERENTIAL_COMMITTED,
       ));
   }
 
   private function buildMailTagCheckboxes(
     array $tags,
     array $prefs) {
 
     $control = new AphrontFormCheckboxControl();
     foreach ($tags as $key => $label) {
       $control->addCheckbox(
         'mailtags['.$key.']',
         1,
         $label,
         idx($prefs, $key, 1));
     }
 
     return $control;
   }
 
 }
diff --git a/src/applications/people/controller/settings/panels/emailpref/__init__.php b/src/applications/people/controller/settings/panels/emailpref/__init__.php
index c6bf80fd0..21869c2bd 100644
--- a/src/applications/people/controller/settings/panels/emailpref/__init__.php
+++ b/src/applications/people/controller/settings/panels/emailpref/__init__.php
@@ -1,25 +1,26 @@
 <?php
 /**
  * This file is automatically generated. Lint this module to rebuild it.
  * @generated
  */
 
 
 
 phutil_require_module('phabricator', 'aphront/response/redirect');
 phutil_require_module('phabricator', 'applications/metamta/constants/notificationtype');
+phutil_require_module('phabricator', 'applications/metamta/storage/mail');
 phutil_require_module('phabricator', 'applications/people/controller/settings/panels/base');
 phutil_require_module('phabricator', 'applications/people/storage/preferences');
 phutil_require_module('phabricator', 'infrastructure/env');
 phutil_require_module('phabricator', 'view/form/base');
 phutil_require_module('phabricator', 'view/form/control/checkbox');
 phutil_require_module('phabricator', 'view/form/control/select');
 phutil_require_module('phabricator', 'view/form/control/submit');
 phutil_require_module('phabricator', 'view/form/error');
 phutil_require_module('phabricator', 'view/layout/panel');
 phutil_require_module('phabricator', 'view/null');
 
 phutil_require_module('phutil', 'utils');
 
 
 phutil_require_source('PhabricatorUserEmailPreferenceSettingsPanelController.php');
diff --git a/src/applications/people/storage/preferences/PhabricatorUserPreferences.php b/src/applications/people/storage/preferences/PhabricatorUserPreferences.php
index 0e8339b96..c1512a0a0 100644
--- a/src/applications/people/storage/preferences/PhabricatorUserPreferences.php
+++ b/src/applications/people/storage/preferences/PhabricatorUserPreferences.php
@@ -1,58 +1,59 @@
 <?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 PhabricatorUserPreferences extends PhabricatorUserDAO {
 
   const PREFERENCE_MONOSPACED      = 'monospaced';
   const PREFERENCE_EDITOR          = 'editor';
   const PREFERENCE_TITLES          = 'titles';
 
   const PREFERENCE_RE_PREFIX       = 're-prefix';
   const PREFERENCE_NO_SELF_MAIL    = 'self-mail';
   const PREFERENCE_MAILTAGS        = 'mailtags';
+  const PREFERENCE_VARY_SUBJECT    = 'vary-subject';
 
   const PREFERENCE_SEARCHBAR_JUMP  = 'searchbar-jump';
   const PREFERENCE_SEARCH_SHORTCUT = 'search-shortcut';
 
   protected $userPHID;
   protected $preferences = array();
 
   public function getConfiguration() {
     return array(
       self::CONFIG_SERIALIZATION => array(
         'preferences' => self::SERIALIZATION_JSON,
       ),
       self::CONFIG_TIMESTAMPS => false,
     ) + parent::getConfiguration();
   }
 
   public function getPreference($key, $default = null) {
     return idx($this->preferences, $key, $default);
   }
 
   public function setPreference($key, $value) {
     $this->preferences[$key] = $value;
     return $this;
   }
 
   public function unsetPreference($key) {
     unset($this->preferences[$key]);
     return $this;
   }
 
 }
diff --git a/src/applications/repository/worker/herald/PhabricatorRepositoryCommitHeraldWorker.php b/src/applications/repository/worker/herald/PhabricatorRepositoryCommitHeraldWorker.php
index ad35e89df..203dee9e3 100644
--- a/src/applications/repository/worker/herald/PhabricatorRepositoryCommitHeraldWorker.php
+++ b/src/applications/repository/worker/herald/PhabricatorRepositoryCommitHeraldWorker.php
@@ -1,273 +1,277 @@
 <?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;
 
-    $subject = "[Herald/Commit] {$commit_name} ({$who}) {$name}";
+    $prefix = PhabricatorEnv::getEnvConfig('metamta.diffusion.subject-prefix');
+
+    $subject = trim("{$prefix} {$commit_name}: {$name}");
+    $vary_subject = trim("{$prefix} [Commit] {$commit_name}: {$name}");
 
     $threading = PhabricatorAuditCommentEditor::getMailThreading(
       $commit->getPHID());
     list($thread_id, $thread_topic) = $threading;
 
     $template = new PhabricatorMetaMTAMail();
     $template->setRelatedPHID($commit->getPHID());
     $template->setSubject($subject);
+    $template->setVarySubject($subject);
     $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();
   }
 
 }