diff --git a/src/applications/maniphest/conduit/ConduitAPI_maniphest_Method.php b/src/applications/maniphest/conduit/ConduitAPI_maniphest_Method.php
index aa6a652bfc..c2074ac7e8 100644
--- a/src/applications/maniphest/conduit/ConduitAPI_maniphest_Method.php
+++ b/src/applications/maniphest/conduit/ConduitAPI_maniphest_Method.php
@@ -1,296 +1,300 @@
 <?php
 
 /**
  * @group conduit
  */
 abstract class ConduitAPI_maniphest_Method extends ConduitAPIMethod {
 
   public function getApplication() {
     return PhabricatorApplication::getByClass(
       'PhabricatorApplicationManiphest');
   }
 
   public function defineErrorTypes() {
     return array(
       'ERR-INVALID-PARAMETER' => 'Missing or malformed parameter.'
     );
   }
 
   protected function buildTaskInfoDictionary(ManiphestTask $task) {
     $results = $this->buildTaskInfoDictionaries(array($task));
     return idx($results, $task->getPHID());
   }
 
   protected function getTaskFields($is_new) {
     $fields = array();
 
     if (!$is_new) {
       $fields += array(
         'id'        => 'optional int',
         'phid'      => 'optional int',
       );
     }
 
     $fields += array(
       'title'         => $is_new ? 'required string' : 'optional string',
       'description'   => 'optional string',
       'ownerPHID'     => 'optional phid',
       'ccPHIDs'       => 'optional list<phid>',
       'priority'      => 'optional int',
       'projectPHIDs'  => 'optional list<phid>',
       'filePHIDs'     => 'optional list<phid>',
       'auxiliary'     => 'optional dict',
     );
 
     if (!$is_new) {
       $fields += array(
         'status'    => 'optional int',
         'comments'  => 'optional string',
       );
     }
 
     return $fields;
   }
 
   protected function applyRequest(
     ManiphestTask $task,
     ConduitAPIRequest $request,
     $is_new) {
 
     $changes = array();
 
     if ($is_new) {
       $task->setTitle((string)$request->getValue('title'));
       $task->setDescription((string)$request->getValue('description'));
       $changes[ManiphestTransactionType::TYPE_STATUS] =
         ManiphestTaskStatus::STATUS_OPEN;
     } else {
 
       $comments = $request->getValue('comments');
       if (!$is_new && $comments !== null) {
         $changes[PhabricatorTransactions::TYPE_COMMENT] = null;
       }
 
       $title = $request->getValue('title');
       if ($title !== null) {
         $changes[ManiphestTransactionType::TYPE_TITLE] = $title;
       }
 
       $desc = $request->getValue('description');
       if ($desc !== null) {
         $changes[ManiphestTransactionType::TYPE_DESCRIPTION] = $desc;
       }
 
       $status = $request->getValue('status');
       if ($status !== null) {
         $valid_statuses = ManiphestTaskStatus::getTaskStatusMap();
         if (!isset($valid_statuses[$status])) {
           throw id(new ConduitException('ERR-INVALID-PARAMETER'))
             ->setErrorDescription('Status set to invalid value.');
         }
         $changes[ManiphestTransactionType::TYPE_STATUS] = $status;
       }
     }
 
     $priority = $request->getValue('priority');
     if ($priority !== null) {
       $valid_priorities = ManiphestTaskPriority::getTaskPriorityMap();
       if (!isset($valid_priorities[$priority])) {
         throw id(new ConduitException('ERR-INVALID-PARAMETER'))
           ->setErrorDescription('Priority set to invalid value.');
       }
       $changes[ManiphestTransactionType::TYPE_PRIORITY] = $priority;
     }
 
     $owner_phid = $request->getValue('ownerPHID');
     if ($owner_phid !== null) {
       $this->validatePHIDList(array($owner_phid),
                               PhabricatorPeoplePHIDTypeUser::TYPECONST,
                               'ownerPHID');
       $changes[ManiphestTransactionType::TYPE_OWNER] = $owner_phid;
     }
 
     $ccs = $request->getValue('ccPHIDs');
     if ($ccs !== null) {
       $this->validatePHIDList($ccs,
                               PhabricatorPeoplePHIDTypeUser::TYPECONST,
                               'ccPHIDS');
       $changes[ManiphestTransactionType::TYPE_CCS] = $ccs;
     }
 
     $project_phids = $request->getValue('projectPHIDs');
     if ($project_phids !== null) {
       $this->validatePHIDList($project_phids,
                               PhabricatorProjectPHIDTypeProject::TYPECONST,
                               'projectPHIDS');
       $changes[ManiphestTransactionType::TYPE_PROJECTS] = $project_phids;
     }
 
     $file_phids = $request->getValue('filePHIDs');
     if ($file_phids !== null) {
       $this->validatePHIDList($file_phids,
                               PhabricatorFilePHIDTypeFile::TYPECONST,
                               'filePHIDS');
       $file_map = array_fill_keys($file_phids, true);
       $attached = $task->getAttached();
       $attached[PhabricatorFilePHIDTypeFile::TYPECONST] = $file_map;
 
       $changes[ManiphestTransactionType::TYPE_ATTACH] = $attached;
     }
 
     $template = new ManiphestTransactionPro();
 
     $transactions = array();
     foreach ($changes as $type => $value) {
       $transaction = clone $template;
       $transaction->setTransactionType($type);
       if ($type == PhabricatorTransactions::TYPE_COMMENT) {
         $transaction->attachComment(
           id(new ManiphestTransactionComment())
             ->setContent($comments));
       } else {
         $transaction->setNewValue($value);
       }
 
       $transactions[] = $transaction;
     }
 
     $field_list = PhabricatorCustomField::getObjectFields(
       $task,
       PhabricatorCustomField::ROLE_EDIT);
     $field_list->readFieldsFromStorage($task);
 
     $auxiliary = $request->getValue('auxiliary');
     if ($auxiliary) {
       foreach ($field_list->getFields() as $key => $field) {
         if (!array_key_exists($key, $auxiliary)) {
           continue;
         }
         $transaction = clone $template;
         $transaction->setTransactionType(
           PhabricatorTransactions::TYPE_CUSTOMFIELD);
         $transaction->setMetadataValue('customfield:key', $key);
         $transaction->setOldValue(
           $field->getOldValueForApplicationTransactions());
         $transaction->setNewValue($auxiliary[$key]);
         $transactions[] = $transaction;
       }
     }
 
     if (!$transactions) {
       return;
     }
 
     $event = new PhabricatorEvent(
       PhabricatorEventType::TYPE_MANIPHEST_WILLEDITTASK,
       array(
         'task'          => $task,
         'new'           => $is_new,
         'transactions'  => $transactions,
       ));
     $event->setUser($request->getUser());
     $event->setConduitRequest($request);
     PhutilEventEngine::dispatchEvent($event);
 
     $task = $event->getValue('task');
     $transactions = $event->getValue('transactions');
 
     $content_source = PhabricatorContentSource::newForSource(
       PhabricatorContentSource::SOURCE_CONDUIT,
       array());
 
     $editor = id(new ManiphestTransactionEditorPro())
       ->setActor($request->getUser())
       ->setContentSource($content_source)
       ->setContinueOnNoEffect(true);
 
+    if (!$is_new) {
+      $editor->setContinueOnMissingFields(true);
+    }
+
     $editor->applyTransactions($task, $transactions);
 
     $event = new PhabricatorEvent(
       PhabricatorEventType::TYPE_MANIPHEST_DIDEDITTASK,
       array(
         'task'          => $task,
         'new'           => $is_new,
         'transactions'  => $transactions,
       ));
     $event->setUser($request->getUser());
     $event->setConduitRequest($request);
     PhutilEventEngine::dispatchEvent($event);
 
   }
 
   protected function buildTaskInfoDictionaries(array $tasks) {
     assert_instances_of($tasks, 'ManiphestTask');
     if (!$tasks) {
       return array();
     }
 
     $task_phids = mpull($tasks, 'getPHID');
 
     $all_deps = id(new PhabricatorEdgeQuery())
       ->withSourcePHIDs($task_phids)
       ->withEdgeTypes(array(PhabricatorEdgeConfig::TYPE_TASK_DEPENDS_ON_TASK));
     $all_deps->execute();
 
     $result = array();
     foreach ($tasks as $task) {
       // TODO: Batch this get as CustomField gets cleaned up.
       $field_list = PhabricatorCustomField::getObjectFields(
         $task,
         PhabricatorCustomField::ROLE_EDIT);
       $field_list->readFieldsFromStorage($task);
 
       $auxiliary = mpull(
         $field_list->getFields(),
         'getValueForStorage',
         'getFieldKey');
 
       $task_deps = $all_deps->getDestinationPHIDs(
         array($task->getPHID()),
         array(PhabricatorEdgeConfig::TYPE_TASK_DEPENDS_ON_TASK));
 
       $result[$task->getPHID()] = array(
         'id'           => $task->getID(),
         'phid'         => $task->getPHID(),
         'authorPHID'   => $task->getAuthorPHID(),
         'ownerPHID'    => $task->getOwnerPHID(),
         'ccPHIDs'      => $task->getCCPHIDs(),
         'status'       => $task->getStatus(),
         'priority'     => ManiphestTaskPriority::getTaskPriorityName(
           $task->getPriority()),
         'title'        => $task->getTitle(),
         'description'  => $task->getDescription(),
         'projectPHIDs' => $task->getProjectPHIDs(),
         'uri'          => PhabricatorEnv::getProductionURI('/T'.$task->getID()),
         'auxiliary'    => $auxiliary,
 
         'objectName'   => 'T'.$task->getID(),
         'dateCreated'  => $task->getDateCreated(),
         'dateModified' => $task->getDateModified(),
         'dependsOnTaskPHIDs' => $task_deps,
       );
     }
 
     return $result;
   }
 
   /**
    * Note this is a temporary stop gap since its easy to make malformed Tasks.
    * Long-term, the values set in @{method:defineParamTypes} will be used to
    * validate data implicitly within the larger Conduit application.
    *
    * TODO -- remove this in favor of generalized Conduit hotness
    */
   private function validatePHIDList(array $phid_list, $phid_type, $field) {
     $phid_groups = phid_group_by_type($phid_list);
     unset($phid_groups[$phid_type]);
     if (!empty($phid_groups)) {
       throw id(new ConduitException('ERR-INVALID-PARAMETER'))
         ->setErrorDescription(
           'One or more PHIDs were invalid for '.$field.'.');
     }
 
     return true;
   }
 
 }
diff --git a/src/applications/maniphest/controller/ManiphestBatchEditController.php b/src/applications/maniphest/controller/ManiphestBatchEditController.php
index 5b1c71ad9c..ffc917989d 100644
--- a/src/applications/maniphest/controller/ManiphestBatchEditController.php
+++ b/src/applications/maniphest/controller/ManiphestBatchEditController.php
@@ -1,331 +1,332 @@
 <?php
 
 /**
  * @group maniphest
  */
 final class ManiphestBatchEditController extends ManiphestController {
 
   public function processRequest() {
 
     $request = $this->getRequest();
     $user = $request->getUser();
 
     $task_ids = $request->getArr('batch');
     $tasks = id(new ManiphestTask())->loadAllWhere(
       'id IN (%Ld)',
       $task_ids);
 
     $actions = $request->getStr('actions');
     if ($actions) {
       $actions = json_decode($actions, true);
     }
 
     if ($request->isFormPost() && is_array($actions)) {
       foreach ($tasks as $task) {
         $field_list = PhabricatorCustomField::getObjectFields(
           $task,
           PhabricatorCustomField::ROLE_EDIT);
         $field_list->readFieldsFromStorage($task);
 
         $xactions = $this->buildTransactions($actions, $task);
         if ($xactions) {
           // TODO: Set content source to "batch edit".
 
           $editor = id(new ManiphestTransactionEditorPro())
             ->setActor($user)
             ->setContentSourceFromRequest($request)
             ->setContinueOnNoEffect(true)
+            ->setContinueOnMissingFields(true)
             ->applyTransactions($task, $xactions);
         }
       }
 
       $task_ids = implode(',', mpull($tasks, 'getID'));
 
       return id(new AphrontRedirectResponse())
         ->setURI('/maniphest/?ids='.$task_ids);
     }
 
     $handle_phids = mpull($tasks, 'getOwnerPHID');
     $handles = $this->loadViewerHandles($handle_phids);
 
     $list = new ManiphestTaskListView();
     $list->setTasks($tasks);
     $list->setUser($user);
     $list->setHandles($handles);
 
     $template = new AphrontTokenizerTemplateView();
     $template = $template->render();
 
     require_celerity_resource('maniphest-batch-editor');
     Javelin::initBehavior(
       'maniphest-batch-editor',
       array(
         'root' => 'maniphest-batch-edit-form',
         'tokenizerTemplate' => $template,
         'sources' => array(
           'project' => array(
             'src'           => '/typeahead/common/projects/',
             'placeholder'   => pht('Type a project name...'),
           ),
           'owner' => array(
             'src'           => '/typeahead/common/searchowner/',
             'placeholder'   => pht('Type a user name...'),
             'limit'         => 1,
           ),
           'cc'    => array(
             'src'           => '/typeahead/common/mailable/',
             'placeholder'   => pht('Type a user name...'),
           )
         ),
         'input' => 'batch-form-actions',
         'priorityMap' => ManiphestTaskPriority::getTaskPriorityMap(),
         'statusMap'   => ManiphestTaskStatus::getTaskStatusMap(),
       ));
 
     $form = new AphrontFormView();
     $form->setUser($user);
     $form->setID('maniphest-batch-edit-form');
 
     foreach ($tasks as $task) {
       $form->appendChild(
         phutil_tag(
           'input',
           array(
             'type' => 'hidden',
             'name' => 'batch[]',
             'value' => $task->getID(),
           )));
     }
 
     $form->appendChild(
       phutil_tag(
         'input',
         array(
           'type' => 'hidden',
           'name' => 'actions',
           'id'   => 'batch-form-actions',
         )));
     $form->appendChild(
       phutil_tag('p', array(), pht('These tasks will be edited:')));
     $form->appendChild($list);
     $form->appendChild(
       id(new AphrontFormInsetView())
         ->setTitle('Actions')
         ->setRightButton(javelin_tag(
             'a',
             array(
               'href' => '#',
               'class' => 'button green',
               'sigil' => 'add-action',
               'mustcapture' => true,
             ),
             pht('Add Another Action')))
         ->setContent(javelin_tag(
           'table',
           array(
             'sigil' => 'maniphest-batch-actions',
             'class' => 'maniphest-batch-actions-table',
           ),
           '')))
       ->appendChild(
         id(new AphrontFormSubmitControl())
           ->setValue(pht('Update Tasks'))
           ->addCancelButton('/maniphest/'));
 
     $title = pht('Batch Editor');
 
     $crumbs = $this->buildApplicationCrumbs();
     $crumbs->addCrumb(
       id(new PhabricatorCrumbView())
         ->setName($title));
 
     $form_box = id(new PHUIFormBoxView())
       ->setHeaderText(pht('Batch Edit Tasks'))
       ->setForm($form);
 
     return $this->buildApplicationPage(
       array(
         $crumbs,
         $form_box,
       ),
       array(
         'title' => $title,
       ));
   }
 
   private function buildTransactions($actions, ManiphestTask $task) {
     $value_map = array();
     $type_map = array(
       'add_comment'     => PhabricatorTransactions::TYPE_COMMENT,
       'assign'          => ManiphestTransactionType::TYPE_OWNER,
       'status'          => ManiphestTransactionType::TYPE_STATUS,
       'priority'        => ManiphestTransactionType::TYPE_PRIORITY,
       'add_project'     => ManiphestTransactionType::TYPE_PROJECTS,
       'remove_project'  => ManiphestTransactionType::TYPE_PROJECTS,
       'add_ccs'         => ManiphestTransactionType::TYPE_CCS,
       'remove_ccs'      => ManiphestTransactionType::TYPE_CCS,
     );
 
     $edge_edit_types = array(
       'add_project'    => true,
       'remove_project' => true,
       'add_ccs'        => true,
       'remove_ccs'     => true,
     );
 
     $xactions = array();
     foreach ($actions as $action) {
       if (empty($type_map[$action['action']])) {
         throw new Exception("Unknown batch edit action '{$action}'!");
       }
 
       $type = $type_map[$action['action']];
 
       // Figure out the current value, possibly after modifications by other
       // batch actions of the same type. For example, if the user chooses to
       // "Add Comment" twice, we should add both comments. More notably, if the
       // user chooses "Remove Project..." and also "Add Project...", we should
       // avoid restoring the removed project in the second transaction.
 
       if (array_key_exists($type, $value_map)) {
         $current = $value_map[$type];
       } else {
         switch ($type) {
           case PhabricatorTransactions::TYPE_COMMENT:
             $current = null;
             break;
           case ManiphestTransactionType::TYPE_OWNER:
             $current = $task->getOwnerPHID();
             break;
           case ManiphestTransactionType::TYPE_STATUS:
             $current = $task->getStatus();
             break;
           case ManiphestTransactionType::TYPE_PRIORITY:
             $current = $task->getPriority();
             break;
           case ManiphestTransactionType::TYPE_PROJECTS:
             $current = $task->getProjectPHIDs();
             break;
           case ManiphestTransactionType::TYPE_CCS:
             $current = $task->getCCPHIDs();
             break;
         }
       }
 
       // Check if the value is meaningful / provided, and normalize it if
       // necessary. This discards, e.g., empty comments and empty owner
       // changes.
 
       $value = $action['value'];
       switch ($type) {
         case PhabricatorTransactions::TYPE_COMMENT:
           if (!strlen($value)) {
             continue 2;
           }
           break;
         case ManiphestTransactionType::TYPE_OWNER:
           if (empty($value)) {
             continue 2;
           }
           $value = head($value);
           if ($value === ManiphestTaskOwner::OWNER_UP_FOR_GRABS) {
             $value = null;
           }
           break;
         case ManiphestTransactionType::TYPE_PROJECTS:
           if (empty($value)) {
             continue 2;
           }
           break;
         case ManiphestTransactionType::TYPE_CCS:
           if (empty($value)) {
             continue 2;
           }
           break;
       }
 
       // If the edit doesn't change anything, go to the next action. This
       // check is only valid for changes like "owner", "status", etc, not
       // for edge edits, because we should still apply an edit like
       // "Remove Projects: A, B" to a task with projects "A, B".
 
       if (empty($edge_edit_types[$action['action']])) {
         if ($value == $current) {
           continue;
         }
       }
 
       // Apply the value change; for most edits this is just replacement, but
       // some need to merge the current and edited values (add/remove project).
 
       switch ($type) {
         case PhabricatorTransactions::TYPE_COMMENT:
           if (strlen($current)) {
             $value = $current."\n\n".$value;
           }
           break;
         case ManiphestTransactionType::TYPE_PROJECTS:
         case ManiphestTransactionType::TYPE_CCS:
           $remove_actions = array(
             'remove_project' => true,
             'remove_ccs'    => true,
           );
           $is_remove = isset($remove_actions[$action['action']]);
 
           $current = array_fill_keys($current, true);
           $value   = array_fill_keys($value, true);
 
           $new = $current;
           $did_something = false;
 
           if ($is_remove) {
             foreach ($value as $phid => $ignored) {
               if (isset($new[$phid])) {
                 unset($new[$phid]);
                 $did_something = true;
               }
             }
           } else {
             foreach ($value as $phid => $ignored) {
               if (empty($new[$phid])) {
                 $new[$phid] = true;
                 $did_something = true;
               }
             }
           }
 
           if (!$did_something) {
             continue 2;
           }
 
           $value = array_keys($new);
           break;
       }
 
       $value_map[$type] = $value;
     }
 
     $template = new ManiphestTransactionPro();
 
     foreach ($value_map as $type => $value) {
       $xaction = clone $template;
       $xaction->setTransactionType($type);
 
       switch ($type) {
         case PhabricatorTransactions::TYPE_COMMENT:
           $xaction->attachComment(
             id(new ManiphestTransactionComment())
               ->setContent($value));
           break;
         default:
           $xaction->setNewValue($value);
           break;
       }
 
       $xactions[] = $xaction;
     }
 
     return $xactions;
   }
 
 }
diff --git a/src/applications/maniphest/controller/ManiphestSubpriorityController.php b/src/applications/maniphest/controller/ManiphestSubpriorityController.php
index d1e707924f..199e98433b 100644
--- a/src/applications/maniphest/controller/ManiphestSubpriorityController.php
+++ b/src/applications/maniphest/controller/ManiphestSubpriorityController.php
@@ -1,61 +1,62 @@
 <?php
 
 /**
  * @group maniphest
  */
 final class ManiphestSubpriorityController extends ManiphestController {
 
   public function processRequest() {
     $request = $this->getRequest();
     $user = $request->getUser();
 
     if (!$request->validateCSRF()) {
       return new Aphront403Response();
     }
 
     $task = id(new ManiphestTask())->load($request->getInt('task'));
     if (!$task) {
       return new Aphront404Response();
     }
 
     if ($request->getInt('after')) {
       $after_task = id(new ManiphestTask())->load($request->getInt('after'));
       if (!$after_task) {
         return new Aphront404Response();
       }
       $after_pri = $after_task->getPriority();
       $after_sub = $after_task->getSubpriority();
     } else {
       $after_pri = $request->getInt('priority');
       $after_sub = null;
     }
 
     $new_sub = ManiphestTransactionEditor::getNextSubpriority(
       $after_pri,
       $after_sub);
 
     $task->setSubpriority($new_sub);
 
     if ($after_pri != $task->getPriority()) {
       $xactions = array();
       $xactions[] = id(new ManiphestTransactionPro())
         ->setTransactionType(ManiphestTransactionPro::TYPE_PRIORITY)
         ->setNewValue($after_pri);
 
       $editor = id(new ManiphestTransactionEditorPro())
         ->setActor($user)
-        ->setContinueOnNoEffect($request->isContinueRequest())
+        ->setContinueOnMissingFields(true)
+        ->setContinueOnNoEffect(true)
         ->setContentSourceFromRequest($request);
 
       $editor->applyTransactions($task, $xactions);
     } else {
       $task->save();
     }
 
     return id(new AphrontAjaxResponse())->setContent(
       array(
         'tasks' => $this->renderSingleTask($task),
       ));
   }
 
 }
diff --git a/src/applications/search/controller/PhabricatorSearchAttachController.php b/src/applications/search/controller/PhabricatorSearchAttachController.php
index 5c9483dad8..769ad90045 100644
--- a/src/applications/search/controller/PhabricatorSearchAttachController.php
+++ b/src/applications/search/controller/PhabricatorSearchAttachController.php
@@ -1,319 +1,336 @@
 <?php
 
 /**
  * @group search
  */
 final class PhabricatorSearchAttachController
   extends PhabricatorSearchBaseController {
 
   private $phid;
   private $type;
   private $action;
 
   const ACTION_ATTACH       = 'attach';
   const ACTION_MERGE        = 'merge';
   const ACTION_DEPENDENCIES = 'dependencies';
   const ACTION_EDGE         = 'edge';
 
   public function willProcessRequest(array $data) {
     $this->phid = $data['phid'];
     $this->type = $data['type'];
     $this->action = idx($data, 'action', self::ACTION_ATTACH);
   }
 
   public function processRequest() {
 
     $request = $this->getRequest();
     $user = $request->getUser();
 
     $handle = id(New PhabricatorHandleQuery())
       ->setViewer($user)
       ->withPHIDs(array($this->phid))
       ->executeOne();
 
     $object_type = $handle->getType();
     $attach_type = $this->type;
 
     $object = id(new PhabricatorObjectQuery())
       ->setViewer($user)
       ->withPHIDs(array($this->phid))
       ->executeOne();
 
     if (!$object) {
       return new Aphront404Response();
     }
 
     $edge_type = null;
     switch ($this->action) {
       case self::ACTION_EDGE:
       case self::ACTION_DEPENDENCIES:
       case self::ACTION_ATTACH:
         $edge_type = $this->getEdgeType($object_type, $attach_type);
         break;
     }
 
     if ($request->isFormPost()) {
       $phids = explode(';', $request->getStr('phids'));
       $phids = array_filter($phids);
       $phids = array_values($phids);
 
       if ($edge_type) {
         $do_txn = $object instanceof PhabricatorApplicationTransactionInterface;
         $old_phids = PhabricatorEdgeQuery::loadDestinationPHIDs(
           $this->phid,
           $edge_type);
         $add_phids = $phids;
         $rem_phids = array_diff($old_phids, $add_phids);
 
         if ($do_txn) {
 
           $txn_editor = $object->getApplicationTransactionEditor()
             ->setActor($user)
             ->setContentSourceFromRequest($request);
           $txn_template = $object->getApplicationTransactionObject()
             ->setTransactionType(PhabricatorTransactions::TYPE_EDGE)
             ->setMetadataValue('edge:type', $edge_type)
             ->setNewValue(array(
               '+' => array_fuse($add_phids),
               '-' => array_fuse($rem_phids)));
           $txn_editor->applyTransactions($object, array($txn_template));
 
         } else {
 
           $editor = id(new PhabricatorEdgeEditor());
           $editor->setActor($user);
           foreach ($add_phids as $phid) {
             $editor->addEdge($this->phid, $edge_type, $phid);
           }
           foreach ($rem_phids as $phid) {
             $editor->removeEdge($this->phid, $edge_type, $phid);
           }
 
           try {
             $editor->save();
           } catch (PhabricatorEdgeCycleException $ex) {
             $this->raiseGraphCycleException($ex);
           }
         }
 
         return id(new AphrontReloadResponse())->setURI($handle->getURI());
       } else {
         return $this->performMerge($object, $handle, $phids);
       }
     } else {
       if ($edge_type) {
         $phids = PhabricatorEdgeQuery::loadDestinationPHIDs(
           $this->phid,
           $edge_type);
       } else {
         // This is a merge.
         $phids = array();
       }
     }
 
     $strings = $this->getStrings();
 
     $handles = $this->loadViewerHandles($phids);
 
     $obj_dialog = new PhabricatorObjectSelectorDialog();
     $obj_dialog
       ->setUser($user)
       ->setHandles($handles)
       ->setFilters($this->getFilters($strings))
       ->setSelectedFilter($strings['selected'])
       ->setExcluded($this->phid)
       ->setCancelURI($handle->getURI())
       ->setSearchURI('/search/select/'.$attach_type.'/')
       ->setTitle($strings['title'])
       ->setHeader($strings['header'])
       ->setButtonText($strings['button'])
       ->setInstructions($strings['instructions']);
 
     $dialog = $obj_dialog->buildDialog();
 
     return id(new AphrontDialogResponse())->setDialog($dialog);
   }
 
   private function performMerge(
     ManiphestTask $task,
     PhabricatorObjectHandle $handle,
     array $phids) {
 
     $user = $this->getRequest()->getUser();
     $response = id(new AphrontReloadResponse())->setURI($handle->getURI());
 
     $phids = array_fill_keys($phids, true);
     unset($phids[$task->getPHID()]); // Prevent merging a task into itself.
 
     if (!$phids) {
       return $response;
     }
 
     $targets = id(new ManiphestTask())->loadAllWhere(
       'phid in (%Ls) ORDER BY id ASC',
       array_keys($phids));
 
     if (empty($targets)) {
       return $response;
     }
 
-    $editor = new ManiphestTransactionEditor();
-    $editor->setActor($user);
+    $editor = id(new ManiphestTransactionEditorPro())
+      ->setActor($user)
+      ->setContentSourceFromRequest($this->getRequest())
+      ->setContinueOnNoEffect(true)
+      ->setContinueOnMissingFields(true);
 
     $task_names = array();
 
     $merge_into_name = 'T'.$task->getID();
 
     $cc_vector = array();
     $cc_vector[] = $task->getCCPHIDs();
     foreach ($targets as $target) {
       $cc_vector[] = $target->getCCPHIDs();
       $cc_vector[] = array(
         $target->getAuthorPHID(),
         $target->getOwnerPHID());
 
-      $close_task = id(new ManiphestTransaction())
-        ->setAuthorPHID($user->getPHID())
+      $close_task = id(new ManiphestTransactionPro())
         ->setTransactionType(ManiphestTransactionType::TYPE_STATUS)
-        ->setNewValue(ManiphestTaskStatus::STATUS_CLOSED_DUPLICATE)
-        ->setComments("\xE2\x9C\x98 Merged into {$merge_into_name}.");
+        ->setNewValue(ManiphestTaskStatus::STATUS_CLOSED_DUPLICATE);
 
-      $editor->applyTransactions($target, array($close_task));
+      $merge_comment = id(new ManiphestTransactionPro())
+        ->setTransactionType(PhabricatorTransactions::TYPE_COMMENT)
+        ->attachComment(
+          id(new ManiphestTransactionComment())
+            ->setContent("\xE2\x9C\x98 Merged into {$merge_into_name}."));
+
+      $editor->applyTransactions(
+        $target,
+        array(
+          $close_task,
+          $merge_comment,
+        ));
 
       $task_names[] = 'T'.$target->getID();
     }
     $all_ccs = array_mergev($cc_vector);
     $all_ccs = array_filter($all_ccs);
     $all_ccs = array_unique($all_ccs);
 
     $task_names = implode(', ', $task_names);
 
-    $add_ccs = id(new ManiphestTransaction())
-      ->setAuthorPHID($user->getPHID())
+    $add_ccs = id(new ManiphestTransactionPro())
       ->setTransactionType(ManiphestTransactionType::TYPE_CCS)
-      ->setNewValue($all_ccs)
-      ->setComments("\xE2\x97\x80 Merged tasks: {$task_names}.");
-    $editor->applyTransactions($task, array($add_ccs));
+      ->setNewValue($all_ccs);
+
+    $merged_comment = id(new ManiphestTransactionPro())
+      ->setTransactionType(PhabricatorTransactions::TYPE_COMMENT)
+      ->attachComment(
+        id(new ManiphestTransactionComment())
+          ->setContent("\xE2\x97\x80 Merged tasks: {$task_names}."));
+
+    $editor->applyTransactions($task, array($add_ccs, $merged_comment));
 
     return $response;
   }
 
   private function getStrings() {
     switch ($this->type) {
       case DifferentialPHIDTypeRevision::TYPECONST:
         $noun = 'Revisions';
         $selected = 'created';
         break;
       case ManiphestPHIDTypeTask::TYPECONST:
         $noun = 'Tasks';
         $selected = 'assigned';
         break;
       case PhabricatorRepositoryPHIDTypeCommit::TYPECONST:
         $noun = 'Commits';
         $selected = 'created';
         break;
       case PholioPHIDTypeMock::TYPECONST:
         $noun = 'Mocks';
         $selected = 'created';
         break;
     }
 
     switch ($this->action) {
       case self::ACTION_EDGE:
       case self::ACTION_ATTACH:
         $dialog_title = "Manage Attached {$noun}";
         $header_text = "Currently Attached {$noun}";
         $button_text = "Save {$noun}";
         $instructions = null;
         break;
       case self::ACTION_MERGE:
         $dialog_title = "Merge Duplicate Tasks";
         $header_text = "Tasks To Merge";
         $button_text = "Merge {$noun}";
         $instructions =
           "These tasks will be merged into the current task and then closed. ".
           "The current task will grow stronger.";
         break;
       case self::ACTION_DEPENDENCIES:
         $dialog_title = "Edit Dependencies";
         $header_text = "Current Dependencies";
         $button_text = "Save Dependencies";
         $instructions = null;
         break;
     }
 
     return array(
       'target_plural_noun'    => $noun,
       'selected'              => $selected,
       'title'                 => $dialog_title,
       'header'                => $header_text,
       'button'                => $button_text,
       'instructions'          => $instructions,
     );
   }
 
   private function getFilters(array $strings) {
     if ($this->type == PholioPHIDTypeMock::TYPECONST) {
       $filters = array(
         'created' => 'Created By Me',
         'all' => 'All '.$strings['target_plural_noun'],
       );
     } else {
       $filters = array(
         'assigned' => 'Assigned to Me',
         'created' => 'Created By Me',
         'open' => 'All Open '.$strings['target_plural_noun'],
         'all' => 'All '.$strings['target_plural_noun'],
       );
     }
 
     return $filters;
   }
 
   private function getEdgeType($src_type, $dst_type) {
     $t_cmit = PhabricatorRepositoryPHIDTypeCommit::TYPECONST;
     $t_task = ManiphestPHIDTypeTask::TYPECONST;
     $t_drev = DifferentialPHIDTypeRevision::TYPECONST;
     $t_mock = PholioPHIDTypeMock::TYPECONST;
 
     $map = array(
       $t_cmit => array(
         $t_task => PhabricatorEdgeConfig::TYPE_COMMIT_HAS_TASK,
       ),
       $t_task => array(
         $t_cmit => PhabricatorEdgeConfig::TYPE_TASK_HAS_COMMIT,
         $t_task => PhabricatorEdgeConfig::TYPE_TASK_DEPENDS_ON_TASK,
         $t_drev => PhabricatorEdgeConfig::TYPE_TASK_HAS_RELATED_DREV,
         $t_mock => PhabricatorEdgeConfig::TYPE_TASK_HAS_MOCK,
       ),
       $t_drev => array(
         $t_drev => PhabricatorEdgeConfig::TYPE_DREV_DEPENDS_ON_DREV,
         $t_task => PhabricatorEdgeConfig::TYPE_DREV_HAS_RELATED_TASK,
       ),
       $t_mock => array(
         $t_task => PhabricatorEdgeConfig::TYPE_MOCK_HAS_TASK,
       ),
     );
 
     if (empty($map[$src_type][$dst_type])) {
       return null;
     }
 
     return $map[$src_type][$dst_type];
   }
 
   private function raiseGraphCycleException(PhabricatorEdgeCycleException $ex) {
     $cycle = $ex->getCycle();
 
     $handles = $this->loadViewerHandles($cycle);
     $names = array();
     foreach ($cycle as $cycle_phid) {
       $names[] = $handles[$cycle_phid]->getFullName();
     }
     $names = implode(" \xE2\x86\x92 ", $names);
     throw new Exception(
       "You can not create that dependency, because it would create a ".
       "circular dependency: {$names}.");
   }
 
 }
diff --git a/src/applications/transactions/editor/PhabricatorApplicationTransactionEditor.php b/src/applications/transactions/editor/PhabricatorApplicationTransactionEditor.php
index 38fb82a17a..254969cb2b 100644
--- a/src/applications/transactions/editor/PhabricatorApplicationTransactionEditor.php
+++ b/src/applications/transactions/editor/PhabricatorApplicationTransactionEditor.php
@@ -1,1502 +1,1541 @@
 <?php
 
 /**
  * @task mail   Sending Mail
  * @task feed   Publishing Feed Stories
  * @task search Search Index
  */
 abstract class PhabricatorApplicationTransactionEditor
   extends PhabricatorEditor {
 
   private $contentSource;
   private $object;
   private $xactions;
 
   private $isNewObject;
   private $mentionedPHIDs;
   private $continueOnNoEffect;
+  private $continueOnMissingFields;
   private $parentMessageID;
   private $heraldAdapter;
   private $heraldTranscript;
   private $subscribers;
 
   private $isPreview;
 
   /**
    * When the editor tries to apply transactions that have no effect, should
    * it raise an exception (default) or drop them and continue?
    *
    * Generally, you will set this flag for edits coming from "Edit" interfaces,
    * and leave it cleared for edits coming from "Comment" interfaces, so the
    * user will get a useful error if they try to submit a comment that does
    * nothing (e.g., empty comment with a status change that has already been
    * performed by another user).
    *
    * @param bool  True to drop transactions without effect and continue.
    * @return this
    */
   public function setContinueOnNoEffect($continue) {
     $this->continueOnNoEffect = $continue;
     return $this;
   }
 
   public function getContinueOnNoEffect() {
     return $this->continueOnNoEffect;
   }
 
+
+  /**
+   * When the editor tries to apply transactions which don't populate all of
+   * an object's required fields, should it raise an exception (default) or
+   * drop them and continue?
+   *
+   * For example, if a user adds a new required custom field (like "Severity")
+   * to a task, all existing tasks won't have it populated. When users
+   * manually edit existing tasks, it's usually desirable to have them provide
+   * a severity. However, other operations (like batch editing just the
+   * owner of a task) will fail by default.
+   *
+   * By setting this flag for edit operations which apply to specific fields
+   * (like the priority, batch, and merge editors in Maniphest), these
+   * operations can continue to function even if an object is outdated.
+   *
+   * @param bool  True to continue when transactions don't completely satisfy
+   *              all required fields.
+   * @return this
+   */
+  public function setContinueOnMissingFields($continue_on_missing_fields) {
+    $this->continueOnMissingFields = $continue_on_missing_fields;
+    return $this;
+  }
+
+  public function getContinueOnMissingFields() {
+    return $this->continueOnMissingFields;
+  }
+
+
   /**
    * Not strictly necessary, but reply handlers ideally set this value to
    * make email threading work better.
    */
   public function setParentMessageID($parent_message_id) {
     $this->parentMessageID = $parent_message_id;
     return $this;
   }
   public function getParentMessageID() {
     return $this->parentMessageID;
   }
 
   protected function getIsNewObject() {
     return $this->isNewObject;
   }
 
   protected function getMentionedPHIDs() {
     return $this->mentionedPHIDs;
   }
 
   public function setIsPreview($is_preview) {
     $this->isPreview = $is_preview;
     return $this;
   }
 
   public function getIsPreview() {
     return $this->isPreview;
   }
 
   public function getTransactionTypes() {
     $types = array();
 
     if ($this->object instanceof PhabricatorSubscribableInterface) {
       $types[] = PhabricatorTransactions::TYPE_SUBSCRIBERS;
     }
 
     if ($this->object instanceof PhabricatorCustomFieldInterface) {
       $types[] = PhabricatorTransactions::TYPE_CUSTOMFIELD;
     }
 
     return $types;
   }
 
   private function adjustTransactionValues(
     PhabricatorLiskDAO $object,
     PhabricatorApplicationTransaction $xaction) {
     $old = $this->getTransactionOldValue($object, $xaction);
     $xaction->setOldValue($old);
 
     $new = $this->getTransactionNewValue($object, $xaction);
     $xaction->setNewValue($new);
   }
 
   private function getTransactionOldValue(
     PhabricatorLiskDAO $object,
     PhabricatorApplicationTransaction $xaction) {
     switch ($xaction->getTransactionType()) {
       case PhabricatorTransactions::TYPE_SUBSCRIBERS:
         return array_values($this->subscribers);
       case PhabricatorTransactions::TYPE_VIEW_POLICY:
         return $object->getViewPolicy();
       case PhabricatorTransactions::TYPE_EDIT_POLICY:
         return $object->getEditPolicy();
       case PhabricatorTransactions::TYPE_EDGE:
         $edge_type = $xaction->getMetadataValue('edge:type');
         if (!$edge_type) {
           throw new Exception("Edge transaction has no 'edge:type'!");
         }
 
         $old_edges = array();
         if ($object->getPHID()) {
           $edge_src = $object->getPHID();
 
           $old_edges = id(new PhabricatorEdgeQuery())
             ->withSourcePHIDs(array($edge_src))
             ->withEdgeTypes(array($edge_type))
             ->needEdgeData(true)
             ->execute();
 
           $old_edges = $old_edges[$edge_src][$edge_type];
         }
         return $old_edges;
       case PhabricatorTransactions::TYPE_CUSTOMFIELD:
         // NOTE: Custom fields have their old value pre-populated when they are
         // built by PhabricatorCustomFieldList.
         return $xaction->getOldValue();
       default:
         return $this->getCustomTransactionOldValue($object, $xaction);
     }
   }
 
   private function getTransactionNewValue(
     PhabricatorLiskDAO $object,
     PhabricatorApplicationTransaction $xaction) {
     switch ($xaction->getTransactionType()) {
       case PhabricatorTransactions::TYPE_SUBSCRIBERS:
         return $this->getPHIDTransactionNewValue($xaction);
       case PhabricatorTransactions::TYPE_VIEW_POLICY:
       case PhabricatorTransactions::TYPE_EDIT_POLICY:
         return $xaction->getNewValue();
       case PhabricatorTransactions::TYPE_EDGE:
         return $this->getEdgeTransactionNewValue($xaction);
       case PhabricatorTransactions::TYPE_CUSTOMFIELD:
         $field = $this->getCustomFieldForTransaction($object, $xaction);
         return $field->getNewValueFromApplicationTransactions($xaction);
       default:
         return $this->getCustomTransactionNewValue($object, $xaction);
     }
   }
 
   protected function getCustomTransactionOldValue(
     PhabricatorLiskDAO $object,
     PhabricatorApplicationTransaction $xaction) {
     throw new Exception("Capability not supported!");
   }
 
   protected function getCustomTransactionNewValue(
     PhabricatorLiskDAO $object,
     PhabricatorApplicationTransaction $xaction) {
     throw new Exception("Capability not supported!");
   }
 
   protected function transactionHasEffect(
     PhabricatorLiskDAO $object,
     PhabricatorApplicationTransaction $xaction) {
 
     switch ($xaction->getTransactionType()) {
       case PhabricatorTransactions::TYPE_COMMENT:
         return $xaction->hasComment();
       case PhabricatorTransactions::TYPE_CUSTOMFIELD:
         $field = $this->getCustomFieldForTransaction($object, $xaction);
         return $field->getApplicationTransactionHasEffect($xaction);
     }
 
     return ($xaction->getOldValue() !== $xaction->getNewValue());
   }
 
   protected function shouldApplyInitialEffects(
     PhabricatorLiskDAO $object,
     array $xactions) {
     return false;
   }
 
   protected function applyInitialEffects(
     PhabricatorLiskDAO $object,
     array $xactions) {
     throw new Exception('Not implemented.');
   }
 
   private function applyInternalEffects(
     PhabricatorLiskDAO $object,
     PhabricatorApplicationTransaction $xaction) {
     switch ($xaction->getTransactionType()) {
       case PhabricatorTransactions::TYPE_VIEW_POLICY:
         $object->setViewPolicy($xaction->getNewValue());
         break;
       case PhabricatorTransactions::TYPE_EDIT_POLICY:
         $object->setEditPolicy($xaction->getNewValue());
         break;
       case PhabricatorTransactions::TYPE_CUSTOMFIELD:
         $field = $this->getCustomFieldForTransaction($object, $xaction);
         return $field->applyApplicationTransactionInternalEffects($xaction);
     }
     return $this->applyCustomInternalTransaction($object, $xaction);
   }
 
   private function applyExternalEffects(
     PhabricatorLiskDAO $object,
     PhabricatorApplicationTransaction $xaction) {
     switch ($xaction->getTransactionType()) {
       case PhabricatorTransactions::TYPE_SUBSCRIBERS:
         $subeditor = id(new PhabricatorSubscriptionsEditor())
           ->setObject($object)
           ->setActor($this->requireActor());
 
         $old_map = array_fuse($xaction->getOldValue());
         $new_map = array_fuse($xaction->getNewValue());
 
         $subeditor->unsubscribe(
           array_keys(
             array_diff_key($old_map, $new_map)));
 
         $subeditor->subscribeExplicit(
           array_keys(
             array_diff_key($new_map, $old_map)));
 
         $subeditor->save();
 
         // for the rest of these edits, subscribers should include those just
         // added as well as those just removed.
         $subscribers = array_unique(array_merge(
           $this->subscribers,
           $xaction->getOldValue(),
           $xaction->getNewValue()));
         $this->subscribers = $subscribers;
 
         break;
       case PhabricatorTransactions::TYPE_EDGE:
         $old = $xaction->getOldValue();
         $new = $xaction->getNewValue();
         $src = $object->getPHID();
         $type = $xaction->getMetadataValue('edge:type');
 
         foreach ($new as $dst_phid => $edge) {
           $new[$dst_phid]['src'] = $src;
         }
 
         $editor = id(new PhabricatorEdgeEditor())
           ->setActor($this->getActor());
 
         foreach ($old as $dst_phid => $edge) {
           if (!empty($new[$dst_phid])) {
             if ($old[$dst_phid]['data'] === $new[$dst_phid]['data']) {
               continue;
             }
           }
           $editor->removeEdge($src, $type, $dst_phid);
         }
 
         foreach ($new as $dst_phid => $edge) {
           if (!empty($old[$dst_phid])) {
             if ($old[$dst_phid]['data'] === $new[$dst_phid]['data']) {
               continue;
             }
           }
 
           $data = array(
             'data' => $edge['data'],
           );
 
           $editor->addEdge($src, $type, $dst_phid, $data);
         }
 
         $editor->save();
         break;
       case PhabricatorTransactions::TYPE_CUSTOMFIELD:
         $field = $this->getCustomFieldForTransaction($object, $xaction);
         return $field->applyApplicationTransactionExternalEffects($xaction);
     }
 
     return $this->applyCustomExternalTransaction($object, $xaction);
   }
 
   protected function applyCustomInternalTransaction(
     PhabricatorLiskDAO $object,
     PhabricatorApplicationTransaction $xaction) {
     throw new Exception("Capability not supported!");
   }
 
   protected function applyCustomExternalTransaction(
     PhabricatorLiskDAO $object,
     PhabricatorApplicationTransaction $xaction) {
     throw new Exception("Capability not supported!");
   }
 
   protected function applyFinalEffects(
     PhabricatorLiskDAO $object,
     array $xactions) {
   }
 
   public function setContentSource(PhabricatorContentSource $content_source) {
     $this->contentSource = $content_source;
     return $this;
   }
 
   public function setContentSourceFromRequest(AphrontRequest $request) {
     return $this->setContentSource(
       PhabricatorContentSource::newFromRequest($request));
   }
 
   public function getContentSource() {
     return $this->contentSource;
   }
 
   final public function applyTransactions(
     PhabricatorLiskDAO $object,
     array $xactions) {
 
     $this->object = $object;
     $this->xactions = $xactions;
     $this->isNewObject = ($object->getPHID() === null);
 
     $this->validateEditParameters($object, $xactions);
 
     $actor = $this->requireActor();
 
     $this->loadSubscribers($object);
 
     $xactions = $this->applyImplicitCC($object, $xactions);
 
     $mention_xaction = $this->buildMentionTransaction($object, $xactions);
     if ($mention_xaction) {
       $xactions[] = $mention_xaction;
     }
 
     $xactions = $this->combineTransactions($xactions);
 
     foreach ($xactions as $xaction) {
       // TODO: This needs to be more sophisticated once we have meta-policies.
       $xaction->setViewPolicy(PhabricatorPolicies::POLICY_PUBLIC);
       $xaction->setEditPolicy($actor->getPHID());
 
       $xaction->setAuthorPHID($actor->getPHID());
       $xaction->setContentSource($this->getContentSource());
     }
 
     $is_preview = $this->getIsPreview();
     $read_locking = false;
     $transaction_open = false;
 
     if (!$is_preview) {
       $errors = array();
       $type_map = mgroup($xactions, 'getTransactionType');
       foreach ($this->getTransactionTypes() as $type) {
         $type_xactions = idx($type_map, $type, array());
         $errors[] = $this->validateTransaction($object, $type, $type_xactions);
       }
 
       $errors = array_mergev($errors);
+
+      $continue_on_missing = $this->getContinueOnMissingFields();
+      foreach ($errors as $key => $error) {
+        if ($continue_on_missing && $error->getIsMissingFieldError()) {
+          unset($errors[$key]);
+        }
+      }
+
       if ($errors) {
         throw new PhabricatorApplicationTransactionValidationException($errors);
       }
 
       if ($object->getID()) {
         foreach ($xactions as $xaction) {
 
           // If any of the transactions require a read lock, hold one and
           // reload the object. We need to do this fairly early so that the
           // call to `adjustTransactionValues()` (which populates old values)
           // is based on the synchronized state of the object, which may differ
           // from the state when it was originally loaded.
 
           if ($this->shouldReadLock($object, $xaction)) {
             $object->openTransaction();
             $object->beginReadLocking();
             $transaction_open = true;
             $read_locking = true;
             $object->reload();
             break;
           }
         }
       }
 
       if ($this->shouldApplyInitialEffects($object, $xactions)) {
         if (!$transaction_open) {
           $object->openTransaction();
           $transaction_open = true;
         }
       }
     }
 
     if ($this->shouldApplyInitialEffects($object, $xactions)) {
       $this->applyInitialEffects($object, $xactions);
     }
 
     foreach ($xactions as $xaction) {
       $this->adjustTransactionValues($object, $xaction);
     }
 
     $xactions = $this->filterTransactions($object, $xactions);
 
     if (!$xactions) {
       if ($read_locking) {
         $object->endReadLocking();
         $read_locking = false;
       }
       if ($transaction_open) {
         $object->killTransaction();
         $transaction_open = false;
       }
       return array();
     }
 
     $xactions = $this->sortTransactions($xactions);
 
     if ($is_preview) {
       $this->loadHandles($xactions);
       return $xactions;
     }
 
     $comment_editor = id(new PhabricatorApplicationTransactionCommentEditor())
       ->setActor($actor)
       ->setContentSource($this->getContentSource());
 
     if (!$transaction_open) {
       $object->openTransaction();
     }
 
       foreach ($xactions as $xaction) {
         $this->applyInternalEffects($object, $xaction);
       }
 
       $object->save();
 
       foreach ($xactions as $xaction) {
         $xaction->setObjectPHID($object->getPHID());
         if ($xaction->getComment()) {
           $xaction->setPHID($xaction->generatePHID());
           $comment_editor->applyEdit($xaction, $xaction->getComment());
         } else {
           $xaction->save();
         }
       }
 
       foreach ($xactions as $xaction) {
         $this->applyExternalEffects($object, $xaction);
       }
 
       if ($this->supportsHerald()) {
         $this->applyHeraldRules($object, $xactions);
       }
 
       $this->applyFinalEffects($object, $xactions);
 
       if ($read_locking) {
         $object->endReadLocking();
         $read_locking = false;
       }
 
     $object->saveTransaction();
 
     $this->loadHandles($xactions);
 
     $mail = null;
     if ($this->shouldSendMail($object, $xactions)) {
       $mail = $this->sendMail($object, $xactions);
     }
 
     if ($this->supportsSearch()) {
       id(new PhabricatorSearchIndexer())
         ->indexDocumentByPHID($object->getPHID());
     }
 
     if ($this->supportsFeed()) {
       $mailed = array();
       if ($mail) {
         $mailed = $mail->buildRecipientList();
       }
       $this->publishFeedStory(
         $object,
         $xactions,
         $mailed);
     }
 
     $this->didApplyTransactions($xactions);
 
     if ($object instanceof PhabricatorCustomFieldInterface) {
       // Maybe this makes more sense to move into the search index itself? For
       // now I'm putting it here since I think we might end up with things that
       // need it to be up to date once the next page loads, but if we don't go
       // there we we could move it into search once search moves to the daemons.
 
       $fields = PhabricatorCustomField::getObjectFields(
         $object,
         PhabricatorCustomField::ROLE_APPLICATIONSEARCH);
       $fields->readFieldsFromStorage($object);
       $fields->rebuildIndexes($object);
     }
 
     return $xactions;
   }
 
   protected function didApplyTransactions(array $xactions) {
     // Hook for subclasses.
     return;
   }
 
 
   /**
    * Determine if the editor should hold a read lock on the object while
    * applying a transaction.
    *
    * If the editor does not hold a lock, two editors may read an object at the
    * same time, then apply their changes without any synchronization. For most
    * transactions, this does not matter much. However, it is important for some
    * transactions. For example, if an object has a transaction count on it, both
    * editors may read the object with `count = 23`, then independently update it
    * and save the object with `count = 24` twice. This will produce the wrong
    * state: the object really has 25 transactions, but the count is only 24.
    *
    * Generally, transactions fall into one of four buckets:
    *
    *   - Append operations: Actions like adding a comment to an object purely
    *     add information to its state, and do not depend on the current object
    *     state in any way. These transactions never need to hold locks.
    *   - Overwrite operations: Actions like changing the title or description
    *     of an object replace the current value with a new value, so the end
    *     state is consistent without a lock. We currently do not lock these
    *     transactions, although we may in the future.
    *   - Edge operations: Edge and subscription operations have internal
    *     synchronization which limits the damage race conditions can cause.
    *     We do not currently lock these transactions, although we may in the
    *     future.
    *   - Update operations: Actions like incrementing a count on an object.
    *     These operations generally should use locks, unless it is not
    *     important that the state remain consistent in the presence of races.
    *
    * @param   PhabricatorLiskDAO  Object being updated.
    * @param   PhabricatorApplicationTransaction Transaction being applied.
    * @return  bool                True to synchronize the edit with a lock.
    */
   protected function shouldReadLock(
     PhabricatorLiskDAO $object,
     PhabricatorApplicationTransaction $xaction) {
     return false;
   }
 
   private function loadHandles(array $xactions) {
     $phids = array();
     foreach ($xactions as $key => $xaction) {
       $phids[$key] = $xaction->getRequiredHandlePHIDs();
     }
     $handles = array();
     $merged = array_mergev($phids);
     if ($merged) {
       $handles = id(new PhabricatorHandleQuery())
         ->setViewer($this->requireActor())
         ->withPHIDs($merged)
         ->execute();
     }
     foreach ($xactions as $key => $xaction) {
       $xaction->setHandles(array_select_keys($handles, $phids[$key]));
     }
   }
 
   private function loadSubscribers(PhabricatorLiskDAO $object) {
     if ($object->getPHID() &&
         ($object instanceof PhabricatorSubscribableInterface)) {
       $subs = PhabricatorSubscribersQuery::loadSubscribersForPHID(
         $object->getPHID());
       $this->subscribers = array_fuse($subs);
     } else {
       $this->subscribers = array();
     }
   }
 
   private function validateEditParameters(
     PhabricatorLiskDAO $object,
     array $xactions) {
 
     if (!$this->getContentSource()) {
       throw new Exception(
         "Call setContentSource() before applyTransactions()!");
     }
 
     // Do a bunch of sanity checks that the incoming transactions are fresh.
     // They should be unsaved and have only "transactionType" and "newValue"
     // set.
 
     $types = array_fill_keys($this->getTransactionTypes(), true);
 
     assert_instances_of($xactions, 'PhabricatorApplicationTransaction');
     foreach ($xactions as $xaction) {
       if ($xaction->getPHID() || $xaction->getID()) {
         throw new Exception(
           "You can not apply transactions which already have IDs/PHIDs!");
       }
       if ($xaction->getObjectPHID()) {
         throw new Exception(
           "You can not apply transactions which already have objectPHIDs!");
       }
       if ($xaction->getAuthorPHID()) {
         throw new Exception(
           "You can not apply transactions which already have authorPHIDs!");
       }
       if ($xaction->getCommentPHID()) {
         throw new Exception(
           "You can not apply transactions which already have commentPHIDs!");
       }
       if ($xaction->getCommentVersion() !== 0) {
         throw new Exception(
           "You can not apply transactions which already have commentVersions!");
       }
 
       $custom_field_type = PhabricatorTransactions::TYPE_CUSTOMFIELD;
       if ($xaction->getTransactionType() != $custom_field_type) {
         if ($xaction->getOldValue() !== null) {
           throw new Exception(
             "You can not apply transactions which already have oldValue!");
         }
       }
 
       $type = $xaction->getTransactionType();
       if (empty($types[$type])) {
         throw new Exception("Transaction has unknown type '{$type}'.");
       }
     }
 
     // The actor must have permission to view and edit the object.
 
     $actor = $this->requireActor();
 
     PhabricatorPolicyFilter::requireCapability(
       $actor,
       $object,
       PhabricatorPolicyCapability::CAN_VIEW);
 
     // TODO: This should be "$object", not "$xaction", but probably breaks a
     // lot of stuff if fixed -- you don't need to be able to edit in order to
     // comment. Instead, transactions should specify the capabilities they
     // require.
 
     /*
 
     PhabricatorPolicyFilter::requireCapability(
       $actor,
       $xaction,
       PhabricatorPolicyCapability::CAN_EDIT);
 
     */
   }
 
   private function buildMentionTransaction(
     PhabricatorLiskDAO $object,
     array $xactions) {
 
     if (!($object instanceof PhabricatorSubscribableInterface)) {
       return null;
     }
 
     $texts = array();
     foreach ($xactions as $xaction) {
       $texts[] = $this->getMentionableTextsFromTransaction($xaction);
     }
     $texts = array_mergev($texts);
 
     $phids = PhabricatorMarkupEngine::extractPHIDsFromMentions($texts);
 
     $this->mentionedPHIDs = $phids;
 
     if ($object->getPHID()) {
       // Don't try to subscribe already-subscribed mentions: we want to generate
       // a dialog about an action having no effect if the user explicitly adds
       // existing CCs, but not if they merely mention existing subscribers.
       $phids = array_diff($phids, $this->subscribers);
     }
 
     foreach ($phids as $key => $phid) {
       if ($object->isAutomaticallySubscribed($phid)) {
         unset($phids[$key]);
       }
     }
     $phids = array_values($phids);
 
     if (!$phids) {
       return null;
     }
 
     $xaction = newv(get_class(head($xactions)), array());
     $xaction->setTransactionType(PhabricatorTransactions::TYPE_SUBSCRIBERS);
     $xaction->setNewValue(array('+' => $phids));
 
     return $xaction;
   }
 
   protected function getMentionableTextsFromTransaction(
     PhabricatorApplicationTransaction $transaction) {
     $texts = array();
     if ($transaction->getComment()) {
       $texts[] = $transaction->getComment()->getContent();
     }
     return $texts;
   }
 
   protected function mergeTransactions(
     PhabricatorApplicationTransaction $u,
     PhabricatorApplicationTransaction $v) {
 
     $type = $u->getTransactionType();
 
     switch ($type) {
       case PhabricatorTransactions::TYPE_SUBSCRIBERS:
         return $this->mergePHIDOrEdgeTransactions($u, $v);
       case PhabricatorTransactions::TYPE_EDGE:
         $u_type = $u->getMetadataValue('edge:type');
         $v_type = $v->getMetadataValue('edge:type');
         if ($u_type == $v_type) {
           return $this->mergePHIDOrEdgeTransactions($u, $v);
         }
         return null;
     }
 
     // By default, do not merge the transactions.
     return null;
   }
 
 
   /**
    * Attempt to combine similar transactions into a smaller number of total
    * transactions. For example, two transactions which edit the title of an
    * object can be merged into a single edit.
    */
   private function combineTransactions(array $xactions) {
     $stray_comments = array();
 
     $result = array();
     $types = array();
     foreach ($xactions as $key => $xaction) {
       $type = $xaction->getTransactionType();
       if (isset($types[$type])) {
         foreach ($types[$type] as $other_key) {
           $merged = $this->mergeTransactions($result[$other_key], $xaction);
           if ($merged) {
             $result[$other_key] = $merged;
 
             if ($xaction->getComment() &&
                 ($xaction->getComment() !== $merged->getComment())) {
               $stray_comments[] = $xaction->getComment();
             }
 
             if ($result[$other_key]->getComment() &&
                 ($result[$other_key]->getComment() !== $merged->getComment())) {
               $stray_comments[] = $result[$other_key]->getComment();
             }
 
             // Move on to the next transaction.
             continue 2;
           }
         }
       }
       $result[$key] = $xaction;
       $types[$type][] = $key;
     }
 
     // If we merged any comments away, restore them.
     foreach ($stray_comments as $comment) {
       $xaction = newv(get_class(head($result)), array());
       $xaction->setTransactionType(PhabricatorTransactions::TYPE_COMMENT);
       $xaction->setComment($comment);
       $result[] = $xaction;
     }
 
     return array_values($result);
   }
 
   protected function mergePHIDOrEdgeTransactions(
     PhabricatorApplicationTransaction $u,
     PhabricatorApplicationTransaction $v) {
 
     $result = $u->getNewValue();
     foreach ($v->getNewValue() as $key => $value) {
       $result[$key] = array_merge($value, idx($result, $key, array()));
     }
     $u->setNewValue($result);
 
     return $u;
   }
 
   protected function getPHIDTransactionNewValue(
     PhabricatorApplicationTransaction $xaction) {
 
     $old = array_fuse($xaction->getOldValue());
 
     $new = $xaction->getNewValue();
     $new_add = idx($new, '+', array());
     unset($new['+']);
     $new_rem = idx($new, '-', array());
     unset($new['-']);
     $new_set = idx($new, '=', null);
     if ($new_set !== null) {
       $new_set = array_fuse($new_set);
     }
     unset($new['=']);
 
     if ($new) {
       throw new Exception(
         "Invalid 'new' value for PHID transaction. Value should contain only ".
         "keys '+' (add PHIDs), '-' (remove PHIDs) and '=' (set PHIDS).");
     }
 
     $result = array();
 
     foreach ($old as $phid) {
       if ($new_set !== null && empty($new_set[$phid])) {
         continue;
       }
       $result[$phid] = $phid;
     }
 
     if ($new_set !== null) {
       foreach ($new_set as $phid) {
         $result[$phid] = $phid;
       }
     }
 
     foreach ($new_add as $phid) {
       $result[$phid] = $phid;
     }
 
     foreach ($new_rem as $phid) {
       unset($result[$phid]);
     }
 
     return array_values($result);
   }
 
   protected function getEdgeTransactionNewValue(
     PhabricatorApplicationTransaction $xaction) {
 
     $new = $xaction->getNewValue();
     $new_add = idx($new, '+', array());
     unset($new['+']);
     $new_rem = idx($new, '-', array());
     unset($new['-']);
     $new_set = idx($new, '=', null);
     unset($new['=']);
 
     if ($new) {
       throw new Exception(
         "Invalid 'new' value for Edge transaction. Value should contain only ".
         "keys '+' (add edges), '-' (remove edges) and '=' (set edges).");
     }
 
     $old = $xaction->getOldValue();
 
     $lists = array($new_set, $new_add, $new_rem);
     foreach ($lists as $list) {
       $this->checkEdgeList($list);
     }
 
     $result = array();
     foreach ($old as $dst_phid => $edge) {
       if ($new_set !== null && empty($new_set[$dst_phid])) {
         continue;
       }
       $result[$dst_phid] = $this->normalizeEdgeTransactionValue(
         $xaction,
         $edge);
     }
 
     if ($new_set !== null) {
       foreach ($new_set as $dst_phid => $edge) {
         $result[$dst_phid] = $this->normalizeEdgeTransactionValue(
           $xaction,
           $edge);
       }
     }
 
     foreach ($new_add as $dst_phid => $edge) {
       $result[$dst_phid] = $this->normalizeEdgeTransactionValue(
         $xaction,
         $edge);
     }
 
     foreach ($new_rem as $dst_phid => $edge) {
       unset($result[$dst_phid]);
     }
 
     return $result;
   }
 
   private function checkEdgeList($list) {
     if (!$list) {
       return;
     }
     foreach ($list as $key => $item) {
       if (phid_get_type($key) === PhabricatorPHIDConstants::PHID_TYPE_UNKNOWN) {
         throw new Exception(
           "Edge transactions must have destination PHIDs as in edge ".
           "lists (found key '{$key}').");
       }
       if (!is_array($item) && $item !== $key) {
         throw new Exception(
           "Edge transactions must have PHIDs or edge specs as values ".
           "(found value '{$item}').");
       }
     }
   }
 
   protected function normalizeEdgeTransactionValue(
     PhabricatorApplicationTransaction $xaction,
     $edge) {
 
     if (!is_array($edge)) {
       $edge = array(
         'dst' => $edge,
       );
     }
 
     $edge_type = $xaction->getMetadataValue('edge:type');
 
     if (empty($edge['type'])) {
       $edge['type'] = $edge_type;
     } else {
       if ($edge['type'] != $edge_type) {
         $this_type = $edge['type'];
         throw new Exception(
           "Edge transaction includes edge of type '{$this_type}', but ".
           "transaction is of type '{$edge_type}'. Each edge transaction must ".
           "alter edges of only one type.");
       }
     }
 
     if (!isset($edge['data'])) {
       $edge['data'] = null;
     }
 
     return $edge;
   }
 
   protected function sortTransactions(array $xactions) {
     $head = array();
     $tail = array();
 
     // Move bare comments to the end, so the actions precede them.
     foreach ($xactions as $xaction) {
       $type = $xaction->getTransactionType();
       if ($type == PhabricatorTransactions::TYPE_COMMENT) {
         $tail[] = $xaction;
       } else {
         $head[] = $xaction;
       }
     }
 
     return array_values(array_merge($head, $tail));
   }
 
 
   protected function filterTransactions(
     PhabricatorLiskDAO $object,
     array $xactions) {
 
     $type_comment = PhabricatorTransactions::TYPE_COMMENT;
 
     $no_effect = array();
     $has_comment = false;
     $any_effect = false;
     foreach ($xactions as $key => $xaction) {
       if ($this->transactionHasEffect($object, $xaction)) {
         if ($xaction->getTransactionType() != $type_comment) {
           $any_effect = true;
         }
       } else {
         $no_effect[$key] = $xaction;
       }
       if ($xaction->hasComment()) {
         $has_comment = true;
       }
     }
 
     if (!$no_effect) {
       return $xactions;
     }
 
     if (!$this->getContinueOnNoEffect() && !$this->getIsPreview()) {
       throw new PhabricatorApplicationTransactionNoEffectException(
         $no_effect,
         $any_effect,
         $has_comment);
     }
 
     if (!$any_effect && !$has_comment) {
       // If we only have empty comment transactions, just drop them all.
       return array();
     }
 
     foreach ($no_effect as $key => $xaction) {
       if ($xaction->getComment()) {
         $xaction->setTransactionType($type_comment);
         $xaction->setOldValue(null);
         $xaction->setNewValue(null);
       } else {
         unset($xactions[$key]);
       }
     }
 
     return $xactions;
   }
 
 
   /**
    * Hook for validating transactions. This callback will be invoked for each
    * available transaction type, even if an edit does not apply any transactions
    * of that type. This allows you to raise exceptions when required fields are
    * missing, by detecting that the object has no field value and there is no
    * transaction which sets one.
    *
    * @param PhabricatorLiskDAO Object being edited.
    * @param string Transaction type to validate.
    * @param list<PhabricatorApplicationTransaction> Transactions of given type,
    *   which may be empty if the edit does not apply any transactions of the
    *   given type.
    * @return list<PhabricatorApplicationTransactionValidationError> List of
    *   validation errors.
    */
   protected function validateTransaction(
     PhabricatorLiskDAO $object,
     $type,
     array $xactions) {
 
     $errors = array();
     switch ($type) {
       case PhabricatorTransactions::TYPE_CUSTOMFIELD:
         $groups = array();
         foreach ($xactions as $xaction) {
           $groups[$xaction->getMetadataValue('customfield:key')][] = $xaction;
         }
 
         $field_list = PhabricatorCustomField::getObjectFields(
           $object,
           PhabricatorCustomField::ROLE_EDIT);
 
         $role_xactions = PhabricatorCustomField::ROLE_APPLICATIONTRANSACTIONS;
         foreach ($field_list->getFields() as $field) {
           if (!$field->shouldEnableForRole($role_xactions)) {
             continue;
           }
           $errors[] = $field->validateApplicationTransactions(
             $this,
             $type,
             idx($groups, $field->getFieldKey(), array()));
         }
         break;
     }
 
     return array_mergev($errors);
   }
 
 
 /* -(  Implicit CCs  )------------------------------------------------------- */
 
 
   /**
    * When a user interacts with an object, we might want to add them to CC.
    */
   final public function applyImplicitCC(
     PhabricatorLiskDAO $object,
     array $xactions) {
 
     if (!($object instanceof PhabricatorSubscribableInterface)) {
       // If the object isn't subscribable, we can't CC them.
       return $xactions;
     }
 
     $actor_phid = $this->requireActor()->getPHID();
     if ($object->isAutomaticallySubscribed($actor_phid)) {
       // If they're auto-subscribed, don't CC them.
       return $xactions;
     }
 
     $should_cc = false;
     foreach ($xactions as $xaction) {
       if ($this->shouldImplyCC($object, $xaction)) {
         $should_cc = true;
         break;
       }
     }
 
     if (!$should_cc) {
       // Only some types of actions imply a CC (like adding a comment).
       return $xactions;
     }
 
     if ($object->getPHID()) {
       if (isset($this->subscribers[$actor_phid])) {
         // If the user is already subscribed, don't implicitly CC them.
         return $xactions;
       }
 
       $unsub = PhabricatorEdgeQuery::loadDestinationPHIDs(
         $object->getPHID(),
         PhabricatorEdgeConfig::TYPE_OBJECT_HAS_UNSUBSCRIBER);
       $unsub = array_fuse($unsub);
       if (isset($unsub[$actor_phid])) {
         // If the user has previously unsubscribed from this object explicitly,
         // don't implicitly CC them.
         return $xactions;
       }
     }
 
     $xaction = newv(get_class(head($xactions)), array());
     $xaction->setTransactionType(PhabricatorTransactions::TYPE_SUBSCRIBERS);
     $xaction->setNewValue(array('+' => array($actor_phid)));
 
     array_unshift($xactions, $xaction);
 
     return $xactions;
   }
 
   protected function shouldImplyCC(
     PhabricatorLiskDAO $object,
     PhabricatorApplicationTransaction $xaction) {
 
     switch ($xaction->getTransactionType()) {
       case PhabricatorTransactions::TYPE_COMMENT:
         return true;
       default:
         return false;
     }
   }
 
 
 /* -(  Sending Mail  )------------------------------------------------------- */
 
 
   /**
    * @task mail
    */
   protected function shouldSendMail(
     PhabricatorLiskDAO $object,
     array $xactions) {
     return false;
   }
 
 
   /**
    * @task mail
    */
   protected function sendMail(
     PhabricatorLiskDAO $object,
     array $xactions) {
 
     $email_to = array_unique($this->getMailTo($object));
     $email_cc = array_unique($this->getMailCC($object));
 
     $phids = array_merge($email_to, $email_cc);
     $handles = id(new PhabricatorHandleQuery())
       ->setViewer($this->requireActor())
       ->withPHIDs($phids)
       ->execute();
 
     $template = $this->buildMailTemplate($object);
     $body = $this->buildMailBody($object, $xactions);
 
     $mail_tags = $this->getMailTags($object, $xactions);
 
     $action = $this->getStrongestAction($object, $xactions)->getActionName();
 
     $template
       ->setFrom($this->requireActor()->getPHID())
       ->setSubjectPrefix($this->getMailSubjectPrefix())
       ->setVarySubjectPrefix('['.$action.']')
       ->setThreadID($this->getMailThreadID($object), $this->getIsNewObject())
       ->setRelatedPHID($object->getPHID())
       ->setExcludeMailRecipientPHIDs($this->getExcludeMailRecipientPHIDs())
       ->setMailTags($mail_tags)
       ->setIsBulk(true)
       ->setBody($body->render());
 
     if ($this->getParentMessageID()) {
       $template->setParentMessageID($this->getParentMessageID());
     }
 
     $mails = $this
       ->buildReplyHandler($object)
       ->multiplexMail(
         $template,
         array_select_keys($handles, $email_to),
         array_select_keys($handles, $email_cc));
 
     foreach ($mails as $mail) {
       $mail->saveAndSend();
     }
 
     $template->addTos($email_to);
     $template->addCCs($email_cc);
 
     return $template;
   }
 
   protected function getMailThreadID(PhabricatorLiskDAO $object) {
     return $object->getPHID();
   }
 
 
   /**
    * @task mail
    */
   protected function getStrongestAction(
     PhabricatorLiskDAO $object,
     array $xactions) {
     return last(msort($xactions, 'getActionStrength'));
   }
 
 
   /**
    * @task mail
    */
   protected function buildReplyHandler(PhabricatorLiskDAO $object) {
     throw new Exception("Capability not supported.");
   }
 
 
   /**
    * @task mail
    */
   protected function getMailSubjectPrefix() {
     throw new Exception("Capability not supported.");
   }
 
 
   /**
    * @task mail
    */
   protected function getMailTags(
     PhabricatorLiskDAO $object,
     array $xactions) {
     $tags = array();
 
     foreach ($xactions as $xaction) {
       $tags[] = $xaction->getMailTags();
     }
 
     return array_mergev($tags);
   }
 
 
   /**
    * @task mail
    */
   protected function buildMailTemplate(PhabricatorLiskDAO $object) {
     throw new Exception("Capability not supported.");
   }
 
 
   /**
    * @task mail
    */
   protected function getMailTo(PhabricatorLiskDAO $object) {
     throw new Exception("Capability not supported.");
   }
 
 
   /**
    * @task mail
    */
   protected function getMailCC(PhabricatorLiskDAO $object) {
     if ($object instanceof PhabricatorSubscribableInterface) {
       return $this->subscribers;
     }
     throw new Exception("Capability not supported.");
   }
 
 
   /**
    * @task mail
    */
   protected function buildMailBody(
     PhabricatorLiskDAO $object,
     array $xactions) {
 
     $headers = array();
     $comments = array();
 
     foreach ($xactions as $xaction) {
       if ($xaction->shouldHideForMail()) {
         continue;
       }
       $headers[] = id(clone $xaction)->setRenderingTarget('text')->getTitle();
       $comment = $xaction->getComment();
       if ($comment && strlen($comment->getContent())) {
         $comments[] = $comment->getContent();
       }
     }
 
     $body = new PhabricatorMetaMTAMailBody();
     $body->addRawSection(implode("\n", $headers));
 
     foreach ($comments as $comment) {
       $body->addRawSection($comment);
     }
 
     return $body;
   }
 
 
 /* -(  Publishing Feed Stories  )-------------------------------------------- */
 
 
   /**
    * @task feed
    */
   protected function supportsFeed() {
     return false;
   }
 
 
   /**
    * @task feed
    */
   protected function getFeedStoryType() {
     return 'PhabricatorApplicationTransactionFeedStory';
   }
 
 
   /**
    * @task feed
    */
   protected function getFeedRelatedPHIDs(
     PhabricatorLiskDAO $object,
     array $xactions) {
 
     return array(
       $object->getPHID(),
       $this->requireActor()->getPHID(),
     );
   }
 
 
   /**
    * @task feed
    */
   protected function getFeedNotifyPHIDs(
     PhabricatorLiskDAO $object,
     array $xactions) {
 
     return array_unique(array_merge(
       $this->getMailTo($object),
       $this->getMailCC($object)));
   }
 
 
   /**
    * @task feed
    */
   protected function getFeedStoryData(
     PhabricatorLiskDAO $object,
     array $xactions) {
 
     $xactions = msort($xactions, 'getActionStrength');
     $xactions = array_reverse($xactions);
 
     return array(
       'objectPHID'        => $object->getPHID(),
       'transactionPHIDs'  => mpull($xactions, 'getPHID'),
     );
   }
 
 
   /**
    * @task feed
    */
   protected function publishFeedStory(
     PhabricatorLiskDAO $object,
     array $xactions,
     array $mailed_phids) {
 
     $related_phids = $this->getFeedRelatedPHIDs($object, $xactions);
     $subscribed_phids = $this->getFeedNotifyPHIDs($object, $xactions);
 
     $story_type = $this->getFeedStoryType();
     $story_data = $this->getFeedStoryData($object, $xactions);
 
     id(new PhabricatorFeedStoryPublisher())
       ->setStoryType($story_type)
       ->setStoryData($story_data)
       ->setStoryTime(time())
       ->setStoryAuthorPHID($this->requireActor()->getPHID())
       ->setRelatedPHIDs($related_phids)
       ->setPrimaryObjectPHID($object->getPHID())
       ->setSubscribedPHIDs($subscribed_phids)
       ->setMailRecipientPHIDs($mailed_phids)
       ->publish();
   }
 
 
 /* -(  Search Index  )------------------------------------------------------- */
 
 
   /**
    * @task search
    */
   protected function supportsSearch() {
     return false;
   }
 
 
 /* -(  Herald Integration )-------------------------------------------------- */
 
 
   protected function supportsHerald() {
     return false;
   }
 
   protected function buildHeraldAdapter(
     PhabricatorLiskDAO $object,
     array $xactions) {
     throw new Exception('No herald adapter specified.');
   }
 
   private function setHeraldAdapter(HeraldAdapter $adapter) {
     $this->heraldAdapter = $adapter;
     return $this;
   }
 
   protected function getHeraldAdapter() {
     return $this->heraldAdapter;
   }
 
   private function setHeraldTranscript(HeraldTranscript $transcript) {
     $this->heraldTranscript = $transcript;
     return $this;
   }
 
   protected function getHeraldTranscript() {
     return $this->heraldTranscript;
   }
 
   private function applyHeraldRules(
     PhabricatorLiskDAO $object,
     array $xactions) {
 
     $adapter = $this->buildHeraldAdapter($object, $xactions);
     $xscript = HeraldEngine::loadAndApplyRules($adapter);
 
     $this->setHeraldAdapter($adapter);
     $this->setHeraldTranscript($xscript);
 
     $this->didApplyHeraldRules($object, $adapter, $xscript);
   }
 
   protected function didApplyHeraldRules(
     PhabricatorLiskDAO $object,
     HeraldAdapter $adapter,
     HeraldTranscript $transcript) {
 
   }
 
 
 /* -(  Custom Fields  )------------------------------------------------------ */
 
 
   /**
    * @task customfield
    */
   private function getCustomFieldForTransaction(
     PhabricatorLiskDAO $object,
     PhabricatorApplicationTransaction $xaction) {
 
     $field_key = $xaction->getMetadataValue('customfield:key');
     if (!$field_key) {
       throw new Exception(
         "Custom field transaction has no 'customfield:key'!");
     }
 
     $field = PhabricatorCustomField::getObjectField(
       $object,
       PhabricatorCustomField::ROLE_APPLICATIONTRANSACTIONS,
       $field_key);
 
     if (!$field) {
       throw new Exception(
         "Custom field transaction has invalid 'customfield:key'; field ".
         "'{$field_key}' is disabled or does not exist.");
     }
 
     if (!$field->shouldAppearInApplicationTransactions()) {
       throw new Exception(
         "Custom field transaction '{$field_key}' does not implement ".
         "integration for ApplicationTransactions.");
     }
 
     return $field;
   }
 
 }
diff --git a/src/applications/transactions/error/PhabricatorApplicationTransactionValidationError.php b/src/applications/transactions/error/PhabricatorApplicationTransactionValidationError.php
index 65661abc06..abad50b7bd 100644
--- a/src/applications/transactions/error/PhabricatorApplicationTransactionValidationError.php
+++ b/src/applications/transactions/error/PhabricatorApplicationTransactionValidationError.php
@@ -1,39 +1,49 @@
 <?php
 
 final class PhabricatorApplicationTransactionValidationError
   extends Phobject {
 
   private $type;
   private $transaction;
   private $shortMessage;
   private $message;
+  private $isMissingFieldError;
 
   public function __construct(
     $type,
     $short_message,
     $message,
     PhabricatorApplicationTransaction $xaction = null) {
 
     $this->type = $type;
     $this->shortMessage = $short_message;
     $this->message = $message;
     $this->transaction = $xaction;
   }
 
   public function getType() {
     return $this->type;
   }
 
   public function getTransaction() {
     return $this->tranaction;
   }
 
   public function getShortMessage() {
     return $this->shortMessage;
   }
 
   public function getMessage() {
     return $this->message;
   }
 
+  public function setIsMissingFieldError($is_missing_field_error) {
+    $this->isMissingFieldError = $is_missing_field_error;
+    return $this;
+  }
+
+  public function getIsMissingFieldError() {
+    return $this->isMissingFieldError;
+  }
+
 }
diff --git a/src/applications/transactions/view/PhabricatorApplicationTransactionView.php b/src/applications/transactions/view/PhabricatorApplicationTransactionView.php
index 8579d6a774..e64b5b86ff 100644
--- a/src/applications/transactions/view/PhabricatorApplicationTransactionView.php
+++ b/src/applications/transactions/view/PhabricatorApplicationTransactionView.php
@@ -1,299 +1,299 @@
 <?php
 
 /**
  * @concrete-extensible
  */
 class PhabricatorApplicationTransactionView extends AphrontView {
 
   private $transactions;
   private $engine;
   private $anchorOffset = 1;
   private $showEditActions = true;
   private $isPreview;
   private $objectPHID;
   private $isDetailView;
 
   public function setIsDetailView($is_detail_view) {
     $this->isDetailView = $is_detail_view;
     return $this;
   }
 
   public function setObjectPHID($object_phid) {
     $this->objectPHID = $object_phid;
     return $this;
   }
 
   public function getObjectPHID() {
     return $this->objectPHID;
   }
 
   public function setIsPreview($is_preview) {
     $this->isPreview = $is_preview;
     return $this;
   }
 
   public function setShowEditActions($show_edit_actions) {
     $this->showEditActions = $show_edit_actions;
     return $this;
   }
 
   public function getShowEditActions() {
     return $this->showEditActions;
   }
 
   public function setAnchorOffset($anchor_offset) {
     $this->anchorOffset = $anchor_offset;
     return $this;
   }
 
   public function setMarkupEngine(PhabricatorMarkupEngine $engine) {
     $this->engine = $engine;
     return $this;
   }
 
   public function setTransactions(array $transactions) {
     assert_instances_of($transactions, 'PhabricatorApplicationTransaction');
     $this->transactions = $transactions;
     return $this;
   }
 
   public function buildEvents() {
     $user = $this->getUser();
 
     $anchor = $this->anchorOffset;
     $events = array();
 
     $xactions = $this->transactions;
     foreach ($xactions as $key => $xaction) {
       if ($xaction->shouldHide()) {
         unset($xactions[$key]);
       }
     }
 
     $last = null;
     $last_key = null;
     $groups = array();
     foreach ($xactions as $key => $xaction) {
       if ($last && $this->shouldGroupTransactions($last, $xaction)) {
         $groups[$last_key][] = $xaction;
         unset($xactions[$key]);
       } else {
         $last = $xaction;
         $last_key = $key;
       }
     }
 
     foreach ($xactions as $key => $xaction) {
       $xaction->attachTransactionGroup(idx($groups, $key, array()));
 
       $event = id(new PhabricatorTimelineEventView())
         ->setUser($user)
         ->setTransactionPHID($xaction->getPHID())
         ->setUserHandle($xaction->getHandle($xaction->getAuthorPHID()))
         ->setIcon($xaction->getIcon())
         ->setColor($xaction->getColor());
 
       $title = $xaction->getTitle();
       if ($xaction->hasChangeDetails()) {
         if ($this->isPreview || $this->isDetailView) {
           $details = $this->buildChangeDetails($xaction);
         } else {
           $details = $this->buildChangeDetailsLink($xaction);
         }
         $title = array(
           $title,
           ' ',
           $details,
         );
       }
       $event->setTitle($title);
 
       if ($this->isPreview) {
         $event->setIsPreview(true);
       } else {
         $event
           ->setDateCreated($xaction->getDateCreated())
           ->setContentSource($xaction->getContentSource())
           ->setAnchor($anchor);
 
         $anchor++;
       }
 
       $has_deleted_comment = $xaction->getComment() &&
         $xaction->getComment()->getIsDeleted();
 
       if ($this->getShowEditActions() && !$this->isPreview) {
         if ($xaction->getCommentVersion() > 1) {
           $event->setIsEdited(true);
         }
 
         $can_edit = PhabricatorPolicyCapability::CAN_EDIT;
 
         if ($xaction->hasComment() || $has_deleted_comment) {
           $has_edit_capability = PhabricatorPolicyFilter::hasCapability(
             $user,
             $xaction,
             $can_edit);
           if ($has_edit_capability) {
             $event->setIsEditable(true);
           }
         }
       }
 
       $content = $this->renderTransactionContent($xaction);
       if ($content) {
         $event->appendChild($content);
       }
 
       $events[] = $event;
     }
 
     return $events;
   }
 
   public function render() {
     if (!$this->getObjectPHID()) {
       throw new Exception("Call setObjectPHID() before render()!");
     }
 
     $view = new PhabricatorTimelineView();
     $events = $this->buildEvents();
     foreach ($events as $event) {
       $view->addEvent($event);
     }
 
     if ($this->getShowEditActions()) {
       $list_id = celerity_generate_unique_node_id();
 
       $view->setID($list_id);
 
       Javelin::initBehavior(
         'phabricator-transaction-list',
         array(
           'listID'      => $list_id,
           'objectPHID'  => $this->getObjectPHID(),
           'nextAnchor'  => $this->anchorOffset + count($events),
         ));
     }
 
     return $view->render();
   }
 
   protected function getOrBuildEngine() {
     if ($this->engine) {
       return $this->engine;
     }
 
     $field = PhabricatorApplicationTransactionComment::MARKUP_FIELD_COMMENT;
 
     $engine = id(new PhabricatorMarkupEngine())
       ->setViewer($this->getUser());
     foreach ($this->transactions as $xaction) {
       if (!$xaction->hasComment()) {
         continue;
       }
       $engine->addObject($xaction->getComment(), $field);
     }
     $engine->process();
 
     return $engine;
   }
 
   private function buildChangeDetails(
     PhabricatorApplicationTransaction $xaction) {
 
     Javelin::initBehavior('phabricator-reveal-content');
 
     $show_id = celerity_generate_unique_node_id();
     $hide_id = celerity_generate_unique_node_id();
     $content_id = celerity_generate_unique_node_id();
 
     $show_more = javelin_tag(
       'a',
       array(
         'href' => '#',
         'sigil' => 'reveal-content',
         'mustcapture' => true,
         'id' => $show_id,
         'style' => 'display: none',
         'meta' => array(
           'hideIDs' => array($show_id),
           'showIDs' => array($hide_id, $content_id),
         ),
       ),
       pht('(Show Details)'));
 
     $hide_more = javelin_tag(
       'a',
       array(
         'href' => '#',
         'sigil' => 'reveal-content',
         'mustcapture' => true,
         'id' => $hide_id,
         'meta' => array(
           'hideIDs' => array($hide_id, $content_id),
           'showIDs' => array($show_id),
         ),
       ),
       pht('(Hide Details)'));
 
     $content = phutil_tag(
       'div',
       array(
         'id'    => $content_id,
         'class' => 'phabricator-timeline-change-details',
       ),
       $xaction->renderChangeDetails($this->getUser()));
 
     return array(
       $show_more,
       $hide_more,
       $content,
     );
   }
 
   private function buildChangeDetailsLink(
     PhabricatorApplicationTransaction $xaction) {
 
     return javelin_tag(
       'a',
       array(
         'href' => '/transactions/detail/'.$xaction->getPHID().'/',
         'sigil' => 'transaction-detail',
         'mustcapture' => true,
         'meta' => array(
           'anchor' => $this->anchorOffset,
         ),
       ),
       pht('(Show Details)'));
   }
 
   protected function shouldGroupTransactions(
     PhabricatorApplicationTransaction $u,
     PhabricatorApplicationTransaction $v) {
     return false;
   }
 
   protected function renderTransactionContent(
     PhabricatorApplicationTransaction $xaction) {
 
     $field = PhabricatorApplicationTransactionComment::MARKUP_FIELD_COMMENT;
     $engine = $this->getOrBuildEngine();
     $comment = $xaction->getComment();
 
-    if ($comment) {
+    if ($xaction->hasComment()) {
       if ($comment->getIsDeleted()) {
         return phutil_tag(
           'em',
           array(),
           pht('This comment has been deleted.'));
       } else {
         return $engine->getOutput($comment, $field);
       }
     }
 
     return null;
   }
 
 }
 
diff --git a/src/infrastructure/customfield/standard/PhabricatorStandardCustomField.php b/src/infrastructure/customfield/standard/PhabricatorStandardCustomField.php
index ec42904f2b..085805e466 100644
--- a/src/infrastructure/customfield/standard/PhabricatorStandardCustomField.php
+++ b/src/infrastructure/customfield/standard/PhabricatorStandardCustomField.php
@@ -1,332 +1,334 @@
 <?php
 
 abstract class PhabricatorStandardCustomField
   extends PhabricatorCustomField {
 
   private $fieldKey;
   private $fieldName;
   private $fieldValue;
   private $fieldDescription;
   private $fieldConfig;
   private $applicationField;
   private $strings = array();
   private $caption;
   private $fieldError;
   private $required;
   private $default;
 
   abstract public function getFieldType();
 
   public static function buildStandardFields(
     PhabricatorCustomField $template,
     array $config) {
 
     $types = id(new PhutilSymbolLoader())
       ->setAncestorClass(__CLASS__)
       ->loadObjects();
     $types = mpull($types, null, 'getFieldType');
 
     $fields = array();
     foreach ($config as $key => $value) {
       $type = idx($value, 'type', 'text');
       if (empty($types[$type])) {
         // TODO: We should have better typechecking somewhere, and then make
         // this more serious.
         continue;
       }
 
       $namespace = $template->getStandardCustomFieldNamespace();
       $full_key = "std:{$namespace}:{$key}";
 
       $template = clone $template;
       $standard = id(clone $types[$type])
         ->setFieldKey($full_key)
         ->setFieldConfig($value)
         ->setApplicationField($template);
 
       $field = $template->setProxy($standard);
       $fields[] = $field;
     }
 
     return $fields;
   }
 
   public function setApplicationField(
     PhabricatorStandardCustomFieldInterface $application_field) {
     $this->applicationField = $application_field;
     return $this;
   }
 
   public function getApplicationField() {
     return $this->applicationField;
   }
 
   public function setFieldName($name) {
     $this->fieldName = $name;
     return $this;
   }
 
   public function getFieldValue() {
     return $this->fieldValue;
   }
 
   public function setFieldValue($value) {
     $this->fieldValue = $value;
     return $this;
   }
 
   public function setCaption($caption) {
     $this->caption = $caption;
     return $this;
   }
 
   public function getCaption() {
     return $this->caption;
   }
 
   public function setFieldDescription($description) {
     $this->fieldDescription = $description;
     return $this;
   }
 
   public function setFieldConfig(array $config) {
     foreach ($config as $key => $value) {
       switch ($key) {
         case 'name':
           $this->setFieldName($value);
           break;
         case 'description':
           $this->setFieldDescription($value);
           break;
         case 'strings':
           $this->setStrings($value);
           break;
         case 'caption':
           $this->setCaption($value);
           break;
         case 'required':
           $this->setRequired($value);
           $this->setFieldError(true);
           break;
         case 'default':
           $this->setFieldValue($value);
           break;
         case 'type':
           // We set this earlier on.
           break;
       }
     }
     $this->fieldConfig = $config;
     return $this;
   }
 
   public function getFieldConfigValue($key, $default = null) {
     return idx($this->fieldConfig, $key, $default);
   }
 
   public function setFieldError($field_error) {
     $this->fieldError = $field_error;
     return $this;
   }
 
   public function getFieldError() {
     return $this->fieldError;
   }
 
   public function setRequired($required) {
     $this->required = $required;
     return $this;
   }
 
   public function getRequired() {
     return $this->required;
   }
 
 
 /* -(  PhabricatorCustomField  )--------------------------------------------- */
 
 
   public function setFieldKey($field_key) {
     $this->fieldKey = $field_key;
     return $this;
   }
 
   public function getFieldKey() {
     return $this->fieldKey;
   }
 
   public function getFieldName() {
     return coalesce($this->fieldName, parent::getFieldName());
   }
 
   public function getFieldDescription() {
     return coalesce($this->fieldDescription, parent::getFieldDescription());
   }
 
   public function setStrings(array $strings) {
     $this->strings = $strings;
     return;
   }
 
   public function getString($key, $default = null) {
     return idx($this->strings, $key, $default);
   }
 
   public function shouldUseStorage() {
     return true;
   }
 
   public function getValueForStorage() {
     return $this->getFieldValue();
   }
 
   public function setValueFromStorage($value) {
     return $this->setFieldValue($value);
   }
 
   public function shouldAppearInApplicationTransactions() {
     return true;
   }
 
   public function shouldAppearInEditView() {
     return $this->getFieldConfigValue('edit', true);
   }
 
   public function readValueFromRequest(AphrontRequest $request) {
     $value = $request->getStr($this->getFieldKey());
     if (!strlen($value)) {
       $value = null;
     }
     $this->setFieldValue($value);
   }
 
   public function renderEditControl() {
     return id(new AphrontFormTextControl())
       ->setName($this->getFieldKey())
       ->setCaption($this->getCaption())
       ->setValue($this->getFieldValue())
       ->setError($this->getFieldError())
       ->setLabel($this->getFieldName());
   }
 
   public function newStorageObject() {
     return $this->getApplicationField()->newStorageObject();
   }
 
   public function shouldAppearInPropertyView() {
     return $this->getFieldConfigValue('view', true);
   }
 
   public function renderPropertyViewValue() {
     return $this->getFieldValue();
   }
 
   public function shouldAppearInApplicationSearch() {
     return $this->getFieldConfigValue('search', false);
   }
 
   protected function newStringIndexStorage() {
     return $this->getApplicationField()->newStringIndexStorage();
   }
 
   protected function newNumericIndexStorage() {
     return $this->getApplicationField()->newNumericIndexStorage();
   }
 
   public function buildFieldIndexes() {
     return array();
   }
 
   public function readApplicationSearchValueFromRequest(
     PhabricatorApplicationSearchEngine $engine,
     AphrontRequest $request) {
     return;
   }
 
   public function applyApplicationSearchConstraintToQuery(
     PhabricatorApplicationSearchEngine $engine,
     PhabricatorCursorPagedPolicyAwareQuery $query,
     $value) {
     return;
   }
 
   public function appendToApplicationSearchForm(
     PhabricatorApplicationSearchEngine $engine,
     AphrontFormView $form,
     $value,
     array $handles) {
     return;
   }
 
   public function validateApplicationTransactions(
     PhabricatorApplicationTransactionEditor $editor,
     $type,
     array $xactions) {
 
     $this->setFieldError(null);
 
     $errors = parent::validateApplicationTransactions(
       $editor,
       $type,
       $xactions);
 
     if ($this->getRequired()) {
       $value = $this->getOldValueForApplicationTransactions();
 
       $transaction = null;
       foreach ($xactions as $xaction) {
         $value = $xaction->getNewValue();
         if (!$this->isValueEmpty($value)) {
           $transaction = $xaction;
           break;
         }
       }
       if ($this->isValueEmpty($value)) {
-        $errors[] = new PhabricatorApplicationTransactionValidationError(
+        $error = new PhabricatorApplicationTransactionValidationError(
           $type,
           pht('Required'),
           pht('%s is required.', $this->getFieldName()),
           $transaction);
+        $error->setIsMissingFieldError(true);
+        $errors[] = $error;
         $this->setFieldError(pht('Required'));
       }
     }
 
     return $errors;
   }
 
   protected function isValueEmpty($value) {
     if (is_array($value)) {
       return empty($value);
     }
     return !strlen($value);
   }
 
   public function getApplicationTransactionTitle(
     PhabricatorApplicationTransaction $xaction) {
     $author_phid = $xaction->getAuthorPHID();
     $old = $xaction->getOldValue();
     $new = $xaction->getNewValue();
 
     if (!$old) {
       return pht(
         '%s set %s to %s.',
         $xaction->renderHandleLink($author_phid),
         $this->getFieldName(),
         $new);
     } else if (!$new) {
       return pht(
         '%s removed %s.',
         $xaction->renderHandleLink($author_phid),
         $this->getFieldName());
     } else {
       return pht(
         '%s changed %s from %s to %s.',
         $xaction->renderHandleLink($author_phid),
         $this->getFieldName(),
         $old,
         $new);
     }
   }
 
 
 }