diff --git a/src/applications/project/__tests__/PhabricatorProjectCoreTestCase.php b/src/applications/project/__tests__/PhabricatorProjectCoreTestCase.php
index 6c0f05ebbb..74f637f16d 100644
--- a/src/applications/project/__tests__/PhabricatorProjectCoreTestCase.php
+++ b/src/applications/project/__tests__/PhabricatorProjectCoreTestCase.php
@@ -1,1198 +1,1357 @@
 <?php
 
 final class PhabricatorProjectCoreTestCase extends PhabricatorTestCase {
 
   protected function getPhabricatorTestCaseConfiguration() {
     return array(
       self::PHABRICATOR_TESTCONFIG_BUILD_STORAGE_FIXTURES => true,
     );
   }
 
   public function testViewProject() {
     $user = $this->createUser();
     $user->save();
 
     $user2 = $this->createUser();
     $user2->save();
 
     $proj = $this->createProject($user);
 
     $proj = $this->refreshProject($proj, $user, true);
 
     $this->joinProject($proj, $user);
     $proj->setViewPolicy(PhabricatorPolicies::POLICY_USER);
     $proj->save();
 
     $can_view = PhabricatorPolicyCapability::CAN_VIEW;
 
     // When the view policy is set to "users", any user can see the project.
     $this->assertTrue((bool)$this->refreshProject($proj, $user));
     $this->assertTrue((bool)$this->refreshProject($proj, $user2));
 
 
     // When the view policy is set to "no one", members can still see the
     // project.
     $proj->setViewPolicy(PhabricatorPolicies::POLICY_NOONE);
     $proj->save();
 
     $this->assertTrue((bool)$this->refreshProject($proj, $user));
     $this->assertFalse((bool)$this->refreshProject($proj, $user2));
   }
 
   public function testIsViewerMemberOrWatcher() {
     $user1 = $this->createUser()
       ->save();
 
     $user2 = $this->createUser()
       ->save();
 
     $user3 = $this->createUser()
       ->save();
 
     $proj1 = $this->createProject($user1);
     $proj1 = $this->refreshProject($proj1, $user1);
 
     $this->joinProject($proj1, $user1);
     $this->joinProject($proj1, $user3);
     $this->watchProject($proj1, $user3);
 
     $proj1 = $this->refreshProject($proj1, $user1);
 
     $this->assertTrue($proj1->isUserMember($user1->getPHID()));
 
     $proj1 = $this->refreshProject($proj1, $user1, false, true);
 
     $this->assertTrue($proj1->isUserMember($user1->getPHID()));
     $this->assertFalse($proj1->isUserWatcher($user1->getPHID()));
 
     $proj1 = $this->refreshProject($proj1, $user1, true, false);
 
     $this->assertTrue($proj1->isUserMember($user1->getPHID()));
     $this->assertFalse($proj1->isUserMember($user2->getPHID()));
     $this->assertTrue($proj1->isUserMember($user3->getPHID()));
 
     $proj1 = $this->refreshProject($proj1, $user1, true, true);
 
     $this->assertTrue($proj1->isUserMember($user1->getPHID()));
     $this->assertFalse($proj1->isUserMember($user2->getPHID()));
     $this->assertTrue($proj1->isUserMember($user3->getPHID()));
 
     $this->assertFalse($proj1->isUserWatcher($user1->getPHID()));
     $this->assertFalse($proj1->isUserWatcher($user2->getPHID()));
     $this->assertTrue($proj1->isUserWatcher($user3->getPHID()));
   }
 
   public function testEditProject() {
     $user = $this->createUser();
     $user->save();
 
     $user2 = $this->createUser();
     $user2->save();
 
     $proj = $this->createProject($user);
 
 
     // When edit and view policies are set to "user", anyone can edit.
     $proj->setViewPolicy(PhabricatorPolicies::POLICY_USER);
     $proj->setEditPolicy(PhabricatorPolicies::POLICY_USER);
     $proj->save();
 
     $this->assertTrue($this->attemptProjectEdit($proj, $user));
 
 
     // When edit policy is set to "no one", no one can edit.
     $proj->setEditPolicy(PhabricatorPolicies::POLICY_NOONE);
     $proj->save();
 
     $caught = null;
     try {
       $this->attemptProjectEdit($proj, $user);
     } catch (Exception $ex) {
       $caught = $ex;
     }
     $this->assertTrue($caught instanceof Exception);
   }
 
   public function testAncestorMembers() {
     $user1 = $this->createUser();
     $user1->save();
 
     $user2 = $this->createUser();
     $user2->save();
 
     $parent = $this->createProject($user1);
     $child = $this->createProject($user1, $parent);
 
     $this->joinProject($child, $user1);
     $this->joinProject($child, $user2);
 
     $project = id(new PhabricatorProjectQuery())
       ->setViewer($user1)
       ->withPHIDs(array($child->getPHID()))
       ->needAncestorMembers(true)
       ->executeOne();
 
     $members = array_fuse($project->getParentProject()->getMemberPHIDs());
     ksort($members);
 
     $expect = array_fuse(
       array(
         $user1->getPHID(),
         $user2->getPHID(),
       ));
     ksort($expect);
 
     $this->assertEqual($expect, $members);
   }
 
   public function testAncestryQueries() {
     $user = $this->createUser();
     $user->save();
 
     $ancestor = $this->createProject($user);
     $parent = $this->createProject($user, $ancestor);
     $child = $this->createProject($user, $parent);
 
     $projects = id(new PhabricatorProjectQuery())
       ->setViewer($user)
       ->withAncestorProjectPHIDs(array($ancestor->getPHID()))
       ->execute();
     $this->assertEqual(2, count($projects));
 
     $projects = id(new PhabricatorProjectQuery())
       ->setViewer($user)
       ->withParentProjectPHIDs(array($ancestor->getPHID()))
       ->execute();
     $this->assertEqual(1, count($projects));
     $this->assertEqual(
       $parent->getPHID(),
       head($projects)->getPHID());
 
     $projects = id(new PhabricatorProjectQuery())
       ->setViewer($user)
       ->withAncestorProjectPHIDs(array($ancestor->getPHID()))
       ->withDepthBetween(2, null)
       ->execute();
     $this->assertEqual(1, count($projects));
     $this->assertEqual(
       $child->getPHID(),
       head($projects)->getPHID());
 
     $parent2 = $this->createProject($user, $ancestor);
     $child2 = $this->createProject($user, $parent2);
     $grandchild2 = $this->createProject($user, $child2);
 
     $projects = id(new PhabricatorProjectQuery())
       ->setViewer($user)
       ->withAncestorProjectPHIDs(array($ancestor->getPHID()))
       ->execute();
     $this->assertEqual(5, count($projects));
 
     $projects = id(new PhabricatorProjectQuery())
       ->setViewer($user)
       ->withParentProjectPHIDs(array($ancestor->getPHID()))
       ->execute();
     $this->assertEqual(2, count($projects));
 
     $projects = id(new PhabricatorProjectQuery())
       ->setViewer($user)
       ->withAncestorProjectPHIDs(array($ancestor->getPHID()))
       ->withDepthBetween(2, null)
       ->execute();
     $this->assertEqual(3, count($projects));
 
     $projects = id(new PhabricatorProjectQuery())
       ->setViewer($user)
       ->withAncestorProjectPHIDs(array($ancestor->getPHID()))
       ->withDepthBetween(3, null)
       ->execute();
     $this->assertEqual(1, count($projects));
 
     $projects = id(new PhabricatorProjectQuery())
       ->setViewer($user)
       ->withPHIDs(
         array(
           $child->getPHID(),
           $grandchild2->getPHID(),
         ))
       ->execute();
     $this->assertEqual(2, count($projects));
   }
 
   public function testMemberMaterialization() {
     $material_type = PhabricatorProjectMaterializedMemberEdgeType::EDGECONST;
 
     $user = $this->createUser();
     $user->save();
 
     $parent = $this->createProject($user);
     $child = $this->createProject($user, $parent);
 
     $this->joinProject($child, $user);
 
     $parent_material = PhabricatorEdgeQuery::loadDestinationPHIDs(
       $parent->getPHID(),
       $material_type);
 
     $this->assertEqual(
       array($user->getPHID()),
       $parent_material);
   }
 
   public function testMilestones() {
     $user = $this->createUser();
     $user->save();
 
     $parent = $this->createProject($user);
 
     $m1 = $this->createProject($user, $parent, true);
     $m2 = $this->createProject($user, $parent, true);
     $m3 = $this->createProject($user, $parent, true);
 
     $this->assertEqual(1, $m1->getMilestoneNumber());
     $this->assertEqual(2, $m2->getMilestoneNumber());
     $this->assertEqual(3, $m3->getMilestoneNumber());
   }
 
   public function testMilestoneMembership() {
     $user = $this->createUser();
     $user->save();
 
     $parent = $this->createProject($user);
     $milestone = $this->createProject($user, $parent, true);
 
     $this->joinProject($parent, $user);
 
     $milestone = id(new PhabricatorProjectQuery())
       ->setViewer($user)
       ->withPHIDs(array($milestone->getPHID()))
       ->executeOne();
 
     $this->assertTrue($milestone->isUserMember($user->getPHID()));
 
     $milestone = id(new PhabricatorProjectQuery())
       ->setViewer($user)
       ->withPHIDs(array($milestone->getPHID()))
       ->needMembers(true)
       ->executeOne();
 
     $this->assertEqual(
       array($user->getPHID()),
       $milestone->getMemberPHIDs());
   }
 
   public function testSameSlugAsName() {
     // It should be OK to type the primary hashtag into "additional hashtags",
     // even if the primary hashtag doesn't exist yet because you're creating
     // or renaming the project.
 
     $user = $this->createUser();
     $user->save();
 
     $project = $this->createProject($user);
 
     // In this first case, set the name and slugs at the same time.
     $name = 'slugproject';
 
     $xactions = array();
     $xactions[] = id(new PhabricatorProjectTransaction())
       ->setTransactionType(PhabricatorProjectTransaction::TYPE_NAME)
       ->setNewValue($name);
     $this->applyTransactions($project, $user, $xactions);
 
     $xactions = array();
     $xactions[] = id(new PhabricatorProjectTransaction())
       ->setTransactionType(PhabricatorProjectTransaction::TYPE_SLUGS)
       ->setNewValue(array($name));
     $this->applyTransactions($project, $user, $xactions);
 
     $project = id(new PhabricatorProjectQuery())
       ->setViewer($user)
       ->withPHIDs(array($project->getPHID()))
       ->needSlugs(true)
       ->executeOne();
 
     $slugs = $project->getSlugs();
     $slugs = mpull($slugs, 'getSlug');
 
     $this->assertTrue(in_array($name, $slugs));
 
     // In this second case, set the name first and then the slugs separately.
     $name2 = 'slugproject2';
     $xactions = array();
 
     $xactions[] = id(new PhabricatorProjectTransaction())
       ->setTransactionType(PhabricatorProjectTransaction::TYPE_NAME)
       ->setNewValue($name2);
 
     $xactions[] = id(new PhabricatorProjectTransaction())
       ->setTransactionType(PhabricatorProjectTransaction::TYPE_SLUGS)
       ->setNewValue(array($name2));
 
     $this->applyTransactions($project, $user, $xactions);
 
     $project = id(new PhabricatorProjectQuery())
       ->setViewer($user)
       ->withPHIDs(array($project->getPHID()))
       ->needSlugs(true)
       ->executeOne();
 
     $slugs = $project->getSlugs();
     $slugs = mpull($slugs, 'getSlug');
 
     $this->assertTrue(in_array($name2, $slugs));
   }
 
   public function testDuplicateSlugs() {
     // Creating a project with multiple duplicate slugs should succeed.
 
     $user = $this->createUser();
     $user->save();
 
     $project = $this->createProject($user);
 
     $input = 'duplicate';
 
     $xactions = array();
 
     $xactions[] = id(new PhabricatorProjectTransaction())
       ->setTransactionType(PhabricatorProjectTransaction::TYPE_SLUGS)
       ->setNewValue(array($input, $input));
 
     $this->applyTransactions($project, $user, $xactions);
 
     $project = id(new PhabricatorProjectQuery())
       ->setViewer($user)
       ->withPHIDs(array($project->getPHID()))
       ->needSlugs(true)
       ->executeOne();
 
     $slugs = $project->getSlugs();
     $slugs = mpull($slugs, 'getSlug');
 
     $this->assertTrue(in_array($input, $slugs));
   }
 
   public function testNormalizeSlugs() {
     // When a user creates a project with slug "XxX360n0sc0perXxX", normalize
     // it before writing it.
 
     $user = $this->createUser();
     $user->save();
 
     $project = $this->createProject($user);
 
     $input = 'NoRmAlIzE';
     $expect = 'normalize';
 
     $xactions = array();
 
     $xactions[] = id(new PhabricatorProjectTransaction())
       ->setTransactionType(PhabricatorProjectTransaction::TYPE_SLUGS)
       ->setNewValue(array($input));
 
     $this->applyTransactions($project, $user, $xactions);
 
     $project = id(new PhabricatorProjectQuery())
       ->setViewer($user)
       ->withPHIDs(array($project->getPHID()))
       ->needSlugs(true)
       ->executeOne();
 
     $slugs = $project->getSlugs();
     $slugs = mpull($slugs, 'getSlug');
 
     $this->assertTrue(in_array($expect, $slugs));
 
 
     // If another user tries to add the same slug in denormalized form, it
     // should be caught and fail, even though the database version of the slug
     // is normalized.
 
     $project2 = $this->createProject($user);
 
     $xactions = array();
 
     $xactions[] = id(new PhabricatorProjectTransaction())
       ->setTransactionType(PhabricatorProjectTransaction::TYPE_SLUGS)
       ->setNewValue(array($input));
 
     $caught = null;
     try {
       $this->applyTransactions($project2, $user, $xactions);
     } catch (PhabricatorApplicationTransactionValidationException $ex) {
       $caught = $ex;
     }
 
     $this->assertTrue((bool)$caught);
   }
 
   public function testProjectMembersVisibility() {
     // This is primarily testing that you can create a project and set the
     // visibility or edit policy to "Project Members" immediately.
 
     $user1 = $this->createUser();
     $user1->save();
 
     $user2 = $this->createUser();
     $user2->save();
 
     $project = PhabricatorProject::initializeNewProject($user1);
     $name = pht('Test Project %d', mt_rand());
 
     $xactions = array();
 
     $xactions[] = id(new PhabricatorProjectTransaction())
       ->setTransactionType(PhabricatorProjectTransaction::TYPE_NAME)
       ->setNewValue($name);
 
     $xactions[] = id(new PhabricatorProjectTransaction())
       ->setTransactionType(PhabricatorTransactions::TYPE_VIEW_POLICY)
       ->setNewValue(
         id(new PhabricatorProjectMembersPolicyRule())
           ->getObjectPolicyFullKey());
 
     $edge_type = PhabricatorProjectProjectHasMemberEdgeType::EDGECONST;
 
     $xactions[] = id(new PhabricatorProjectTransaction())
       ->setTransactionType(PhabricatorTransactions::TYPE_EDGE)
       ->setMetadataValue('edge:type', $edge_type)
       ->setNewValue(
         array(
           '=' => array($user1->getPHID() => $user1->getPHID()),
         ));
 
     $this->applyTransactions($project, $user1, $xactions);
 
     $this->assertTrue((bool)$this->refreshProject($project, $user1));
     $this->assertFalse((bool)$this->refreshProject($project, $user2));
 
     $this->leaveProject($project, $user1);
 
     $this->assertFalse((bool)$this->refreshProject($project, $user1));
   }
 
   public function testParentProject() {
     $user = $this->createUser();
     $user->save();
 
     $parent = $this->createProject($user);
     $child = $this->createProject($user, $parent);
 
     $this->assertTrue(true);
 
     $child = $this->refreshProject($child, $user);
 
     $this->assertEqual(
       $parent->getPHID(),
       $child->getParentProject()->getPHID());
 
     $this->assertEqual(1, (int)$child->getProjectDepth());
 
     $this->assertFalse(
       $child->isUserMember($user->getPHID()));
 
     $this->assertFalse(
       $child->getParentProject()->isUserMember($user->getPHID()));
 
     $this->joinProject($child, $user);
 
     $child = $this->refreshProject($child, $user);
 
     $this->assertTrue(
       $child->isUserMember($user->getPHID()));
 
     $this->assertTrue(
       $child->getParentProject()->isUserMember($user->getPHID()));
 
 
     // Test that hiding a parent hides the child.
 
     $user2 = $this->createUser();
     $user2->save();
 
     // Second user can see the project for now.
     $this->assertTrue((bool)$this->refreshProject($child, $user2));
 
     // Hide the parent.
     $this->setViewPolicy($parent, $user, $user->getPHID());
 
     // First user (who can see the parent because they are a member of
     // the child) can see the project.
     $this->assertTrue((bool)$this->refreshProject($child, $user));
 
     // Second user can not, because they can't see the parent.
     $this->assertFalse((bool)$this->refreshProject($child, $user2));
   }
 
   public function testSlugMaps() {
     // When querying by slugs, slugs should be normalized and the mapping
     // should be reported correctly.
     $user = $this->createUser();
     $user->save();
 
     $name = 'queryslugproject';
     $name2 = 'QUERYslugPROJECT';
     $slug = 'queryslugextra';
     $slug2 = 'QuErYSlUgExTrA';
 
     $project = PhabricatorProject::initializeNewProject($user);
 
     $xactions = array();
 
     $xactions[] = id(new PhabricatorProjectTransaction())
       ->setTransactionType(PhabricatorProjectTransaction::TYPE_NAME)
       ->setNewValue($name);
 
     $xactions[] = id(new PhabricatorProjectTransaction())
       ->setTransactionType(PhabricatorProjectTransaction::TYPE_SLUGS)
       ->setNewValue(array($slug));
 
     $this->applyTransactions($project, $user, $xactions);
 
     $project_query = id(new PhabricatorProjectQuery())
       ->setViewer($user)
       ->withSlugs(array($name));
     $project_query->execute();
     $map = $project_query->getSlugMap();
 
     $this->assertEqual(
       array(
         $name => $project->getPHID(),
       ),
       ipull($map, 'projectPHID'));
 
     $project_query = id(new PhabricatorProjectQuery())
       ->setViewer($user)
       ->withSlugs(array($slug));
     $project_query->execute();
     $map = $project_query->getSlugMap();
 
     $this->assertEqual(
       array(
         $slug => $project->getPHID(),
       ),
       ipull($map, 'projectPHID'));
 
     $project_query = id(new PhabricatorProjectQuery())
       ->setViewer($user)
       ->withSlugs(array($name, $slug, $name2, $slug2));
     $project_query->execute();
     $map = $project_query->getSlugMap();
 
     $expect = array(
       $name => $project->getPHID(),
       $slug => $project->getPHID(),
       $name2 => $project->getPHID(),
       $slug2 => $project->getPHID(),
     );
 
     $actual = ipull($map, 'projectPHID');
 
     ksort($expect);
     ksort($actual);
 
     $this->assertEqual($expect, $actual);
 
     $expect = array(
       $name => $name,
       $slug => $slug,
       $name2 => $name,
       $slug2 => $slug,
     );
 
     $actual = ipull($map, 'slug');
 
     ksort($expect);
     ksort($actual);
 
     $this->assertEqual($expect, $actual);
   }
 
   public function testJoinLeaveProject() {
     $user = $this->createUser();
     $user->save();
 
     $proj = $this->createProjectWithNewAuthor();
 
     $proj = $this->refreshProject($proj, $user, true);
     $this->assertTrue(
       (bool)$proj,
       pht(
         'Assumption that projects are default visible '.
         'to any user when created.'));
 
     $this->assertFalse(
       $proj->isUserMember($user->getPHID()),
       pht('Arbitrary user not member of project.'));
 
     // Join the project.
     $this->joinProject($proj, $user);
 
     $proj = $this->refreshProject($proj, $user, true);
     $this->assertTrue((bool)$proj);
 
     $this->assertTrue(
       $proj->isUserMember($user->getPHID()),
       pht('Join works.'));
 
 
     // Join the project again.
     $this->joinProject($proj, $user);
 
     $proj = $this->refreshProject($proj, $user, true);
     $this->assertTrue((bool)$proj);
 
     $this->assertTrue(
       $proj->isUserMember($user->getPHID()),
       pht('Joining an already-joined project is a no-op.'));
 
 
     // Leave the project.
     $this->leaveProject($proj, $user);
 
     $proj = $this->refreshProject($proj, $user, true);
     $this->assertTrue((bool)$proj);
 
     $this->assertFalse(
       $proj->isUserMember($user->getPHID()),
       pht('Leave works.'));
 
 
     // Leave the project again.
     $this->leaveProject($proj, $user);
 
     $proj = $this->refreshProject($proj, $user, true);
     $this->assertTrue((bool)$proj);
 
     $this->assertFalse(
       $proj->isUserMember($user->getPHID()),
       pht('Leaving an already-left project is a no-op.'));
 
 
     // If a user can't edit or join a project, joining fails.
     $proj->setEditPolicy(PhabricatorPolicies::POLICY_NOONE);
     $proj->setJoinPolicy(PhabricatorPolicies::POLICY_NOONE);
     $proj->save();
 
     $proj = $this->refreshProject($proj, $user, true);
     $caught = null;
     try {
       $this->joinProject($proj, $user);
     } catch (Exception $ex) {
       $caught = $ex;
     }
     $this->assertTrue($ex instanceof Exception);
 
 
     // If a user can edit a project, they can join.
     $proj->setEditPolicy(PhabricatorPolicies::POLICY_USER);
     $proj->setJoinPolicy(PhabricatorPolicies::POLICY_NOONE);
     $proj->save();
 
     $proj = $this->refreshProject($proj, $user, true);
     $this->joinProject($proj, $user);
     $proj = $this->refreshProject($proj, $user, true);
     $this->assertTrue(
       $proj->isUserMember($user->getPHID()),
       pht('Join allowed with edit permission.'));
     $this->leaveProject($proj, $user);
 
 
     // If a user can join a project, they can join, even if they can't edit.
     $proj->setEditPolicy(PhabricatorPolicies::POLICY_NOONE);
     $proj->setJoinPolicy(PhabricatorPolicies::POLICY_USER);
     $proj->save();
 
     $proj = $this->refreshProject($proj, $user, true);
     $this->joinProject($proj, $user);
     $proj = $this->refreshProject($proj, $user, true);
     $this->assertTrue(
       $proj->isUserMember($user->getPHID()),
       pht('Join allowed with join permission.'));
 
 
     // A user can leave a project even if they can't edit it or join.
     $proj->setEditPolicy(PhabricatorPolicies::POLICY_NOONE);
     $proj->setJoinPolicy(PhabricatorPolicies::POLICY_NOONE);
     $proj->save();
 
     $proj = $this->refreshProject($proj, $user, true);
     $this->leaveProject($proj, $user);
     $proj = $this->refreshProject($proj, $user, true);
     $this->assertFalse(
       $proj->isUserMember($user->getPHID()),
       pht('Leave allowed without any permission.'));
   }
 
 
   public function testComplexConstraints() {
     $user = $this->createUser();
     $user->save();
 
     $engineering = $this->createProject($user);
     $engineering_scan = $this->createProject($user, $engineering);
     $engineering_warp = $this->createProject($user, $engineering);
 
     $exploration = $this->createProject($user);
     $exploration_diplomacy = $this->createProject($user, $exploration);
 
     $task_engineering = $this->newTask(
       $user,
       array($engineering),
       pht('Engineering Only'));
 
     $task_exploration = $this->newTask(
       $user,
       array($exploration),
       pht('Exploration Only'));
 
     $task_warp_explore = $this->newTask(
       $user,
       array($engineering_warp, $exploration),
       pht('Warp to New Planet'));
 
     $task_diplomacy_scan = $this->newTask(
       $user,
       array($engineering_scan, $exploration_diplomacy),
       pht('Scan Diplomat'));
 
     $task_diplomacy = $this->newTask(
       $user,
       array($exploration_diplomacy),
       pht('Diplomatic Meeting'));
 
     $task_warp_scan = $this->newTask(
       $user,
       array($engineering_scan, $engineering_warp),
       pht('Scan Warp Drives'));
 
     $this->assertQueryByProjects(
       $user,
       array(
         $task_engineering,
         $task_warp_explore,
         $task_diplomacy_scan,
         $task_warp_scan,
       ),
       array($engineering),
       pht('All Engineering'));
 
     $this->assertQueryByProjects(
       $user,
       array(
         $task_diplomacy_scan,
         $task_warp_scan,
       ),
       array($engineering_scan),
       pht('All Scan'));
 
     $this->assertQueryByProjects(
       $user,
       array(
         $task_warp_explore,
         $task_diplomacy_scan,
       ),
       array($engineering, $exploration),
       pht('Engineering + Exploration'));
 
     // This is testing that a query for "Parent" and "Parent > Child" works
     // properly.
     $this->assertQueryByProjects(
       $user,
       array(
         $task_diplomacy_scan,
         $task_warp_scan,
       ),
       array($engineering, $engineering_scan),
       pht('Engineering + Scan'));
   }
 
   public function testTagAncestryConflicts() {
     $user = $this->createUser();
     $user->save();
 
     $stonework = $this->createProject($user);
     $stonework_masonry = $this->createProject($user, $stonework);
     $stonework_sculpting = $this->createProject($user, $stonework);
 
     $task = $this->newTask($user, array());
     $this->assertEqual(array(), $this->getTaskProjects($task));
 
     $this->addProjectTags($user, $task, array($stonework->getPHID()));
     $this->assertEqual(
       array(
         $stonework->getPHID(),
       ),
       $this->getTaskProjects($task));
 
     // Adding a descendant should remove the parent.
     $this->addProjectTags($user, $task, array($stonework_masonry->getPHID()));
     $this->assertEqual(
       array(
         $stonework_masonry->getPHID(),
       ),
       $this->getTaskProjects($task));
 
     // Adding an ancestor should remove the descendant.
     $this->addProjectTags($user, $task, array($stonework->getPHID()));
     $this->assertEqual(
       array(
         $stonework->getPHID(),
       ),
       $this->getTaskProjects($task));
 
     // Adding two tags in the same hierarchy which are not mutual ancestors
     // should remove the ancestor but otherwise work fine.
     $this->addProjectTags(
       $user,
       $task,
       array(
         $stonework_masonry->getPHID(),
         $stonework_sculpting->getPHID(),
       ));
 
     $expect = array(
       $stonework_masonry->getPHID(),
       $stonework_sculpting->getPHID(),
     );
     sort($expect);
 
     $this->assertEqual($expect,  $this->getTaskProjects($task));
   }
 
   public function testTagMilestoneConflicts() {
     $user = $this->createUser();
     $user->save();
 
     $stonework = $this->createProject($user);
     $stonework_1 = $this->createProject($user, $stonework, true);
     $stonework_2 = $this->createProject($user, $stonework, true);
 
     $task = $this->newTask($user, array());
     $this->assertEqual(array(), $this->getTaskProjects($task));
 
     $this->addProjectTags($user, $task, array($stonework->getPHID()));
     $this->assertEqual(
       array(
         $stonework->getPHID(),
       ),
       $this->getTaskProjects($task));
 
     // Adding a milesone should remove the parent.
     $this->addProjectTags($user, $task, array($stonework_1->getPHID()));
     $this->assertEqual(
       array(
         $stonework_1->getPHID(),
       ),
       $this->getTaskProjects($task));
 
     // Adding the parent should remove the milestone.
     $this->addProjectTags($user, $task, array($stonework->getPHID()));
     $this->assertEqual(
       array(
         $stonework->getPHID(),
       ),
       $this->getTaskProjects($task));
 
     // First, add one milestone.
     $this->addProjectTags($user, $task, array($stonework_1->getPHID()));
     // Now, adding a second milestone should remove the first milestone.
     $this->addProjectTags($user, $task, array($stonework_2->getPHID()));
     $this->assertEqual(
       array(
         $stonework_2->getPHID(),
       ),
       $this->getTaskProjects($task));
   }
 
+  public function testBoardMoves() {
+    $user = $this->createUser();
+    $user->save();
+
+    $board = $this->createProject($user);
+
+    $backlog = $this->addColumn($user, $board, 0);
+    $column = $this->addColumn($user, $board, 1);
+
+    // New tasks should appear in the backlog.
+    $task1 = $this->newTask($user, array($board));
+    $expect = array(
+      $backlog->getPHID(),
+    );
+    $this->assertColumns($expect, $user, $board, $task1);
+
+    // Moving a task should move it to the destination column.
+    $this->moveToColumn($user, $board, $task1, $backlog, $column);
+    $expect = array(
+      $column->getPHID(),
+    );
+    $this->assertColumns($expect, $user, $board, $task1);
+
+    // Same thing again, with a new task.
+    $task2 = $this->newTask($user, array($board));
+    $expect = array(
+      $backlog->getPHID(),
+    );
+    $this->assertColumns($expect, $user, $board, $task2);
+
+    // Move it, too.
+    $this->moveToColumn($user, $board, $task2, $backlog, $column);
+    $expect = array(
+      $column->getPHID(),
+    );
+    $this->assertColumns($expect, $user, $board, $task2);
+
+    // Now the stuff should be in the column, in order, with the more recently
+    // moved task on top.
+    $expect = array(
+      $task2->getPHID(),
+      $task1->getPHID(),
+    );
+    $this->assertTasksInColumn($expect, $user, $board, $column);
+
+    // Move the second task after the first task.
+    $options = array(
+      'afterPHID' => $task1->getPHID(),
+    );
+    $this->moveToColumn($user, $board, $task2, $column, $column, $options);
+    $expect = array(
+      $task1->getPHID(),
+      $task2->getPHID(),
+    );
+    $this->assertTasksInColumn($expect, $user, $board, $column);
+
+    // Move the second task before the first task.
+    $options = array(
+      'beforePHID' => $task1->getPHID(),
+    );
+    $this->moveToColumn($user, $board, $task2, $column, $column, $options);
+    $expect = array(
+      $task2->getPHID(),
+      $task1->getPHID(),
+    );
+    $this->assertTasksInColumn($expect, $user, $board, $column);
+
+  }
+
+  private function moveToColumn(
+    PhabricatorUser $viewer,
+    PhabricatorProject $board,
+    ManiphestTask $task,
+    PhabricatorProjectColumn $src,
+    PhabricatorProjectColumn $dst,
+    $options = null) {
+
+    $xactions = array();
+
+    if (!$options) {
+      $options = array();
+    }
+
+    $xactions[] = id(new ManiphestTransaction())
+      ->setTransactionType(ManiphestTransaction::TYPE_PROJECT_COLUMN)
+      ->setOldValue(
+        array(
+          'projectPHID' => $board->getPHID(),
+          'columnPHIDs' => array($src->getPHID()),
+        ))
+      ->setNewValue(
+        array(
+          'projectPHID' => $board->getPHID(),
+          'columnPHIDs' => array($dst->getPHID()),
+        ) + $options);
+
+    $editor = id(new ManiphestTransactionEditor())
+      ->setActor($viewer)
+      ->setContentSource(PhabricatorContentSource::newConsoleSource())
+      ->setContinueOnNoEffect(true)
+      ->applyTransactions($task, $xactions);
+  }
+
+  private function assertColumns(
+    array $expect,
+    PhabricatorUser $viewer,
+    PhabricatorProject $board,
+    ManiphestTask $task) {
+
+    $engine = id(new PhabricatorBoardLayoutEngine())
+      ->setViewer($viewer)
+      ->setBoardPHIDs(array($board->getPHID()))
+      ->setObjectPHIDs(
+        array(
+          $task->getPHID(),
+        ))
+      ->executeLayout();
+
+    $columns = $engine->getObjectColumns($board->getPHID(), $task->getPHID());
+    $column_phids = mpull($columns, 'getPHID');
+    $column_phids = array_values($column_phids);
+
+    $this->assertEqual($expect, $column_phids);
+  }
+
+  private function assertTasksInColumn(
+    array $expect,
+    PhabricatorUser $viewer,
+    PhabricatorProject $board,
+    PhabricatorProjectColumn $column) {
+
+    $engine = id(new PhabricatorBoardLayoutEngine())
+      ->setViewer($viewer)
+      ->setBoardPHIDs(array($board->getPHID()))
+      ->setObjectPHIDs($expect)
+      ->executeLayout();
+
+    $object_phids = $engine->getColumnObjectPHIDs(
+      $board->getPHID(),
+      $column->getPHID());
+    $object_phids = array_values($object_phids);
+
+    $this->assertEqual($expect, $object_phids);
+  }
+
+  private function addColumn(
+    PhabricatorUser $viewer,
+    PhabricatorProject $project,
+    $sequence) {
+
+    $project->setHasWorkboard(1)->save();
+
+    return PhabricatorProjectColumn::initializeNewColumn($viewer)
+      ->setSequence(0)
+      ->setProperty('isDefault', ($sequence == 0))
+      ->setProjectPHID($project->getPHID())
+      ->save();
+  }
+
   private function getTaskProjects(ManiphestTask $task) {
     $project_phids = PhabricatorEdgeQuery::loadDestinationPHIDs(
       $task->getPHID(),
       PhabricatorProjectObjectHasProjectEdgeType::EDGECONST);
 
     sort($project_phids);
 
     return $project_phids;
   }
 
   private function attemptProjectEdit(
     PhabricatorProject $proj,
     PhabricatorUser $user,
     $skip_refresh = false) {
 
     $proj = $this->refreshProject($proj, $user, true);
 
     $new_name = $proj->getName().' '.mt_rand();
 
     $xaction = new PhabricatorProjectTransaction();
     $xaction->setTransactionType(PhabricatorProjectTransaction::TYPE_NAME);
     $xaction->setNewValue($new_name);
 
     $this->applyTransactions($proj, $user, array($xaction));
 
     return true;
   }
 
 
   private function addProjectTags(
     PhabricatorUser $viewer,
     ManiphestTask $task,
     array $phids) {
 
     $xactions = array();
 
     $xactions[] = id(new ManiphestTransaction())
       ->setTransactionType(PhabricatorTransactions::TYPE_EDGE)
       ->setMetadataValue(
         'edge:type',
         PhabricatorProjectObjectHasProjectEdgeType::EDGECONST)
       ->setNewValue(
         array(
           '+' => array_fuse($phids),
         ));
 
     $editor = id(new ManiphestTransactionEditor())
       ->setActor($viewer)
       ->setContentSource(PhabricatorContentSource::newConsoleSource())
       ->setContinueOnNoEffect(true)
       ->applyTransactions($task, $xactions);
   }
 
   private function newTask(
     PhabricatorUser $viewer,
     array $projects,
     $name = null) {
 
     $task = ManiphestTask::initializeNewTask($viewer);
 
     if (!strlen($name)) {
       $name = pht('Test Task');
     }
 
     $xactions = array();
 
     $xactions[] = id(new ManiphestTransaction())
       ->setTransactionType(ManiphestTransaction::TYPE_TITLE)
       ->setNewValue($name);
 
     if ($projects) {
       $xactions[] = id(new ManiphestTransaction())
         ->setTransactionType(PhabricatorTransactions::TYPE_EDGE)
         ->setMetadataValue(
           'edge:type',
           PhabricatorProjectObjectHasProjectEdgeType::EDGECONST)
         ->setNewValue(
           array(
             '=' => array_fuse(mpull($projects, 'getPHID')),
           ));
     }
 
     $editor = id(new ManiphestTransactionEditor())
       ->setActor($viewer)
       ->setContentSource(PhabricatorContentSource::newConsoleSource())
       ->setContinueOnNoEffect(true)
       ->applyTransactions($task, $xactions);
 
     return $task;
   }
 
   private function assertQueryByProjects(
     PhabricatorUser $viewer,
     array $expect,
     array $projects,
     $label = null) {
 
     $datasource = id(new PhabricatorProjectLogicalDatasource())
       ->setViewer($viewer);
 
     $project_phids = mpull($projects, 'getPHID');
     $constraints = $datasource->evaluateTokens($project_phids);
 
     $query = id(new ManiphestTaskQuery())
       ->setViewer($viewer);
 
     $query->withEdgeLogicConstraints(
       PhabricatorProjectObjectHasProjectEdgeType::EDGECONST,
       $constraints);
 
     $tasks = $query->execute();
 
     $expect_phids = mpull($expect, 'getTitle', 'getPHID');
     ksort($expect_phids);
 
     $actual_phids = mpull($tasks, 'getTitle', 'getPHID');
     ksort($actual_phids);
 
     $this->assertEqual($expect_phids, $actual_phids, $label);
   }
 
   private function refreshProject(
     PhabricatorProject $project,
     PhabricatorUser $viewer,
     $need_members = false,
     $need_watchers = false) {
 
     $results = id(new PhabricatorProjectQuery())
       ->setViewer($viewer)
       ->needMembers($need_members)
       ->needWatchers($need_watchers)
       ->withIDs(array($project->getID()))
       ->execute();
 
     if ($results) {
       return head($results);
     } else {
       return null;
     }
   }
 
   private function createProject(
     PhabricatorUser $user,
     PhabricatorProject $parent = null,
     $is_milestone = false) {
 
     $project = PhabricatorProject::initializeNewProject($user);
 
 
     $name = pht('Test Project %d', mt_rand());
 
     $xactions = array();
 
     $xactions[] = id(new PhabricatorProjectTransaction())
       ->setTransactionType(PhabricatorProjectTransaction::TYPE_NAME)
       ->setNewValue($name);
 
     if ($parent) {
       if ($is_milestone) {
         $xactions[] = id(new PhabricatorProjectTransaction())
           ->setTransactionType(PhabricatorProjectTransaction::TYPE_MILESTONE)
           ->setNewValue($parent->getPHID());
       } else {
         $xactions[] = id(new PhabricatorProjectTransaction())
           ->setTransactionType(PhabricatorProjectTransaction::TYPE_PARENT)
           ->setNewValue($parent->getPHID());
       }
     }
 
     $this->applyTransactions($project, $user, $xactions);
 
     return $project;
   }
 
   private function setViewPolicy(
     PhabricatorProject $project,
     PhabricatorUser $user,
     $policy) {
 
     $xactions = array();
 
     $xactions[] = id(new PhabricatorProjectTransaction())
       ->setTransactionType(PhabricatorTransactions::TYPE_VIEW_POLICY)
       ->setNewValue($policy);
 
     $this->applyTransactions($project, $user, $xactions);
 
     return $project;
   }
 
   private function createProjectWithNewAuthor() {
     $author = $this->createUser();
     $author->save();
 
     $project = $this->createProject($author);
 
     return $project;
   }
 
   private function createUser() {
     $rand = mt_rand();
 
     $user = new PhabricatorUser();
     $user->setUsername('unittestuser'.$rand);
     $user->setRealName(pht('Unit Test User %d', $rand));
 
     return $user;
   }
 
   private function joinProject(
     PhabricatorProject $project,
     PhabricatorUser $user) {
     return $this->joinOrLeaveProject($project, $user, '+');
   }
 
   private function leaveProject(
     PhabricatorProject $project,
     PhabricatorUser $user) {
     return $this->joinOrLeaveProject($project, $user, '-');
   }
 
   private function watchProject(
     PhabricatorProject $project,
     PhabricatorUser $user) {
     return $this->watchOrUnwatchProject($project, $user, '+');
   }
 
   private function unwatchProject(
     PhabricatorProject $project,
     PhabricatorUser $user) {
     return $this->watchOrUnwatchProject($project, $user, '-');
   }
 
   private function joinOrLeaveProject(
     PhabricatorProject $project,
     PhabricatorUser $user,
     $operation) {
     return $this->applyProjectEdgeTransaction(
       $project,
       $user,
       $operation,
       PhabricatorProjectProjectHasMemberEdgeType::EDGECONST);
   }
 
   private function watchOrUnwatchProject(
     PhabricatorProject $project,
     PhabricatorUser $user,
     $operation) {
     return $this->applyProjectEdgeTransaction(
       $project,
       $user,
       $operation,
       PhabricatorObjectHasWatcherEdgeType::EDGECONST);
   }
 
   private function applyProjectEdgeTransaction(
     PhabricatorProject $project,
     PhabricatorUser $user,
     $operation,
     $edge_type) {
 
     $spec = array(
       $operation => array($user->getPHID() => $user->getPHID()),
     );
 
     $xactions = array();
     $xactions[] = id(new PhabricatorProjectTransaction())
       ->setTransactionType(PhabricatorTransactions::TYPE_EDGE)
       ->setMetadataValue('edge:type', $edge_type)
       ->setNewValue($spec);
 
     $this->applyTransactions($project, $user, $xactions);
 
     return $project;
   }
 
   private function applyTransactions(
     PhabricatorProject $project,
     PhabricatorUser $user,
     array $xactions) {
 
     $editor = id(new PhabricatorProjectTransactionEditor())
       ->setActor($user)
       ->setContentSource(PhabricatorContentSource::newConsoleSource())
       ->setContinueOnNoEffect(true)
       ->applyTransactions($project, $xactions);
   }
 
 
 }
diff --git a/src/applications/project/engine/PhabricatorBoardLayoutEngine.php b/src/applications/project/engine/PhabricatorBoardLayoutEngine.php
index 8a6143c81d..e578131c83 100644
--- a/src/applications/project/engine/PhabricatorBoardLayoutEngine.php
+++ b/src/applications/project/engine/PhabricatorBoardLayoutEngine.php
@@ -1,412 +1,412 @@
 <?php
 
 final class PhabricatorBoardLayoutEngine extends Phobject {
 
   private $viewer;
   private $boardPHIDs;
   private $objectPHIDs;
   private $boards;
   private $columnMap = array();
   private $objectColumnMap = array();
   private $boardLayout = array();
 
   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 = $board_phids;
+    $this->boardPHIDs = array_fuse($board_phids);
     return $this;
   }
 
   public function getBoardPHIDs() {
     return $this->boardPHIDs;
   }
 
   public function setObjectPHIDs(array $object_phids) {
-    $this->objectPHIDs = $object_phids;
+    $this->objectPHIDs = array_fuse($object_phids);
     return $this;
   }
 
   public function getObjectPHIDs() {
     return $this->objectPHIDs;
   }
 
   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 getColumnObjectPHIDs($board_phid, $column_phid) {
     $columns = idx($this->boardLayout, $board_phid, array());
     $positions = idx($columns, $column_phid, array());
     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');
 
     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, 'getSequence');
     $columns = mpull($columns, null, 'getPHID');
 
     $this->columnMap = $columns;
     $columns = mgroup($columns, 'getProjectPHID');
 
     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) {
 
     $board_phid = $board->getPHID();
     $position_groups = mgroup($positions, 'getObjectPHID');
 
     $layout = array();
     foreach ($columns as $column) {
       $column_phid = $column->getPHID();
       $layout[$column_phid] = array();
 
       if ($column->isDefaultColumn()) {
         $default_phid = $column_phid;
       }
     }
 
     $object_phids = $this->getObjectPHIDs();
     foreach ($object_phids as $object_phid) {
       $positions = idx($position_groups, $object_phid, array());
 
       // Remove any positions in columns which no longer exist.
       foreach ($positions as $key => $position) {
         $column_phid = $position->getColumnPHID();
         if (empty($columns[$column_phid])) {
           $this->remQueue[] = $position;
           unset($positions[$key]);
         }
       }
 
       // If the object has no position, put it on the default column.
       if (!$positions) {
         $new_position = id(new PhabricatorProjectColumnPosition())
           ->setBoardPHID($board_phid)
           ->setColumnPHID($default_phid)
           ->setObjectPHID($object_phid)
           ->setSequence(0);
 
         $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;
   }
 
 }