diff --git a/src/applications/maniphest/editor/ManiphestTransactionEditor.php b/src/applications/maniphest/editor/ManiphestTransactionEditor.php
index 08cfc66632..97c567c30d 100644
--- a/src/applications/maniphest/editor/ManiphestTransactionEditor.php
+++ b/src/applications/maniphest/editor/ManiphestTransactionEditor.php
@@ -1,1070 +1,1076 @@
 <?php
 
 final class ManiphestTransactionEditor
   extends PhabricatorApplicationTransactionEditor {
 
   public function getEditorApplicationClass() {
     return 'PhabricatorManiphestApplication';
   }
 
   public function getEditorObjectsDescription() {
     return pht('Maniphest Tasks');
   }
 
   public function getTransactionTypes() {
     $types = parent::getTransactionTypes();
 
     $types[] = PhabricatorTransactions::TYPE_COMMENT;
     $types[] = PhabricatorTransactions::TYPE_EDGE;
     $types[] = ManiphestTransaction::TYPE_PRIORITY;
     $types[] = ManiphestTransaction::TYPE_STATUS;
     $types[] = ManiphestTransaction::TYPE_TITLE;
     $types[] = ManiphestTransaction::TYPE_DESCRIPTION;
     $types[] = ManiphestTransaction::TYPE_OWNER;
     $types[] = ManiphestTransaction::TYPE_SUBPRIORITY;
     $types[] = ManiphestTransaction::TYPE_PROJECT_COLUMN;
     $types[] = ManiphestTransaction::TYPE_MERGED_INTO;
     $types[] = ManiphestTransaction::TYPE_MERGED_FROM;
     $types[] = ManiphestTransaction::TYPE_UNBLOCK;
     $types[] = ManiphestTransaction::TYPE_PARENT;
     $types[] = ManiphestTransaction::TYPE_COLUMN;
     $types[] = ManiphestTransaction::TYPE_COVER_IMAGE;
     $types[] = ManiphestTransaction::TYPE_POINTS;
     $types[] = PhabricatorTransactions::TYPE_VIEW_POLICY;
     $types[] = PhabricatorTransactions::TYPE_EDIT_POLICY;
 
     return $types;
   }
 
   protected function getCustomTransactionOldValue(
     PhabricatorLiskDAO $object,
     PhabricatorApplicationTransaction $xaction) {
 
     switch ($xaction->getTransactionType()) {
       case ManiphestTransaction::TYPE_PRIORITY:
         if ($this->getIsNewObject()) {
           return null;
         }
         return (int)$object->getPriority();
       case ManiphestTransaction::TYPE_STATUS:
         if ($this->getIsNewObject()) {
           return null;
         }
         return $object->getStatus();
       case ManiphestTransaction::TYPE_TITLE:
         if ($this->getIsNewObject()) {
           return null;
         }
         return $object->getTitle();
       case ManiphestTransaction::TYPE_DESCRIPTION:
         if ($this->getIsNewObject()) {
           return null;
         }
         return $object->getDescription();
       case ManiphestTransaction::TYPE_OWNER:
         return nonempty($object->getOwnerPHID(), null);
       case ManiphestTransaction::TYPE_PROJECT_COLUMN:
         // These are pre-populated.
         return $xaction->getOldValue();
       case ManiphestTransaction::TYPE_SUBPRIORITY:
         return $object->getSubpriority();
       case ManiphestTransaction::TYPE_COVER_IMAGE:
         return $object->getCoverImageFilePHID();
       case ManiphestTransaction::TYPE_POINTS:
         $points = $object->getPoints();
         if ($points !== null) {
           $points = (double)$points;
         }
         return $points;
       case ManiphestTransaction::TYPE_MERGED_INTO:
       case ManiphestTransaction::TYPE_MERGED_FROM:
         return null;
       case ManiphestTransaction::TYPE_PARENT:
       case ManiphestTransaction::TYPE_COLUMN:
         return null;
     }
   }
 
   protected function getCustomTransactionNewValue(
     PhabricatorLiskDAO $object,
     PhabricatorApplicationTransaction $xaction) {
 
     switch ($xaction->getTransactionType()) {
       case ManiphestTransaction::TYPE_PRIORITY:
         return (int)$xaction->getNewValue();
       case ManiphestTransaction::TYPE_OWNER:
         return nonempty($xaction->getNewValue(), null);
       case ManiphestTransaction::TYPE_STATUS:
       case ManiphestTransaction::TYPE_TITLE:
       case ManiphestTransaction::TYPE_DESCRIPTION:
       case ManiphestTransaction::TYPE_SUBPRIORITY:
       case ManiphestTransaction::TYPE_PROJECT_COLUMN:
       case ManiphestTransaction::TYPE_MERGED_INTO:
       case ManiphestTransaction::TYPE_MERGED_FROM:
       case ManiphestTransaction::TYPE_UNBLOCK:
       case ManiphestTransaction::TYPE_COVER_IMAGE:
         return $xaction->getNewValue();
       case ManiphestTransaction::TYPE_PARENT:
       case ManiphestTransaction::TYPE_COLUMN:
         return $xaction->getNewValue();
       case ManiphestTransaction::TYPE_POINTS:
         $value = $xaction->getNewValue();
         if (!strlen($value)) {
           $value = null;
         }
         if ($value !== null) {
           $value = (double)$value;
         }
         return $value;
     }
   }
 
   protected function transactionHasEffect(
     PhabricatorLiskDAO $object,
     PhabricatorApplicationTransaction $xaction) {
 
     $old = $xaction->getOldValue();
     $new = $xaction->getNewValue();
 
     switch ($xaction->getTransactionType()) {
       case ManiphestTransaction::TYPE_PROJECT_COLUMN:
         $new_column_phids = $new['columnPHIDs'];
         $old_column_phids = $old['columnPHIDs'];
         sort($new_column_phids);
         sort($old_column_phids);
         return ($old !== $new);
     }
 
     return parent::transactionHasEffect($object, $xaction);
   }
 
   protected function applyCustomInternalTransaction(
     PhabricatorLiskDAO $object,
     PhabricatorApplicationTransaction $xaction) {
 
     switch ($xaction->getTransactionType()) {
       case ManiphestTransaction::TYPE_PRIORITY:
         return $object->setPriority($xaction->getNewValue());
       case ManiphestTransaction::TYPE_STATUS:
         return $object->setStatus($xaction->getNewValue());
       case ManiphestTransaction::TYPE_TITLE:
         return $object->setTitle($xaction->getNewValue());
       case ManiphestTransaction::TYPE_DESCRIPTION:
         return $object->setDescription($xaction->getNewValue());
       case ManiphestTransaction::TYPE_OWNER:
         $phid = $xaction->getNewValue();
 
         // Update the "ownerOrdering" column to contain the full name of the
         // owner, if the task is assigned.
 
         $handle = null;
         if ($phid) {
           $handle = id(new PhabricatorHandleQuery())
             ->setViewer($this->getActor())
             ->withPHIDs(array($phid))
             ->executeOne();
         }
 
         if ($handle) {
           $object->setOwnerOrdering($handle->getName());
         } else {
           $object->setOwnerOrdering(null);
         }
 
         return $object->setOwnerPHID($phid);
       case ManiphestTransaction::TYPE_SUBPRIORITY:
         $object->setSubpriority($xaction->getNewValue());
         return;
       case ManiphestTransaction::TYPE_PROJECT_COLUMN:
         // these do external (edge) updates
         return;
       case ManiphestTransaction::TYPE_MERGED_INTO:
         $object->setStatus(ManiphestTaskStatus::getDuplicateStatus());
         return;
       case ManiphestTransaction::TYPE_COVER_IMAGE:
         $file_phid = $xaction->getNewValue();
 
         if ($file_phid) {
           $file = id(new PhabricatorFileQuery())
             ->setViewer($this->getActor())
             ->withPHIDs(array($file_phid))
             ->executeOne();
         } else {
           $file = null;
         }
 
         if (!$file || !$file->isTransformableImage()) {
           $object->setProperty('cover.filePHID', null);
           $object->setProperty('cover.thumbnailPHID', null);
           return;
         }
 
         $xform_key = PhabricatorFileThumbnailTransform::TRANSFORM_WORKCARD;
 
         $xform = PhabricatorFileTransform::getTransformByKey($xform_key)
           ->executeTransform($file);
 
         $object->setProperty('cover.filePHID', $file->getPHID());
         $object->setProperty('cover.thumbnailPHID', $xform->getPHID());
         return;
       case ManiphestTransaction::TYPE_POINTS:
         $object->setPoints($xaction->getNewValue());
         return;
       case ManiphestTransaction::TYPE_MERGED_FROM:
       case ManiphestTransaction::TYPE_PARENT:
       case ManiphestTransaction::TYPE_COLUMN:
         return;
     }
   }
 
   protected function applyCustomExternalTransaction(
     PhabricatorLiskDAO $object,
     PhabricatorApplicationTransaction $xaction) {
 
     switch ($xaction->getTransactionType()) {
       case ManiphestTransaction::TYPE_PARENT:
         $parent_phid = $xaction->getNewValue();
         $parent_type = ManiphestTaskDependsOnTaskEdgeType::EDGECONST;
         $task_phid = $object->getPHID();
 
         id(new PhabricatorEdgeEditor())
           ->addEdge($parent_phid, $parent_type, $task_phid)
           ->save();
         break;
       case ManiphestTransaction::TYPE_PROJECT_COLUMN:
         $board_phid = idx($xaction->getNewValue(), 'projectPHID');
         if (!$board_phid) {
           throw new Exception(
             pht(
               "Expected '%s' in column transaction.",
               'projectPHID'));
         }
 
         $old_phids = idx($xaction->getOldValue(), 'columnPHIDs', array());
         $new_phids = idx($xaction->getNewValue(), 'columnPHIDs', array());
         if (count($new_phids) !== 1) {
           throw new Exception(
             pht(
               "Expected exactly one '%s' in column transaction.",
               'columnPHIDs'));
         }
 
         $before_phid = idx($xaction->getNewValue(), 'beforePHID');
         $after_phid = idx($xaction->getNewValue(), 'afterPHID');
 
         if (!$before_phid && !$after_phid && ($old_phids == $new_phids)) {
           // If we are not moving the object between columns and also not
           // reordering the position, this is a move on some other order
           // (like priority). We can leave the positions untouched and just
           // bail, there's no work to be done.
           return;
         }
 
         // Otherwise, we're either moving between columns or adjusting the
         // object's position in the "natural" ordering, so we do need to update
         // some rows.
 
         $object_phid = $object->getPHID();
 
         // We're doing layout with the ominpotent viewer to make sure we don't
         // remove positions in columns that exist, but which the actual actor
         // can't see.
         $omnipotent_viewer = PhabricatorUser::getOmnipotentUser();
 
         $select_phids = array($board_phid);
 
         $descendants = id(new PhabricatorProjectQuery())
           ->setViewer($omnipotent_viewer)
           ->withAncestorProjectPHIDs($select_phids)
           ->execute();
         foreach ($descendants as $descendant) {
           $select_phids[] = $descendant->getPHID();
         }
 
         $board_tasks = id(new ManiphestTaskQuery())
           ->setViewer($omnipotent_viewer)
           ->withEdgeLogicPHIDs(
             PhabricatorProjectObjectHasProjectEdgeType::EDGECONST,
             PhabricatorQueryConstraint::OPERATOR_ANCESTOR,
             array($select_phids))
           ->execute();
 
-        $object_phids = mpull($board_tasks, 'getPHID');
-        $object_phids[] = $object_phid;
+        $board_tasks = mpull($board_tasks, null, 'getPHID');
+        $board_tasks[$object_phid] = $object;
+
+        // Make sure tasks are sorted by ID, so we lay out new positions in
+        // a consistent way.
+        $board_tasks = msort($board_tasks, 'getID');
+
+        $object_phids = array_keys($board_tasks);
 
         $engine = id(new PhabricatorBoardLayoutEngine())
           ->setViewer($omnipotent_viewer)
           ->setBoardPHIDs(array($board_phid))
           ->setObjectPHIDs($object_phids)
           ->executeLayout();
 
         // TODO: This logic needs to be revised if we legitimately support
         // multiple column positions.
 
         // NOTE: When a task is newly created, it's implicitly added to the
         // backlog but we don't currently record that in the "$old_phids". Just
         // clean it up for now.
         $columns = $engine->getObjectColumns($board_phid, $object_phid);
         foreach ($columns as $column) {
           $engine->queueRemovePosition(
             $board_phid,
             $column->getPHID(),
             $object_phid);
         }
 
         // Remove all existing column positions on the board.
         foreach ($old_phids as $column_phid) {
           $engine->queueRemovePosition(
             $board_phid,
             $column_phid,
             $object_phid);
         }
 
         // Add new positions.
         foreach ($new_phids as $column_phid) {
           if ($before_phid) {
             $engine->queueAddPositionBefore(
               $board_phid,
               $column_phid,
               $object_phid,
               $before_phid);
           } else if ($after_phid) {
             $engine->queueAddPositionAfter(
               $board_phid,
               $column_phid,
               $object_phid,
               $after_phid);
           } else {
             $engine->queueAddPosition(
               $board_phid,
               $column_phid,
               $object_phid);
           }
         }
 
         $engine->applyPositionUpdates();
 
         break;
       default:
         break;
     }
   }
 
   protected function applyFinalEffects(
     PhabricatorLiskDAO $object,
     array $xactions) {
 
     // When we change the status of a task, update tasks this tasks blocks
     // with a message to the effect of "alincoln resolved blocking task Txxx."
     $unblock_xaction = null;
     foreach ($xactions as $xaction) {
       switch ($xaction->getTransactionType()) {
         case ManiphestTransaction::TYPE_STATUS:
           $unblock_xaction = $xaction;
           break;
       }
     }
 
     if ($unblock_xaction !== null) {
       $blocked_phids = PhabricatorEdgeQuery::loadDestinationPHIDs(
         $object->getPHID(),
         ManiphestTaskDependedOnByTaskEdgeType::EDGECONST);
       if ($blocked_phids) {
         // In theory we could apply these through policies, but that seems a
         // little bit surprising. For now, use the actor's vision.
         $blocked_tasks = id(new ManiphestTaskQuery())
           ->setViewer($this->getActor())
           ->withPHIDs($blocked_phids)
           ->needSubscriberPHIDs(true)
           ->needProjectPHIDs(true)
           ->execute();
 
         $old = $unblock_xaction->getOldValue();
         $new = $unblock_xaction->getNewValue();
 
         foreach ($blocked_tasks as $blocked_task) {
           $parent_xaction = id(new ManiphestTransaction())
             ->setTransactionType(ManiphestTransaction::TYPE_UNBLOCK)
             ->setOldValue(array($object->getPHID() => $old))
             ->setNewValue(array($object->getPHID() => $new));
 
           if ($this->getIsNewObject()) {
             $parent_xaction->setMetadataValue('blocker.new', true);
           }
 
           id(new ManiphestTransactionEditor())
             ->setActor($this->getActor())
             ->setActingAsPHID($this->getActingAsPHID())
             ->setContentSource($this->getContentSource())
             ->setContinueOnNoEffect(true)
             ->setContinueOnMissingFields(true)
             ->applyTransactions($blocked_task, array($parent_xaction));
         }
       }
     }
 
     return $xactions;
   }
 
   protected function shouldSendMail(
     PhabricatorLiskDAO $object,
     array $xactions) {
     return true;
   }
 
   protected function getMailSubjectPrefix() {
     return PhabricatorEnv::getEnvConfig('metamta.maniphest.subject-prefix');
   }
 
   protected function getMailThreadID(PhabricatorLiskDAO $object) {
     return 'maniphest-task-'.$object->getPHID();
   }
 
   protected function getMailTo(PhabricatorLiskDAO $object) {
     $phids = array();
 
     if ($object->getOwnerPHID()) {
       $phids[] = $object->getOwnerPHID();
     }
     $phids[] = $this->getActingAsPHID();
 
     return $phids;
   }
 
   public function getMailTagsMap() {
     return array(
       ManiphestTransaction::MAILTAG_STATUS =>
         pht("A task's status changes."),
       ManiphestTransaction::MAILTAG_OWNER =>
         pht("A task's owner changes."),
       ManiphestTransaction::MAILTAG_PRIORITY =>
         pht("A task's priority changes."),
       ManiphestTransaction::MAILTAG_CC =>
         pht("A task's subscribers change."),
       ManiphestTransaction::MAILTAG_PROJECTS =>
         pht("A task's associated projects change."),
       ManiphestTransaction::MAILTAG_UNBLOCK =>
         pht('One of the tasks a task is blocked by changes status.'),
       ManiphestTransaction::MAILTAG_COLUMN =>
         pht('A task is moved between columns on a workboard.'),
       ManiphestTransaction::MAILTAG_COMMENT =>
         pht('Someone comments on a task.'),
       ManiphestTransaction::MAILTAG_OTHER =>
         pht('Other task activity not listed above occurs.'),
     );
   }
 
   protected function buildReplyHandler(PhabricatorLiskDAO $object) {
     return id(new ManiphestReplyHandler())
       ->setMailReceiver($object);
   }
 
   protected function buildMailTemplate(PhabricatorLiskDAO $object) {
     $id = $object->getID();
     $title = $object->getTitle();
 
     return id(new PhabricatorMetaMTAMail())
       ->setSubject("T{$id}: {$title}")
       ->addHeader('Thread-Topic', "T{$id}: ".$object->getOriginalTitle());
   }
 
   protected function buildMailBody(
     PhabricatorLiskDAO $object,
     array $xactions) {
 
     $body = parent::buildMailBody($object, $xactions);
 
     if ($this->getIsNewObject()) {
       $body->addRemarkupSection(
         pht('TASK DESCRIPTION'),
         $object->getDescription());
     }
 
     $body->addLinkSection(
       pht('TASK DETAIL'),
       PhabricatorEnv::getProductionURI('/T'.$object->getID()));
 
 
     $board_phids = array();
     $type_column = ManiphestTransaction::TYPE_PROJECT_COLUMN;
     foreach ($xactions as $xaction) {
       if ($xaction->getTransactionType() == $type_column) {
         $new = $xaction->getNewValue();
         $project_phid = idx($new, 'projectPHID');
         if ($project_phid) {
           $board_phids[] = $project_phid;
         }
       }
     }
 
     if ($board_phids) {
       $projects = id(new PhabricatorProjectQuery())
         ->setViewer($this->requireActor())
         ->withPHIDs($board_phids)
         ->execute();
 
       foreach ($projects as $project) {
         $body->addLinkSection(
           pht('WORKBOARD'),
           PhabricatorEnv::getProductionURI(
             '/project/board/'.$project->getID().'/'));
       }
     }
 
 
     return $body;
   }
 
   protected function shouldPublishFeedStory(
     PhabricatorLiskDAO $object,
     array $xactions) {
     return $this->shouldSendMail($object, $xactions);
   }
 
   protected function supportsSearch() {
     return true;
   }
 
   protected function shouldApplyHeraldRules(
     PhabricatorLiskDAO $object,
     array $xactions) {
     return true;
   }
 
   protected function buildHeraldAdapter(
     PhabricatorLiskDAO $object,
     array $xactions) {
 
     return id(new HeraldManiphestTaskAdapter())
       ->setTask($object);
   }
 
   protected function requireCapabilities(
     PhabricatorLiskDAO $object,
     PhabricatorApplicationTransaction $xaction) {
 
     parent::requireCapabilities($object, $xaction);
 
     $app_capability_map = array(
       ManiphestTransaction::TYPE_PRIORITY =>
         ManiphestEditPriorityCapability::CAPABILITY,
       ManiphestTransaction::TYPE_STATUS =>
         ManiphestEditStatusCapability::CAPABILITY,
       ManiphestTransaction::TYPE_OWNER =>
         ManiphestEditAssignCapability::CAPABILITY,
       PhabricatorTransactions::TYPE_EDIT_POLICY =>
         ManiphestEditPoliciesCapability::CAPABILITY,
       PhabricatorTransactions::TYPE_VIEW_POLICY =>
         ManiphestEditPoliciesCapability::CAPABILITY,
     );
 
 
     $transaction_type = $xaction->getTransactionType();
 
     $app_capability = null;
     if ($transaction_type == PhabricatorTransactions::TYPE_EDGE) {
       switch ($xaction->getMetadataValue('edge:type')) {
         case PhabricatorProjectObjectHasProjectEdgeType::EDGECONST:
           $app_capability = ManiphestEditProjectsCapability::CAPABILITY;
           break;
       }
     } else {
       $app_capability = idx($app_capability_map, $transaction_type);
     }
 
     if ($app_capability) {
       $app = id(new PhabricatorApplicationQuery())
         ->setViewer($this->getActor())
         ->withClasses(array('PhabricatorManiphestApplication'))
         ->executeOne();
       PhabricatorPolicyFilter::requireCapability(
         $this->getActor(),
         $app,
         $app_capability);
     }
   }
 
   protected function adjustObjectForPolicyChecks(
     PhabricatorLiskDAO $object,
     array $xactions) {
 
     $copy = parent::adjustObjectForPolicyChecks($object, $xactions);
     foreach ($xactions as $xaction) {
       switch ($xaction->getTransactionType()) {
         case ManiphestTransaction::TYPE_OWNER:
           $copy->setOwnerPHID($xaction->getNewValue());
           break;
         default:
           continue;
       }
     }
 
     return $copy;
   }
 
   /**
    * Get priorities for moving a task to a new priority.
    */
   public static function getEdgeSubpriority(
     $priority,
     $is_end) {
 
     $query = id(new ManiphestTaskQuery())
       ->setViewer(PhabricatorUser::getOmnipotentUser())
       ->withPriorities(array($priority))
       ->setLimit(1);
 
     if ($is_end) {
       $query->setOrderVector(array('-priority', '-subpriority', '-id'));
     } else {
       $query->setOrderVector(array('priority', 'subpriority', 'id'));
     }
 
     $result = $query->executeOne();
     $step = (double)(2 << 32);
 
     if ($result) {
       $base = $result->getSubpriority();
       if ($is_end) {
         $sub = ($base - $step);
       } else {
         $sub = ($base + $step);
       }
     } else {
       $sub = 0;
     }
 
     return array($priority, $sub);
   }
 
 
   /**
    * Get priorities for moving a task before or after another task.
    */
   public static function getAdjacentSubpriority(
     ManiphestTask $dst,
     $is_after,
     $allow_recursion = true) {
 
     $query = id(new ManiphestTaskQuery())
       ->setViewer(PhabricatorUser::getOmnipotentUser())
       ->setOrder(ManiphestTaskQuery::ORDER_PRIORITY)
       ->withPriorities(array($dst->getPriority()))
       ->setLimit(1);
 
     if ($is_after) {
       $query->setAfterID($dst->getID());
     } else {
       $query->setBeforeID($dst->getID());
     }
 
     $adjacent = $query->executeOne();
 
     $base = $dst->getSubpriority();
     $step = (double)(2 << 32);
 
     // If we find an adjacent task, we average the two subpriorities and
     // return the result.
     if ($adjacent) {
       $epsilon = 0.01;
 
       // If the adjacent task has a subpriority that is identical or very
       // close to the task we're looking at, we're going to move it and all
       // tasks with the same subpriority a little farther down the subpriority
       // scale.
       if ($allow_recursion &&
           (abs($adjacent->getSubpriority() - $base) < $epsilon)) {
         $conn_w = $adjacent->establishConnection('w');
 
         $min = ($adjacent->getSubpriority() - ($epsilon));
         $max = ($adjacent->getSubpriority() + ($epsilon));
 
         // Get all of the tasks with the similar subpriorities to the adjacent
         // task, including the adjacent task itself.
         $query = id(new ManiphestTaskQuery())
           ->setViewer(PhabricatorUser::getOmnipotentUser())
           ->withPriorities(array($adjacent->getPriority()))
           ->withSubpriorityBetween($min, $max);
 
         if (!$is_after) {
           $query->setOrderVector(array('-priority', '-subpriority', '-id'));
         } else {
           $query->setOrderVector(array('priority', 'subpriority', 'id'));
         }
 
         $shift_all = $query->execute();
         $shift_last = last($shift_all);
 
         // Select the most extreme subpriority in the result set as the
         // base value.
         $shift_base = head($shift_all)->getSubpriority();
 
         // Find the subpriority before or after the task at the end of the
         // block.
         list($shift_pri, $shift_sub) = self::getAdjacentSubpriority(
           $shift_last,
           $is_after,
           $allow_recursion = false);
 
         $delta = ($shift_sub - $shift_base);
         $count = count($shift_all);
 
         $shift = array();
         $cursor = 1;
         foreach ($shift_all as $shift_task) {
           $shift_target = $shift_base + (($cursor / $count) * $delta);
           $cursor++;
 
           queryfx(
             $conn_w,
             'UPDATE %T SET subpriority = %f WHERE id = %d',
             $adjacent->getTableName(),
             $shift_target,
             $shift_task->getID());
 
           // If we're shifting the adjacent task, update it.
           if ($shift_task->getID() == $adjacent->getID()) {
             $adjacent->setSubpriority($shift_target);
           }
 
           // If we're shifting the original target task, update the base
           // subpriority.
           if ($shift_task->getID() == $dst->getID()) {
             $base = $shift_target;
           }
         }
       }
 
       $sub = ($adjacent->getSubpriority() + $base) / 2;
     } else {
       // Otherwise, we take a step away from the target's subpriority and
       // use that.
       if ($is_after) {
         $sub = ($base - $step);
       } else {
         $sub = ($base + $step);
       }
     }
 
     return array($dst->getPriority(), $sub);
   }
 
   protected function validateTransaction(
     PhabricatorLiskDAO $object,
     $type,
     array $xactions) {
 
     $errors = parent::validateTransaction($object, $type, $xactions);
 
     switch ($type) {
       case ManiphestTransaction::TYPE_TITLE:
         $missing = $this->validateIsEmptyTextField(
           $object->getTitle(),
           $xactions);
 
         if ($missing) {
           $error = new PhabricatorApplicationTransactionValidationError(
             $type,
             pht('Required'),
             pht('Task title is required.'),
             nonempty(last($xactions), null));
 
           $error->setIsMissingFieldError(true);
           $errors[] = $error;
         }
         break;
       case ManiphestTransaction::TYPE_PARENT:
         $with_effect = array();
         foreach ($xactions as $xaction) {
           $task_phid = $xaction->getNewValue();
           if (!$task_phid) {
             continue;
           }
 
           $with_effect[] = $xaction;
 
           $task = id(new ManiphestTaskQuery())
             ->setViewer($this->getActor())
             ->withPHIDs(array($task_phid))
             ->executeOne();
           if (!$task) {
             $errors[] = new PhabricatorApplicationTransactionValidationError(
               $type,
               pht('Invalid'),
               pht(
                 'Parent task identifier "%s" does not identify a visible '.
                 'task.',
                 $task_phid),
               $xaction);
           }
         }
 
         if ($with_effect && !$this->getIsNewObject()) {
           $errors[] = new PhabricatorApplicationTransactionValidationError(
             $type,
             pht('Invalid'),
             pht(
               'You can only select a parent task when creating a '.
               'transaction for the first time.'),
             last($with_effect));
         }
         break;
       case ManiphestTransaction::TYPE_COLUMN:
         $with_effect = array();
         foreach ($xactions as $xaction) {
           $column_phid = $xaction->getNewValue();
           if (!$column_phid) {
             continue;
           }
 
           $with_effect[] = $xaction;
 
           $column = $this->loadProjectColumn($column_phid);
           if (!$column) {
             $errors[] = new PhabricatorApplicationTransactionValidationError(
               $type,
               pht('Invalid'),
               pht(
                 'Column PHID "%s" does not identify a visible column.',
                 $column_phid),
               $xaction);
           }
         }
 
         if ($with_effect && !$this->getIsNewObject()) {
           $errors[] = new PhabricatorApplicationTransactionValidationError(
             $type,
             pht('Invalid'),
             pht(
               'You can only put a task into an initial column during task '.
               'creation.'),
             last($with_effect));
         }
         break;
       case ManiphestTransaction::TYPE_OWNER:
         foreach ($xactions as $xaction) {
           $old = $xaction->getOldValue();
           $new = $xaction->getNewValue();
           if (!strlen($new)) {
             continue;
           }
 
           if ($new === $old) {
             continue;
           }
 
           $assignee_list = id(new PhabricatorPeopleQuery())
             ->setViewer($this->getActor())
             ->withPHIDs(array($new))
             ->execute();
           if (!$assignee_list) {
             $errors[] = new PhabricatorApplicationTransactionValidationError(
               $type,
               pht('Invalid'),
               pht(
                 'User "%s" is not a valid user.',
                 $new),
               $xaction);
           }
         }
         break;
       case ManiphestTransaction::TYPE_COVER_IMAGE:
         foreach ($xactions as $xaction) {
           $old = $xaction->getOldValue();
           $new = $xaction->getNewValue();
           if (!$new) {
             continue;
           }
 
           if ($new === $old) {
             continue;
           }
 
           $file = id(new PhabricatorFileQuery())
             ->setViewer($this->getActor())
             ->withPHIDs(array($new))
             ->executeOne();
           if (!$file) {
             $errors[] = new PhabricatorApplicationTransactionValidationError(
               $type,
               pht('Invalid'),
               pht('File "%s" is not valid.', $new),
               $xaction);
             continue;
           }
 
           if (!$file->isTransformableImage()) {
             $errors[] = new PhabricatorApplicationTransactionValidationError(
               $type,
               pht('Invalid'),
               pht('File "%s" is not a valid image file.', $new),
               $xaction);
             continue;
           }
         }
         break;
 
       case ManiphestTransaction::TYPE_POINTS:
         foreach ($xactions as $xaction) {
           $new = $xaction->getNewValue();
           if (strlen($new) && !is_numeric($new)) {
             $errors[] = new PhabricatorApplicationTransactionValidationError(
               $type,
               pht('Invalid'),
               pht('Points value must be numeric or empty.'),
               $xaction);
             continue;
           }
 
           if ((double)$new < 0) {
             $errors[] = new PhabricatorApplicationTransactionValidationError(
               $type,
               pht('Invalid'),
               pht('Points value must be nonnegative.'),
               $xaction);
             continue;
           }
         }
         break;
 
     }
 
     return $errors;
   }
 
   protected function expandTransactions(
     PhabricatorLiskDAO $object,
     array $xactions) {
 
     $actor = $this->getActor();
     $actor_phid = $actor->getPHID();
 
     $results = parent::expandTransactions($object, $xactions);
 
     $is_unassigned = ($object->getOwnerPHID() === null);
 
     $any_assign = false;
     foreach ($xactions as $xaction) {
       if ($xaction->getTransactionType() == ManiphestTransaction::TYPE_OWNER) {
         $any_assign = true;
         break;
       }
     }
 
     $is_open = !$object->isClosed();
 
     $new_status = null;
     foreach ($xactions as $xaction) {
       switch ($xaction->getTransactionType()) {
         case ManiphestTransaction::TYPE_STATUS:
           $new_status = $xaction->getNewValue();
           break;
       }
     }
 
     if ($new_status === null) {
       $is_closing = false;
     } else {
       $is_closing = ManiphestTaskStatus::isClosedStatus($new_status);
     }
 
     // If the task is not assigned, not being assigned, currently open, and
     // being closed, try to assign the actor as the owner.
     if ($is_unassigned && !$any_assign && $is_open && $is_closing) {
       $is_claim = ManiphestTaskStatus::isClaimStatus($new_status);
 
       // Don't assign the actor if they aren't a real user.
       // Don't claim the task if the status is configured to not claim.
       if ($actor_phid && $is_claim) {
         $results[] = id(new ManiphestTransaction())
           ->setTransactionType(ManiphestTransaction::TYPE_OWNER)
           ->setNewValue($actor_phid);
       }
     }
 
     // Automatically subscribe the author when they create a task.
     if ($this->getIsNewObject()) {
       if ($actor_phid) {
         $results[] = id(new ManiphestTransaction())
           ->setTransactionType(PhabricatorTransactions::TYPE_SUBSCRIBERS)
           ->setNewValue(
             array(
               '+' => array($actor_phid => $actor_phid),
             ));
       }
     }
 
     return $results;
   }
 
   protected function expandTransaction(
     PhabricatorLiskDAO $object,
     PhabricatorApplicationTransaction $xaction) {
 
     $results = parent::expandTransaction($object, $xaction);
 
     switch ($xaction->getTransactionType()) {
       case ManiphestTransaction::TYPE_COLUMN:
         $column_phid = $xaction->getNewValue();
         if (!$column_phid) {
           break;
         }
 
         // When a task is created into a column, we also generate a transaction
         // to actually put it in that column.
         $column = $this->loadProjectColumn($column_phid);
         $results[] = id(new ManiphestTransaction())
           ->setTransactionType(ManiphestTransaction::TYPE_PROJECT_COLUMN)
           ->setOldValue(
             array(
               'projectPHID' => $column->getProjectPHID(),
               'columnPHIDs' => array(),
             ))
           ->setNewValue(
             array(
               'projectPHID' => $column->getProjectPHID(),
               'columnPHIDs' => array($column->getPHID()),
             ));
         break;
       case ManiphestTransaction::TYPE_OWNER:
         // When a task is reassigned, move the old owner to the subscriber
         // list so they're still in the loop.
         $owner_phid = $object->getOwnerPHID();
         if ($owner_phid) {
           $results[] = id(new ManiphestTransaction())
             ->setTransactionType(PhabricatorTransactions::TYPE_SUBSCRIBERS)
             ->setIgnoreOnNoEffect(true)
             ->setNewValue(
               array(
                 '+' => array($owner_phid => $owner_phid),
               ));
         }
         break;
     }
 
     return $results;
   }
 
   private function loadProjectColumn($column_phid) {
     return id(new PhabricatorProjectColumnQuery())
       ->setViewer($this->getActor())
       ->withPHIDs(array($column_phid))
       ->executeOne();
   }
 
   protected function extractFilePHIDsFromCustomTransaction(
     PhabricatorLiskDAO $object,
     PhabricatorApplicationTransaction $xaction) {
     $phids = parent::extractFilePHIDsFromCustomTransaction($object, $xaction);
 
     switch ($xaction->getTransactionType()) {
       case ManiphestTransaction::TYPE_COVER_IMAGE:
         $phids[] = $xaction->getNewValue();
         break;
     }
 
     return $phids;
   }
 
 
 }
diff --git a/src/applications/project/controller/PhabricatorProjectBoardViewController.php b/src/applications/project/controller/PhabricatorProjectBoardViewController.php
index e8de61e3cc..963cb2a752 100644
--- a/src/applications/project/controller/PhabricatorProjectBoardViewController.php
+++ b/src/applications/project/controller/PhabricatorProjectBoardViewController.php
@@ -1,1083 +1,1087 @@
 <?php
 
 final class PhabricatorProjectBoardViewController
   extends PhabricatorProjectBoardController {
 
   const BATCH_EDIT_ALL = 'all';
 
   private $id;
   private $slug;
   private $queryKey;
   private $sortKey;
   private $showHidden;
 
   public function shouldAllowPublic() {
     return true;
   }
 
   public function handleRequest(AphrontRequest $request) {
     $viewer = $request->getUser();
 
     $response = $this->loadProject();
     if ($response) {
       return $response;
     }
 
     $project = $this->getProject();
 
     $this->readRequestState();
 
     $board_uri = $this->getApplicationURI('board/'.$project->getID().'/');
 
     $search_engine = id(new ManiphestTaskSearchEngine())
       ->setViewer($viewer)
       ->setBaseURI($board_uri)
       ->setIsBoardView(true);
 
     if ($request->isFormPost() && !$request->getBool('initialize')) {
       $saved = $search_engine->buildSavedQueryFromRequest($request);
       $search_engine->saveQuery($saved);
       $filter_form = id(new AphrontFormView())
         ->setUser($viewer);
       $search_engine->buildSearchForm($filter_form, $saved);
       if ($search_engine->getErrors()) {
         return $this->newDialog()
           ->setWidth(AphrontDialogView::WIDTH_FULL)
           ->setTitle(pht('Advanced Filter'))
           ->appendChild($filter_form->buildLayoutView())
           ->setErrors($search_engine->getErrors())
           ->setSubmitURI($board_uri)
           ->addSubmitButton(pht('Apply Filter'))
           ->addCancelButton($board_uri);
       }
       return id(new AphrontRedirectResponse())->setURI(
         $this->getURIWithState(
           $search_engine->getQueryResultsPageURI($saved->getQueryKey())));
     }
 
     $query_key = $this->getDefaultFilter($project);
 
     $request_query = $request->getStr('filter');
     if (strlen($request_query)) {
       $query_key = $request_query;
     }
 
     $uri_query = $request->getURIData('queryKey');
     if (strlen($uri_query)) {
       $query_key = $uri_query;
     }
 
     $this->queryKey = $query_key;
 
     $custom_query = null;
     if ($search_engine->isBuiltinQuery($query_key)) {
       $saved = $search_engine->buildSavedQueryFromBuiltin($query_key);
     } else {
       $saved = id(new PhabricatorSavedQueryQuery())
         ->setViewer($viewer)
         ->withQueryKeys(array($query_key))
         ->executeOne();
 
       if (!$saved) {
         return new Aphront404Response();
       }
 
       $custom_query = $saved;
     }
 
     if ($request->getURIData('filter')) {
       $filter_form = id(new AphrontFormView())
         ->setUser($viewer);
       $search_engine->buildSearchForm($filter_form, $saved);
 
       return $this->newDialog()
         ->setWidth(AphrontDialogView::WIDTH_FULL)
         ->setTitle(pht('Advanced Filter'))
         ->appendChild($filter_form->buildLayoutView())
         ->setSubmitURI($board_uri)
         ->addSubmitButton(pht('Apply Filter'))
         ->addCancelButton($board_uri);
     }
 
     $task_query = $search_engine->buildQueryFromSavedQuery($saved);
 
     $select_phids = array($project->getPHID());
     if ($project->getHasSubprojects() || $project->getHasMilestones()) {
       $descendants = id(new PhabricatorProjectQuery())
         ->setViewer($viewer)
         ->withAncestorProjectPHIDs($select_phids)
         ->execute();
       foreach ($descendants as $descendant) {
         $select_phids[] = $descendant->getPHID();
       }
     }
 
     $tasks = $task_query
       ->withEdgeLogicPHIDs(
         PhabricatorProjectObjectHasProjectEdgeType::EDGECONST,
         PhabricatorQueryConstraint::OPERATOR_ANCESTOR,
         array($select_phids))
       ->setOrder(ManiphestTaskQuery::ORDER_PRIORITY)
       ->setViewer($viewer)
       ->execute();
     $tasks = mpull($tasks, null, 'getPHID');
 
     $board_phid = $project->getPHID();
 
+    // Regardless of display order, pass tasks to the layout engine in ID order
+    // so layout is consistent.
+    $board_tasks = msort($tasks, 'getID');
+
     $layout_engine = id(new PhabricatorBoardLayoutEngine())
       ->setViewer($viewer)
       ->setBoardPHIDs(array($board_phid))
-      ->setObjectPHIDs(array_keys($tasks))
+      ->setObjectPHIDs(array_keys($board_tasks))
       ->setFetchAllBoards(true)
       ->executeLayout();
 
     $columns = $layout_engine->getColumns($board_phid);
     if (!$columns || !$project->getHasWorkboard()) {
       $has_normal_columns = false;
 
       foreach ($columns as $column) {
         if (!$column->getProxyPHID()) {
           $has_normal_columns = true;
           break;
         }
       }
 
       $can_edit = PhabricatorPolicyFilter::hasCapability(
         $viewer,
         $project,
         PhabricatorPolicyCapability::CAN_EDIT);
 
       if (!$has_normal_columns) {
         if (!$can_edit) {
           $content = $this->buildNoAccessContent($project);
         } else {
           $content = $this->buildInitializeContent($project);
         }
       } else {
         if (!$can_edit) {
           $content = $this->buildDisabledContent($project);
         } else {
           $content = $this->buildEnableContent($project);
         }
       }
 
       if ($content instanceof AphrontResponse) {
         return $content;
       }
 
       $nav = $this->getProfileMenu();
       $nav->selectFilter(PhabricatorProject::PANEL_WORKBOARD);
 
       $crumbs = $this->buildApplicationCrumbs();
       $crumbs->addTextCrumb(pht('Workboard'));
 
       return $this->newPage()
         ->setTitle(
           array(
             $project->getDisplayName(),
             pht('Workboard'),
           ))
         ->setNavigation($nav)
         ->setCrumbs($crumbs)
         ->appendChild($content);
     }
 
     $task_can_edit_map = id(new PhabricatorPolicyFilter())
       ->setViewer($viewer)
       ->requireCapabilities(array(PhabricatorPolicyCapability::CAN_EDIT))
       ->apply($tasks);
 
     // If this is a batch edit, select the editable tasks in the chosen column
     // and ship the user into the batch editor.
     $batch_edit = $request->getStr('batch');
     if ($batch_edit) {
       if ($batch_edit !== self::BATCH_EDIT_ALL) {
         $column_id_map = mpull($columns, null, 'getID');
         $batch_column = idx($column_id_map, $batch_edit);
         if (!$batch_column) {
           return new Aphront404Response();
         }
 
         $batch_task_phids = $layout_engine->getColumnObjectPHIDs(
           $board_phid,
           $batch_column->getPHID());
 
         foreach ($batch_task_phids as $key => $batch_task_phid) {
           if (empty($task_can_edit_map[$batch_task_phid])) {
             unset($batch_task_phids[$key]);
           }
         }
 
         $batch_tasks = array_select_keys($tasks, $batch_task_phids);
       } else {
         $batch_tasks = $task_can_edit_map;
       }
 
       if (!$batch_tasks) {
         $cancel_uri = $this->getURIWithState($board_uri);
         return $this->newDialog()
           ->setTitle(pht('No Editable Tasks'))
           ->appendParagraph(
             pht(
               'The selected column contains no visible tasks which you '.
               'have permission to edit.'))
           ->addCancelButton($board_uri);
       }
 
       $batch_ids = mpull($batch_tasks, 'getID');
       $batch_ids = implode(',', $batch_ids);
 
       $batch_uri = new PhutilURI('/maniphest/batch/');
       $batch_uri->setQueryParam('board', $this->id);
       $batch_uri->setQueryParam('batch', $batch_ids);
       return id(new AphrontRedirectResponse())
         ->setURI($batch_uri);
     }
 
     $board_id = celerity_generate_unique_node_id();
 
     $board = id(new PHUIWorkboardView())
       ->setUser($viewer)
       ->setID($board_id)
       ->addSigil('jx-workboard')
       ->setMetadata(
         array(
           'boardPHID' => $project->getPHID(),
         ));
 
     $visible_columns = array();
     $column_phids = array();
     $visible_phids = array();
     foreach ($columns as $column) {
       if (!$this->showHidden) {
         if ($column->isHidden()) {
           continue;
         }
       }
 
       $proxy = $column->getProxy();
       if ($proxy && !$proxy->isMilestone()) {
         // TODO: For now, don't show subproject columns because we can't
         // handle tasks with multiple positions yet.
         continue;
       }
 
       $task_phids = $layout_engine->getColumnObjectPHIDs(
         $board_phid,
         $column->getPHID());
 
       $column_tasks = array_select_keys($tasks, $task_phids);
 
       // If we aren't using "natural" order, reorder the column by the original
       // query order.
       if ($this->sortKey != PhabricatorProjectColumn::ORDER_NATURAL) {
         $column_tasks = array_select_keys($column_tasks, array_keys($tasks));
       }
 
       $column_phid = $column->getPHID();
 
       $visible_columns[$column_phid] = $column;
       $column_phids[$column_phid] = $column_tasks;
 
       foreach ($column_tasks as $phid => $task) {
         $visible_phids[$phid] = $phid;
       }
     }
 
     $rendering_engine = id(new PhabricatorBoardRenderingEngine())
       ->setViewer($viewer)
       ->setObjects(array_select_keys($tasks, $visible_phids))
       ->setEditMap($task_can_edit_map)
       ->setExcludedProjectPHIDs($select_phids);
 
     $templates = array();
     $column_maps = array();
     $all_tasks = array();
     foreach ($visible_columns as $column_phid => $column) {
       $column_tasks = $column_phids[$column_phid];
 
       $panel = id(new PHUIWorkpanelView())
         ->setHeader($column->getDisplayName())
         ->setSubHeader($column->getDisplayType())
         ->addSigil('workpanel');
 
       $proxy = $column->getProxy();
       if ($proxy) {
         $proxy_id = $proxy->getID();
         $href = $this->getApplicationURI("view/{$proxy_id}/");
         $panel->setHref($href);
       }
 
       $header_icon = $column->getHeaderIcon();
       if ($header_icon) {
         $panel->setHeaderIcon($header_icon);
       }
 
       $display_class = $column->getDisplayClass();
       if ($display_class) {
         $panel->addClass($display_class);
       }
 
       if ($column->isHidden()) {
         $panel->addClass('project-panel-hidden');
       }
 
       $column_menu = $this->buildColumnMenu($project, $column);
       $panel->addHeaderAction($column_menu);
 
       $count_tag = id(new PHUITagView())
         ->setType(PHUITagView::TYPE_SHADE)
         ->setShade(PHUITagView::COLOR_BLUE)
         ->addSigil('column-points')
         ->setName(
           javelin_tag(
             'span',
             array(
               'sigil' => 'column-points-content',
             ),
             pht('-')))
         ->setStyle('display: none');
 
       $panel->setHeaderTag($count_tag);
 
       $cards = id(new PHUIObjectItemListView())
         ->setUser($viewer)
         ->setFlush(true)
         ->setAllowEmptyList(true)
         ->addSigil('project-column')
         ->setItemClass('phui-workcard')
         ->setMetadata(
           array(
             'columnPHID' => $column->getPHID(),
             'pointLimit' => $column->getPointLimit(),
           ));
 
       foreach ($column_tasks as $task) {
         $object_phid = $task->getPHID();
 
         $card = $rendering_engine->renderCard($object_phid);
         $templates[$object_phid] = hsprintf('%s', $card->getItem());
         $column_maps[$column_phid][] = $object_phid;
 
         $all_tasks[$object_phid] = $task;
       }
 
       $panel->setCards($cards);
       $board->addPanel($panel);
     }
 
     $behavior_config = array(
       'moveURI' => $this->getApplicationURI('move/'.$project->getID().'/'),
       'createURI' => $this->getCreateURI(),
       'uploadURI' => '/file/dropupload/',
       'coverURI' => $this->getApplicationURI('cover/'),
       'chunkThreshold' => PhabricatorFileStorageEngine::getChunkThreshold(),
       'pointsEnabled' => ManiphestTaskPoints::getIsEnabled(),
 
       'boardPHID' => $project->getPHID(),
       'order' => $this->sortKey,
       'templateMap' => $templates,
       'columnMaps' => $column_maps,
       'orderMaps' => mpull($all_tasks, 'getWorkboardOrderVectors'),
       'propertyMaps' => mpull($all_tasks, 'getWorkboardProperties'),
 
       'boardID' => $board_id,
       'projectPHID' => $project->getPHID(),
     );
     $this->initBehavior('project-boards', $behavior_config);
 
 
     $sort_menu = $this->buildSortMenu(
       $viewer,
       $project,
       $this->sortKey);
 
     $filter_menu = $this->buildFilterMenu(
       $viewer,
       $project,
       $custom_query,
       $search_engine,
       $query_key);
 
     $manage_menu = $this->buildManageMenu($project, $this->showHidden);
 
     $header_link = phutil_tag(
       'a',
       array(
         'href' => $this->getApplicationURI('profile/'.$project->getID().'/'),
       ),
       $project->getName());
 
     $board_box = id(new PHUIBoxView())
       ->appendChild($board)
       ->addClass('project-board-wrapper');
 
     $nav = $this->getProfileMenu();
     $divider = id(new PHUIListItemView())
       ->setType(PHUIListItemView::TYPE_DIVIDER);
     $fullscreen = $this->buildFullscreenMenu();
 
     $crumbs = $this->buildApplicationCrumbs();
     $crumbs->addTextCrumb(pht('Workboard'));
     $crumbs->setBorder(true);
 
     $crumbs->addAction($sort_menu);
     $crumbs->addAction($filter_menu);
     $crumbs->addAction($divider);
     $crumbs->addAction($manage_menu);
     $crumbs->addAction($fullscreen);
 
     // TODO: Wire to Workboard Preferences
     // require_celerity_resource('phui-workboard-color-css');
     // ->addClass('phui-workboard-color')
     // ->addClass('phui-workboard-bluegrey')
 
     return $this->newPage()
       ->setTitle(
         array(
           $project->getDisplayName(),
           pht('Workboard'),
         ))
       ->setPageObjectPHIDs(array($project->getPHID()))
       ->setShowFooter(false)
       ->setNavigation($nav)
       ->setCrumbs($crumbs)
       ->addQuicksandConfig(
         array(
           'boardConfig' => $behavior_config,
         ))
       ->appendChild(
         array(
           $board_box,
         ));
   }
 
   private function readRequestState() {
     $request = $this->getRequest();
     $project = $this->getProject();
 
     $this->showHidden = $request->getBool('hidden');
     $this->id = $project->getID();
 
     $sort_key = $this->getDefaultSort($project);
 
     $request_sort = $request->getStr('order');
     if ($this->isValidSort($request_sort)) {
       $sort_key = $request_sort;
     }
 
     $this->sortKey = $sort_key;
   }
 
   private function getDefaultSort(PhabricatorProject $project) {
     $default_sort = $project->getDefaultWorkboardSort();
 
     if ($this->isValidSort($default_sort)) {
       return $default_sort;
     }
 
     return PhabricatorProjectColumn::DEFAULT_ORDER;
   }
 
   private function getDefaultFilter(PhabricatorProject $project) {
     $default_filter = $project->getDefaultWorkboardFilter();
 
     if (strlen($default_filter)) {
       return $default_filter;
     }
 
     return 'open';
   }
 
   private function isValidSort($sort) {
     switch ($sort) {
       case PhabricatorProjectColumn::ORDER_NATURAL:
       case PhabricatorProjectColumn::ORDER_PRIORITY:
         return true;
     }
 
     return false;
   }
 
   private function buildSortMenu(
     PhabricatorUser $viewer,
     PhabricatorProject $project,
     $sort_key) {
 
     $sort_icon = id(new PHUIIconView())
       ->setIcon('fa-sort-amount-asc bluegrey');
 
     $named = array(
       PhabricatorProjectColumn::ORDER_NATURAL => pht('Natural'),
       PhabricatorProjectColumn::ORDER_PRIORITY => pht('Sort by Priority'),
     );
 
     $base_uri = $this->getURIWithState();
 
     $items = array();
     foreach ($named as $key => $name) {
       $is_selected = ($key == $sort_key);
       if ($is_selected) {
         $active_order = $name;
       }
 
       $item = id(new PhabricatorActionView())
         ->setIcon('fa-sort-amount-asc')
         ->setSelected($is_selected)
         ->setName($name);
 
       $uri = $base_uri->alter('order', $key);
       $item->setHref($uri);
 
       $items[] = $item;
     }
 
     $id = $project->getID();
 
     $save_uri = "default/{$id}/sort/";
     $save_uri = $this->getApplicationURI($save_uri);
     $save_uri = $this->getURIWithState($save_uri, $force = true);
 
     $can_edit = PhabricatorPolicyFilter::hasCapability(
       $viewer,
       $project,
       PhabricatorPolicyCapability::CAN_EDIT);
 
     $items[] = id(new PhabricatorActionView())
       ->setIcon('fa-floppy-o')
       ->setName(pht('Save as Default'))
       ->setHref($save_uri)
       ->setWorkflow(true)
       ->setDisabled(!$can_edit);
 
     $sort_menu = id(new PhabricatorActionListView())
       ->setUser($viewer);
     foreach ($items as $item) {
       $sort_menu->addAction($item);
     }
 
     $sort_button = id(new PHUIListItemView())
       ->setName($active_order)
       ->setIcon('fa-sort-amount-asc')
       ->setHref('#')
       ->addSigil('boards-dropdown-menu')
       ->setMetadata(
         array(
           'items' => hsprintf('%s', $sort_menu),
         ));
 
     return $sort_button;
   }
 
   private function buildFilterMenu(
     PhabricatorUser $viewer,
     PhabricatorProject $project,
     $custom_query,
     PhabricatorApplicationSearchEngine $engine,
     $query_key) {
 
     $named = array(
       'open' => pht('Open Tasks'),
       'all' => pht('All Tasks'),
     );
 
     if ($viewer->isLoggedIn()) {
       $named['assigned'] = pht('Assigned to Me');
     }
 
     if ($custom_query) {
       $named[$custom_query->getQueryKey()] = pht('Custom Filter');
     }
 
     $items = array();
     foreach ($named as $key => $name) {
       $is_selected = ($key == $query_key);
       if ($is_selected) {
         $active_filter = $name;
       }
 
       $is_custom = false;
       if ($custom_query) {
         $is_custom = ($key == $custom_query->getQueryKey());
       }
 
       $item = id(new PhabricatorActionView())
         ->setIcon('fa-search')
         ->setSelected($is_selected)
         ->setName($name);
 
       if ($is_custom) {
         $uri = $this->getApplicationURI(
           'board/'.$this->id.'/filter/query/'.$key.'/');
         $item->setWorkflow(true);
       } else {
         $uri = $engine->getQueryResultsPageURI($key);
       }
 
       $uri = $this->getURIWithState($uri)
         ->setQueryParam('filter', null);
       $item->setHref($uri);
 
       $items[] = $item;
     }
 
     $id = $project->getID();
 
     $filter_uri = $this->getApplicationURI("board/{$id}/filter/");
     $filter_uri = $this->getURIWithState($filter_uri, $force = true);
 
     $items[] = id(new PhabricatorActionView())
       ->setIcon('fa-cog')
       ->setHref($filter_uri)
       ->setWorkflow(true)
       ->setName(pht('Advanced Filter...'));
 
     $save_uri = "default/{$id}/filter/";
     $save_uri = $this->getApplicationURI($save_uri);
     $save_uri = $this->getURIWithState($save_uri, $force = true);
 
     $can_edit = PhabricatorPolicyFilter::hasCapability(
       $viewer,
       $project,
       PhabricatorPolicyCapability::CAN_EDIT);
 
     $items[] = id(new PhabricatorActionView())
       ->setIcon('fa-floppy-o')
       ->setName(pht('Save as Default'))
       ->setHref($save_uri)
       ->setWorkflow(true)
       ->setDisabled(!$can_edit);
 
     $filter_menu = id(new PhabricatorActionListView())
         ->setUser($viewer);
     foreach ($items as $item) {
       $filter_menu->addAction($item);
     }
 
     $filter_button = id(new PHUIListItemView())
       ->setName($active_filter)
       ->setIcon('fa-search')
       ->setHref('#')
       ->addSigil('boards-dropdown-menu')
       ->setMetadata(
         array(
           'items' => hsprintf('%s', $filter_menu),
         ));
 
     return $filter_button;
   }
 
   private function buildManageMenu(
     PhabricatorProject $project,
     $show_hidden) {
 
     $request = $this->getRequest();
     $viewer = $request->getUser();
 
     $id = $project->getID();
 
     $disable_uri = $this->getApplicationURI("board/{$id}/disable/");
     $add_uri = $this->getApplicationURI("board/{$id}/edit/");
     $reorder_uri = $this->getApplicationURI("board/{$id}/reorder/");
 
     $can_edit = PhabricatorPolicyFilter::hasCapability(
       $viewer,
       $project,
       PhabricatorPolicyCapability::CAN_EDIT);
 
     $manage_items = array();
 
     $manage_items[] = id(new PhabricatorActionView())
       ->setIcon('fa-plus')
       ->setName(pht('Add Column'))
       ->setHref($add_uri)
       ->setDisabled(!$can_edit)
       ->setWorkflow(true);
 
     $manage_items[] = id(new PhabricatorActionView())
       ->setIcon('fa-exchange')
       ->setName(pht('Reorder Columns'))
       ->setHref($reorder_uri)
       ->setDisabled(!$can_edit)
       ->setWorkflow(true);
 
     if ($show_hidden) {
       $hidden_uri = $this->getURIWithState()
         ->setQueryParam('hidden', null);
       $hidden_icon = 'fa-eye-slash';
       $hidden_text = pht('Hide Hidden Columns');
     } else {
       $hidden_uri = $this->getURIWithState()
         ->setQueryParam('hidden', 'true');
       $hidden_icon = 'fa-eye';
       $hidden_text = pht('Show Hidden Columns');
     }
 
     $manage_items[] = id(new PhabricatorActionView())
       ->setIcon($hidden_icon)
       ->setName($hidden_text)
       ->setHref($hidden_uri);
 
     $batch_edit_uri = $request->getRequestURI();
     $batch_edit_uri->setQueryParam('batch', self::BATCH_EDIT_ALL);
     $can_batch_edit = PhabricatorPolicyFilter::hasCapability(
       $viewer,
       PhabricatorApplication::getByClass('PhabricatorManiphestApplication'),
       ManiphestBulkEditCapability::CAPABILITY);
 
     $manage_items[] = id(new PhabricatorActionView())
       ->setIcon('fa-list-ul')
       ->setName(pht('Batch Edit Visible Tasks...'))
       ->setHref($batch_edit_uri)
       ->setDisabled(!$can_batch_edit);
 
     $manage_items[] = id(new PhabricatorActionView())
       ->setIcon('fa-ban')
       ->setName(pht('Disable Workboard'))
       ->setHref($disable_uri)
       ->setWorkflow(true)
       ->setDisabled(!$can_edit);
 
     $manage_menu = id(new PhabricatorActionListView())
         ->setUser($viewer);
     foreach ($manage_items as $item) {
       $manage_menu->addAction($item);
     }
 
     $manage_button = id(new PHUIListItemView())
       ->setIcon('fa-cog')
       ->setHref('#')
       ->addSigil('boards-dropdown-menu')
       ->addSigil('has-tooltip')
       ->setMetadata(
         array(
           'tip' => pht('Manage'),
           'align' => 'S',
           'items' => hsprintf('%s', $manage_menu),
         ));
 
     return $manage_button;
   }
 
   private function buildFullscreenMenu() {
 
     $up = id(new PHUIListItemView())
       ->setIcon('fa-arrows-alt')
       ->setHref('#')
       ->addClass('phui-workboard-expand-icon')
       ->addSigil('jx-toggle-class')
       ->addSigil('has-tooltip')
       ->setMetaData(array(
         'tip' => pht('Fullscreen'),
         'map' => array(
           'phabricator-standard-page' => 'phui-workboard-fullscreen',
         ),
       ));
 
     return $up;
   }
 
   private function buildColumnMenu(
     PhabricatorProject $project,
     PhabricatorProjectColumn $column) {
 
     $request = $this->getRequest();
     $viewer = $request->getUser();
 
     $can_edit = PhabricatorPolicyFilter::hasCapability(
       $viewer,
       $project,
       PhabricatorPolicyCapability::CAN_EDIT);
 
     $column_items = array();
 
     if ($column->getProxyPHID()) {
       $default_phid = $column->getProxyPHID();
     } else {
       $default_phid = $column->getProjectPHID();
     }
 
     $column_items[] = id(new PhabricatorActionView())
       ->setIcon('fa-plus')
       ->setName(pht('Create Task...'))
       ->setHref($this->getCreateURI())
       ->addSigil('column-add-task')
       ->setMetadata(
         array(
           'columnPHID' => $column->getPHID(),
           'boardPHID' => $project->getPHID(),
           'projectPHID' => $default_phid,
         ));
 
     $batch_edit_uri = $request->getRequestURI();
     $batch_edit_uri->setQueryParam('batch', $column->getID());
     $can_batch_edit = PhabricatorPolicyFilter::hasCapability(
       $viewer,
       PhabricatorApplication::getByClass('PhabricatorManiphestApplication'),
       ManiphestBulkEditCapability::CAPABILITY);
 
     $column_items[] = id(new PhabricatorActionView())
       ->setIcon('fa-list-ul')
       ->setName(pht('Batch Edit Tasks...'))
       ->setHref($batch_edit_uri)
       ->setDisabled(!$can_batch_edit);
 
     $detail_uri = $this->getApplicationURI(
       'board/'.$this->id.'/column/'.$column->getID().'/');
 
     $column_items[] = id(new PhabricatorActionView())
       ->setIcon('fa-columns')
       ->setName(pht('Column Details'))
       ->setHref($detail_uri);
 
     $can_hide = ($can_edit && !$column->isDefaultColumn());
     $hide_uri = 'board/'.$this->id.'/hide/'.$column->getID().'/';
     $hide_uri = $this->getApplicationURI($hide_uri);
     $hide_uri = $this->getURIWithState($hide_uri);
 
     if (!$column->isHidden()) {
       $column_items[] = id(new PhabricatorActionView())
         ->setName(pht('Hide Column'))
         ->setIcon('fa-eye-slash')
         ->setHref($hide_uri)
         ->setDisabled(!$can_hide)
         ->setWorkflow(true);
     } else {
       $column_items[] = id(new PhabricatorActionView())
         ->setName(pht('Show Column'))
         ->setIcon('fa-eye')
         ->setHref($hide_uri)
         ->setDisabled(!$can_hide)
         ->setWorkflow(true);
     }
 
     $column_menu = id(new PhabricatorActionListView())
       ->setUser($viewer);
     foreach ($column_items as $item) {
       $column_menu->addAction($item);
     }
 
     $column_button = id(new PHUIIconView())
       ->setIcon('fa-caret-down')
       ->setHref('#')
       ->addSigil('boards-dropdown-menu')
       ->setMetadata(
         array(
           'items' => hsprintf('%s', $column_menu),
         ));
 
     return $column_button;
   }
 
 
   /**
    * Add current state parameters (like order and the visibility of hidden
    * columns) to a URI.
    *
    * This allows actions which toggle or adjust one piece of state to keep
    * the rest of the board state persistent. If no URI is provided, this method
    * starts with the request URI.
    *
    * @param string|null URI to add state parameters to.
    * @param bool True to explicitly include all state.
    * @return PhutilURI URI with state parameters.
    */
   private function getURIWithState($base = null, $force = false) {
     $project = $this->getProject();
 
     if ($base === null) {
       $base = $this->getRequest()->getRequestURI();
     }
 
     $base = new PhutilURI($base);
 
     if ($force || ($this->sortKey != $this->getDefaultSort($project))) {
       $base->setQueryParam('order', $this->sortKey);
     } else {
       $base->setQueryParam('order', null);
     }
 
     if ($force || ($this->queryKey != $this->getDefaultFilter($project))) {
       $base->setQueryParam('filter', $this->queryKey);
     } else {
       $base->setQueryParam('filter', null);
     }
 
     $base->setQueryParam('hidden', $this->showHidden ? 'true' : null);
 
     return $base;
   }
 
   private function getCreateURI() {
     $viewer = $this->getViewer();
 
     // TODO: This should be cleaned up, but maybe we're going to make options
     // for each column or board?
     $edit_config = id(new ManiphestEditEngine())
       ->setViewer($viewer)
       ->loadDefaultEditConfiguration();
     if ($edit_config) {
       $form_key = $edit_config->getIdentifier();
       $create_uri = "/maniphest/task/edit/form/{$form_key}/";
     } else {
       $create_uri = '/maniphest/task/edit/';
     }
 
     return $create_uri;
   }
 
 
   private function buildInitializeContent(PhabricatorProject $project) {
     $request = $this->getRequest();
     $viewer = $this->getViewer();
 
     $type = $request->getStr('initialize-type');
 
     $id = $project->getID();
 
     $profile_uri = $this->getApplicationURI("profile/{$id}/");
     $board_uri = $this->getApplicationURI("board/{$id}/");
     $import_uri = $this->getApplicationURI("board/{$id}/import/");
 
     $set_default = $request->getBool('default');
     if ($set_default) {
       $this
         ->getProfilePanelEngine()
         ->adjustDefault(PhabricatorProject::PANEL_WORKBOARD);
     }
 
     if ($request->isFormPost()) {
       if ($type == 'backlog-only') {
         $column = PhabricatorProjectColumn::initializeNewColumn($viewer)
           ->setSequence(0)
           ->setProperty('isDefault', true)
           ->setProjectPHID($project->getPHID())
           ->save();
 
         $project->setHasWorkboard(1)->save();
 
         return id(new AphrontRedirectResponse())
           ->setURI($board_uri);
       } else {
         return id(new AphrontRedirectResponse())
           ->setURI($import_uri);
       }
     }
 
     // TODO: Tailor this UI if the project is already a parent project. We
     // should not offer options for creating a parent project workboard, since
     // they can't have their own columns.
 
     $new_selector = id(new AphrontFormRadioButtonControl())
       ->setLabel(pht('Columns'))
       ->setName('initialize-type')
       ->setValue('backlog-only')
       ->addButton(
         'backlog-only',
         pht('New Empty Board'),
         pht('Create a new board with just a backlog column.'))
       ->addButton(
         'import',
         pht('Import Columns'),
         pht('Import board columns from another project.'));
 
     $default_checkbox = id(new AphrontFormCheckboxControl())
       ->setLabel(pht('Make Default'))
       ->addCheckbox(
         'default',
         1,
         pht('Make the workboard the default view for this project.'),
         true);
 
     $form = id(new AphrontFormView())
       ->setUser($viewer)
       ->addHiddenInput('initialize', 1)
       ->appendRemarkupInstructions(
         pht('The workboard for this project has not been created yet.'))
       ->appendControl($new_selector)
       ->appendControl($default_checkbox)
       ->appendControl(
         id(new AphrontFormSubmitControl())
           ->addCancelButton($profile_uri)
           ->setValue(pht('Create Workboard')));
 
     $box = id(new PHUIObjectBoxView())
       ->setHeaderText(pht('Create Workboard'))
       ->setForm($form);
 
     return $box;
   }
 
   private function buildNoAccessContent(PhabricatorProject $project) {
     $viewer = $this->getViewer();
 
     $id = $project->getID();
 
     $profile_uri = $this->getApplicationURI("profile/{$id}/");
 
     return $this->newDialog()
       ->setTitle(pht('Unable to Create Workboard'))
       ->appendParagraph(
         pht(
           'The workboard for this project has not been created yet, '.
           'but you do not have permission to create it. Only users '.
           'who can edit this project can create a workboard for it.'))
       ->addCancelButton($profile_uri);
   }
 
 
   private function buildEnableContent(PhabricatorProject $project) {
     $request = $this->getRequest();
     $viewer = $this->getViewer();
 
     $id = $project->getID();
     $profile_uri = $this->getApplicationURI("profile/{$id}/");
     $board_uri = $this->getApplicationURI("board/{$id}/");
 
     if ($request->isFormPost()) {
       $xactions = array();
 
       $xactions[] = id(new PhabricatorProjectTransaction())
         ->setTransactionType(PhabricatorProjectTransaction::TYPE_HASWORKBOARD)
         ->setNewValue(1);
 
       id(new PhabricatorProjectTransactionEditor())
         ->setActor($viewer)
         ->setContentSourceFromRequest($request)
         ->setContinueOnNoEffect(true)
         ->setContinueOnMissingFields(true)
         ->applyTransactions($project, $xactions);
 
       return id(new AphrontRedirectResponse())
         ->setURI($board_uri);
     }
 
     return $this->newDialog()
       ->setTitle(pht('Workboard Disabled'))
       ->addHiddenInput('initialize', 1)
       ->appendParagraph(
         pht(
           'This workboard has been disabled, but can be restored to its '.
           'former glory.'))
       ->addCancelButton($profile_uri)
       ->addSubmitButton(pht('Enable Workboard'));
   }
 
   private function buildDisabledContent(PhabricatorProject $project) {
     $viewer = $this->getViewer();
 
     $id = $project->getID();
 
     $profile_uri = $this->getApplicationURI("profile/{$id}/");
 
     return $this->newDialog()
       ->setTitle(pht('Workboard Disabled'))
       ->appendParagraph(
         pht(
           'This workboard has been disabled, and you do not have permission '.
           'to enable it. Only users who can edit this project can restore '.
           'the workboard.'))
       ->addCancelButton($profile_uri);
   }
 
 }
diff --git a/src/applications/project/engine/PhabricatorBoardLayoutEngine.php b/src/applications/project/engine/PhabricatorBoardLayoutEngine.php
index 3525af5ff0..248677fbec 100644
--- a/src/applications/project/engine/PhabricatorBoardLayoutEngine.php
+++ b/src/applications/project/engine/PhabricatorBoardLayoutEngine.php
@@ -1,609 +1,612 @@
 <?php
 
 final class PhabricatorBoardLayoutEngine extends Phobject {
 
   private $viewer;
   private $boardPHIDs;
   private $objectPHIDs;
   private $boards;
   private $columnMap = array();
   private $objectColumnMap = array();
   private $boardLayout = array();
   private $fetchAllBoards;
 
   private $remQueue = array();
   private $addQueue = array();
 
   public function setViewer(PhabricatorUser $viewer) {
     $this->viewer = $viewer;
     return $this;
   }
 
   public function getViewer() {
     return $this->viewer;
   }
 
   public function setBoardPHIDs(array $board_phids) {
     $this->boardPHIDs = array_fuse($board_phids);
     return $this;
   }
 
   public function getBoardPHIDs() {
     return $this->boardPHIDs;
   }
 
   public function setObjectPHIDs(array $object_phids) {
     $this->objectPHIDs = array_fuse($object_phids);
     return $this;
   }
 
   public function getObjectPHIDs() {
     return $this->objectPHIDs;
   }
 
   /**
    * Fetch all boards, even if the board is disabled.
    */
   public function setFetchAllBoards($fetch_all) {
     $this->fetchAllBoards = $fetch_all;
     return $this;
   }
 
   public function getFetchAllBoards() {
     return $this->fetchAllBoards;
   }
 
   public function executeLayout() {
     $viewer = $this->getViewer();
 
     $boards = $this->loadBoards();
     if (!$boards) {
       return $this;
     }
 
     $columns = $this->loadColumns($boards);
     $positions = $this->loadPositions($boards);
 
     foreach ($boards as $board_phid => $board) {
       $board_columns = idx($columns, $board_phid);
 
       // Don't layout boards with no columns. These boards need to be formally
       // created first.
       if (!$columns) {
         continue;
       }
 
       $board_positions = idx($positions, $board_phid, array());
 
       $this->layoutBoard($board, $board_columns, $board_positions);
     }
 
     return $this;
   }
 
   public function getColumns($board_phid) {
     $columns = idx($this->boardLayout, $board_phid, array());
     return array_select_keys($this->columnMap, array_keys($columns));
   }
 
   public function getColumnObjectPositions($board_phid, $column_phid) {
     $columns = idx($this->boardLayout, $board_phid, array());
     return idx($columns, $column_phid, array());
   }
 
 
   public function getColumnObjectPHIDs($board_phid, $column_phid) {
     $positions = $this->getColumnObjectPositions($board_phid, $column_phid);
     return mpull($positions, 'getObjectPHID');
   }
 
   public function getObjectColumns($board_phid, $object_phid) {
     $board_map = idx($this->objectColumnMap, $board_phid, array());
 
     $column_phids = idx($board_map, $object_phid);
     if (!$column_phids) {
       return array();
     }
 
     return array_select_keys($this->columnMap, $column_phids);
   }
 
   public function queueRemovePosition(
     $board_phid,
     $column_phid,
     $object_phid) {
 
     $board_layout = idx($this->boardLayout, $board_phid, array());
     $positions = idx($board_layout, $column_phid, array());
     $position = idx($positions, $object_phid);
 
     if ($position) {
       $this->remQueue[] = $position;
 
       // If this position hasn't been saved yet, get it out of the add queue.
       if (!$position->getID()) {
         foreach ($this->addQueue as $key => $add_position) {
           if ($add_position === $position) {
             unset($this->addQueue[$key]);
           }
         }
       }
     }
 
     unset($this->boardLayout[$board_phid][$column_phid][$object_phid]);
 
     return $this;
   }
 
   public function queueAddPositionBefore(
     $board_phid,
     $column_phid,
     $object_phid,
     $before_phid) {
 
     return $this->queueAddPositionRelative(
       $board_phid,
       $column_phid,
       $object_phid,
       $before_phid,
       true);
   }
 
   public function queueAddPositionAfter(
     $board_phid,
     $column_phid,
     $object_phid,
     $after_phid) {
 
     return $this->queueAddPositionRelative(
       $board_phid,
       $column_phid,
       $object_phid,
       $after_phid,
       false);
   }
 
   public function queueAddPosition(
     $board_phid,
     $column_phid,
     $object_phid) {
     return $this->queueAddPositionRelative(
       $board_phid,
       $column_phid,
       $object_phid,
       null,
       true);
   }
 
   private function queueAddPositionRelative(
     $board_phid,
     $column_phid,
     $object_phid,
     $relative_phid,
     $is_before) {
 
     $board_layout = idx($this->boardLayout, $board_phid, array());
     $positions = idx($board_layout, $column_phid, array());
 
     // Check if the object is already in the column, and remove it if it is.
     $object_position = idx($positions, $object_phid);
     unset($positions[$object_phid]);
 
     if (!$object_position) {
       $object_position = id(new PhabricatorProjectColumnPosition())
         ->setBoardPHID($board_phid)
         ->setColumnPHID($column_phid)
         ->setObjectPHID($object_phid);
     }
 
     $found = false;
     if (!$positions) {
       $object_position->setSequence(0);
     } else {
       foreach ($positions as $position) {
         if (!$found) {
           if ($relative_phid === null) {
             $is_match = true;
           } else {
             $position_phid = $position->getObjectPHID();
             $is_match = ($relative_phid == $position_phid);
           }
 
           if ($is_match) {
             $found = true;
 
             $sequence = $position->getSequence();
 
             if (!$is_before) {
               $sequence++;
             }
 
             $object_position->setSequence($sequence++);
 
             if (!$is_before) {
               // If we're inserting after this position, continue the loop so
               // we don't update it.
               continue;
             }
           }
         }
 
         if ($found) {
           $position->setSequence($sequence++);
           $this->addQueue[] = $position;
         }
       }
     }
 
     if ($relative_phid && !$found) {
       throw new Exception(
         pht(
           'Unable to find object "%s" in column "%s" on board "%s".',
           $relative_phid,
           $column_phid,
           $board_phid));
     }
 
     $this->addQueue[] = $object_position;
 
     $positions[$object_phid] = $object_position;
     $positions = msort($positions, 'getOrderingKey');
 
     $this->boardLayout[$board_phid][$column_phid] = $positions;
 
     return $this;
   }
 
   public function applyPositionUpdates() {
     foreach ($this->remQueue as $position) {
       if ($position->getID()) {
         $position->delete();
       }
     }
     $this->remQueue = array();
 
     $adds = array();
     $updates = array();
 
     foreach ($this->addQueue as $position) {
       $id = $position->getID();
       if ($id) {
         $updates[$id] = $position;
       } else {
         $adds[] = $position;
       }
     }
     $this->addQueue = array();
 
     $table = new PhabricatorProjectColumnPosition();
     $conn_w = $table->establishConnection('w');
 
     $pairs = array();
     foreach ($updates as $id => $position) {
       // This is ugly because MySQL gets upset with us if it is configured
       // strictly and we attempt inserts which can't work. We'll never actually
       // do these inserts since they'll always collide (triggering the ON
       // DUPLICATE KEY logic), so we just provide dummy values in order to get
       // there.
 
       $pairs[] = qsprintf(
         $conn_w,
         '(%d, %d, "", "", "")',
         $id,
         $position->getSequence());
     }
 
     if ($pairs) {
       queryfx(
         $conn_w,
         'INSERT INTO %T (id, sequence, boardPHID, columnPHID, objectPHID)
           VALUES %Q ON DUPLICATE KEY UPDATE sequence = VALUES(sequence)',
         $table->getTableName(),
         implode(', ', $pairs));
     }
 
     foreach ($adds as $position) {
       $position->save();
     }
 
     return $this;
   }
 
   private function loadBoards() {
     $viewer = $this->getViewer();
     $board_phids = $this->getBoardPHIDs();
 
     $boards = id(new PhabricatorObjectQuery())
       ->setViewer($viewer)
       ->withPHIDs($board_phids)
       ->execute();
     $boards = mpull($boards, null, 'getPHID');
 
     if (!$this->fetchAllBoards) {
       foreach ($boards as $key => $board) {
         if (!$board->getHasWorkboard()) {
           unset($boards[$key]);
         }
       }
     }
 
     return $boards;
   }
 
   private function loadColumns(array $boards) {
     $viewer = $this->getViewer();
 
     $columns = id(new PhabricatorProjectColumnQuery())
       ->setViewer($viewer)
       ->withProjectPHIDs(array_keys($boards))
       ->execute();
     $columns = msort($columns, 'getOrderingKey');
     $columns = mpull($columns, null, 'getPHID');
 
     $need_children = array();
     foreach ($boards as $phid => $board) {
       if ($board->getHasMilestones() || $board->getHasSubprojects()) {
         $need_children[] = $phid;
       }
     }
 
     if ($need_children) {
       $children = id(new PhabricatorProjectQuery())
         ->setViewer($viewer)
         ->withParentProjectPHIDs($need_children)
         ->execute();
       $children = mpull($children, null, 'getPHID');
       $children = mgroup($children, 'getParentProjectPHID');
     } else {
       $children = array();
     }
 
     $columns = mgroup($columns, 'getProjectPHID');
     foreach ($boards as $board_phid => $board) {
       $board_columns = idx($columns, $board_phid, array());
 
       // If the project has milestones, create any missing columns.
       if ($board->getHasMilestones() || $board->getHasSubprojects()) {
         $child_projects = idx($children, $board_phid, array());
 
         if ($board_columns) {
           $next_sequence = last($board_columns)->getSequence() + 1;
         } else {
           $next_sequence = 1;
         }
 
         $proxy_columns = mpull($board_columns, null, 'getProxyPHID');
         foreach ($child_projects as $child_phid => $child) {
           if (isset($proxy_columns[$child_phid])) {
             continue;
           }
 
           $new_column = PhabricatorProjectColumn::initializeNewColumn($viewer)
             ->attachProject($board)
             ->attachProxy($child)
             ->setSequence($next_sequence++)
             ->setProjectPHID($board_phid)
             ->setProxyPHID($child_phid);
 
           $unguarded = AphrontWriteGuard::beginScopedUnguardedWrites();
             $new_column->save();
           unset($unguarded);
 
           $board_columns[$new_column->getPHID()] = $new_column;
         }
       }
 
       $board_columns = msort($board_columns, 'getOrderingKey');
 
       $columns[$board_phid] = $board_columns;
     }
 
     foreach ($columns as $board_phid => $board_columns) {
       foreach ($board_columns as $board_column) {
         $column_phid = $board_column->getPHID();
         $this->columnMap[$column_phid] = $board_column;
       }
     }
 
     return $columns;
   }
 
   private function loadPositions(array $boards) {
     $viewer = $this->getViewer();
 
     $object_phids = $this->getObjectPHIDs();
     if (!$object_phids) {
       return array();
     }
 
     $positions = id(new PhabricatorProjectColumnPositionQuery())
       ->setViewer($viewer)
       ->withBoardPHIDs(array_keys($boards))
       ->withObjectPHIDs($object_phids)
       ->execute();
     $positions = msort($positions, 'getOrderingKey');
     $positions = mgroup($positions, 'getBoardPHID');
 
     return $positions;
   }
 
   private function layoutBoard(
     $board,
     array $columns,
     array $positions) {
 
     $viewer = $this->getViewer();
 
     $board_phid = $board->getPHID();
     $position_groups = mgroup($positions, 'getObjectPHID');
 
     $layout = array();
     $default_phid = null;
     foreach ($columns as $column) {
       $column_phid = $column->getPHID();
       $layout[$column_phid] = array();
 
       if ($column->isDefaultColumn()) {
         $default_phid = $column_phid;
       }
     }
 
     // Find all the columns which are proxies for other objects.
     $proxy_map = array();
     foreach ($columns as $column) {
       $proxy_phid = $column->getProxyPHID();
       if ($proxy_phid) {
         $proxy_map[$proxy_phid] = $column->getPHID();
       }
     }
 
     $object_phids = $this->getObjectPHIDs();
 
     // If we have proxies, we need to force cards into the correct proxy
     // columns.
     if ($proxy_map && $object_phids) {
       $edge_query = id(new PhabricatorEdgeQuery())
         ->withSourcePHIDs($object_phids)
         ->withEdgeTypes(
           array(
             PhabricatorProjectObjectHasProjectEdgeType::EDGECONST,
           ));
       $edge_query->execute();
 
       $project_phids = $edge_query->getDestinationPHIDs();
       $project_phids = array_fuse($project_phids);
     } else {
       $project_phids = array();
     }
 
     if ($project_phids) {
       $projects = id(new PhabricatorProjectQuery())
         ->setViewer($viewer)
         ->withPHIDs($project_phids)
         ->execute();
       $projects = mpull($projects, null, 'getPHID');
     } else {
       $projects = array();
     }
 
     // Build a map from every project that any task is tagged with to the
     // ancestor project which has a column on this board, if one exists.
     $ancestor_map = array();
     foreach ($projects as $phid => $project) {
       if (isset($proxy_map[$phid])) {
         $ancestor_map[$phid] = $proxy_map[$phid];
       } else {
         $seen = array($phid);
         foreach ($project->getAncestorProjects() as $ancestor) {
           $ancestor_phid = $ancestor->getPHID();
           $seen[] = $ancestor_phid;
           if (isset($proxy_map[$ancestor_phid])) {
             foreach ($seen as $project_phid) {
               $ancestor_map[$project_phid] = $proxy_map[$ancestor_phid];
             }
           }
         }
       }
     }
 
+    $view_sequence = 1;
     foreach ($object_phids as $object_phid) {
       $positions = idx($position_groups, $object_phid, array());
 
       // First, check for objects that have corresponding proxy columns. We're
       // going to overwrite normal column positions if a tag belongs to a proxy
       // column, since you can't be in normal columns if you're in proxy
       // columns.
       $proxy_hits = array();
       if ($proxy_map) {
         $object_project_phids = $edge_query->getDestinationPHIDs(
           array(
             $object_phid,
           ));
 
         foreach ($object_project_phids as $project_phid) {
           if (isset($ancestor_map[$project_phid])) {
             $proxy_hits[] = $ancestor_map[$project_phid];
           }
         }
       }
 
       if ($proxy_hits) {
         // TODO: For now, only one column hit is permissible.
         $proxy_hits = array_slice($proxy_hits, 0, 1);
 
         $proxy_hits = array_fuse($proxy_hits);
 
         // Check the object positions: we hope to find a position in each
         // column the object should be part of. We're going to drop any
         // invalid positions and create new positions where positions are
         // missing.
         foreach ($positions as $key => $position) {
           $column_phid = $position->getColumnPHID();
           if (isset($proxy_hits[$column_phid])) {
             // Valid column, mark the position as found.
             unset($proxy_hits[$column_phid]);
           } else {
             // Invalid column, ignore the position.
             unset($positions[$key]);
           }
         }
 
         // Create new positions for anything we haven't found.
         foreach ($proxy_hits as $proxy_hit) {
           $new_position = id(new PhabricatorProjectColumnPosition())
             ->setBoardPHID($board_phid)
             ->setColumnPHID($proxy_hit)
             ->setObjectPHID($object_phid)
-            ->setSequence(0);
+            ->setSequence(0)
+            ->setViewSequence($view_sequence++);
 
           $this->addQueue[] = $new_position;
 
           $positions[] = $new_position;
         }
       } else {
         // Ignore any positions in columns which no longer exist. We don't
         // actively destory them because the rest of the code ignores them and
         // there's no real need to destroy the data.
         foreach ($positions as $key => $position) {
           $column_phid = $position->getColumnPHID();
           if (empty($columns[$column_phid])) {
             unset($positions[$key]);
           }
         }
 
         // If the object has no position, put it on the default column if
         // one exists.
         if (!$positions && $default_phid) {
           $new_position = id(new PhabricatorProjectColumnPosition())
             ->setBoardPHID($board_phid)
             ->setColumnPHID($default_phid)
             ->setObjectPHID($object_phid)
-            ->setSequence(0);
+            ->setSequence(0)
+            ->setViewSequence($view_sequence++);
 
           $this->addQueue[] = $new_position;
 
           $positions = array(
             $new_position,
           );
         }
       }
 
       foreach ($positions as $position) {
         $column_phid = $position->getColumnPHID();
         $layout[$column_phid][$object_phid] = $position;
       }
     }
 
     foreach ($layout as $column_phid => $map) {
       $map = msort($map, 'getOrderingKey');
       $layout[$column_phid] = $map;
 
       foreach ($map as $object_phid => $position) {
         $this->objectColumnMap[$board_phid][$object_phid][] = $column_phid;
       }
     }
 
     $this->boardLayout[$board_phid] = $layout;
   }
 
 }
diff --git a/src/applications/project/storage/PhabricatorProjectColumnPosition.php b/src/applications/project/storage/PhabricatorProjectColumnPosition.php
index c59676f8e4..40929606ac 100644
--- a/src/applications/project/storage/PhabricatorProjectColumnPosition.php
+++ b/src/applications/project/storage/PhabricatorProjectColumnPosition.php
@@ -1,81 +1,94 @@
 <?php
 
 final class PhabricatorProjectColumnPosition extends PhabricatorProjectDAO
   implements PhabricatorPolicyInterface {
 
   protected $boardPHID;
   protected $columnPHID;
   protected $objectPHID;
   protected $sequence;
 
   private $column = self::ATTACHABLE;
+  private $viewSequence = 0;
 
   protected function getConfiguration() {
     return array(
       self::CONFIG_TIMESTAMPS => false,
       self::CONFIG_COLUMN_SCHEMA => array(
         'sequence' => 'uint32',
       ),
       self::CONFIG_KEY_SCHEMA => array(
         'boardPHID' => array(
           'columns' => array('boardPHID', 'columnPHID', 'objectPHID'),
           'unique' => true,
         ),
         'objectPHID' => array(
           'columns' => array('objectPHID', 'boardPHID'),
         ),
         'boardPHID_2' => array(
           'columns' => array('boardPHID', 'columnPHID', 'sequence'),
         ),
       ),
     ) + parent::getConfiguration();
   }
 
   public function getColumn() {
     return $this->assertAttached($this->column);
   }
 
   public function attachColumn(PhabricatorProjectColumn $column) {
     $this->column = $column;
     return $this;
   }
 
+  public function setViewSequence($view_sequence) {
+    $this->viewSequence = $view_sequence;
+    return $this;
+  }
+
   public function getOrderingKey() {
-    if (!$this->getID() && !$this->getSequence()) {
-      return 0;
-    }
+    // We're ordering both real positions and "virtual" positions which we have
+    // created but not saved yet.
+
+    // Low sequence numbers go above high sequence numbers. Virtual positions
+    // will have sequence number 0.
+
+    // High virtual sequence numbers go above low virtual sequence numbers.
+    // The layout engine gets objects in ID order, and this puts them in
+    // reverse ID order.
+
+    // High IDs go above low IDs.
 
-    // Low sequence numbers go above high sequence numbers.
-    // High position IDs go above low position IDs.
-    // Broadly, this makes newly added stuff float to the top.
+    // Broadly, this collectively makes newly added stuff float to the top.
 
     return sprintf(
-      '~%012d%012d',
+      '~%012d%012d%012d',
       $this->getSequence(),
+      ((1 << 31) - $this->viewSequence),
       ((1 << 31) - $this->getID()));
   }
 
 /* -(  PhabricatorPolicyInterface  )----------------------------------------- */
 
   public function getCapabilities() {
     return array(
       PhabricatorPolicyCapability::CAN_VIEW,
     );
   }
 
   public function getPolicy($capability) {
     switch ($capability) {
       case PhabricatorPolicyCapability::CAN_VIEW:
         return PhabricatorPolicies::getMostOpenPolicy();
     }
   }
 
   public function hasAutomaticCapability($capability, PhabricatorUser $viewer) {
     return false;
   }
 
   public function describeAutomaticCapability($capability) {
     return null;
   }
 
 }