diff --git a/src/applications/maniphest/storage/ManiphestTask.php b/src/applications/maniphest/storage/ManiphestTask.php
index 0a313a5b16..d3f30b03c0 100644
--- a/src/applications/maniphest/storage/ManiphestTask.php
+++ b/src/applications/maniphest/storage/ManiphestTask.php
@@ -1,323 +1,324 @@
 <?php
 
 final class ManiphestTask extends ManiphestDAO
   implements
     PhabricatorMarkupInterface,
     PhabricatorPolicyInterface,
     PhabricatorTokenReceiverInterface,
     PhabricatorFlaggableInterface,
     PhrequentTrackableInterface,
     PhabricatorCustomFieldInterface,
     PhabricatorDestructibleInterface,
     PhabricatorApplicationTransactionInterface {
 
   const MARKUP_FIELD_DESCRIPTION = 'markup:desc';
 
   protected $authorPHID;
   protected $ownerPHID;
   protected $ccPHIDs = array();
 
   protected $status;
   protected $priority;
   protected $subpriority = 0;
 
   protected $title = '';
   protected $originalTitle = '';
   protected $description = '';
   protected $originalEmailSource;
   protected $mailKey;
   protected $viewPolicy = PhabricatorPolicies::POLICY_USER;
   protected $editPolicy = PhabricatorPolicies::POLICY_USER;
 
   protected $attached = array();
   protected $projectPHIDs = array();
   private $subscribersNeedUpdate;
 
   protected $ownerOrdering;
 
   private $groupByProjectPHID = self::ATTACHABLE;
   private $customFields = self::ATTACHABLE;
   private $edgeProjectPHIDs = self::ATTACHABLE;
 
   public static function initializeNewTask(PhabricatorUser $actor) {
     $app = id(new PhabricatorApplicationQuery())
       ->setViewer($actor)
       ->withClasses(array('PhabricatorManiphestApplication'))
       ->executeOne();
 
     $view_policy = $app->getPolicy(ManiphestDefaultViewCapability::CAPABILITY);
     $edit_policy = $app->getPolicy(ManiphestDefaultEditCapability::CAPABILITY);
 
     return id(new ManiphestTask())
       ->setStatus(ManiphestTaskStatus::getDefaultStatus())
       ->setPriority(ManiphestTaskPriority::getDefaultPriority())
       ->setAuthorPHID($actor->getPHID())
       ->setViewPolicy($view_policy)
       ->setEditPolicy($edit_policy)
       ->attachProjectPHIDs(array());
   }
 
   public function getConfiguration() {
     return array(
       self::CONFIG_AUX_PHID => true,
       self::CONFIG_SERIALIZATION => array(
         'ccPHIDs' => self::SERIALIZATION_JSON,
         'attached' => self::SERIALIZATION_JSON,
         'projectPHIDs' => self::SERIALIZATION_JSON,
       ),
     ) + parent::getConfiguration();
   }
 
   public function loadDependsOnTaskPHIDs() {
     return PhabricatorEdgeQuery::loadDestinationPHIDs(
       $this->getPHID(),
       PhabricatorEdgeConfig::TYPE_TASK_DEPENDS_ON_TASK);
   }
 
   public function loadDependedOnByTaskPHIDs() {
     return PhabricatorEdgeQuery::loadDestinationPHIDs(
       $this->getPHID(),
       PhabricatorEdgeConfig::TYPE_TASK_DEPENDED_ON_BY_TASK);
   }
 
   public function getAttachedPHIDs($type) {
     return array_keys(idx($this->attached, $type, array()));
   }
 
   public function generatePHID() {
     return PhabricatorPHID::generateNewPHID(ManiphestTaskPHIDType::TYPECONST);
   }
 
   public function getCCPHIDs() {
     return array_values(nonempty($this->ccPHIDs, array()));
   }
 
   public function getProjectPHIDs() {
     return $this->assertAttached($this->edgeProjectPHIDs);
   }
 
   public function attachProjectPHIDs(array $phids) {
     $this->edgeProjectPHIDs = $phids;
     return $this;
   }
 
   public function setCCPHIDs(array $phids) {
     $this->ccPHIDs = array_values($phids);
     $this->subscribersNeedUpdate = true;
     return $this;
   }
 
   public function setOwnerPHID($phid) {
     $this->ownerPHID = nonempty($phid, null);
     $this->subscribersNeedUpdate = true;
     return $this;
   }
 
   public function setTitle($title) {
     $this->title = $title;
     if (!$this->getID()) {
       $this->originalTitle = $title;
     }
     return $this;
   }
 
   public function getMonogram() {
     return 'T'.$this->getID();
   }
 
   public function attachGroupByProjectPHID($phid) {
     $this->groupByProjectPHID = $phid;
     return $this;
   }
 
   public function getGroupByProjectPHID() {
     return $this->assertAttached($this->groupByProjectPHID);
   }
 
   public function save() {
     if (!$this->mailKey) {
       $this->mailKey = Filesystem::readRandomCharacters(20);
     }
 
     $result = parent::save();
 
     if ($this->subscribersNeedUpdate) {
       // If we've changed the subscriber PHIDs for this task, update the link
       // table.
       ManiphestTaskSubscriber::updateTaskSubscribers($this);
       $this->subscribersNeedUpdate = false;
     }
 
     return $result;
   }
 
   public function isClosed() {
     return ManiphestTaskStatus::isClosedStatus($this->getStatus());
   }
 
   public function getPrioritySortVector() {
     return array(
       $this->getPriority(),
       -$this->getSubpriority(),
+      $this->getID(),
     );
   }
 
 
 /* -(  Markup Interface  )--------------------------------------------------- */
 
 
   /**
    * @task markup
    */
   public function getMarkupFieldKey($field) {
     $hash = PhabricatorHash::digest($this->getMarkupText($field));
     $id = $this->getID();
     return "maniphest:T{$id}:{$field}:{$hash}";
   }
 
 
   /**
    * @task markup
    */
   public function getMarkupText($field) {
     return $this->getDescription();
   }
 
 
   /**
    * @task markup
    */
   public function newMarkupEngine($field) {
     return PhabricatorMarkupEngine::newManiphestMarkupEngine();
   }
 
 
   /**
    * @task markup
    */
   public function didMarkupText(
     $field,
     $output,
     PhutilMarkupEngine $engine) {
     return $output;
   }
 
 
   /**
    * @task markup
    */
   public function shouldUseMarkupCache($field) {
     return (bool)$this->getID();
   }
 
 
 /* -(  Policy Interface  )--------------------------------------------------- */
 
 
   public function getCapabilities() {
     return array(
       PhabricatorPolicyCapability::CAN_VIEW,
       PhabricatorPolicyCapability::CAN_EDIT,
     );
   }
 
   public function getPolicy($capability) {
     switch ($capability) {
       case PhabricatorPolicyCapability::CAN_VIEW:
         return $this->getViewPolicy();
       case PhabricatorPolicyCapability::CAN_EDIT:
         return $this->getEditPolicy();
     }
   }
 
   public function hasAutomaticCapability($capability, PhabricatorUser $user) {
     // The owner of a task can always view and edit it.
     $owner_phid = $this->getOwnerPHID();
     if ($owner_phid) {
       $user_phid = $user->getPHID();
       if ($user_phid == $owner_phid) {
         return true;
       }
     }
 
     return false;
   }
 
   public function describeAutomaticCapability($capability) {
     return pht('The owner of a task can always view and edit it.');
   }
 
 
 /* -(  PhabricatorTokenReceiverInterface  )---------------------------------- */
 
 
   public function getUsersToNotifyOfTokenGiven() {
     // Sort of ambiguous who this was intended for; just let them both know.
     return array_filter(
       array_unique(
         array(
           $this->getAuthorPHID(),
           $this->getOwnerPHID(),
         )));
   }
 
 
 /* -(  PhabricatorCustomFieldInterface  )------------------------------------ */
 
 
   public function getCustomFieldSpecificationForRole($role) {
     return PhabricatorEnv::getEnvConfig('maniphest.fields');
   }
 
   public function getCustomFieldBaseClass() {
     return 'ManiphestCustomField';
   }
 
   public function getCustomFields() {
     return $this->assertAttached($this->customFields);
   }
 
   public function attachCustomFields(PhabricatorCustomFieldAttachment $fields) {
     $this->customFields = $fields;
     return $this;
   }
 
 
 /* -(  PhabricatorDestructibleInterface  )----------------------------------- */
 
 
   public function destroyObjectPermanently(
     PhabricatorDestructionEngine $engine) {
 
     $this->openTransaction();
 
       // TODO: Once this implements PhabricatorTransactionInterface, this
       // will be handled automatically and can be removed.
       $xactions = id(new ManiphestTransaction())->loadAllWhere(
         'objectPHID = %s',
         $this->getPHID());
       foreach ($xactions as $xaction) {
         $engine->destroyObject($xaction);
       }
 
       $this->delete();
     $this->saveTransaction();
   }
 
 
 /* -(  PhabricatorApplicationTransactionInterface  )------------------------- */
 
 
   public function getApplicationTransactionEditor() {
     return new ManiphestTransactionEditor();
   }
 
   public function getApplicationTransactionObject() {
     return $this;
   }
 
   public function getApplicationTransactionTemplate() {
     return new ManiphestTransaction();
   }
 
 }
diff --git a/webroot/rsrc/js/application/projects/behavior-project-boards.js b/webroot/rsrc/js/application/projects/behavior-project-boards.js
index 90320c60f4..c050562878 100644
--- a/webroot/rsrc/js/application/projects/behavior-project-boards.js
+++ b/webroot/rsrc/js/application/projects/behavior-project-boards.js
@@ -1,173 +1,181 @@
 /**
  * @provides javelin-behavior-project-boards
  * @requires javelin-behavior
  *           javelin-dom
  *           javelin-util
  *           javelin-stratcom
  *           javelin-workflow
  *           phabricator-draggable-list
  */
 
 JX.behavior('project-boards', function(config) {
 
   function finditems(col) {
     return JX.DOM.scry(col, 'li', 'project-card');
   }
 
   function onupdate(node) {
     JX.DOM.alterClass(node, 'project-column-empty', !this.findItems().length);
   }
 
   function onresponse(response, item, list) {
     list.unlock();
     JX.DOM.alterClass(item, 'drag-sending', false);
     JX.DOM.replace(item, JX.$H(response.task));
   }
 
   function colsort(u, v) {
     var ud = JX.Stratcom.getData(u).sort || [];
     var vd = JX.Stratcom.getData(v).sort || [];
 
     for (var ii = 0; ii < ud.length; ii++) {
-      if (ud[ii] < vd[ii]) {
+
+      if (parseInt(ud[ii]) < parseInt(vd[ii])) {
         return 1;
       }
-      if (ud[ii] > vd[ii]) {
+      if (parseInt(ud[ii]) > parseInt(vd[ii])) {
         return -1;
       }
     }
 
     return 0;
   }
 
   function ondrop(list, item, after) {
     list.lock();
     JX.DOM.alterClass(item, 'drag-sending', true);
 
     var item_phid = JX.Stratcom.getData(item).objectPHID;
     var data = {
       objectPHID: item_phid,
       columnPHID: JX.Stratcom.getData(list.getRootNode()).columnPHID
     };
 
     var after_phid = null;
     var items = finditems(list.getRootNode());
     if (after) {
       after_phid = JX.Stratcom.getData(after).objectPHID;
       data.afterPHID = after_phid;
     }
     var ii;
     var ii_item;
     var ii_item_phid;
     var ii_prev_item_phid = null;
     var before_phid = null;
     for (ii = 0; ii < items.length; ii++) {
       ii_item = items[ii];
       ii_item_phid = JX.Stratcom.getData(ii_item).objectPHID;
       if (ii_item_phid == item_phid) {
         // skip the item we just dropped
         continue;
       }
       // note this handles when there is no after phid - we are at the top of
       // the list - quite nicely
       if (ii_prev_item_phid == after_phid) {
         before_phid = ii_item_phid;
         break;
       }
       ii_prev_item_phid = ii_item_phid;
     }
     if (before_phid) {
       data.beforePHID = before_phid;
     }
 
     var workflow = new JX.Workflow(config.moveURI, data)
       .setHandler(function(response) {
         onresponse(response, item, list);
       });
 
     workflow.start();
   }
 
   var lists = [];
   var ii;
   var cols = JX.DOM.scry(JX.$(config.boardID), 'ul', 'project-column');
 
   for (ii = 0; ii < cols.length; ii++) {
     var list = new JX.DraggableList('project-card', cols[ii])
       .setFindItemsHandler(JX.bind(null, finditems, cols[ii]));
 
     list.listen('didSend', JX.bind(list, onupdate, cols[ii]));
     list.listen('didReceive', JX.bind(list, onupdate, cols[ii]));
 
     list.listen('didDrop', JX.bind(null, ondrop, list));
 
     lists.push(list);
   }
 
   for (ii = 0; ii < lists.length; ii++) {
     lists[ii].setGroup(lists);
   }
 
-  var onedit = function(card, column, r) {
+  var onedit = function(column, r) {
     var new_card = JX.$H(r.tasks).getNode();
     var new_data = JX.Stratcom.getData(new_card);
     var items = finditems(column);
+    var edited = false;
 
     for (var ii = 0; ii < items.length; ii++) {
       var item = items[ii];
 
       var data = JX.Stratcom.getData(item);
       var phid = data.objectPHID;
 
       if (phid == new_data.objectPHID) {
         items[ii] = new_card;
         data = new_data;
+        edited = true;
       }
 
       data.sort = r.data.sortMap[data.objectPHID] || data.sort;
     }
 
+    // this is an add then...!
+    if (!edited) {
+      items[items.length + 1] = new_card;
+      new_data.sort = r.data.sortMap[new_data.objectPHID] || new_data.sort;
+    }
+
     items.sort(colsort);
 
     JX.DOM.setContent(column, items);
   };
 
   JX.Stratcom.listen(
     'click',
     ['edit-project-card'],
     function(e) {
       e.kill();
-      var card = e.getNode('project-card');
       var column = e.getNode('project-column');
       var request_data = {
         'responseType' : 'card',
         'columnPHID'   : JX.Stratcom.getData(column).columnPHID };
       new JX.Workflow(e.getNode('tag:a').href, request_data)
-      .setHandler(JX.bind(null, onedit, card, column))
+      .setHandler(JX.bind(null, onedit, column))
       .start();
     });
 
   JX.Stratcom.listen(
     'click',
     ['column-add-task'],
     function (e) {
       e.kill();
       var column_phid = e.getNodeData('column-add-task').columnPHID;
       var request_data = {
         'responseType' : 'card',
         'columnPHID'   : column_phid,
         'projects'     : config.projectPHID };
       var cols = JX.DOM.scry(JX.$(config.boardID), 'ul', 'project-column');
       var ii;
       var column;
       for (ii = 0; ii < cols.length; ii++) {
         if (JX.Stratcom.getData(cols[ii]).columnPHID == column_phid) {
           column = cols[ii];
           break;
         }
       }
       new JX.Workflow(config.createURI, request_data)
-      .setHandler(JX.bind(null, onedit, null, column))
+      .setHandler(JX.bind(null, onedit, column))
       .start();
     });
 });