diff --git a/src/applications/maniphest/editor/ManiphestEditEngine.php b/src/applications/maniphest/editor/ManiphestEditEngine.php
index d49851cdfd..58606538ca 100644
--- a/src/applications/maniphest/editor/ManiphestEditEngine.php
+++ b/src/applications/maniphest/editor/ManiphestEditEngine.php
@@ -1,453 +1,454 @@
 <?php
 
 final class ManiphestEditEngine
   extends PhabricatorEditEngine {
 
   const ENGINECONST = 'maniphest.task';
 
   public function getEngineName() {
     return pht('Maniphest Tasks');
   }
 
   public function getSummaryHeader() {
     return pht('Configure Maniphest Task Forms');
   }
 
   public function getSummaryText() {
     return pht('Configure how users create and edit tasks.');
   }
 
   public function getEngineApplicationClass() {
     return 'PhabricatorManiphestApplication';
   }
 
   protected function newEditableObject() {
     return ManiphestTask::initializeNewTask($this->getViewer());
   }
 
   protected function newObjectQuery() {
     return id(new ManiphestTaskQuery());
   }
 
   protected function getObjectCreateTitleText($object) {
     return pht('Create New Task');
   }
 
   protected function getObjectEditTitleText($object) {
     return pht('Edit Task: %s', $object->getTitle());
   }
 
   protected function getObjectEditShortText($object) {
     return $object->getMonogram();
   }
 
   protected function getObjectCreateShortText() {
     return pht('Create Task');
   }
 
   protected function getObjectName() {
     return pht('Task');
   }
 
   protected function getEditorURI() {
     return $this->getApplication()->getApplicationURI('task/edit/');
   }
 
   protected function getCommentViewHeaderText($object) {
     return pht('Weigh In');
   }
 
   protected function getCommentViewButtonText($object) {
     return pht('Set Sail for Adventure');
   }
 
   protected function getObjectViewURI($object) {
     return '/'.$object->getMonogram();
   }
 
   protected function buildCustomEditFields($object) {
     $status_map = $this->getTaskStatusMap($object);
     $priority_map = $this->getTaskPriorityMap($object);
 
     if ($object->isClosed()) {
       $default_status = ManiphestTaskStatus::getDefaultStatus();
     } else {
       $default_status = ManiphestTaskStatus::getDefaultClosedStatus();
     }
 
     if ($object->getOwnerPHID()) {
       $owner_value = array($object->getOwnerPHID());
     } else {
       $owner_value = array($this->getViewer()->getPHID());
     }
 
     $column_documentation = pht(<<<EODOCS
 You can use this transaction type to create a task into a particular workboard
 column, or move an existing task between columns.
 
 The transaction value can be specified in several forms. Some are simpler but
 less powerful, while others are more complex and more powerful.
 
 The simplest valid value is a single column PHID:
 
 ```lang=json
 "PHID-PCOL-1111"
 ```
 
 This will move the task into that column, or create the task into that column
 if you are creating a new task. If the task is currently on the board, it will
 be moved out of any exclusive columns. If the task is not currently on the
 board, it will be added to the board.
 
 You can also perform multiple moves at the same time by passing a list of
 PHIDs:
 
 ```lang=json
 ["PHID-PCOL-2222", "PHID-PCOL-3333"]
 ```
 
 This is equivalent to performing each move individually.
 
 The most complex and most powerful form uses a dictionary to provide additional
 information about the move, including an optional specific position within the
 column.
 
 The target column should be identified as `columnPHID`, and you may select a
 position by passing either `beforePHID` or `afterPHID`, specifying the PHID of
 a task currently in the column that you want to move this task before or after:
 
 ```lang=json
 [
   {
     "columnPHID": "PHID-PCOL-4444",
     "beforePHID": "PHID-TASK-5555"
   }
 ]
 ```
 
 Note that this affects only the "natural" position of the task. The task
 position when the board is sorted by some other attribute (like priority)
 depends on that attribute value: change a task's priority to move it on
 priority-sorted boards.
 EODOCS
       );
 
     $column_map = $this->getColumnMap($object);
 
     $fields = array(
       id(new PhabricatorHandlesEditField())
         ->setKey('parent')
         ->setLabel(pht('Parent Task'))
         ->setDescription(pht('Task to make this a subtask of.'))
         ->setConduitDescription(pht('Create as a subtask of another task.'))
         ->setConduitTypeDescription(pht('PHID of the parent task.'))
         ->setAliases(array('parentPHID'))
         ->setTransactionType(ManiphestTransaction::TYPE_PARENT)
         ->setHandleParameterType(new ManiphestTaskListHTTPParameterType())
         ->setSingleValue(null)
         ->setIsReorderable(false)
         ->setIsDefaultable(false)
         ->setIsLockable(false),
       id(new PhabricatorColumnsEditField())
         ->setKey('column')
         ->setLabel(pht('Column'))
         ->setDescription(pht('Create a task in a workboard column.'))
         ->setConduitDescription(
           pht('Move a task to one or more workboard columns.'))
         ->setConduitTypeDescription(
           pht('List of columns to move the task to.'))
         ->setConduitDocumentation($column_documentation)
         ->setAliases(array('columnPHID', 'columns', 'columnPHIDs'))
         ->setTransactionType(PhabricatorTransactions::TYPE_COLUMNS)
         ->setIsReorderable(false)
         ->setIsDefaultable(false)
         ->setIsLockable(false)
         ->setCommentActionLabel(pht('Move on Workboard'))
+        ->setCommentActionOrder(2000)
         ->setColumnMap($column_map),
       id(new PhabricatorTextEditField())
         ->setKey('title')
         ->setLabel(pht('Title'))
         ->setDescription(pht('Name of the task.'))
         ->setConduitDescription(pht('Rename the task.'))
         ->setConduitTypeDescription(pht('New task name.'))
         ->setTransactionType(ManiphestTransaction::TYPE_TITLE)
         ->setIsRequired(true)
         ->setValue($object->getTitle()),
       id(new PhabricatorUsersEditField())
         ->setKey('owner')
         ->setAliases(array('ownerPHID', 'assign', 'assigned'))
         ->setLabel(pht('Assigned To'))
         ->setDescription(pht('User who is responsible for the task.'))
         ->setConduitDescription(pht('Reassign the task.'))
         ->setConduitTypeDescription(
           pht('New task owner, or `null` to unassign.'))
         ->setTransactionType(ManiphestTransaction::TYPE_OWNER)
         ->setIsCopyable(true)
         ->setSingleValue($object->getOwnerPHID())
         ->setCommentActionLabel(pht('Assign / Claim'))
         ->setCommentActionValue($owner_value),
       id(new PhabricatorSelectEditField())
         ->setKey('status')
         ->setLabel(pht('Status'))
         ->setDescription(pht('Status of the task.'))
         ->setConduitDescription(pht('Change the task status.'))
         ->setConduitTypeDescription(pht('New task status constant.'))
         ->setTransactionType(ManiphestTransaction::TYPE_STATUS)
         ->setIsCopyable(true)
         ->setValue($object->getStatus())
         ->setOptions($status_map)
         ->setCommentActionLabel(pht('Change Status'))
         ->setCommentActionValue($default_status),
       id(new PhabricatorSelectEditField())
         ->setKey('priority')
         ->setLabel(pht('Priority'))
         ->setDescription(pht('Priority of the task.'))
         ->setConduitDescription(pht('Change the priority of the task.'))
         ->setConduitTypeDescription(pht('New task priority constant.'))
         ->setTransactionType(ManiphestTransaction::TYPE_PRIORITY)
         ->setIsCopyable(true)
         ->setValue($object->getPriority())
         ->setOptions($priority_map)
         ->setCommentActionLabel(pht('Change Priority')),
     );
 
     if (ManiphestTaskPoints::getIsEnabled()) {
       $points_label = ManiphestTaskPoints::getPointsLabel();
       $action_label = ManiphestTaskPoints::getPointsActionLabel();
 
       $fields[] = id(new PhabricatorPointsEditField())
         ->setKey('points')
         ->setLabel($points_label)
         ->setDescription(pht('Point value of the task.'))
         ->setConduitDescription(pht('Change the task point value.'))
         ->setConduitTypeDescription(pht('New task point value.'))
         ->setTransactionType(ManiphestTransaction::TYPE_POINTS)
         ->setIsCopyable(true)
         ->setValue($object->getPoints())
         ->setCommentActionLabel($action_label);
     }
 
     $fields[] = id(new PhabricatorRemarkupEditField())
       ->setKey('description')
       ->setLabel(pht('Description'))
       ->setDescription(pht('Task description.'))
       ->setConduitDescription(pht('Update the task description.'))
       ->setConduitTypeDescription(pht('New task description.'))
       ->setTransactionType(ManiphestTransaction::TYPE_DESCRIPTION)
       ->setValue($object->getDescription())
       ->setPreviewPanel(
         id(new PHUIRemarkupPreviewPanel())
           ->setHeader(pht('Description Preview')));
 
     return $fields;
   }
 
   private function getTaskStatusMap(ManiphestTask $task) {
     $status_map = ManiphestTaskStatus::getTaskStatusMap();
 
     $current_status = $task->getStatus();
 
     // If the current status is something we don't recognize (maybe an older
     // status which was deleted), put a dummy entry in the status map so that
     // saving the form doesn't destroy any data by accident.
     if (idx($status_map, $current_status) === null) {
       $status_map[$current_status] = pht('<Unknown: %s>', $current_status);
     }
 
     $dup_status = ManiphestTaskStatus::getDuplicateStatus();
     foreach ($status_map as $status => $status_name) {
       // Always keep the task's current status.
       if ($status == $current_status) {
         continue;
       }
 
       // Don't allow tasks to be changed directly into "Closed, Duplicate"
       // status. Instead, you have to merge them. See T4819.
       if ($status == $dup_status) {
         unset($status_map[$status]);
         continue;
       }
 
       // Don't let new or existing tasks be moved into a disabled status.
       if (ManiphestTaskStatus::isDisabledStatus($status)) {
         unset($status_map[$status]);
         continue;
       }
     }
 
     return $status_map;
   }
 
   private function getTaskPriorityMap(ManiphestTask $task) {
     $priority_map = ManiphestTaskPriority::getTaskPriorityMap();
     $current_priority = $task->getPriority();
 
     // If the current value isn't a legitimate one, put it in the dropdown
     // anyway so saving the form doesn't cause a side effects.
     if (idx($priority_map, $current_priority) === null) {
       $priority_map[$current_priority] = pht(
         '<Unknown: %s>',
         $current_priority);
     }
 
     foreach ($priority_map as $priority => $priority_name) {
       // Always keep the current priority.
       if ($priority == $current_priority) {
         continue;
       }
 
       if (ManiphestTaskPriority::isDisabledPriority($priority)) {
         unset($priority_map[$priority]);
         continue;
       }
     }
 
     return $priority_map;
   }
 
   protected function newEditResponse(
     AphrontRequest $request,
     $object,
     array $xactions) {
 
     if ($request->isAjax()) {
       // Reload the task to make sure we pick up the final task state.
       $viewer = $this->getViewer();
       $task = id(new ManiphestTaskQuery())
         ->setViewer($viewer)
         ->withIDs(array($object->getID()))
         ->needSubscriberPHIDs(true)
         ->needProjectPHIDs(true)
         ->executeOne();
 
       switch ($request->getStr('responseType')) {
         case 'card':
           return $this->buildCardResponse($task);
         default:
           return $this->buildListResponse($task);
       }
 
     }
 
     return parent::newEditResponse($request, $object, $xactions);
   }
 
   private function buildListResponse(ManiphestTask $task) {
     $controller = $this->getController();
 
     $payload = array(
       'tasks' => $controller->renderSingleTask($task),
       'data' => array(),
     );
 
     return id(new AphrontAjaxResponse())->setContent($payload);
   }
 
   private function buildCardResponse(ManiphestTask $task) {
     $controller = $this->getController();
     $request = $controller->getRequest();
     $viewer = $request->getViewer();
 
     $column_phid = $request->getStr('columnPHID');
 
     $visible_phids = $request->getStrList('visiblePHIDs');
     if (!$visible_phids) {
       $visible_phids = array();
     }
 
     $column = id(new PhabricatorProjectColumnQuery())
       ->setViewer($viewer)
       ->withPHIDs(array($column_phid))
       ->executeOne();
     if (!$column) {
       return new Aphront404Response();
     }
 
     $board_phid = $column->getProjectPHID();
     $object_phid = $task->getPHID();
 
     return id(new PhabricatorBoardResponseEngine())
       ->setViewer($viewer)
       ->setBoardPHID($board_phid)
       ->setObjectPHID($object_phid)
       ->setVisiblePHIDs($visible_phids)
       ->buildResponse();
   }
 
   private function getColumnMap(ManiphestTask $task) {
     $phid = $task->getPHID();
     if (!$phid) {
       return array();
     }
 
     $board_phids = PhabricatorEdgeQuery::loadDestinationPHIDs(
       $phid,
       PhabricatorProjectObjectHasProjectEdgeType::EDGECONST);
     if (!$board_phids) {
       return array();
     }
 
     $viewer = $this->getViewer();
 
     $layout_engine = id(new PhabricatorBoardLayoutEngine())
       ->setViewer($viewer)
       ->setBoardPHIDs($board_phids)
       ->setObjectPHIDs(array($task->getPHID()))
       ->setFetchAllBoards(true)
       ->executeLayout();
 
     $map = array();
     foreach ($board_phids as $board_phid) {
       $in_columns = $layout_engine->getObjectColumns($board_phid, $phid);
       $in_columns = mpull($in_columns, null, 'getPHID');
 
       $all_columns = $layout_engine->getColumns($board_phid);
       $options = array();
       foreach ($all_columns as $column) {
         $name = $column->getDisplayName();
 
         $is_hidden = $column->isHidden();
         $is_selected = isset($in_columns[$column->getPHID()]);
 
         // Don't show hidden, subproject or milestone columns in this map
         // unless the object is currently in the column.
         $skip_column = ($is_hidden || $column->getProxyPHID());
         if ($skip_column) {
           if (!$is_selected) {
             continue;
           }
         }
 
         if ($is_hidden) {
           $name = pht('(%s)', $name);
         }
 
         if ($is_selected) {
           $name = pht("\xE2\x97\x8F %s", $name);
         } else {
           $name = pht("\xE2\x97\x8B %s", $name);
         }
 
         $option = array(
           'key' => $column->getPHID(),
           'label' => $name,
           'selected' => (bool)$is_selected,
         );
 
         $options[] = $option;
       }
 
       $map[] = array(
         'label' => head($all_columns)->getProject()->getDisplayName(),
         'options' => $options,
       );
     }
 
     $map = isort($map, 'label');
     $map = array_values($map);
 
     return $map;
   }
 
 
 }
diff --git a/src/applications/project/engineextension/PhabricatorProjectsEditEngineExtension.php b/src/applications/project/engineextension/PhabricatorProjectsEditEngineExtension.php
index cd481946b2..ce9fbf332c 100644
--- a/src/applications/project/engineextension/PhabricatorProjectsEditEngineExtension.php
+++ b/src/applications/project/engineextension/PhabricatorProjectsEditEngineExtension.php
@@ -1,75 +1,76 @@
 <?php
 
 final class PhabricatorProjectsEditEngineExtension
   extends PhabricatorEditEngineExtension {
 
   const EXTENSIONKEY = 'projects.projects';
 
   public function getExtensionPriority() {
     return 500;
   }
 
   public function isExtensionEnabled() {
     return PhabricatorApplication::isClassInstalled(
       'PhabricatorProjectApplication');
   }
 
   public function getExtensionName() {
     return pht('Projects');
   }
 
   public function supportsObject(
     PhabricatorEditEngine $engine,
     PhabricatorApplicationTransactionInterface $object) {
 
     return ($object instanceof PhabricatorProjectInterface);
   }
 
   public function buildCustomEditFields(
     PhabricatorEditEngine $engine,
     PhabricatorApplicationTransactionInterface $object) {
 
     $edge_type = PhabricatorTransactions::TYPE_EDGE;
     $project_edge_type = PhabricatorProjectObjectHasProjectEdgeType::EDGECONST;
 
     $object_phid = $object->getPHID();
     if ($object_phid) {
       $project_phids = PhabricatorEdgeQuery::loadDestinationPHIDs(
         $object_phid,
         $project_edge_type);
       $project_phids = array_reverse($project_phids);
     } else {
       $project_phids = array();
     }
 
     $projects_field = id(new PhabricatorProjectsEditField())
       ->setKey('projectPHIDs')
       ->setLabel(pht('Tags'))
       ->setEditTypeKey('projects')
       ->setAliases(array('project', 'projects', 'tag', 'tags'))
       ->setIsCopyable(true)
       ->setUseEdgeTransactions(true)
       ->setCommentActionLabel(pht('Change Project Tags'))
+      ->setCommentActionOrder(8000)
       ->setDescription(pht('Select project tags for the object.'))
       ->setTransactionType($edge_type)
       ->setMetadataValue('edge:type', $project_edge_type)
       ->setValue($project_phids);
 
     $projects_field->setViewer($engine->getViewer());
 
     $edit_add = $projects_field->getConduitEditType('projects.add')
       ->setConduitDescription(pht('Add project tags.'));
 
     $edit_set = $projects_field->getConduitEditType('projects.set')
       ->setConduitDescription(
         pht('Set project tags, overwriting current value.'));
 
     $edit_rem = $projects_field->getConduitEditType('projects.remove')
       ->setConduitDescription(pht('Remove project tags.'));
 
     return array(
       $projects_field,
     );
   }
 
 }
diff --git a/src/applications/subscriptions/engineextension/PhabricatorSubscriptionsEditEngineExtension.php b/src/applications/subscriptions/engineextension/PhabricatorSubscriptionsEditEngineExtension.php
index 19b9281d02..a0a6cbf7be 100644
--- a/src/applications/subscriptions/engineextension/PhabricatorSubscriptionsEditEngineExtension.php
+++ b/src/applications/subscriptions/engineextension/PhabricatorSubscriptionsEditEngineExtension.php
@@ -1,69 +1,70 @@
 <?php
 
 final class PhabricatorSubscriptionsEditEngineExtension
   extends PhabricatorEditEngineExtension {
 
   const EXTENSIONKEY = 'subscriptions.subscribers';
 
   public function getExtensionPriority() {
     return 750;
   }
 
   public function isExtensionEnabled() {
     return true;
   }
 
   public function getExtensionName() {
     return pht('Subscriptions');
   }
 
   public function supportsObject(
     PhabricatorEditEngine $engine,
     PhabricatorApplicationTransactionInterface $object) {
     return ($object instanceof PhabricatorSubscribableInterface);
   }
 
   public function buildCustomEditFields(
     PhabricatorEditEngine $engine,
     PhabricatorApplicationTransactionInterface $object) {
 
     $subscribers_type = PhabricatorTransactions::TYPE_SUBSCRIBERS;
 
     $object_phid = $object->getPHID();
     if ($object_phid) {
       $sub_phids = PhabricatorSubscribersQuery::loadSubscribersForPHID(
         $object_phid);
     } else {
       $sub_phids = array();
     }
 
     $subscribers_field = id(new PhabricatorSubscribersEditField())
       ->setKey('subscriberPHIDs')
       ->setLabel(pht('Subscribers'))
       ->setEditTypeKey('subscribers')
       ->setAliases(array('subscriber', 'subscribers'))
       ->setIsCopyable(true)
       ->setUseEdgeTransactions(true)
       ->setCommentActionLabel(pht('Change Subscribers'))
+      ->setCommentActionOrder(9000)
       ->setDescription(pht('Choose subscribers.'))
       ->setTransactionType($subscribers_type)
       ->setValue($sub_phids);
 
     $subscribers_field->setViewer($engine->getViewer());
 
     $edit_add = $subscribers_field->getConduitEditType('subscribers.add')
       ->setConduitDescription(pht('Add subscribers.'));
 
     $edit_set = $subscribers_field->getConduitEditType('subscribers.set')
       ->setConduitDescription(
         pht('Set subscribers, overwriting current value.'));
 
     $edit_rem = $subscribers_field->getConduitEditType('subscribers.remove')
       ->setConduitDescription(pht('Remove subscribers.'));
 
     return array(
       $subscribers_field,
     );
   }
 
 }
diff --git a/src/applications/transactions/commentaction/PhabricatorEditEngineCommentAction.php b/src/applications/transactions/commentaction/PhabricatorEditEngineCommentAction.php
index 548039ce15..dc676630ba 100644
--- a/src/applications/transactions/commentaction/PhabricatorEditEngineCommentAction.php
+++ b/src/applications/transactions/commentaction/PhabricatorEditEngineCommentAction.php
@@ -1,49 +1,64 @@
 <?php
 
 abstract class PhabricatorEditEngineCommentAction extends Phobject {
 
   private $key;
   private $label;
   private $value;
   private $initialValue;
+  private $order;
 
   abstract public function getPHUIXControlType();
   abstract public function getPHUIXControlSpecification();
 
   public function setKey($key) {
     $this->key = $key;
     return $this;
   }
 
   public function getKey() {
     return $this->key;
   }
 
   public function setLabel($label) {
     $this->label = $label;
     return $this;
   }
 
   public function getLabel() {
     return $this->label;
   }
 
   public function setValue($value) {
     $this->value = $value;
     return $this;
   }
 
   public function getValue() {
     return $this->value;
   }
 
+  public function setOrder($order) {
+    $this->order = $order;
+    return $this;
+  }
+
+  public function getOrder() {
+    return $this->order;
+  }
+
+  public function getSortVector() {
+    return id(new PhutilSortVector())
+      ->addInt($this->getOrder());
+  }
+
   public function setInitialValue($initial_value) {
     $this->initialValue = $initial_value;
     return $this;
   }
 
   public function getInitialValue() {
     return $this->initialValue;
   }
 
 }
diff --git a/src/applications/transactions/editengine/PhabricatorEditEngine.php b/src/applications/transactions/editengine/PhabricatorEditEngine.php
index 9655a83e65..185ac13a5a 100644
--- a/src/applications/transactions/editengine/PhabricatorEditEngine.php
+++ b/src/applications/transactions/editengine/PhabricatorEditEngine.php
@@ -1,1986 +1,1988 @@
 <?php
 
 
 /**
  * @task fields Managing Fields
  * @task text Display Text
  * @task config Edit Engine Configuration
  * @task uri Managing URIs
  * @task load Creating and Loading Objects
  * @task web Responding to Web Requests
  * @task edit Responding to Edit Requests
  * @task http Responding to HTTP Parameter Requests
  * @task conduit Responding to Conduit Requests
  */
 abstract class PhabricatorEditEngine
   extends Phobject
   implements PhabricatorPolicyInterface {
 
   const EDITENGINECONFIG_DEFAULT = 'default';
 
   private $viewer;
   private $controller;
   private $isCreate;
   private $editEngineConfiguration;
   private $contextParameters = array();
   private $targetObject;
 
   final public function setViewer(PhabricatorUser $viewer) {
     $this->viewer = $viewer;
     return $this;
   }
 
   final public function getViewer() {
     return $this->viewer;
   }
 
   final public function setController(PhabricatorController $controller) {
     $this->controller = $controller;
     $this->setViewer($controller->getViewer());
     return $this;
   }
 
   final public function getController() {
     return $this->controller;
   }
 
   final public function getEngineKey() {
     return $this->getPhobjectClassConstant('ENGINECONST', 64);
   }
 
   final public function getApplication() {
     $app_class = $this->getEngineApplicationClass();
     return PhabricatorApplication::getByClass($app_class);
   }
 
   final public function addContextParameter($key) {
     $this->contextParameters[] = $key;
     return $this;
   }
 
   public function isEngineConfigurable() {
     return true;
   }
 
   public function isEngineExtensible() {
     return true;
   }
 
   /**
    * Force the engine to edit a particular object.
    */
   public function setTargetObject($target_object) {
     $this->targetObject = $target_object;
     return $this;
   }
 
   public function getTargetObject() {
     return $this->targetObject;
   }
 
 
 /* -(  Managing Fields  )---------------------------------------------------- */
 
 
   abstract public function getEngineApplicationClass();
   abstract protected function buildCustomEditFields($object);
 
   public function getFieldsForConfig(
     PhabricatorEditEngineConfiguration $config) {
 
     $object = $this->newEditableObject();
 
     $this->editEngineConfiguration = $config;
 
     // This is mostly making sure that we fill in default values.
     $this->setIsCreate(true);
 
     return $this->buildEditFields($object);
   }
 
   final protected function buildEditFields($object) {
     $viewer = $this->getViewer();
 
     $fields = $this->buildCustomEditFields($object);
 
     foreach ($fields as $field) {
       $field
         ->setViewer($viewer)
         ->setObject($object);
     }
 
     $fields = mpull($fields, null, 'getKey');
 
     if ($this->isEngineExtensible()) {
       $extensions = PhabricatorEditEngineExtension::getAllEnabledExtensions();
     } else {
       $extensions = array();
     }
 
     foreach ($extensions as $extension) {
       $extension->setViewer($viewer);
 
       if (!$extension->supportsObject($this, $object)) {
         continue;
       }
 
       $extension_fields = $extension->buildCustomEditFields($this, $object);
 
       // TODO: Validate this in more detail with a more tailored error.
       assert_instances_of($extension_fields, 'PhabricatorEditField');
 
       foreach ($extension_fields as $field) {
         $field
           ->setViewer($viewer)
           ->setObject($object);
       }
 
       $extension_fields = mpull($extension_fields, null, 'getKey');
 
       foreach ($extension_fields as $key => $field) {
         $fields[$key] = $field;
       }
     }
 
     $config = $this->getEditEngineConfiguration();
     $fields = $this->willConfigureFields($object, $fields);
     $fields = $config->applyConfigurationToFields($this, $object, $fields);
 
     return $fields;
   }
 
   protected function willConfigureFields($object, array $fields) {
     return $fields;
   }
 
 
 /* -(  Display Text  )------------------------------------------------------- */
 
 
   /**
    * @task text
    */
   abstract public function getEngineName();
 
 
   /**
    * @task text
    */
   abstract protected function getObjectCreateTitleText($object);
 
   /**
    * @task text
    */
   protected function getFormHeaderText($object) {
     $config = $this->getEditEngineConfiguration();
     return $config->getName();
   }
 
   /**
    * @task text
    */
   abstract protected function getObjectEditTitleText($object);
 
 
   /**
    * @task text
    */
   abstract protected function getObjectCreateShortText();
 
 
   /**
    * @task text
    */
   abstract protected function getObjectName();
 
 
   /**
    * @task text
    */
   abstract protected function getObjectEditShortText($object);
 
 
   /**
    * @task text
    */
   protected function getObjectCreateButtonText($object) {
     return $this->getObjectCreateTitleText($object);
   }
 
 
   /**
    * @task text
    */
   protected function getObjectEditButtonText($object) {
     return pht('Save Changes');
   }
 
 
   /**
    * @task text
    */
   protected function getCommentViewSeriousHeaderText($object) {
     return pht('Take Action');
   }
 
 
   /**
    * @task text
    */
   protected function getCommentViewSeriousButtonText($object) {
     return pht('Submit');
   }
 
 
   /**
    * @task text
    */
   protected function getCommentViewHeaderText($object) {
     return $this->getCommentViewSeriousHeaderText($object);
   }
 
 
   /**
    * @task text
    */
   protected function getCommentViewButtonText($object) {
     return $this->getCommentViewSeriousButtonText($object);
   }
 
 
   /**
    * @task text
    */
   protected function getQuickCreateMenuHeaderText() {
     return $this->getObjectCreateShortText();
   }
 
 
   /**
    * Return a human-readable header describing what this engine is used to do,
    * like "Configure Maniphest Task Forms".
    *
    * @return string Human-readable description of the engine.
    * @task text
    */
   abstract public function getSummaryHeader();
 
 
   /**
    * Return a human-readable summary of what this engine is used to do.
    *
    * @return string Human-readable description of the engine.
    * @task text
    */
   abstract public function getSummaryText();
 
 
 
 
 /* -(  Edit Engine Configuration  )------------------------------------------ */
 
 
   protected function supportsEditEngineConfiguration() {
     return true;
   }
 
   final protected function getEditEngineConfiguration() {
     return $this->editEngineConfiguration;
   }
 
   private function newConfigurationQuery() {
     return id(new PhabricatorEditEngineConfigurationQuery())
       ->setViewer($this->getViewer())
       ->withEngineKeys(array($this->getEngineKey()));
   }
 
   private function loadEditEngineConfigurationWithQuery(
     PhabricatorEditEngineConfigurationQuery $query,
     $sort_method) {
 
     if ($sort_method) {
       $results = $query->execute();
       $results = msort($results, $sort_method);
       $result = head($results);
     } else {
       $result = $query->executeOne();
     }
 
     if (!$result) {
       return null;
     }
 
     $this->editEngineConfiguration = $result;
     return $result;
   }
 
   private function loadEditEngineConfigurationWithIdentifier($identifier) {
     $query = $this->newConfigurationQuery()
       ->withIdentifiers(array($identifier));
 
     return $this->loadEditEngineConfigurationWithQuery($query, null);
   }
 
   private function loadDefaultConfiguration() {
     $query = $this->newConfigurationQuery()
       ->withIdentifiers(
         array(
           self::EDITENGINECONFIG_DEFAULT,
         ))
       ->withIgnoreDatabaseConfigurations(true);
 
     return $this->loadEditEngineConfigurationWithQuery($query, null);
   }
 
   private function loadDefaultCreateConfiguration() {
     $query = $this->newConfigurationQuery()
       ->withIsDefault(true)
       ->withIsDisabled(false);
 
     return $this->loadEditEngineConfigurationWithQuery(
       $query,
       'getCreateSortKey');
   }
 
   public function loadDefaultEditConfiguration() {
     $query = $this->newConfigurationQuery()
       ->withIsEdit(true)
       ->withIsDisabled(false);
 
     return $this->loadEditEngineConfigurationWithQuery(
       $query,
       'getEditSortKey');
   }
 
   final public function getBuiltinEngineConfigurations() {
     $configurations = $this->newBuiltinEngineConfigurations();
 
     if (!$configurations) {
       throw new Exception(
         pht(
           'EditEngine ("%s") returned no builtin engine configurations, but '.
           'an edit engine must have at least one configuration.',
           get_class($this)));
     }
 
     assert_instances_of($configurations, 'PhabricatorEditEngineConfiguration');
 
     $has_default = false;
     foreach ($configurations as $config) {
       if ($config->getBuiltinKey() == self::EDITENGINECONFIG_DEFAULT) {
         $has_default = true;
       }
     }
 
     if (!$has_default) {
       $first = head($configurations);
       if (!$first->getBuiltinKey()) {
         $first
           ->setBuiltinKey(self::EDITENGINECONFIG_DEFAULT)
           ->setIsDefault(true)
           ->setIsEdit(true);
 
         if (!strlen($first->getName())) {
           $first->setName($this->getObjectCreateShortText());
         }
     } else {
         throw new Exception(
           pht(
             'EditEngine ("%s") returned builtin engine configurations, '.
             'but none are marked as default and the first configuration has '.
             'a different builtin key already. Mark a builtin as default or '.
             'omit the key from the first configuration',
             get_class($this)));
       }
     }
 
     $builtins = array();
     foreach ($configurations as $key => $config) {
       $builtin_key = $config->getBuiltinKey();
 
       if ($builtin_key === null) {
         throw new Exception(
           pht(
             'EditEngine ("%s") returned builtin engine configurations, '.
             'but one (with key "%s") is missing a builtin key. Provide a '.
             'builtin key for each configuration (you can omit it from the '.
             'first configuration in the list to automatically assign the '.
             'default key).',
             get_class($this),
             $key));
       }
 
       if (isset($builtins[$builtin_key])) {
         throw new Exception(
           pht(
             'EditEngine ("%s") returned builtin engine configurations, '.
             'but at least two specify the same builtin key ("%s"). Engines '.
             'must have unique builtin keys.',
             get_class($this),
             $builtin_key));
       }
 
       $builtins[$builtin_key] = $config;
     }
 
 
     return $builtins;
   }
 
   protected function newBuiltinEngineConfigurations() {
     return array(
       $this->newConfiguration(),
     );
   }
 
   final protected function newConfiguration() {
     return PhabricatorEditEngineConfiguration::initializeNewConfiguration(
       $this->getViewer(),
       $this);
   }
 
 
 /* -(  Managing URIs  )------------------------------------------------------ */
 
 
   /**
    * @task uri
    */
   abstract protected function getObjectViewURI($object);
 
 
   /**
    * @task uri
    */
   protected function getObjectCreateCancelURI($object) {
     return $this->getApplication()->getApplicationURI();
   }
 
 
   /**
    * @task uri
    */
   protected function getEditorURI() {
     return $this->getApplication()->getApplicationURI('edit/');
   }
 
 
   /**
    * @task uri
    */
   protected function getObjectEditCancelURI($object) {
     return $this->getObjectViewURI($object);
   }
 
 
   /**
    * @task uri
    */
   public function getEditURI($object = null, $path = null) {
     $parts = array();
 
     $parts[] = $this->getEditorURI();
 
     if ($object && $object->getID()) {
       $parts[] = $object->getID().'/';
     }
 
     if ($path !== null) {
       $parts[] = $path;
     }
 
     return implode('', $parts);
   }
 
 
 /* -(  Creating and Loading Objects  )--------------------------------------- */
 
 
   /**
    * Initialize a new object for creation.
    *
    * @return object Newly initialized object.
    * @task load
    */
   abstract protected function newEditableObject();
 
 
   /**
    * Build an empty query for objects.
    *
    * @return PhabricatorPolicyAwareQuery Query.
    * @task load
    */
   abstract protected function newObjectQuery();
 
 
   /**
    * Test if this workflow is creating a new object or editing an existing one.
    *
    * @return bool True if a new object is being created.
    * @task load
    */
   final public function getIsCreate() {
     return $this->isCreate;
   }
 
 
   /**
    * Flag this workflow as a create or edit.
    *
    * @param bool True if this is a create workflow.
    * @return this
    * @task load
    */
   private function setIsCreate($is_create) {
     $this->isCreate = $is_create;
     return $this;
   }
 
 
   /**
    * Try to load an object by ID, PHID, or monogram. This is done primarily
    * to make Conduit a little easier to use.
    *
    * @param wild ID, PHID, or monogram.
    * @param list<const> List of required capability constants, or omit for
    *   defaults.
    * @return object Corresponding editable object.
    * @task load
    */
   private function newObjectFromIdentifier(
     $identifier,
     array $capabilities = array()) {
     if (is_int($identifier) || ctype_digit($identifier)) {
       $object = $this->newObjectFromID($identifier, $capabilities);
 
       if (!$object) {
         throw new Exception(
           pht(
             'No object exists with ID "%s".',
             $identifier));
       }
 
       return $object;
     }
 
     $type_unknown = PhabricatorPHIDConstants::PHID_TYPE_UNKNOWN;
     if (phid_get_type($identifier) != $type_unknown) {
       $object = $this->newObjectFromPHID($identifier, $capabilities);
 
       if (!$object) {
         throw new Exception(
           pht(
             'No object exists with PHID "%s".',
             $identifier));
       }
 
       return $object;
     }
 
     $target = id(new PhabricatorObjectQuery())
       ->setViewer($this->getViewer())
       ->withNames(array($identifier))
       ->executeOne();
     if (!$target) {
       throw new Exception(
         pht(
           'Monogram "%s" does not identify a valid object.',
           $identifier));
     }
 
     $expect = $this->newEditableObject();
     $expect_class = get_class($expect);
     $target_class = get_class($target);
     if ($expect_class !== $target_class) {
       throw new Exception(
         pht(
           'Monogram "%s" identifies an object of the wrong type. Loaded '.
           'object has class "%s", but this editor operates on objects of '.
           'type "%s".',
           $identifier,
           $target_class,
           $expect_class));
     }
 
     // Load the object by PHID using this engine's standard query. This makes
     // sure it's really valid, goes through standard policy check logic, and
     // picks up any `need...()` clauses we want it to load with.
 
     $object = $this->newObjectFromPHID($target->getPHID(), $capabilities);
     if (!$object) {
       throw new Exception(
         pht(
           'Failed to reload object identified by monogram "%s" when '.
           'querying by PHID.',
           $identifier));
     }
 
     return $object;
   }
 
   /**
    * Load an object by ID.
    *
    * @param int Object ID.
    * @param list<const> List of required capability constants, or omit for
    *   defaults.
    * @return object|null Object, or null if no such object exists.
    * @task load
    */
   private function newObjectFromID($id, array $capabilities = array()) {
     $query = $this->newObjectQuery()
       ->withIDs(array($id));
 
     return $this->newObjectFromQuery($query, $capabilities);
   }
 
 
   /**
    * Load an object by PHID.
    *
    * @param phid Object PHID.
    * @param list<const> List of required capability constants, or omit for
    *   defaults.
    * @return object|null Object, or null if no such object exists.
    * @task load
    */
   private function newObjectFromPHID($phid, array $capabilities = array()) {
     $query = $this->newObjectQuery()
       ->withPHIDs(array($phid));
 
     return $this->newObjectFromQuery($query, $capabilities);
   }
 
 
   /**
    * Load an object given a configured query.
    *
    * @param PhabricatorPolicyAwareQuery Configured query.
    * @param list<const> List of required capabilitiy constants, or omit for
    *  defaults.
    * @return object|null Object, or null if no such object exists.
    * @task load
    */
   private function newObjectFromQuery(
     PhabricatorPolicyAwareQuery $query,
     array $capabilities = array()) {
 
     $viewer = $this->getViewer();
 
     if (!$capabilities) {
       $capabilities = array(
         PhabricatorPolicyCapability::CAN_VIEW,
         PhabricatorPolicyCapability::CAN_EDIT,
       );
     }
 
     $object = $query
       ->setViewer($viewer)
       ->requireCapabilities($capabilities)
       ->executeOne();
     if (!$object) {
       return null;
     }
 
     return $object;
   }
 
 
   /**
    * Verify that an object is appropriate for editing.
    *
    * @param wild Loaded value.
    * @return void
    * @task load
    */
   private function validateObject($object) {
     if (!$object || !is_object($object)) {
       throw new Exception(
         pht(
           'EditEngine "%s" created or loaded an invalid object: object must '.
           'actually be an object, but is of some other type ("%s").',
           get_class($this),
           gettype($object)));
     }
 
     if (!($object instanceof PhabricatorApplicationTransactionInterface)) {
       throw new Exception(
         pht(
           'EditEngine "%s" created or loaded an invalid object: object (of '.
           'class "%s") must implement "%s", but does not.',
           get_class($this),
           get_class($object),
           'PhabricatorApplicationTransactionInterface'));
     }
   }
 
 
 /* -(  Responding to Web Requests  )----------------------------------------- */
 
 
   final public function buildResponse() {
     $viewer = $this->getViewer();
     $controller = $this->getController();
     $request = $controller->getRequest();
 
     $action = $request->getURIData('editAction');
 
     $capabilities = array();
     $use_default = false;
     $require_create = true;
     switch ($action) {
       case 'comment':
         $capabilities = array(
           PhabricatorPolicyCapability::CAN_VIEW,
         );
         $use_default = true;
         break;
       case 'parameters':
         $use_default = true;
         break;
       case 'nodefault':
       case 'nocreate':
       case 'nomanage':
         $require_create = false;
         break;
       default:
         break;
     }
 
     $object = $this->getTargetObject();
     if (!$object) {
       $id = $request->getURIData('id');
 
       if ($id) {
         $this->setIsCreate(false);
         $object = $this->newObjectFromID($id, $capabilities);
         if (!$object) {
           return new Aphront404Response();
         }
       } else {
         // Make sure the viewer has permission to create new objects of
         // this type if we're going to create a new object.
         if ($require_create) {
           $this->requireCreateCapability();
         }
 
         $this->setIsCreate(true);
         $object = $this->newEditableObject();
       }
     } else {
       $id = $object->getID();
     }
 
     $this->validateObject($object);
 
     if ($use_default) {
       $config = $this->loadDefaultConfiguration();
       if (!$config) {
         return new Aphront404Response();
       }
     } else {
       $form_key = $request->getURIData('formKey');
       if (strlen($form_key)) {
         $config = $this->loadEditEngineConfigurationWithIdentifier($form_key);
 
         if (!$config) {
           return new Aphront404Response();
         }
 
         if ($id && !$config->getIsEdit()) {
           return $this->buildNotEditFormRespose($object, $config);
         }
       } else {
         if ($id) {
           $config = $this->loadDefaultEditConfiguration();
           if (!$config) {
             return $this->buildNoEditResponse($object);
           }
         } else {
           $config = $this->loadDefaultCreateConfiguration();
           if (!$config) {
             return $this->buildNoCreateResponse($object);
           }
         }
       }
     }
 
     if ($config->getIsDisabled()) {
       return $this->buildDisabledFormResponse($object, $config);
     }
 
     switch ($action) {
       case 'parameters':
         return $this->buildParametersResponse($object);
       case 'nodefault':
         return $this->buildNoDefaultResponse($object);
       case 'nocreate':
         return $this->buildNoCreateResponse($object);
       case 'nomanage':
         return $this->buildNoManageResponse($object);
       case 'comment':
         return $this->buildCommentResponse($object);
       default:
         return $this->buildEditResponse($object);
     }
   }
 
   private function buildCrumbs($object, $final = false) {
     $controller = $this->getController();
 
     $crumbs = $controller->buildApplicationCrumbsForEditEngine();
     if ($this->getIsCreate()) {
       $create_text = $this->getObjectCreateShortText();
       if ($final) {
         $crumbs->addTextCrumb($create_text);
       } else {
         $edit_uri = $this->getEditURI($object);
         $crumbs->addTextCrumb($create_text, $edit_uri);
       }
     } else {
       $crumbs->addTextCrumb(
         $this->getObjectEditShortText($object),
         $this->getObjectViewURI($object));
 
       $edit_text = pht('Edit');
       if ($final) {
         $crumbs->addTextCrumb($edit_text);
       } else {
         $edit_uri = $this->getEditURI($object);
         $crumbs->addTextCrumb($edit_text, $edit_uri);
       }
     }
 
     return $crumbs;
   }
 
   private function buildEditResponse($object) {
     $viewer = $this->getViewer();
     $controller = $this->getController();
     $request = $controller->getRequest();
 
     $fields = $this->buildEditFields($object);
     $template = $object->getApplicationTransactionTemplate();
 
     $validation_exception = null;
     if ($request->isFormPost() && $request->getBool('editEngine')) {
       $submit_fields = $fields;
 
       foreach ($submit_fields as $key => $field) {
         if (!$field->shouldGenerateTransactionsFromSubmit()) {
           unset($submit_fields[$key]);
           continue;
         }
       }
 
       // Before we read the submitted values, store a copy of what we would
       // use if the form was empty so we can figure out which transactions are
       // just setting things to their default values for the current form.
       $defaults = array();
       foreach ($submit_fields as $key => $field) {
         $defaults[$key] = $field->getValueForTransaction();
       }
 
       foreach ($submit_fields as $key => $field) {
         $field->setIsSubmittedForm(true);
 
         if (!$field->shouldReadValueFromSubmit()) {
           continue;
         }
 
         $field->readValueFromSubmit($request);
       }
 
       $xactions = array();
 
       if ($this->getIsCreate()) {
         $xactions[] = id(clone $template)
           ->setTransactionType(PhabricatorTransactions::TYPE_CREATE);
       }
 
       foreach ($submit_fields as $key => $field) {
         $field_value = $field->getValueForTransaction();
 
         $type_xactions = $field->generateTransactions(
           clone $template,
           array(
             'value' => $field_value,
           ));
 
         foreach ($type_xactions as $type_xaction) {
           $default = $defaults[$key];
 
           if ($default === $field->getValueForTransaction()) {
             $type_xaction->setIsDefaultTransaction(true);
           }
 
           $xactions[] = $type_xaction;
         }
       }
 
       $editor = $object->getApplicationTransactionEditor()
         ->setActor($viewer)
         ->setContentSourceFromRequest($request)
         ->setContinueOnNoEffect(true);
 
       try {
 
         $editor->applyTransactions($object, $xactions);
 
         return $this->newEditResponse($request, $object, $xactions);
       } catch (PhabricatorApplicationTransactionValidationException $ex) {
         $validation_exception = $ex;
 
         foreach ($fields as $field) {
           $xaction_type = $field->getTransactionType();
           if ($xaction_type === null) {
             continue;
           }
 
           $message = $ex->getShortMessage($xaction_type);
           if ($message === null) {
             continue;
           }
 
           $field->setControlError($message);
         }
       }
     } else {
       if ($this->getIsCreate()) {
         $template = $request->getStr('template');
 
         if (strlen($template)) {
           $template_object = $this->newObjectFromIdentifier(
             $template,
             array(
               PhabricatorPolicyCapability::CAN_VIEW,
             ));
           if (!$template_object) {
             return new Aphront404Response();
           }
         } else {
           $template_object = null;
         }
 
         if ($template_object) {
           $copy_fields = $this->buildEditFields($template_object);
           $copy_fields = mpull($copy_fields, null, 'getKey');
           foreach ($copy_fields as $copy_key => $copy_field) {
             if (!$copy_field->getIsCopyable()) {
               unset($copy_fields[$copy_key]);
             }
           }
         } else {
           $copy_fields = array();
         }
 
         foreach ($fields as $field) {
           if (!$field->shouldReadValueFromRequest()) {
             continue;
           }
 
           $field_key = $field->getKey();
           if (isset($copy_fields[$field_key])) {
             $field->readValueFromField($copy_fields[$field_key]);
           }
 
           $field->readValueFromRequest($request);
         }
       }
     }
 
     $action_button = $this->buildEditFormActionButton($object);
 
     if ($this->getIsCreate()) {
       $header_text = $this->getFormHeaderText($object);
       $header_icon = 'fa-plus-square';
     } else {
       $header_text = $this->getObjectEditTitleText($object);
       $header_icon = 'fa-pencil';
     }
 
     $show_preview = !$request->isAjax();
 
     if ($show_preview) {
       $previews = array();
       foreach ($fields as $field) {
         $preview = $field->getPreviewPanel();
         if (!$preview) {
           continue;
         }
 
         $control_id = $field->getControlID();
 
         $preview
           ->setControlID($control_id)
           ->setPreviewURI('/transactions/remarkuppreview/');
 
         $previews[] = $preview;
       }
     } else {
       $previews = array();
     }
 
     $form = $this->buildEditForm($object, $fields);
 
     if ($request->isAjax()) {
       if ($this->getIsCreate()) {
         $cancel_uri = $this->getObjectCreateCancelURI($object);
         $submit_button = $this->getObjectCreateButtonText($object);
       } else {
         $cancel_uri = $this->getObjectEditCancelURI($object);
         $submit_button = $this->getObjectEditButtonText($object);
       }
 
       return $this->getController()
         ->newDialog()
         ->setWidth(AphrontDialogView::WIDTH_FULL)
         ->setTitle($header_text)
         ->setValidationException($validation_exception)
         ->appendForm($form)
         ->addCancelButton($cancel_uri)
         ->addSubmitButton($submit_button);
     }
 
     $header = id(new PHUIHeaderView())
       ->setHeader($header_text)
       ->setHeaderIcon($header_icon);
 
     if ($action_button) {
       $header->addActionLink($action_button);
     }
 
     $crumbs = $this->buildCrumbs($object, $final = true);
     $crumbs->setBorder(true);
 
     $box = id(new PHUIObjectBoxView())
       ->setUser($viewer)
       ->setHeaderText($this->getObjectName())
       ->setValidationException($validation_exception)
       ->setBackground(PHUIObjectBoxView::BLUE_PROPERTY)
       ->appendChild($form);
 
     $view = id(new PHUITwoColumnView())
       ->setHeader($header)
       ->setFooter(array(
         $box,
         $previews,
       ));
 
     return $controller->newPage()
       ->setTitle($header_text)
       ->setCrumbs($crumbs)
       ->appendChild($view);
   }
 
   protected function newEditResponse(
     AphrontRequest $request,
     $object,
     array $xactions) {
     return id(new AphrontRedirectResponse())
       ->setURI($this->getObjectViewURI($object));
   }
 
   private function buildEditForm($object, array $fields) {
     $viewer = $this->getViewer();
     $controller = $this->getController();
     $request = $controller->getRequest();
 
     $form = id(new AphrontFormView())
       ->setUser($viewer)
       ->addHiddenInput('editEngine', 'true');
 
     foreach ($this->contextParameters as $param) {
       $form->addHiddenInput($param, $request->getStr($param));
     }
 
     foreach ($fields as $field) {
       $field->appendToForm($form);
     }
 
     if ($this->getIsCreate()) {
       $cancel_uri = $this->getObjectCreateCancelURI($object);
       $submit_button = $this->getObjectCreateButtonText($object);
     } else {
       $cancel_uri = $this->getObjectEditCancelURI($object);
       $submit_button = $this->getObjectEditButtonText($object);
     }
 
     if (!$request->isAjax()) {
       $form->appendControl(
         id(new AphrontFormSubmitControl())
           ->addCancelButton($cancel_uri)
           ->setValue($submit_button));
     }
 
     return $form;
   }
 
   private function buildEditFormActionButton($object) {
     if (!$this->isEngineConfigurable()) {
       return null;
     }
 
     $viewer = $this->getViewer();
 
     $action_view = id(new PhabricatorActionListView())
       ->setUser($viewer);
 
     foreach ($this->buildEditFormActions($object) as $action) {
       $action_view->addAction($action);
     }
 
     $action_button = id(new PHUIButtonView())
       ->setTag('a')
       ->setText(pht('Configure Form'))
       ->setHref('#')
       ->setIcon('fa-gear')
       ->setDropdownMenu($action_view);
 
     return $action_button;
   }
 
   private function buildEditFormActions($object) {
     $actions = array();
 
     if ($this->supportsEditEngineConfiguration()) {
       $engine_key = $this->getEngineKey();
       $config = $this->getEditEngineConfiguration();
 
       $can_manage = PhabricatorPolicyFilter::hasCapability(
         $this->getViewer(),
         $config,
         PhabricatorPolicyCapability::CAN_EDIT);
 
       if ($can_manage) {
         $manage_uri = $config->getURI();
       } else {
         $manage_uri = $this->getEditURI(null, 'nomanage/');
       }
 
       $view_uri = "/transactions/editengine/{$engine_key}/";
 
       $actions[] = id(new PhabricatorActionView())
         ->setLabel(true)
         ->setName(pht('Configuration'));
 
       $actions[] = id(new PhabricatorActionView())
         ->setName(pht('View Form Configurations'))
         ->setIcon('fa-list-ul')
         ->setHref($view_uri);
 
       $actions[] = id(new PhabricatorActionView())
         ->setName(pht('Edit Form Configuration'))
         ->setIcon('fa-pencil')
         ->setHref($manage_uri)
         ->setDisabled(!$can_manage)
         ->setWorkflow(!$can_manage);
     }
 
     $actions[] = id(new PhabricatorActionView())
       ->setLabel(true)
       ->setName(pht('Documentation'));
 
     $actions[] = id(new PhabricatorActionView())
       ->setName(pht('Using HTTP Parameters'))
       ->setIcon('fa-book')
       ->setHref($this->getEditURI($object, 'parameters/'));
 
     $doc_href = PhabricatorEnv::getDoclink('User Guide: Customizing Forms');
     $actions[] = id(new PhabricatorActionView())
       ->setName(pht('User Guide: Customizing Forms'))
       ->setIcon('fa-book')
       ->setHref($doc_href);
 
     return $actions;
   }
 
 
   /**
    * Test if the viewer could apply a certain type of change by using the
    * normal "Edit" form.
    *
    * This method returns `true` if the user has access to an edit form and
    * that edit form has a field which applied the specified transaction type,
    * and that field is visible and editable for the user.
    *
    * For example, you can use it to test if a user is able to reassign tasks
    * or not, prior to rendering dedicated UI for task reassingment.
    *
    * Note that this method does NOT test if the user can actually edit the
    * current object, just if they have access to the related field.
    *
    * @param const Transaction type to test for.
    * @return bool True if the user could "Edit" to apply the transaction type.
    */
   final public function hasEditAccessToTransaction($xaction_type) {
     $viewer = $this->getViewer();
 
     $config = $this->loadDefaultEditConfiguration();
     if (!$config) {
       return false;
     }
 
     $object = $this->getTargetObject();
     if (!$object) {
       $object = $this->newEditableObject();
     }
 
     $fields = $this->buildEditFields($object);
 
     $field = null;
     foreach ($fields as $form_field) {
       $field_xaction_type = $form_field->getTransactionType();
       if ($field_xaction_type === $xaction_type) {
         $field = $form_field;
         break;
       }
     }
 
     if (!$field) {
       return false;
     }
 
     if (!$field->shouldReadValueFromSubmit()) {
       return false;
     }
 
     return true;
   }
 
 
   final public function addActionToCrumbs(PHUICrumbsView $crumbs) {
     $viewer = $this->getViewer();
 
     $can_create = $this->hasCreateCapability();
     if ($can_create) {
       $configs = $this->loadUsableConfigurationsForCreate();
     } else {
       $configs = array();
     }
 
     $dropdown = null;
     $disabled = false;
     $workflow = false;
 
     $menu_icon = 'fa-plus-square';
 
     if (!$configs) {
       if ($viewer->isLoggedIn()) {
         $disabled = true;
       } else {
         // If the viewer isn't logged in, assume they'll get hit with a login
         // dialog and are likely able to create objects after they log in.
         $disabled = false;
       }
       $workflow = true;
 
       if ($can_create) {
         $create_uri = $this->getEditURI(null, 'nodefault/');
       } else {
         $create_uri = $this->getEditURI(null, 'nocreate/');
       }
     } else {
       $config = head($configs);
       $form_key = $config->getIdentifier();
       $create_uri = $this->getEditURI(null, "form/{$form_key}/");
 
       if (count($configs) > 1) {
         $menu_icon = 'fa-caret-square-o-down';
 
         $dropdown = id(new PhabricatorActionListView())
           ->setUser($viewer);
 
         foreach ($configs as $config) {
           $form_key = $config->getIdentifier();
           $config_uri = $this->getEditURI(null, "form/{$form_key}/");
 
           $item_icon = 'fa-plus';
 
           $dropdown->addAction(
             id(new PhabricatorActionView())
               ->setName($config->getDisplayName())
               ->setIcon($item_icon)
               ->setHref($config_uri));
         }
       }
     }
 
     $action = id(new PHUIListItemView())
       ->setName($this->getObjectCreateShortText())
       ->setHref($create_uri)
       ->setIcon($menu_icon)
       ->setWorkflow($workflow)
       ->setDisabled($disabled);
 
     if ($dropdown) {
       $action->setDropdownMenu($dropdown);
     }
 
     $crumbs->addAction($action);
   }
 
   final public function buildEditEngineCommentView($object) {
     $config = $this->loadDefaultEditConfiguration();
 
     if (!$config) {
       // TODO: This just nukes the entire comment form if you don't have access
       // to any edit forms. We might want to tailor this UX a bit.
       return id(new PhabricatorApplicationTransactionCommentView())
         ->setNoPermission(true);
     }
 
     $viewer = $this->getViewer();
     $object_phid = $object->getPHID();
 
     $is_serious = PhabricatorEnv::getEnvConfig('phabricator.serious-business');
 
     if ($is_serious) {
       $header_text = $this->getCommentViewSeriousHeaderText($object);
       $button_text = $this->getCommentViewSeriousButtonText($object);
     } else {
       $header_text = $this->getCommentViewHeaderText($object);
       $button_text = $this->getCommentViewButtonText($object);
     }
 
     $comment_uri = $this->getEditURI($object, 'comment/');
 
     $view = id(new PhabricatorApplicationTransactionCommentView())
       ->setUser($viewer)
       ->setObjectPHID($object_phid)
       ->setHeaderText($header_text)
       ->setAction($comment_uri)
       ->setSubmitButtonName($button_text);
 
     $draft = PhabricatorVersionedDraft::loadDraft(
       $object_phid,
       $viewer->getPHID());
     if ($draft) {
       $view->setVersionedDraft($draft);
     }
 
     $view->setCurrentVersion($this->loadDraftVersion($object));
 
     $fields = $this->buildEditFields($object);
 
     $comment_actions = array();
     foreach ($fields as $field) {
       if (!$field->shouldGenerateTransactionsFromComment()) {
         continue;
       }
 
       $comment_action = $field->getCommentAction();
       if (!$comment_action) {
         continue;
       }
 
       $key = $comment_action->getKey();
 
       // TODO: Validate these better.
 
       $comment_actions[$key] = $comment_action;
     }
 
+    $comment_actions = msortv($comment_actions, 'getSortVector');
+
     $view->setCommentActions($comment_actions);
 
     return $view;
   }
 
   protected function loadDraftVersion($object) {
     $viewer = $this->getViewer();
 
     if (!$viewer->isLoggedIn()) {
       return null;
     }
 
     $template = $object->getApplicationTransactionTemplate();
     $conn_r = $template->establishConnection('r');
 
     // Find the most recent transaction the user has written. We'll use this
     // as a version number to make sure that out-of-date drafts get discarded.
     $result = queryfx_one(
       $conn_r,
       'SELECT id AS version FROM %T
         WHERE objectPHID = %s AND authorPHID = %s
         ORDER BY id DESC LIMIT 1',
       $template->getTableName(),
       $object->getPHID(),
       $viewer->getPHID());
 
     if ($result) {
       return (int)$result['version'];
     } else {
       return null;
     }
   }
 
 
 /* -(  Responding to HTTP Parameter Requests  )------------------------------ */
 
 
   /**
    * Respond to a request for documentation on HTTP parameters.
    *
    * @param object Editable object.
    * @return AphrontResponse Response object.
    * @task http
    */
   private function buildParametersResponse($object) {
     $controller = $this->getController();
     $viewer = $this->getViewer();
     $request = $controller->getRequest();
     $fields = $this->buildEditFields($object);
 
     $crumbs = $this->buildCrumbs($object);
     $crumbs->addTextCrumb(pht('HTTP Parameters'));
     $crumbs->setBorder(true);
 
     $header_text = pht(
       'HTTP Parameters: %s',
       $this->getObjectCreateShortText());
 
     $header = id(new PHUIHeaderView())
       ->setHeader($header_text);
 
     $help_view = id(new PhabricatorApplicationEditHTTPParameterHelpView())
       ->setUser($viewer)
       ->setFields($fields);
 
     $document = id(new PHUIDocumentViewPro())
       ->setUser($viewer)
       ->setHeader($header)
       ->appendChild($help_view);
 
     return $controller->newPage()
       ->setTitle(pht('HTTP Parameters'))
       ->setCrumbs($crumbs)
       ->appendChild($document);
   }
 
 
   private function buildError($object, $title, $body) {
     $cancel_uri = $this->getObjectCreateCancelURI($object);
 
     return $this->getController()
       ->newDialog()
       ->setTitle($title)
       ->appendParagraph($body)
       ->addCancelButton($cancel_uri);
   }
 
 
   private function buildNoDefaultResponse($object) {
     return $this->buildError(
       $object,
       pht('No Default Create Forms'),
       pht(
         'This application is not configured with any forms for creating '.
         'objects that are visible to you and enabled.'));
   }
 
   private function buildNoCreateResponse($object) {
     return $this->buildError(
       $object,
       pht('No Create Permission'),
       pht('You do not have permission to create these objects.'));
   }
 
   private function buildNoManageResponse($object) {
     return $this->buildError(
       $object,
       pht('No Manage Permission'),
       pht(
         'You do not have permission to configure forms for this '.
         'application.'));
   }
 
   private function buildNoEditResponse($object) {
     return $this->buildError(
       $object,
       pht('No Edit Forms'),
       pht(
         'You do not have access to any forms which are enabled and marked '.
         'as edit forms.'));
   }
 
   private function buildNotEditFormRespose($object, $config) {
     return $this->buildError(
       $object,
       pht('Not an Edit Form'),
       pht(
         'This form ("%s") is not marked as an edit form, so '.
         'it can not be used to edit objects.',
         $config->getName()));
   }
 
   private function buildDisabledFormResponse($object, $config) {
     return $this->buildError(
       $object,
       pht('Form Disabled'),
       pht(
         'This form ("%s") has been disabled, so it can not be used.',
         $config->getName()));
   }
 
   private function buildCommentResponse($object) {
     $viewer = $this->getViewer();
 
     if ($this->getIsCreate()) {
       return new Aphront404Response();
     }
 
     $controller = $this->getController();
     $request = $controller->getRequest();
 
     if (!$request->isFormPost()) {
       return new Aphront400Response();
     }
 
     $config = $this->loadDefaultEditConfiguration();
     if (!$config) {
       return new Aphront404Response();
     }
 
     $fields = $this->buildEditFields($object);
 
     $is_preview = $request->isPreviewRequest();
     $view_uri = $this->getObjectViewURI($object);
 
     $template = $object->getApplicationTransactionTemplate();
     $comment_template = $template->getApplicationTransactionCommentObject();
 
     $comment_text = $request->getStr('comment');
 
     $actions = $request->getStr('editengine.actions');
     if ($actions) {
       $actions = phutil_json_decode($actions);
     }
 
     if ($is_preview) {
       $version_key = PhabricatorVersionedDraft::KEY_VERSION;
       $request_version = $request->getInt($version_key);
       $current_version = $this->loadDraftVersion($object);
       if ($request_version >= $current_version) {
         $draft = PhabricatorVersionedDraft::loadOrCreateDraft(
           $object->getPHID(),
           $viewer->getPHID(),
           $current_version);
 
         $draft
           ->setProperty('comment', $comment_text)
           ->setProperty('actions', $actions)
           ->save();
       }
     }
 
     $xactions = array();
 
     if ($actions) {
       $action_map = array();
       foreach ($actions as $action) {
         $type = idx($action, 'type');
         if (!$type) {
           continue;
         }
 
         if (empty($fields[$type])) {
           continue;
         }
 
         $action_map[$type] = $action;
       }
 
       foreach ($action_map as $type => $action) {
         $field = $fields[$type];
 
         if (!$field->shouldGenerateTransactionsFromComment()) {
           continue;
         }
 
         if (array_key_exists('initialValue', $action)) {
           $field->setInitialValue($action['initialValue']);
         }
 
         $field->readValueFromComment(idx($action, 'value'));
 
         $type_xactions = $field->generateTransactions(
           clone $template,
           array(
             'value' => $field->getValueForTransaction(),
           ));
         foreach ($type_xactions as $type_xaction) {
           $xactions[] = $type_xaction;
         }
       }
     }
 
     if (strlen($comment_text) || !$xactions) {
       $xactions[] = id(clone $template)
         ->setTransactionType(PhabricatorTransactions::TYPE_COMMENT)
         ->attachComment(
           id(clone $comment_template)
             ->setContent($comment_text));
     }
 
     $editor = $object->getApplicationTransactionEditor()
       ->setActor($viewer)
       ->setContinueOnNoEffect($request->isContinueRequest())
       ->setContinueOnMissingFields(true)
       ->setContentSourceFromRequest($request)
       ->setIsPreview($is_preview);
 
     try {
       $xactions = $editor->applyTransactions($object, $xactions);
     } catch (PhabricatorApplicationTransactionNoEffectException $ex) {
       return id(new PhabricatorApplicationTransactionNoEffectResponse())
         ->setCancelURI($view_uri)
         ->setException($ex);
     }
 
     if (!$is_preview) {
       PhabricatorVersionedDraft::purgeDrafts(
         $object->getPHID(),
         $viewer->getPHID(),
         $this->loadDraftVersion($object));
     }
 
     if ($request->isAjax() && $is_preview) {
       return id(new PhabricatorApplicationTransactionResponse())
         ->setViewer($viewer)
         ->setTransactions($xactions)
         ->setIsPreview($is_preview);
     } else {
       return id(new AphrontRedirectResponse())
         ->setURI($view_uri);
     }
   }
 
 
 /* -(  Conduit  )------------------------------------------------------------ */
 
 
   /**
    * Respond to a Conduit edit request.
    *
    * This method accepts a list of transactions to apply to an object, and
    * either edits an existing object or creates a new one.
    *
    * @task conduit
    */
   final public function buildConduitResponse(ConduitAPIRequest $request) {
     $viewer = $this->getViewer();
 
     $config = $this->loadDefaultConfiguration();
     if (!$config) {
       throw new Exception(
         pht(
           'Unable to load configuration for this EditEngine ("%s").',
           get_class($this)));
     }
 
     $identifier = $request->getValue('objectIdentifier');
     if ($identifier) {
       $this->setIsCreate(false);
       $object = $this->newObjectFromIdentifier($identifier);
     } else {
       $this->requireCreateCapability();
 
       $this->setIsCreate(true);
       $object = $this->newEditableObject();
     }
 
     $this->validateObject($object);
 
     $fields = $this->buildEditFields($object);
 
     $types = $this->getConduitEditTypesFromFields($fields);
     $template = $object->getApplicationTransactionTemplate();
 
     $xactions = $this->getConduitTransactions($request, $types, $template);
 
     $editor = $object->getApplicationTransactionEditor()
       ->setActor($viewer)
       ->setContentSource($request->newContentSource())
       ->setContinueOnNoEffect(true);
 
     if (!$this->getIsCreate()) {
       $editor->setContinueOnMissingFields(true);
     }
 
     $xactions = $editor->applyTransactions($object, $xactions);
 
     $xactions_struct = array();
     foreach ($xactions as $xaction) {
       $xactions_struct[] = array(
         'phid' => $xaction->getPHID(),
       );
     }
 
     return array(
       'object' => array(
         'id' => $object->getID(),
         'phid' => $object->getPHID(),
       ),
       'transactions' => $xactions_struct,
     );
   }
 
 
   /**
    * Generate transactions which can be applied from edit actions in a Conduit
    * request.
    *
    * @param ConduitAPIRequest The request.
    * @param list<PhabricatorEditType> Supported edit types.
    * @param PhabricatorApplicationTransaction Template transaction.
    * @return list<PhabricatorApplicationTransaction> Generated transactions.
    * @task conduit
    */
   private function getConduitTransactions(
     ConduitAPIRequest $request,
     array $types,
     PhabricatorApplicationTransaction $template) {
 
     $viewer = $request->getUser();
     $transactions_key = 'transactions';
 
     $xactions = $request->getValue($transactions_key);
     if (!is_array($xactions)) {
       throw new Exception(
         pht(
           'Parameter "%s" is not a list of transactions.',
           $transactions_key));
     }
 
     foreach ($xactions as $key => $xaction) {
       if (!is_array($xaction)) {
         throw new Exception(
           pht(
             'Parameter "%s" must contain a list of transaction descriptions, '.
             'but item with key "%s" is not a dictionary.',
             $transactions_key,
             $key));
       }
 
       if (!array_key_exists('type', $xaction)) {
         throw new Exception(
           pht(
             'Parameter "%s" must contain a list of transaction descriptions, '.
             'but item with key "%s" is missing a "type" field. Each '.
             'transaction must have a type field.',
             $transactions_key,
             $key));
       }
 
       $type = $xaction['type'];
       if (empty($types[$type])) {
         throw new Exception(
           pht(
             'Transaction with key "%s" has invalid type "%s". This type is '.
             'not recognized. Valid types are: %s.',
             $key,
             $type,
             implode(', ', array_keys($types))));
       }
     }
 
     $results = array();
 
     if ($this->getIsCreate()) {
       $results[] = id(clone $template)
         ->setTransactionType(PhabricatorTransactions::TYPE_CREATE);
     }
 
     foreach ($xactions as $xaction) {
       $type = $types[$xaction['type']];
 
       // Let the parameter type interpret the value. This allows you to
       // use usernames in list<user> fields, for example.
       $parameter_type = $type->getConduitParameterType();
 
       $parameter_type->setViewer($viewer);
 
       try {
         $xaction['value'] = $parameter_type->getValue($xaction, 'value');
       } catch (Exception $ex) {
         throw new PhutilProxyException(
           pht(
             'Exception when processing transaction of type "%s".',
             $xaction['type']),
           $ex);
       }
 
       $type_xactions = $type->generateTransactions(
         clone $template,
         $xaction);
 
       foreach ($type_xactions as $type_xaction) {
         $results[] = $type_xaction;
       }
     }
 
     return $results;
   }
 
 
   /**
    * @return map<string, PhabricatorEditType>
    * @task conduit
    */
   private function getConduitEditTypesFromFields(array $fields) {
     $types = array();
     foreach ($fields as $field) {
       $field_types = $field->getConduitEditTypes();
 
       if ($field_types === null) {
         continue;
       }
 
       foreach ($field_types as $field_type) {
         $field_type->setField($field);
         $types[$field_type->getEditType()] = $field_type;
       }
     }
     return $types;
   }
 
   public function getConduitEditTypes() {
     $config = $this->loadDefaultConfiguration();
     if (!$config) {
       return array();
     }
 
     $object = $this->newEditableObject();
     $fields = $this->buildEditFields($object);
     return $this->getConduitEditTypesFromFields($fields);
   }
 
   final public static function getAllEditEngines() {
     return id(new PhutilClassMapQuery())
       ->setAncestorClass(__CLASS__)
       ->setUniqueMethod('getEngineKey')
       ->execute();
   }
 
   final public static function getByKey(PhabricatorUser $viewer, $key) {
     return id(new PhabricatorEditEngineQuery())
       ->setViewer($viewer)
       ->withEngineKeys(array($key))
       ->executeOne();
   }
 
   public function getIcon() {
     $application = $this->getApplication();
     return $application->getIcon();
   }
 
   public function loadQuickCreateItems() {
     $items = array();
 
     if (!$this->hasCreateCapability()) {
       return $items;
     }
 
     $configs = $this->loadUsableConfigurationsForCreate();
 
     if (!$configs) {
       // No items to add.
     } else if (count($configs) == 1) {
       $config = head($configs);
       $items[] = $this->newQuickCreateItem($config);
     } else {
       $group_name = $this->getQuickCreateMenuHeaderText();
 
       $items[] = id(new PHUIListItemView())
         ->setType(PHUIListItemView::TYPE_LABEL)
         ->setName($group_name);
 
       foreach ($configs as $config) {
         $items[] = $this->newQuickCreateItem($config)
           ->setIndented(true);
       }
     }
 
     return $items;
   }
 
   private function loadUsableConfigurationsForCreate() {
     $viewer = $this->getViewer();
 
     $configs = id(new PhabricatorEditEngineConfigurationQuery())
       ->setViewer($viewer)
       ->withEngineKeys(array($this->getEngineKey()))
       ->withIsDefault(true)
       ->withIsDisabled(false)
       ->execute();
 
     $configs = msort($configs, 'getCreateSortKey');
 
     return $configs;
   }
 
   private function newQuickCreateItem(
     PhabricatorEditEngineConfiguration $config) {
 
     $item_name = $config->getName();
     $item_icon = $config->getIcon();
     $form_key = $config->getIdentifier();
     $item_uri = $this->getEditURI(null, "form/{$form_key}/");
 
     return id(new PHUIListItemView())
       ->setName($item_name)
       ->setIcon($item_icon)
       ->setHref($item_uri);
   }
 
   protected function getCreateNewObjectPolicy() {
     return PhabricatorPolicies::POLICY_USER;
   }
 
   private function requireCreateCapability() {
     PhabricatorPolicyFilter::requireCapability(
       $this->getViewer(),
       $this,
       PhabricatorPolicyCapability::CAN_EDIT);
   }
 
   private function hasCreateCapability() {
     return PhabricatorPolicyFilter::hasCapability(
       $this->getViewer(),
       $this,
       PhabricatorPolicyCapability::CAN_EDIT);
   }
 
 
 /* -(  PhabricatorPolicyInterface  )----------------------------------------- */
 
 
   public function getPHID() {
     return get_class($this);
   }
 
   public function getCapabilities() {
     return array(
       PhabricatorPolicyCapability::CAN_VIEW,
       PhabricatorPolicyCapability::CAN_EDIT,
     );
   }
 
   public function getPolicy($capability) {
     switch ($capability) {
       case PhabricatorPolicyCapability::CAN_VIEW:
         return PhabricatorPolicies::getMostOpenPolicy();
       case PhabricatorPolicyCapability::CAN_EDIT:
         return $this->getCreateNewObjectPolicy();
     }
   }
 
   public function hasAutomaticCapability($capability, PhabricatorUser $viewer) {
     return false;
   }
 
   public function describeAutomaticCapability($capability) {
     return null;
   }
 }
diff --git a/src/applications/transactions/editfield/PhabricatorEditField.php b/src/applications/transactions/editfield/PhabricatorEditField.php
index 1216370819..3b4c4e264b 100644
--- a/src/applications/transactions/editfield/PhabricatorEditField.php
+++ b/src/applications/transactions/editfield/PhabricatorEditField.php
@@ -1,780 +1,791 @@
 <?php
 
 abstract class PhabricatorEditField extends Phobject {
 
   private $key;
   private $viewer;
   private $label;
   private $aliases = array();
   private $value;
   private $initialValue;
   private $hasValue = false;
   private $object;
   private $transactionType;
   private $metadata = array();
   private $editTypeKey;
   private $isRequired;
   private $previewPanel;
   private $controlID;
 
   private $description;
   private $conduitDescription;
   private $conduitDocumentation;
   private $conduitTypeDescription;
 
   private $commentActionLabel;
   private $commentActionValue;
+  private $commentActionOrder = 1000;
   private $hasCommentActionValue;
 
   private $isLocked;
   private $isHidden;
 
   private $isPreview;
   private $isEditDefaults;
   private $isSubmittedForm;
   private $controlError;
 
   private $isReorderable = true;
   private $isDefaultable = true;
   private $isLockable = true;
   private $isCopyable = false;
   private $isConduitOnly = false;
 
   private $conduitEditTypes;
 
   public function setKey($key) {
     $this->key = $key;
     return $this;
   }
 
   public function getKey() {
     return $this->key;
   }
 
   public function setLabel($label) {
     $this->label = $label;
     return $this;
   }
 
   public function getLabel() {
     return $this->label;
   }
 
   public function setViewer(PhabricatorUser $viewer) {
     $this->viewer = $viewer;
     return $this;
   }
 
   public function getViewer() {
     return $this->viewer;
   }
 
   public function setAliases(array $aliases) {
     $this->aliases = $aliases;
     return $this;
   }
 
   public function getAliases() {
     return $this->aliases;
   }
 
   public function setObject($object) {
     $this->object = $object;
     return $this;
   }
 
   public function getObject() {
     return $this->object;
   }
 
   public function setIsLocked($is_locked) {
     $this->isLocked = $is_locked;
     return $this;
   }
 
   public function getIsLocked() {
     return $this->isLocked;
   }
 
   public function setIsPreview($preview) {
     $this->isPreview = $preview;
     return $this;
   }
 
   public function getIsPreview() {
     return $this->isPreview;
   }
 
   public function setIsReorderable($is_reorderable) {
     $this->isReorderable = $is_reorderable;
     return $this;
   }
 
   public function getIsReorderable() {
     return $this->isReorderable;
   }
 
   public function setIsConduitOnly($is_conduit_only) {
     $this->isConduitOnly = $is_conduit_only;
     return $this;
   }
 
   public function getIsConduitOnly() {
     return $this->isConduitOnly;
   }
 
   public function setDescription($description) {
     $this->description = $description;
     return $this;
   }
 
   public function getDescription() {
     return $this->description;
   }
 
   public function setConduitDescription($conduit_description) {
     $this->conduitDescription = $conduit_description;
     return $this;
   }
 
   public function getConduitDescription() {
     if ($this->conduitDescription === null) {
       return $this->getDescription();
     }
     return $this->conduitDescription;
   }
 
   public function setConduitDocumentation($conduit_documentation) {
     $this->conduitDocumentation = $conduit_documentation;
     return $this;
   }
 
   public function getConduitDocumentation() {
     return $this->conduitDocumentation;
   }
 
   public function setConduitTypeDescription($conduit_type_description) {
     $this->conduitTypeDescription = $conduit_type_description;
     return $this;
   }
 
   public function getConduitTypeDescription() {
     return $this->conduitTypeDescription;
   }
 
   public function setIsEditDefaults($is_edit_defaults) {
     $this->isEditDefaults = $is_edit_defaults;
     return $this;
   }
 
   public function getIsEditDefaults() {
     return $this->isEditDefaults;
   }
 
   public function setIsDefaultable($is_defaultable) {
     $this->isDefaultable = $is_defaultable;
     return $this;
   }
 
   public function getIsDefaultable() {
     return $this->isDefaultable;
   }
 
   public function setIsLockable($is_lockable) {
     $this->isLockable = $is_lockable;
     return $this;
   }
 
   public function getIsLockable() {
     return $this->isLockable;
   }
 
   public function setIsHidden($is_hidden) {
     $this->isHidden = $is_hidden;
     return $this;
   }
 
   public function getIsHidden() {
     return $this->isHidden;
   }
 
   public function setIsCopyable($is_copyable) {
     $this->isCopyable = $is_copyable;
     return $this;
   }
 
   public function getIsCopyable() {
     return $this->isCopyable;
   }
 
   public function setIsSubmittedForm($is_submitted) {
     $this->isSubmittedForm = $is_submitted;
     return $this;
   }
 
   public function getIsSubmittedForm() {
     return $this->isSubmittedForm;
   }
 
   public function setIsRequired($is_required) {
     $this->isRequired = $is_required;
     return $this;
   }
 
   public function getIsRequired() {
     return $this->isRequired;
   }
 
   public function setControlError($control_error) {
     $this->controlError = $control_error;
     return $this;
   }
 
   public function getControlError() {
     return $this->controlError;
   }
 
   public function setCommentActionLabel($label) {
     $this->commentActionLabel = $label;
     return $this;
   }
 
   public function getCommentActionLabel() {
     return $this->commentActionLabel;
   }
 
+  public function setCommentActionOrder($order) {
+    $this->commentActionOrder = $order;
+    return $this;
+  }
+
+  public function getCommentActionOrder() {
+    return $this->commentActionOrder;
+  }
+
   public function setCommentActionValue($comment_action_value) {
     $this->hasCommentActionValue = true;
     $this->commentActionValue = $comment_action_value;
     return $this;
   }
 
   public function getCommentActionValue() {
     return $this->commentActionValue;
   }
 
   public function setPreviewPanel(PHUIRemarkupPreviewPanel $preview_panel) {
     $this->previewPanel = $preview_panel;
     return $this;
   }
 
   public function getPreviewPanel() {
     return $this->previewPanel;
   }
 
   protected function newControl() {
     throw new PhutilMethodNotImplementedException();
   }
 
   protected function buildControl() {
     if ($this->getIsConduitOnly()) {
       return null;
     }
 
     $control = $this->newControl();
     if ($control === null) {
       return null;
     }
 
     $control
       ->setValue($this->getValueForControl())
       ->setName($this->getKey());
 
     if (!$control->getLabel()) {
       $control->setLabel($this->getLabel());
     }
 
     if ($this->getIsSubmittedForm()) {
       $error = $this->getControlError();
       if ($error !== null) {
         $control->setError($error);
       }
     } else if ($this->getIsRequired()) {
       $control->setError(true);
     }
 
     return $control;
   }
 
   public function getControlID() {
     if (!$this->controlID) {
       $this->controlID = celerity_generate_unique_node_id();
     }
     return $this->controlID;
   }
 
   protected function renderControl() {
     $control = $this->buildControl();
     if ($control === null) {
       return null;
     }
 
     if ($this->getIsPreview()) {
       $disabled = true;
       $hidden = false;
     } else if ($this->getIsEditDefaults()) {
       $disabled = false;
       $hidden = false;
     } else {
       $disabled = $this->getIsLocked();
       $hidden = $this->getIsHidden();
     }
 
     if ($hidden) {
       return null;
     }
 
     $control->setDisabled($disabled);
 
     if ($this->controlID) {
       $control->setID($this->controlID);
     }
 
     return $control;
   }
 
   public function appendToForm(AphrontFormView $form) {
     $control = $this->renderControl();
     if ($control !== null) {
 
       if ($this->getIsPreview()) {
         if ($this->getIsHidden()) {
           $control
             ->addClass('aphront-form-preview-hidden')
             ->setError(pht('Hidden'));
         } else if ($this->getIsLocked()) {
           $control
             ->setError(pht('Locked'));
         }
       }
 
       $form->appendControl($control);
     }
     return $this;
   }
 
   protected function getValueForControl() {
     return $this->getValue();
   }
 
   public function getValueForDefaults() {
     $value = $this->getValue();
 
     // By default, just treat the empty string like `null` since they're
     // equivalent for almost all fields and this reduces the number of
     // meaningless transactions we generate when adjusting defaults.
     if ($value === '') {
       return null;
     }
 
     return $value;
   }
 
   protected function getValue() {
     return $this->value;
   }
 
   public function setValue($value) {
     $this->hasValue = true;
     $this->initialValue = $value;
     $this->value = $value;
     return $this;
   }
 
   public function setMetadataValue($key, $value) {
     $this->metadata[$key] = $value;
     return $this;
   }
 
   public function getMetadata() {
     return $this->metadata;
   }
 
   public function getValueForTransaction() {
     return $this->getValue();
   }
 
   public function getTransactionType() {
     return $this->transactionType;
   }
 
   public function setTransactionType($type) {
     $this->transactionType = $type;
     return $this;
   }
 
   public function readValueFromRequest(AphrontRequest $request) {
     $check = $this->getAllReadValueFromRequestKeys();
     foreach ($check as $key) {
       if (!$this->getValueExistsInRequest($request, $key)) {
         continue;
       }
 
       $this->value = $this->getValueFromRequest($request, $key);
       break;
     }
     return $this;
   }
 
   public function readValueFromComment($value) {
     $this->value = $this->getValueFromComment($value);
     return $this;
   }
 
   protected function getValueFromComment($value) {
     return $value;
   }
 
   public function getAllReadValueFromRequestKeys() {
     $keys = array();
 
     $keys[] = $this->getKey();
     foreach ($this->getAliases() as $alias) {
       $keys[] = $alias;
     }
 
     return $keys;
   }
 
   public function readDefaultValueFromConfiguration($value) {
     $this->value = $this->getDefaultValueFromConfiguration($value);
     return $this;
   }
 
   protected function getDefaultValueFromConfiguration($value) {
     return $value;
   }
 
   protected function getValueFromObject($object) {
     if ($this->hasValue) {
       return $this->value;
     } else {
       return $this->getDefaultValue();
     }
   }
 
   protected function getValueExistsInRequest(AphrontRequest $request, $key) {
     return $this->getHTTPParameterValueExists($request, $key);
   }
 
   protected function getValueFromRequest(AphrontRequest $request, $key) {
     return $this->getHTTPParameterValue($request, $key);
   }
 
   public function readValueFromField(PhabricatorEditField $other) {
     $this->value = $this->getValueFromField($other);
     return $this;
   }
 
   protected function getValueFromField(PhabricatorEditField $other) {
     return $other->getValue();
   }
 
 
   /**
    * Read and return the value the object had when the user first loaded the
    * form.
    *
    * This is the initial value from the user's point of view when they started
    * the edit process, and used primarily to prevent race conditions for fields
    * like "Projects" and "Subscribers" that use tokenizers and support edge
    * transactions.
    *
    * Most fields do not need to store these values or deal with initial value
    * handling.
    *
    * @param AphrontRequest Request to read from.
    * @param string Key to read.
    * @return wild Value read from request.
    */
   protected function getInitialValueFromSubmit(AphrontRequest $request, $key) {
     return null;
   }
 
   public function getInitialValue() {
     return $this->initialValue;
   }
 
   public function setInitialValue($initial_value) {
     $this->initialValue = $initial_value;
     return $this;
   }
 
   public function readValueFromSubmit(AphrontRequest $request) {
     $key = $this->getKey();
     if ($this->getValueExistsInSubmit($request, $key)) {
       $value = $this->getValueFromSubmit($request, $key);
     } else {
       $value = $this->getDefaultValue();
     }
     $this->value = $value;
 
     $initial_value = $this->getInitialValueFromSubmit($request, $key);
     $this->initialValue = $initial_value;
 
     return $this;
   }
 
   protected function getValueExistsInSubmit(AphrontRequest $request, $key) {
     return $this->getHTTPParameterValueExists($request, $key);
   }
 
   protected function getValueFromSubmit(AphrontRequest $request, $key) {
     return $this->getHTTPParameterValue($request, $key);
   }
 
   protected function getHTTPParameterValueExists(
     AphrontRequest $request,
     $key) {
     $type = $this->getHTTPParameterType();
 
     if ($type) {
       return $type->getExists($request, $key);
     }
 
     return false;
   }
 
   protected function getHTTPParameterValue($request, $key) {
     $type = $this->getHTTPParameterType();
 
     if ($type) {
       return $type->getValue($request, $key);
     }
 
     return null;
   }
 
   protected function getDefaultValue() {
     $type = $this->getHTTPParameterType();
 
     if ($type) {
       return $type->getDefaultValue();
     }
 
     return null;
   }
 
   final public function getHTTPParameterType() {
     if ($this->getIsConduitOnly()) {
       return null;
     }
 
     $type = $this->newHTTPParameterType();
 
     if ($type) {
       $type->setViewer($this->getViewer());
     }
 
     return $type;
   }
 
   protected function newHTTPParameterType() {
     return new AphrontStringHTTPParameterType();
   }
 
   public function getConduitParameterType() {
     $type = $this->newConduitParameterType();
 
     if (!$type) {
       return null;
     }
 
     $type->setViewer($this->getViewer());
 
     return $type;
   }
 
   abstract protected function newConduitParameterType();
 
   public function setEditTypeKey($edit_type_key) {
     $this->editTypeKey = $edit_type_key;
     return $this;
   }
 
   public function getEditTypeKey() {
     if ($this->editTypeKey === null) {
       return $this->getKey();
     }
     return $this->editTypeKey;
   }
 
   protected function newEditType() {
     $parameter_type = $this->getConduitParameterType();
     if (!$parameter_type) {
       return null;
     }
 
     return id(new PhabricatorSimpleEditType())
       ->setConduitParameterType($parameter_type);
   }
 
   protected function getEditType() {
     $transaction_type = $this->getTransactionType();
 
     if ($transaction_type === null) {
       return null;
     }
 
     $type_key = $this->getEditTypeKey();
     $edit_type = $this->newEditType();
     if (!$edit_type) {
       return null;
     }
 
     return $edit_type
       ->setEditType($type_key)
       ->setTransactionType($transaction_type)
       ->setMetadata($this->getMetadata());
   }
 
   final public function getConduitEditTypes() {
     if ($this->conduitEditTypes === null) {
       $edit_types = $this->newConduitEditTypes();
       $edit_types = mpull($edit_types, null, 'getEditType');
 
       foreach ($edit_types as $edit_type) {
         $edit_type->setEditField($this);
       }
 
       $this->conduitEditTypes = $edit_types;
     }
 
     return $this->conduitEditTypes;
   }
 
   final public function getConduitEditType($key) {
     $edit_types = $this->getConduitEditTypes();
 
     if (empty($edit_types[$key])) {
       throw new Exception(
         pht(
           'This EditField does not provide a Conduit EditType with key "%s".',
           $key));
     }
 
     return $edit_types[$key];
   }
 
   protected function newConduitEditTypes() {
     $edit_type = $this->getEditType();
 
     if (!$edit_type) {
       return array();
     }
 
     return array($edit_type);
   }
 
   public function getCommentAction() {
     $label = $this->getCommentActionLabel();
     if ($label === null) {
       return null;
     }
 
     $action = $this->newCommentAction();
     if ($action === null) {
       return null;
     }
 
     if ($this->hasCommentActionValue) {
       $value = $this->getCommentActionValue();
     } else {
       $value = $this->getValue();
     }
 
     $action
       ->setKey($this->getKey())
       ->setLabel($label)
-      ->setValue($this->getValueForCommentAction($value));
+      ->setValue($this->getValueForCommentAction($value))
+      ->setOrder($this->getCommentActionOrder());
 
     return $action;
   }
 
   protected function newCommentAction() {
     return null;
   }
 
   protected function getValueForCommentAction($value) {
     return $value;
   }
 
   public function shouldGenerateTransactionsFromSubmit() {
     if ($this->getIsConduitOnly()) {
       return false;
     }
 
     $edit_type = $this->getEditType();
     if (!$edit_type) {
       return false;
     }
 
     return true;
   }
 
   public function shouldReadValueFromRequest() {
     if ($this->getIsConduitOnly()) {
       return false;
     }
 
     if ($this->getIsLocked()) {
       return false;
     }
 
     if ($this->getIsHidden()) {
       return false;
     }
 
     return true;
   }
 
   public function shouldReadValueFromSubmit() {
     if ($this->getIsConduitOnly()) {
       return false;
     }
 
     if ($this->getIsLocked()) {
       return false;
     }
 
     if ($this->getIsHidden()) {
       return false;
     }
 
     return true;
   }
 
   public function shouldGenerateTransactionsFromComment() {
     if ($this->getIsConduitOnly()) {
       return false;
     }
 
     if ($this->getIsLocked()) {
       return false;
     }
 
     if ($this->getIsHidden()) {
       return false;
     }
 
     return true;
   }
 
   public function generateTransactions(
     PhabricatorApplicationTransaction $template,
     array $spec) {
 
     $edit_type = $this->getEditType();
     if (!$edit_type) {
       throw new Exception(
         pht(
           'EditField (with key "%s", of class "%s") is generating '.
           'transactions, but has no EditType.',
           $this->getKey(),
           get_class($this)));
     }
 
     return $edit_type->generateTransactions($template, $spec);
   }
 
 }