diff --git a/resources/sql/autopatches/20141107.phriction.policy.2.php b/resources/sql/autopatches/20141107.phriction.policy.2.php
index a7cc6ca3e4..5e00bd7a40 100644
--- a/resources/sql/autopatches/20141107.phriction.policy.2.php
+++ b/resources/sql/autopatches/20141107.phriction.policy.2.php
@@ -1,58 +1,60 @@
 <?php
 
 $table = new PhrictionDocument();
 $conn_w = $table->establishConnection('w');
 
 echo pht('Populating Phriction policies.')."\n";
 
 $default_view_policy = PhabricatorPolicies::POLICY_USER;
 $default_edit_policy = PhabricatorPolicies::POLICY_USER;
 
 foreach (new LiskMigrationIterator($table) as $doc) {
   $id = $doc->getID();
 
   if ($doc->getViewPolicy() && $doc->getEditPolicy()) {
     echo pht('Skipping document %d; already has policy set.', $id)."\n";
     continue;
   }
 
   // If this was previously a magical project wiki page (under projects/, but
   // not projects/ itself) we need to apply the project policies. Otherwise,
   // apply the default policies.
   $slug = $doc->getSlug();
   $slug = PhabricatorSlug::normalize($slug);
   $prefix = 'projects/';
   if (($slug != $prefix) && (strncmp($slug, $prefix, strlen($prefix)) === 0)) {
     $parts = explode('/', $slug);
-    $project_slug = $parts[1].'/';
+
+    $project_slug = $parts[1];
+    $project_slug = PhabricatorSlug::normalizeProjectSlug($project_slug);
 
     $project_slugs = array($project_slug);
     $project = id(new PhabricatorProjectQuery())
       ->setViewer(PhabricatorUser::getOmnipotentUser())
-      ->withPhrictionSlugs($project_slugs)
+      ->withSlugs($project_slugs)
       ->executeOne();
 
     if ($project) {
 
       $view_policy = nonempty($project->getViewPolicy(), $default_view_policy);
       $edit_policy = nonempty($project->getEditPolicy(), $default_edit_policy);
 
       $project_name = $project->getName();
       echo pht(
         "Migrating document %d to project policy %s...\n",
         $id,
         $project_name);
       $doc->setViewPolicy($view_policy);
       $doc->setEditPolicy($edit_policy);
       $doc->save();
       continue;
     }
   }
 
   echo pht('Migrating document %d to default install policy...', $id)."\n";
   $doc->setViewPolicy($default_view_policy);
   $doc->setEditPolicy($default_edit_policy);
   $doc->save();
 }
 
 echo pht('Done.')."\n";
diff --git a/resources/sql/patches/090.forceuniqueprojectnames.php b/resources/sql/patches/090.forceuniqueprojectnames.php
index a12de8ecfd..a3e029d50a 100644
--- a/resources/sql/patches/090.forceuniqueprojectnames.php
+++ b/resources/sql/patches/090.forceuniqueprojectnames.php
@@ -1,111 +1,112 @@
 <?php
 
 echo pht('Ensuring project names are unique enough...')."\n";
 $table = new PhabricatorProject();
 $table->openTransaction();
 $table->beginReadLocking();
 
 $projects = $table->loadAll();
 
 $slug_map = array();
 
 foreach ($projects as $project) {
-  $project->setPhrictionSlug($project->getName());
-  $slug = $project->getPhrictionSlug();
-  if ($slug == '/') {
+  $slug = PhabricatorSlug::normalizeProjectSlug($project->getName());
+
+  if (!strlen($slug)) {
     $project_id = $project->getID();
     echo pht("Project #%d doesn't have a meaningful name...", $project_id)."\n";
     $project->setName(trim(pht('Unnamed Project %s', $project->getName())));
   }
+
   $slug_map[$slug][] = $project->getID();
 }
 
 
 foreach ($slug_map as $slug => $similar) {
   if (count($similar) <= 1) {
     continue;
   }
   echo pht("Too many projects are similar to '%s'...", $slug)."\n";
 
   foreach (array_slice($similar, 1, null, true) as $key => $project_id) {
     $project = $projects[$project_id];
     $old_name = $project->getName();
     $new_name = rename_project($project, $projects);
 
     echo pht(
       "Renaming project #%d from '%s' to '%s'.\n",
       $project_id,
       $old_name,
       $new_name);
     $project->setName($new_name);
   }
 }
 
 $update = $projects;
 while ($update) {
   $size = count($update);
   foreach ($update as $key => $project) {
     $id = $project->getID();
     $name = $project->getName();
-    $project->setPhrictionSlug($name);
-    $slug = $project->getPhrictionSlug();
+
+    $slug = PhabricatorSlug::normalizeProjectSlug($name).'/';
 
     echo pht("Updating project #%d '%s' (%s)... ", $id, $name, $slug);
     try {
       queryfx(
         $project->establishConnection('w'),
         'UPDATE %T SET name = %s, phrictionSlug = %s WHERE id = %d',
         $project->getTableName(),
         $name,
         $slug,
         $project->getID());
       unset($update[$key]);
       echo pht('OKAY')."\n";
     } catch (AphrontDuplicateKeyQueryException $ex) {
       echo pht('Failed, will retry.')."\n";
     }
   }
   if (count($update) == $size) {
     throw new Exception(
       pht(
         'Failed to make any progress while updating projects. Schema upgrade '.
         'has failed. Go manually fix your project names to be unique '.
         '(they are probably ridiculous?) and then try again.'));
   }
 }
 
 $table->endReadLocking();
 $table->saveTransaction();
 echo pht('Done.')."\n";
 
 
 /**
  * Rename the project so that it has a unique slug, by appending (2), (3), etc.
  * to its name.
  */
 function rename_project($project, $projects) {
   $suffix = 2;
   while (true) {
     $new_name = $project->getName().' ('.$suffix.')';
-    $project->setPhrictionSlug($new_name);
-    $new_slug = $project->getPhrictionSlug();
+
+    $new_slug = PhabricatorSlug::normalizeProjectSlug($new_name).'/';
 
     $okay = true;
     foreach ($projects as $other) {
       if ($other->getID() == $project->getID()) {
         continue;
       }
       if ($other->getPhrictionSlug() == $new_slug) {
         $okay = false;
         break;
       }
     }
     if ($okay) {
       break;
     } else {
       $suffix++;
     }
   }
 
   return $new_name;
 }
diff --git a/src/applications/project/conduit/ProjectQueryConduitAPIMethod.php b/src/applications/project/conduit/ProjectQueryConduitAPIMethod.php
index 3d059d064d..2512a9a019 100644
--- a/src/applications/project/conduit/ProjectQueryConduitAPIMethod.php
+++ b/src/applications/project/conduit/ProjectQueryConduitAPIMethod.php
@@ -1,132 +1,132 @@
 <?php
 
 final class ProjectQueryConduitAPIMethod extends ProjectConduitAPIMethod {
 
   public function getAPIMethodName() {
     return 'project.query';
   }
 
   public function getMethodDescription() {
     return pht('Execute searches for Projects.');
   }
 
   protected function defineParamTypes() {
 
     $statuses = array(
       PhabricatorProjectQuery::STATUS_ANY,
       PhabricatorProjectQuery::STATUS_OPEN,
       PhabricatorProjectQuery::STATUS_CLOSED,
       PhabricatorProjectQuery::STATUS_ACTIVE,
       PhabricatorProjectQuery::STATUS_ARCHIVED,
     );
 
     $status_const = $this->formatStringConstants($statuses);
 
     return array(
       'ids'               => 'optional list<int>',
       'names'             => 'optional list<string>',
       'phids'             => 'optional list<phid>',
       'slugs'             => 'optional list<string>',
       'icons'             => 'optional list<string>',
       'colors'            => 'optional list<string>',
       'status'            => 'optional '.$status_const,
 
       'members'           => 'optional list<phid>',
 
       'limit'             => 'optional int',
       'offset'            => 'optional int',
     );
   }
 
   protected function defineReturnType() {
     return 'list';
   }
 
   protected function execute(ConduitAPIRequest $request) {
     $query = new PhabricatorProjectQuery();
     $query->setViewer($request->getUser());
     $query->needMembers(true);
     $query->needSlugs(true);
 
     $ids = $request->getValue('ids');
     if ($ids) {
       $query->withIDs($ids);
     }
 
     $names = $request->getValue('names');
     if ($names) {
       $query->withNames($names);
     }
 
     $status = $request->getValue('status');
     if ($status) {
       $query->withStatus($status);
     }
 
     $phids = $request->getValue('phids');
     if ($phids) {
       $query->withPHIDs($phids);
     }
 
     $slugs = $request->getValue('slugs');
     if ($slugs) {
       $query->withSlugs($slugs);
     }
 
     $request->getValue('icons');
     if ($request->getValue('icons')) {
       $icons = array();
       // the internal 'fa-' prefix is a detail hidden from api clients
       // but needs to pre prepended to the values in the icons array:
       foreach ($request->getValue('icons') as $value) {
         $icons[] = 'fa-'.$value;
       }
       $query->withIcons($icons);
     }
 
     $colors = $request->getValue('colors');
     if ($colors) {
       $query->withColors($colors);
     }
 
     $members = $request->getValue('members');
     if ($members) {
       $query->withMemberPHIDs($members);
     }
 
     $limit = $request->getValue('limit');
     if ($limit) {
       $query->setLimit($limit);
     }
 
     $offset = $request->getValue('offset');
     if ($offset) {
       $query->setOffset($offset);
     }
 
     $pager = $this->newPager($request);
     $results = $query->executeWithCursorPager($pager);
     $projects = $this->buildProjectInfoDictionaries($results);
 
     // TODO: This is pretty hideous.
     $slug_map = array();
     if ($slugs) {
       foreach ($slugs as $slug) {
-        $normal = rtrim(PhabricatorSlug::normalize($slug), '/');
+        $normal = PhabricatorSlug::normalizeProjectSlug($slug);
         foreach ($projects as $project) {
           if (in_array($normal, $project['slugs'])) {
             $slug_map[$slug] = $project['phid'];
           }
         }
       }
     }
 
     $result = array(
       'data' => $projects,
       'slugMap' => $slug_map,
     );
 
     return $this->addPagerResults($result, $pager);
   }
 
 }
diff --git a/src/applications/project/editor/PhabricatorProjectTransactionEditor.php b/src/applications/project/editor/PhabricatorProjectTransactionEditor.php
index ecd2d5119f..7813195b02 100644
--- a/src/applications/project/editor/PhabricatorProjectTransactionEditor.php
+++ b/src/applications/project/editor/PhabricatorProjectTransactionEditor.php
@@ -1,516 +1,515 @@
 <?php
 
 final class PhabricatorProjectTransactionEditor
   extends PhabricatorApplicationTransactionEditor {
 
   public function getEditorApplicationClass() {
     return 'PhabricatorProjectApplication';
   }
 
   public function getEditorObjectsDescription() {
     return pht('Projects');
   }
 
   public function getTransactionTypes() {
     $types = parent::getTransactionTypes();
 
     $types[] = PhabricatorTransactions::TYPE_EDGE;
     $types[] = PhabricatorTransactions::TYPE_VIEW_POLICY;
     $types[] = PhabricatorTransactions::TYPE_EDIT_POLICY;
     $types[] = PhabricatorTransactions::TYPE_JOIN_POLICY;
 
     $types[] = PhabricatorProjectTransaction::TYPE_NAME;
     $types[] = PhabricatorProjectTransaction::TYPE_SLUGS;
     $types[] = PhabricatorProjectTransaction::TYPE_STATUS;
     $types[] = PhabricatorProjectTransaction::TYPE_IMAGE;
     $types[] = PhabricatorProjectTransaction::TYPE_ICON;
     $types[] = PhabricatorProjectTransaction::TYPE_COLOR;
     $types[] = PhabricatorProjectTransaction::TYPE_LOCKED;
 
     return $types;
   }
 
   protected function getCustomTransactionOldValue(
     PhabricatorLiskDAO $object,
     PhabricatorApplicationTransaction $xaction) {
 
     switch ($xaction->getTransactionType()) {
       case PhabricatorProjectTransaction::TYPE_NAME:
         return $object->getName();
       case PhabricatorProjectTransaction::TYPE_SLUGS:
         $slugs = $object->getSlugs();
         $slugs = mpull($slugs, 'getSlug', 'getSlug');
         unset($slugs[$object->getPrimarySlug()]);
         return array_keys($slugs);
       case PhabricatorProjectTransaction::TYPE_STATUS:
         return $object->getStatus();
       case PhabricatorProjectTransaction::TYPE_IMAGE:
         return $object->getProfileImagePHID();
       case PhabricatorProjectTransaction::TYPE_ICON:
         return $object->getIcon();
       case PhabricatorProjectTransaction::TYPE_COLOR:
         return $object->getColor();
       case PhabricatorProjectTransaction::TYPE_LOCKED:
         return (int)$object->getIsMembershipLocked();
     }
 
     return parent::getCustomTransactionOldValue($object, $xaction);
   }
 
   protected function getCustomTransactionNewValue(
     PhabricatorLiskDAO $object,
     PhabricatorApplicationTransaction $xaction) {
 
     switch ($xaction->getTransactionType()) {
       case PhabricatorProjectTransaction::TYPE_NAME:
       case PhabricatorProjectTransaction::TYPE_SLUGS:
       case PhabricatorProjectTransaction::TYPE_STATUS:
       case PhabricatorProjectTransaction::TYPE_IMAGE:
       case PhabricatorProjectTransaction::TYPE_ICON:
       case PhabricatorProjectTransaction::TYPE_COLOR:
       case PhabricatorProjectTransaction::TYPE_LOCKED:
         return $xaction->getNewValue();
     }
 
     return parent::getCustomTransactionNewValue($object, $xaction);
   }
 
   protected function applyCustomInternalTransaction(
     PhabricatorLiskDAO $object,
     PhabricatorApplicationTransaction $xaction) {
 
     switch ($xaction->getTransactionType()) {
       case PhabricatorProjectTransaction::TYPE_NAME:
-        $object->setName($xaction->getNewValue());
-        // TODO - this is really "setPrimarySlug"
-        $object->setPhrictionSlug($xaction->getNewValue());
+        $name = $xaction->getNewValue();
+        $object->setName($name);
+        $object->setPrimarySlug(PhabricatorSlug::normalizeProjectSlug($name));
         return;
       case PhabricatorProjectTransaction::TYPE_SLUGS:
         return;
       case PhabricatorProjectTransaction::TYPE_STATUS:
         $object->setStatus($xaction->getNewValue());
         return;
       case PhabricatorProjectTransaction::TYPE_IMAGE:
         $object->setProfileImagePHID($xaction->getNewValue());
         return;
       case PhabricatorProjectTransaction::TYPE_ICON:
         $object->setIcon($xaction->getNewValue());
         return;
       case PhabricatorProjectTransaction::TYPE_COLOR:
         $object->setColor($xaction->getNewValue());
         return;
       case PhabricatorProjectTransaction::TYPE_LOCKED:
         $object->setIsMembershipLocked($xaction->getNewValue());
         return;
     }
 
     return parent::applyCustomInternalTransaction($object, $xaction);
   }
 
   protected function applyCustomExternalTransaction(
     PhabricatorLiskDAO $object,
     PhabricatorApplicationTransaction $xaction) {
 
     $old = $xaction->getOldValue();
     $new = $xaction->getNewValue();
 
     switch ($xaction->getTransactionType()) {
       case PhabricatorProjectTransaction::TYPE_NAME:
         // First, add the old name as a secondary slug; this is helpful
         // for renames and generally a good thing to do.
         if ($old !== null) {
           $this->addSlug($object, $old);
         }
         $this->addSlug($object, $new);
 
         return;
       case PhabricatorProjectTransaction::TYPE_SLUGS:
         $old = $xaction->getOldValue();
         $new = $xaction->getNewValue();
         $add = array_diff($new, $old);
         $rem = array_diff($old, $new);
 
         if ($add) {
           $add_slug_template = id(new PhabricatorProjectSlug())
             ->setProjectPHID($object->getPHID());
           foreach ($add as $add_slug_str) {
             $add_slug = id(clone $add_slug_template)
               ->setSlug($add_slug_str)
               ->save();
           }
         }
         if ($rem) {
           $rem_slugs = id(new PhabricatorProjectSlug())
             ->loadAllWhere('slug IN (%Ls)', $rem);
           foreach ($rem_slugs as $rem_slug) {
             $rem_slug->delete();
           }
         }
 
         return;
       case PhabricatorProjectTransaction::TYPE_STATUS:
       case PhabricatorProjectTransaction::TYPE_IMAGE:
       case PhabricatorProjectTransaction::TYPE_ICON:
       case PhabricatorProjectTransaction::TYPE_COLOR:
       case PhabricatorProjectTransaction::TYPE_LOCKED:
         return;
      }
 
     return parent::applyCustomExternalTransaction($object, $xaction);
   }
 
   protected function applyBuiltinExternalTransaction(
     PhabricatorLiskDAO $object,
     PhabricatorApplicationTransaction $xaction) {
 
     switch ($xaction->getTransactionType()) {
       case PhabricatorTransactions::TYPE_EDGE:
         $edge_type = $xaction->getMetadataValue('edge:type');
         switch ($edge_type) {
           case PhabricatorProjectProjectHasMemberEdgeType::EDGECONST:
           case PhabricatorObjectHasWatcherEdgeType::EDGECONST:
             $old = $xaction->getOldValue();
             $new = $xaction->getNewValue();
 
             // When adding members or watchers, we add subscriptions.
             $add = array_keys(array_diff_key($new, $old));
 
             // When removing members, we remove their subscription too.
             // When unwatching, we leave subscriptions, since it's fine to be
             // subscribed to a project but not be a member of it.
             $edge_const = PhabricatorProjectProjectHasMemberEdgeType::EDGECONST;
             if ($edge_type == $edge_const) {
               $rem = array_keys(array_diff_key($old, $new));
             } else {
               $rem = array();
             }
 
             // NOTE: The subscribe is "explicit" because there's no implicit
             // unsubscribe, so Join -> Leave -> Join doesn't resubscribe you
             // if we use an implicit subscribe, even though you never willfully
             // unsubscribed. Not sure if adding implicit unsubscribe (which
             // would not write the unsubscribe row) is justified to deal with
             // this, which is a fairly weird edge case and pretty arguable both
             // ways.
 
             // Subscriptions caused by watches should also clearly be explicit,
             // and that case is unambiguous.
 
             id(new PhabricatorSubscriptionsEditor())
               ->setActor($this->requireActor())
               ->setObject($object)
               ->subscribeExplicit($add)
               ->unsubscribe($rem)
               ->save();
 
             if ($rem) {
               // When removing members, also remove any watches on the project.
               $edge_editor = new PhabricatorEdgeEditor();
               foreach ($rem as $rem_phid) {
                 $edge_editor->removeEdge(
                   $object->getPHID(),
                   PhabricatorObjectHasWatcherEdgeType::EDGECONST,
                   $rem_phid);
               }
               $edge_editor->save();
             }
             break;
         }
         break;
     }
 
     return parent::applyBuiltinExternalTransaction($object, $xaction);
   }
 
   protected function validateTransaction(
     PhabricatorLiskDAO $object,
     $type,
     array $xactions) {
 
     $errors = parent::validateTransaction($object, $type, $xactions);
 
     switch ($type) {
       case PhabricatorProjectTransaction::TYPE_NAME:
         $missing = $this->validateIsEmptyTextField(
           $object->getName(),
           $xactions);
 
         if ($missing) {
           $error = new PhabricatorApplicationTransactionValidationError(
             $type,
             pht('Required'),
             pht('Project name is required.'),
             nonempty(last($xactions), null));
 
           $error->setIsMissingFieldError(true);
           $errors[] = $error;
         }
 
         if (!$xactions) {
           break;
         }
 
         $name = last($xactions)->getNewValue();
         $name_used_already = id(new PhabricatorProjectQuery())
           ->setViewer($this->getActor())
           ->withNames(array($name))
           ->executeOne();
         if ($name_used_already &&
            ($name_used_already->getPHID() != $object->getPHID())) {
           $error = new PhabricatorApplicationTransactionValidationError(
             $type,
             pht('Duplicate'),
             pht('Project name is already used.'),
             nonempty(last($xactions), null));
           $errors[] = $error;
         }
 
-        $slug_builder = clone $object;
-        $slug_builder->setPhrictionSlug($name);
-        $slug = $slug_builder->getPrimarySlug();
+        $slug = PhabricatorSlug::normalizeProjectSlug($name);
+
         $slug_used_already = id(new PhabricatorProjectSlug())
           ->loadOneWhere('slug = %s', $slug);
         if ($slug_used_already &&
             $slug_used_already->getProjectPHID() != $object->getPHID()) {
           $error = new PhabricatorApplicationTransactionValidationError(
             $type,
             pht('Duplicate'),
             pht('Project name can not be used due to hashtag collision.'),
             nonempty(last($xactions), null));
           $errors[] = $error;
         }
         break;
       case PhabricatorProjectTransaction::TYPE_SLUGS:
         if (!$xactions) {
           break;
         }
 
         $slug_xaction = last($xactions);
         $new = $slug_xaction->getNewValue();
 
         if ($new) {
           $slugs_used_already = id(new PhabricatorProjectSlug())
             ->loadAllWhere('slug IN (%Ls)', $new);
         } else {
           // The project doesn't have any extra slugs.
           $slugs_used_already = array();
         }
 
         $slugs_used_already = mgroup($slugs_used_already, 'getProjectPHID');
         foreach ($slugs_used_already as $project_phid => $used_slugs) {
           $used_slug_strs = mpull($used_slugs, 'getSlug');
           if ($project_phid == $object->getPHID()) {
             if (in_array($object->getPrimarySlug(), $used_slug_strs)) {
               $error = new PhabricatorApplicationTransactionValidationError(
                 $type,
                 pht('Invalid'),
                 pht(
                   'Project hashtag %s is already the primary hashtag.',
                   $object->getPrimarySlug()),
                 $slug_xaction);
               $errors[] = $error;
             }
             continue;
           }
 
           $error = new PhabricatorApplicationTransactionValidationError(
             $type,
             pht('Invalid'),
             pht(
               '%d project hashtag(s) are already used: %s.',
               count($used_slug_strs),
               implode(', ', $used_slug_strs)),
             $slug_xaction);
           $errors[] = $error;
         }
 
         break;
 
     }
 
     return $errors;
   }
 
 
   protected function requireCapabilities(
     PhabricatorLiskDAO $object,
     PhabricatorApplicationTransaction $xaction) {
 
     switch ($xaction->getTransactionType()) {
       case PhabricatorProjectTransaction::TYPE_NAME:
       case PhabricatorProjectTransaction::TYPE_STATUS:
       case PhabricatorProjectTransaction::TYPE_IMAGE:
       case PhabricatorProjectTransaction::TYPE_ICON:
       case PhabricatorProjectTransaction::TYPE_COLOR:
         PhabricatorPolicyFilter::requireCapability(
           $this->requireActor(),
           $object,
           PhabricatorPolicyCapability::CAN_EDIT);
         return;
       case PhabricatorProjectTransaction::TYPE_LOCKED:
         PhabricatorPolicyFilter::requireCapability(
           $this->requireActor(),
           newv($this->getEditorApplicationClass(), array()),
           ProjectCanLockProjectsCapability::CAPABILITY);
         return;
       case PhabricatorTransactions::TYPE_EDGE:
         switch ($xaction->getMetadataValue('edge:type')) {
           case PhabricatorProjectProjectHasMemberEdgeType::EDGECONST:
             $old = $xaction->getOldValue();
             $new = $xaction->getNewValue();
 
             $add = array_keys(array_diff_key($new, $old));
             $rem = array_keys(array_diff_key($old, $new));
 
             $actor_phid = $this->requireActor()->getPHID();
 
             $is_join = (($add === array($actor_phid)) && !$rem);
             $is_leave = (($rem === array($actor_phid)) && !$add);
 
             if ($is_join) {
               // You need CAN_JOIN to join a project.
               PhabricatorPolicyFilter::requireCapability(
                 $this->requireActor(),
                 $object,
                 PhabricatorPolicyCapability::CAN_JOIN);
             } else if ($is_leave) {
               // You usually don't need any capabilities to leave a project.
               if ($object->getIsMembershipLocked()) {
                 // you must be able to edit though to leave locked projects
                 PhabricatorPolicyFilter::requireCapability(
                   $this->requireActor(),
                   $object,
                   PhabricatorPolicyCapability::CAN_EDIT);
               }
             } else {
               // You need CAN_EDIT to change members other than yourself.
               PhabricatorPolicyFilter::requireCapability(
                 $this->requireActor(),
                 $object,
                 PhabricatorPolicyCapability::CAN_EDIT);
             }
             return;
         }
         break;
     }
 
     return parent::requireCapabilities($object, $xaction);
   }
 
   protected function willPublish(PhabricatorLiskDAO $object, array $xactions) {
     $member_phids = PhabricatorEdgeQuery::loadDestinationPHIDs(
       $object->getPHID(),
       PhabricatorProjectProjectHasMemberEdgeType::EDGECONST);
     $object->attachMemberPHIDs($member_phids);
 
     return $object;
   }
 
   protected function shouldSendMail(
     PhabricatorLiskDAO $object,
     array $xactions) {
     return true;
   }
 
   protected function getMailSubjectPrefix() {
     return pht('[Project]');
   }
 
   protected function getMailTo(PhabricatorLiskDAO $object) {
     return $object->getMemberPHIDs();
   }
 
   protected function getMailCC(PhabricatorLiskDAO $object) {
     $all = parent::getMailCC($object);
     return array_diff($all, $object->getMemberPHIDs());
   }
 
   public function getMailTagsMap() {
     return array(
       PhabricatorProjectTransaction::MAILTAG_METADATA =>
         pht('Project name, hashtags, icon, image, or color changes.'),
       PhabricatorProjectTransaction::MAILTAG_MEMBERS =>
         pht('Project membership changes.'),
       PhabricatorProjectTransaction::MAILTAG_WATCHERS =>
         pht('Project watcher list changes.'),
       PhabricatorProjectTransaction::MAILTAG_SUBSCRIBERS =>
         pht('Project subscribers change.'),
       PhabricatorProjectTransaction::MAILTAG_OTHER =>
         pht('Other project activity not listed above occurs.'),
     );
   }
 
   protected function buildReplyHandler(PhabricatorLiskDAO $object) {
     return id(new ProjectReplyHandler())
       ->setMailReceiver($object);
   }
 
   protected function buildMailTemplate(PhabricatorLiskDAO $object) {
     $id = $object->getID();
     $name = $object->getName();
 
     return id(new PhabricatorMetaMTAMail())
       ->setSubject("{$name}")
       ->addHeader('Thread-Topic', "Project {$id}");
   }
 
   protected function buildMailBody(
     PhabricatorLiskDAO $object,
     array $xactions) {
 
     $body = parent::buildMailBody($object, $xactions);
 
     $uri = '/project/profile/'.$object->getID().'/';
     $body->addLinkSection(
       pht('PROJECT DETAIL'),
       PhabricatorEnv::getProductionURI($uri));
 
     return $body;
   }
 
   protected function shouldPublishFeedStory(
     PhabricatorLiskDAO $object,
     array $xactions) {
     return true;
   }
 
   protected function supportsSearch() {
     return true;
   }
 
   protected function extractFilePHIDsFromCustomTransaction(
     PhabricatorLiskDAO $object,
     PhabricatorApplicationTransaction $xaction) {
 
     switch ($xaction->getTransactionType()) {
       case PhabricatorProjectTransaction::TYPE_IMAGE:
         $new = $xaction->getNewValue();
         if ($new) {
           return array($new);
         }
         break;
     }
 
     return parent::extractFilePHIDsFromCustomTransaction($object, $xaction);
   }
 
   private function addSlug(
     PhabricatorLiskDAO $object,
     $name) {
 
     $slug = PhabricatorSlug::normalizeProjectSlug($name);
 
     $slug_object = id(new PhabricatorProjectSlug())->loadOneWhere(
       'slug = %s',
       $slug);
 
     if ($slug_object) {
       return;
     }
 
     $new_slug = id(new PhabricatorProjectSlug())
       ->setSlug($slug)
       ->setProjectPHID($object->getPHID())
       ->save();
   }
 }
diff --git a/src/applications/project/query/PhabricatorProjectQuery.php b/src/applications/project/query/PhabricatorProjectQuery.php
index e607ff2dc5..e534e1c4bf 100644
--- a/src/applications/project/query/PhabricatorProjectQuery.php
+++ b/src/applications/project/query/PhabricatorProjectQuery.php
@@ -1,401 +1,388 @@
 <?php
 
 final class PhabricatorProjectQuery
   extends PhabricatorCursorPagedPolicyAwareQuery {
 
   private $ids;
   private $phids;
   private $memberPHIDs;
   private $slugs;
-  private $phrictionSlugs;
   private $names;
   private $nameTokens;
   private $icons;
   private $colors;
 
   private $status       = 'status-any';
   const STATUS_ANY      = 'status-any';
   const STATUS_OPEN     = 'status-open';
   const STATUS_CLOSED   = 'status-closed';
   const STATUS_ACTIVE   = 'status-active';
   const STATUS_ARCHIVED = 'status-archived';
 
   private $needSlugs;
   private $needMembers;
   private $needWatchers;
   private $needImages;
 
   public function withIDs(array $ids) {
     $this->ids = $ids;
     return $this;
   }
 
   public function withPHIDs(array $phids) {
     $this->phids = $phids;
     return $this;
   }
 
   public function withStatus($status) {
     $this->status = $status;
     return $this;
   }
 
   public function withMemberPHIDs(array $member_phids) {
     $this->memberPHIDs = $member_phids;
     return $this;
   }
 
   public function withSlugs(array $slugs) {
     $this->slugs = $slugs;
     return $this;
   }
 
-  public function withPhrictionSlugs(array $slugs) {
-    $this->phrictionSlugs = $slugs;
-    return $this;
-  }
-
   public function withNames(array $names) {
     $this->names = $names;
     return $this;
   }
 
   public function withNameTokens(array $tokens) {
     $this->nameTokens = array_values($tokens);
     return $this;
   }
 
   public function withIcons(array $icons) {
     $this->icons = $icons;
     return $this;
   }
 
   public function withColors(array $colors) {
     $this->colors = $colors;
     return $this;
   }
 
   public function needMembers($need_members) {
     $this->needMembers = $need_members;
     return $this;
   }
 
   public function needWatchers($need_watchers) {
     $this->needWatchers = $need_watchers;
     return $this;
   }
 
   public function needImages($need_images) {
     $this->needImages = $need_images;
     return $this;
   }
 
   public function needSlugs($need_slugs) {
     $this->needSlugs = $need_slugs;
     return $this;
   }
 
   public function newResultObject() {
     return new PhabricatorProject();
   }
 
   protected function getDefaultOrderVector() {
     return array('name');
   }
 
   public function getBuiltinOrders() {
     return array(
       'name' => array(
         'vector' => array('name'),
         'name' => pht('Name'),
       ),
     ) + parent::getBuiltinOrders();
   }
 
   public function getOrderableColumns() {
     return parent::getOrderableColumns() + array(
       'name' => array(
         'table' => $this->getPrimaryTableAlias(),
         'column' => 'name',
         'reverse' => true,
         'type' => 'string',
         'unique' => true,
       ),
     );
   }
 
   protected function getPagingValueMap($cursor, array $keys) {
     $project = $this->loadCursorObject($cursor);
     return array(
       'name' => $project->getName(),
     );
   }
 
   protected function loadPage() {
     $table = new PhabricatorProject();
     $data = $this->loadStandardPageRows($table);
     $projects = $table->loadAllFromArray($data);
 
     if ($projects) {
       $viewer_phid = $this->getViewer()->getPHID();
       $project_phids = mpull($projects, 'getPHID');
 
       $member_type = PhabricatorProjectProjectHasMemberEdgeType::EDGECONST;
       $watcher_type = PhabricatorObjectHasWatcherEdgeType::EDGECONST;
 
       $need_edge_types = array();
       if ($this->needMembers) {
         $need_edge_types[] = $member_type;
       } else {
         foreach ($data as $row) {
           $projects[$row['id']]->setIsUserMember(
             $viewer_phid,
             ($row['viewerIsMember'] !== null));
         }
       }
 
       if ($this->needWatchers) {
         $need_edge_types[] = $watcher_type;
       }
 
       if ($need_edge_types) {
         $edges = id(new PhabricatorEdgeQuery())
           ->withSourcePHIDs($project_phids)
           ->withEdgeTypes($need_edge_types)
           ->execute();
 
         if ($this->needMembers) {
           foreach ($projects as $project) {
             $phid = $project->getPHID();
             $project->attachMemberPHIDs(
               array_keys($edges[$phid][$member_type]));
             $project->setIsUserMember(
               $viewer_phid,
               isset($edges[$phid][$member_type][$viewer_phid]));
           }
         }
 
         if ($this->needWatchers) {
           foreach ($projects as $project) {
             $phid = $project->getPHID();
             $project->attachWatcherPHIDs(
               array_keys($edges[$phid][$watcher_type]));
             $project->setIsUserWatcher(
               $viewer_phid,
               isset($edges[$phid][$watcher_type][$viewer_phid]));
           }
         }
       }
     }
 
     return $projects;
   }
 
   protected function didFilterPage(array $projects) {
     if ($this->needImages) {
       $default = null;
 
       $file_phids = mpull($projects, 'getProfileImagePHID');
       $file_phids = array_filter($file_phids);
       if ($file_phids) {
         $files = id(new PhabricatorFileQuery())
           ->setParentQuery($this)
           ->setViewer($this->getViewer())
           ->withPHIDs($file_phids)
           ->execute();
         $files = mpull($files, null, 'getPHID');
       } else {
         $files = array();
       }
 
       foreach ($projects as $project) {
         $file = idx($files, $project->getProfileImagePHID());
         if (!$file) {
           if (!$default) {
             $default = PhabricatorFile::loadBuiltin(
               $this->getViewer(),
               'project.png');
           }
           $file = $default;
         }
         $project->attachProfileImageFile($file);
       }
     }
 
     if ($this->needSlugs) {
       $slugs = id(new PhabricatorProjectSlug())
         ->loadAllWhere(
           'projectPHID IN (%Ls)',
           mpull($projects, 'getPHID'));
       $slugs = mgroup($slugs, 'getProjectPHID');
       foreach ($projects as $project) {
         $project_slugs = idx($slugs, $project->getPHID(), array());
         $project->attachSlugs($project_slugs);
       }
     }
 
     return $projects;
   }
 
   protected function buildSelectClauseParts(AphrontDatabaseConnection $conn) {
     $select = parent::buildSelectClauseParts($conn);
 
     // NOTE: Because visibility checks for projects depend on whether or not
     // the user is a project member, we always load their membership. If we're
     // loading all members anyway we can piggyback on that; otherwise we
     // do an explicit join.
     if (!$this->needMembers) {
       $select[] = 'vm.dst viewerIsMember';
     }
 
     return $select;
   }
 
   protected function buildWhereClauseParts(AphrontDatabaseConnection $conn) {
     $where = parent::buildWhereClauseParts($conn);
 
     if ($this->status != self::STATUS_ANY) {
       switch ($this->status) {
         case self::STATUS_OPEN:
         case self::STATUS_ACTIVE:
           $filter = array(
             PhabricatorProjectStatus::STATUS_ACTIVE,
           );
           break;
         case self::STATUS_CLOSED:
         case self::STATUS_ARCHIVED:
           $filter = array(
             PhabricatorProjectStatus::STATUS_ARCHIVED,
           );
           break;
         default:
           throw new Exception(
             pht(
               "Unknown project status '%s'!",
               $this->status));
       }
       $where[] = qsprintf(
         $conn,
         'status IN (%Ld)',
         $filter);
     }
 
     if ($this->ids !== null) {
       $where[] = qsprintf(
         $conn,
         'id IN (%Ld)',
         $this->ids);
     }
 
     if ($this->phids !== null) {
       $where[] = qsprintf(
         $conn,
         'phid IN (%Ls)',
         $this->phids);
     }
 
     if ($this->memberPHIDs !== null) {
       $where[] = qsprintf(
         $conn,
         'e.dst IN (%Ls)',
         $this->memberPHIDs);
     }
 
     if ($this->slugs !== null) {
       $where[] = qsprintf(
         $conn,
         'slug.slug IN (%Ls)',
         $this->slugs);
     }
 
-    if ($this->phrictionSlugs !== null) {
-      $where[] = qsprintf(
-        $conn,
-        'phrictionSlug IN (%Ls)',
-        $this->phrictionSlugs);
-    }
-
     if ($this->names !== null) {
       $where[] = qsprintf(
         $conn,
         'name IN (%Ls)',
         $this->names);
     }
 
     if ($this->icons !== null) {
       $where[] = qsprintf(
         $conn,
         'icon IN (%Ls)',
         $this->icons);
     }
 
     if ($this->colors !== null) {
       $where[] = qsprintf(
         $conn,
         'color IN (%Ls)',
         $this->colors);
     }
 
     return $where;
   }
 
   protected function shouldGroupQueryResultRows() {
     if ($this->memberPHIDs || $this->nameTokens) {
       return true;
     }
     return parent::shouldGroupQueryResultRows();
   }
 
   protected function buildJoinClauseParts(AphrontDatabaseConnection $conn) {
     $joins = parent::buildJoinClauseParts($conn);
 
     if (!$this->needMembers !== null) {
       $joins[] = qsprintf(
         $conn,
         'LEFT JOIN %T vm ON vm.src = p.phid AND vm.type = %d AND vm.dst = %s',
         PhabricatorEdgeConfig::TABLE_NAME_EDGE,
         PhabricatorProjectProjectHasMemberEdgeType::EDGECONST,
         $this->getViewer()->getPHID());
     }
 
     if ($this->memberPHIDs !== null) {
       $joins[] = qsprintf(
         $conn,
         'JOIN %T e ON e.src = p.phid AND e.type = %d',
         PhabricatorEdgeConfig::TABLE_NAME_EDGE,
         PhabricatorProjectProjectHasMemberEdgeType::EDGECONST);
     }
 
     if ($this->slugs !== null) {
       $joins[] = qsprintf(
         $conn,
         'JOIN %T slug on slug.projectPHID = p.phid',
         id(new PhabricatorProjectSlug())->getTableName());
     }
 
     if ($this->nameTokens !== null) {
       foreach ($this->nameTokens as $key => $token) {
         $token_table = 'token_'.$key;
         $joins[] = qsprintf(
           $conn,
           'JOIN %T %T ON %T.projectID = p.id AND %T.token LIKE %>',
           PhabricatorProject::TABLE_DATASOURCE_TOKEN,
           $token_table,
           $token_table,
           $token_table,
           $token);
       }
     }
 
     return $joins;
   }
 
   public function getQueryApplicationClass() {
     return 'PhabricatorProjectApplication';
   }
 
   protected function getPrimaryTableAlias() {
     return 'p';
   }
 
 }
diff --git a/src/applications/project/storage/PhabricatorProject.php b/src/applications/project/storage/PhabricatorProject.php
index e5e6e19554..8bbc6e14ad 100644
--- a/src/applications/project/storage/PhabricatorProject.php
+++ b/src/applications/project/storage/PhabricatorProject.php
@@ -1,414 +1,401 @@
 <?php
 
 final class PhabricatorProject extends PhabricatorProjectDAO
   implements
     PhabricatorApplicationTransactionInterface,
     PhabricatorFlaggableInterface,
     PhabricatorPolicyInterface,
     PhabricatorSubscribableInterface,
     PhabricatorCustomFieldInterface,
     PhabricatorDestructibleInterface {
 
   protected $name;
   protected $status = PhabricatorProjectStatus::STATUS_ACTIVE;
   protected $authorPHID;
   protected $subprojectPHIDs = array();
   protected $phrictionSlug;
   protected $profileImagePHID;
   protected $icon;
   protected $color;
   protected $mailKey;
 
   protected $viewPolicy;
   protected $editPolicy;
   protected $joinPolicy;
   protected $isMembershipLocked;
 
   private $memberPHIDs = self::ATTACHABLE;
   private $watcherPHIDs = self::ATTACHABLE;
   private $sparseWatchers = self::ATTACHABLE;
   private $sparseMembers = self::ATTACHABLE;
   private $customFields = self::ATTACHABLE;
   private $profileImageFile = self::ATTACHABLE;
   private $slugs = self::ATTACHABLE;
 
   const DEFAULT_ICON = 'fa-briefcase';
   const DEFAULT_COLOR = 'blue';
 
   const TABLE_DATASOURCE_TOKEN = 'project_datasourcetoken';
 
   public static function initializeNewProject(PhabricatorUser $actor) {
     $app = id(new PhabricatorApplicationQuery())
       ->setViewer(PhabricatorUser::getOmnipotentUser())
       ->withClasses(array('PhabricatorProjectApplication'))
       ->executeOne();
 
     $view_policy = $app->getPolicy(
       ProjectDefaultViewCapability::CAPABILITY);
     $edit_policy = $app->getPolicy(
       ProjectDefaultEditCapability::CAPABILITY);
     $join_policy = $app->getPolicy(
       ProjectDefaultJoinCapability::CAPABILITY);
 
     return id(new PhabricatorProject())
       ->setAuthorPHID($actor->getPHID())
       ->setIcon(self::DEFAULT_ICON)
       ->setColor(self::DEFAULT_COLOR)
       ->setViewPolicy($view_policy)
       ->setEditPolicy($edit_policy)
       ->setJoinPolicy($join_policy)
       ->setIsMembershipLocked(0)
       ->attachMemberPHIDs(array())
       ->attachSlugs(array());
   }
 
   public function getCapabilities() {
     return array(
       PhabricatorPolicyCapability::CAN_VIEW,
       PhabricatorPolicyCapability::CAN_EDIT,
       PhabricatorPolicyCapability::CAN_JOIN,
     );
   }
 
   public function getPolicy($capability) {
     switch ($capability) {
       case PhabricatorPolicyCapability::CAN_VIEW:
         return $this->getViewPolicy();
       case PhabricatorPolicyCapability::CAN_EDIT:
         return $this->getEditPolicy();
       case PhabricatorPolicyCapability::CAN_JOIN:
         return $this->getJoinPolicy();
     }
   }
 
   public function hasAutomaticCapability($capability, PhabricatorUser $viewer) {
 
     switch ($capability) {
       case PhabricatorPolicyCapability::CAN_VIEW:
         if ($this->isUserMember($viewer->getPHID())) {
           // Project members can always view a project.
           return true;
         }
         break;
       case PhabricatorPolicyCapability::CAN_EDIT:
         break;
       case PhabricatorPolicyCapability::CAN_JOIN:
         $can_edit = PhabricatorPolicyCapability::CAN_EDIT;
         if (PhabricatorPolicyFilter::hasCapability($viewer, $this, $can_edit)) {
           // Project editors can always join a project.
           return true;
         }
         break;
     }
 
     return false;
   }
 
   public function describeAutomaticCapability($capability) {
     switch ($capability) {
       case PhabricatorPolicyCapability::CAN_VIEW:
         return pht('Members of a project can always view it.');
       case PhabricatorPolicyCapability::CAN_JOIN:
         return pht('Users who can edit a project can always join it.');
     }
     return null;
   }
 
   public function isUserMember($user_phid) {
     if ($this->memberPHIDs !== self::ATTACHABLE) {
       return in_array($user_phid, $this->memberPHIDs);
     }
     return $this->assertAttachedKey($this->sparseMembers, $user_phid);
   }
 
   public function setIsUserMember($user_phid, $is_member) {
     if ($this->sparseMembers === self::ATTACHABLE) {
       $this->sparseMembers = array();
     }
     $this->sparseMembers[$user_phid] = $is_member;
     return $this;
   }
 
   protected function getConfiguration() {
     return array(
       self::CONFIG_AUX_PHID => true,
       self::CONFIG_SERIALIZATION => array(
         'subprojectPHIDs' => self::SERIALIZATION_JSON,
       ),
       self::CONFIG_COLUMN_SCHEMA => array(
         'name' => 'sort128',
         'status' => 'text32',
         'phrictionSlug' => 'text128?',
         'isMembershipLocked' => 'bool',
         'profileImagePHID' => 'phid?',
         'icon' => 'text32',
         'color' => 'text32',
         'mailKey' => 'bytes20',
 
         // T6203/NULLABILITY
         // These are definitely wrong and should always exist.
         'editPolicy' => 'policy?',
         'viewPolicy' => 'policy?',
         'joinPolicy' => 'policy?',
       ),
       self::CONFIG_KEY_SCHEMA => array(
         'key_phid' => null,
         'phid' => array(
           'columns' => array('phid'),
           'unique' => true,
         ),
         'key_icon' => array(
           'columns' => array('icon'),
         ),
         'key_color' => array(
           'columns' => array('color'),
         ),
         'phrictionSlug' => array(
           'columns' => array('phrictionSlug'),
           'unique' => true,
         ),
         'name' => array(
           'columns' => array('name'),
           'unique' => true,
         ),
       ),
     ) + parent::getConfiguration();
   }
 
   public function generatePHID() {
     return PhabricatorPHID::generateNewPHID(
       PhabricatorProjectProjectPHIDType::TYPECONST);
   }
 
   public function attachMemberPHIDs(array $phids) {
     $this->memberPHIDs = $phids;
     return $this;
   }
 
   public function getMemberPHIDs() {
     return $this->assertAttached($this->memberPHIDs);
   }
 
-  public function setPhrictionSlug($slug) {
-
-    // NOTE: We're doing a little magic here and stripping out '/' so that
-    // project pages always appear at top level under projects/ even if the
-    // display name is "Hack / Slash" or similar (it will become
-    // 'hack_slash' instead of 'hack/slash').
-
-    $slug = str_replace('/', ' ', $slug);
-    $slug = PhabricatorSlug::normalize($slug);
-    $this->phrictionSlug = $slug;
+  public function setPrimarySlug($slug) {
+    $this->phrictionSlug = $slug.'/';
     return $this;
   }
 
-  public function getFullPhrictionSlug() {
-    $slug = $this->getPhrictionSlug();
-    return 'projects/'.$slug;
-  }
-
   // TODO - once we sever project => phriction automagicalness,
   // migrate getPhrictionSlug to have no trailing slash and be called
   // getPrimarySlug
   public function getPrimarySlug() {
     $slug = $this->getPhrictionSlug();
     return rtrim($slug, '/');
   }
 
   public function isArchived() {
     return ($this->getStatus() == PhabricatorProjectStatus::STATUS_ARCHIVED);
   }
 
   public function getProfileImageURI() {
     return $this->getProfileImageFile()->getBestURI();
   }
 
   public function attachProfileImageFile(PhabricatorFile $file) {
     $this->profileImageFile = $file;
     return $this;
   }
 
   public function getProfileImageFile() {
     return $this->assertAttached($this->profileImageFile);
   }
 
 
   public function isUserWatcher($user_phid) {
     if ($this->watcherPHIDs !== self::ATTACHABLE) {
       return in_array($user_phid, $this->watcherPHIDs);
     }
     return $this->assertAttachedKey($this->sparseWatchers, $user_phid);
   }
 
   public function setIsUserWatcher($user_phid, $is_watcher) {
     if ($this->sparseWatchers === self::ATTACHABLE) {
       $this->sparseWatchers = array();
     }
     $this->sparseWatchers[$user_phid] = $is_watcher;
     return $this;
   }
 
   public function attachWatcherPHIDs(array $phids) {
     $this->watcherPHIDs = $phids;
     return $this;
   }
 
   public function getWatcherPHIDs() {
     return $this->assertAttached($this->watcherPHIDs);
   }
 
   public function attachSlugs(array $slugs) {
     $this->slugs = $slugs;
     return $this;
   }
 
   public function getSlugs() {
     return $this->assertAttached($this->slugs);
   }
 
   public function getColor() {
     if ($this->isArchived()) {
       return PHUITagView::COLOR_DISABLED;
     }
 
     return $this->color;
   }
 
   public function save() {
     if (!$this->getMailKey()) {
       $this->setMailKey(Filesystem::readRandomCharacters(20));
     }
 
     $this->openTransaction();
       $result = parent::save();
       $this->updateDatasourceTokens();
     $this->saveTransaction();
 
     return $result;
   }
 
   public function updateDatasourceTokens() {
     $table = self::TABLE_DATASOURCE_TOKEN;
     $conn_w = $this->establishConnection('w');
     $id = $this->getID();
 
     $slugs = queryfx_all(
       $conn_w,
       'SELECT * FROM %T WHERE projectPHID = %s',
       id(new PhabricatorProjectSlug())->getTableName(),
       $this->getPHID());
 
     $all_strings = ipull($slugs, 'slug');
     $all_strings[] = $this->getName();
     $all_strings = implode(' ', $all_strings);
 
     $tokens = PhabricatorTypeaheadDatasource::tokenizeString($all_strings);
 
     $sql = array();
     foreach ($tokens as $token) {
       $sql[] = qsprintf($conn_w, '(%d, %s)', $id, $token);
     }
 
     $this->openTransaction();
       queryfx(
         $conn_w,
         'DELETE FROM %T WHERE projectID = %d',
         $table,
         $id);
 
       foreach (PhabricatorLiskDAO::chunkSQL($sql) as $chunk) {
         queryfx(
           $conn_w,
           'INSERT INTO %T (projectID, token) VALUES %Q',
           $table,
           $chunk);
       }
     $this->saveTransaction();
   }
 
 
 /* -(  PhabricatorSubscribableInterface  )----------------------------------- */
 
 
   public function isAutomaticallySubscribed($phid) {
     return false;
   }
 
   public function shouldShowSubscribersProperty() {
     return false;
   }
 
   public function shouldAllowSubscription($phid) {
     return $this->isUserMember($phid) &&
            !$this->isUserWatcher($phid);
   }
 
 
 /* -(  PhabricatorCustomFieldInterface  )------------------------------------ */
 
 
   public function getCustomFieldSpecificationForRole($role) {
     return PhabricatorEnv::getEnvConfig('projects.fields');
   }
 
   public function getCustomFieldBaseClass() {
     return 'PhabricatorProjectCustomField';
   }
 
   public function getCustomFields() {
     return $this->assertAttached($this->customFields);
   }
 
   public function attachCustomFields(PhabricatorCustomFieldAttachment $fields) {
     $this->customFields = $fields;
     return $this;
   }
 
 
 /* -(  PhabricatorApplicationTransactionInterface  )------------------------- */
 
 
   public function getApplicationTransactionEditor() {
     return new PhabricatorProjectTransactionEditor();
   }
 
   public function getApplicationTransactionObject() {
     return $this;
   }
 
   public function getApplicationTransactionTemplate() {
     return new PhabricatorProjectTransaction();
   }
 
   public function willRenderTimeline(
     PhabricatorApplicationTransactionView $timeline,
     AphrontRequest $request) {
 
     return $timeline;
   }
 
 
 /* -(  PhabricatorDestructibleInterface  )----------------------------------- */
 
   public function destroyObjectPermanently(
     PhabricatorDestructionEngine $engine) {
 
     $this->openTransaction();
       $this->delete();
 
       $columns = id(new PhabricatorProjectColumn())
         ->loadAllWhere('projectPHID = %s', $this->getPHID());
       foreach ($columns as $column) {
         $engine->destroyObject($column);
       }
 
       $slugs = id(new PhabricatorProjectSlug())
         ->loadAllWhere('projectPHID = %s', $this->getPHID());
       foreach ($slugs as $slug) {
         $slug->delete();
       }
 
     $this->saveTransaction();
   }
 
 }
diff --git a/src/infrastructure/util/PhabricatorSlug.php b/src/infrastructure/util/PhabricatorSlug.php
index fdac30a094..a6cf0bc70c 100644
--- a/src/infrastructure/util/PhabricatorSlug.php
+++ b/src/infrastructure/util/PhabricatorSlug.php
@@ -1,92 +1,125 @@
 <?php
 
 final class PhabricatorSlug extends Phobject {
 
   public static function normalizeProjectSlug($slug) {
     $slug = str_replace('/', ' ', $slug);
-    $slug = self::normalize($slug);
+    $slug = self::normalize($slug, $hashtag = true);
     return rtrim($slug, '/');
   }
 
-  public static function normalize($slug) {
+  public static function normalize($slug, $hashtag = false) {
     $slug = preg_replace('@/+@', '/', $slug);
     $slug = trim($slug, '/');
     $slug = phutil_utf8_strtolower($slug);
-    $slug = preg_replace("@[\\x00-\\x19#%&+=\\\\?<> ]+@", '_', $slug);
+
+    $ban =
+      // Ban control characters since users can't type them and they create
+      // various other problems with parsing and rendering.
+      "\\x00-\\x19".
+
+      // Ban characters with special meanings in URIs (and spaces), since we
+      // want slugs to produce nice URIs.
+      "#%&+=?".
+      " ".
+
+      // Ban backslashes and various brackets for parsing and URI quality.
+      "\\\\".
+      "<>{}\\[\\]".
+
+      // Ban single and double quotes since they can mess up URIs.
+      "'".
+      '"';
+
+    // In hashtag mode (used for Project hashtags), ban additional characters
+    // which cause parsing problems.
+    if ($hashtag) {
+      $ban .= '`~!@$^*,:;(|)';
+    }
+
+    $slug = preg_replace('(['.$ban.']+)', '_', $slug);
     $slug = preg_replace('@_+@', '_', $slug);
 
+    $parts = explode('/', $slug);
+
+    // Convert "_-_" into "-". This is a little nicer for inputs with
+    // hyphens used as internal separators, and turns an input like "A - B"
+    // into "a-b" instead of "a_-_b";
+    foreach ($parts as $key => $part) {
+      $parts[$key] = str_replace('_-_', '-', $part);
+    }
+
     // Remove leading and trailing underscores from each component, if the
     // component has not been reduced to a single underscore. For example, "a?"
     // converts to "a", but "??" converts to "_".
-    $parts = explode('/', $slug);
     foreach ($parts as $key => $part) {
       if ($part != '_') {
         $parts[$key] = trim($part, '_');
       }
     }
     $slug = implode('/', $parts);
 
     // Specifically rewrite these slugs. It's OK to have a slug like "a..b",
     // but not a slug which is only "..".
 
     // NOTE: These are explicitly not pht()'d, because they should be stable
     // across languages.
 
     $replace = array(
       '.'   => 'dot',
       '..'  => 'dotdot',
     );
 
     foreach ($replace as $pattern => $replacement) {
       $pattern = preg_quote($pattern, '@');
       $slug = preg_replace(
         '@(^|/)'.$pattern.'(\z|/)@',
         '\1'.$replacement.'\2', $slug);
     }
 
     return $slug.'/';
   }
 
   public static function getDefaultTitle($slug) {
     $parts = explode('/', trim($slug, '/'));
     $default_title = end($parts);
     $default_title = str_replace('_', ' ', $default_title);
     $default_title = phutil_utf8_ucwords($default_title);
     $default_title = nonempty($default_title, pht('Untitled Document'));
     return $default_title;
   }
 
   public static function getAncestry($slug) {
     $slug = self::normalize($slug);
 
     if ($slug == '/') {
       return array();
     }
 
     $ancestors = array(
       '/',
     );
 
     $slug = explode('/', $slug);
     array_pop($slug);
     array_pop($slug);
 
     $accumulate = '';
     foreach ($slug as $part) {
       $accumulate .= $part.'/';
       $ancestors[] = $accumulate;
     }
 
     return $ancestors;
   }
 
   public static function getDepth($slug) {
     $slug = self::normalize($slug);
     if ($slug == '/') {
       return 0;
     } else {
       return substr_count($slug, '/');
     }
   }
 
 }
diff --git a/src/infrastructure/util/__tests__/PhabricatorSlugTestCase.php b/src/infrastructure/util/__tests__/PhabricatorSlugTestCase.php
index 0f96a735e6..e493ab7363 100644
--- a/src/infrastructure/util/__tests__/PhabricatorSlugTestCase.php
+++ b/src/infrastructure/util/__tests__/PhabricatorSlugTestCase.php
@@ -1,77 +1,98 @@
 <?php
 
 final class PhabricatorSlugTestCase extends PhabricatorTestCase {
 
   public function testSlugNormalization() {
     $slugs = array(
       ''                  => '/',
       '/'                 => '/',
       '//'                => '/',
       '&&&'               => '_/',
       '/derp/'            => 'derp/',
       'derp'              => 'derp/',
       'derp//derp'        => 'derp/derp/',
       'DERP//DERP'        => 'derp/derp/',
       'a B c'             => 'a_b_c/',
       '-1~2.3abcd'        => '-1~2.3abcd/',
       "T\x00O\x00D\x00O"  => 't_o_d_o/',
       'x#%&+=\\?<> y'     => 'x_y/',
       "\xE2\x98\x83"      => "\xE2\x98\x83/",
       '..'                => 'dotdot/',
       '../'               => 'dotdot/',
       '/../'              => 'dotdot/',
       'a/b'               => 'a/b/',
       'a//b'              => 'a/b/',
       'a/../b/'           => 'a/dotdot/b/',
       '/../a'             => 'dotdot/a/',
       '../a'              => 'dotdot/a/',
       'a/..'              => 'a/dotdot/',
       'a/../'             => 'a/dotdot/',
       'a?'                => 'a/',
       '??'                => '_/',
       'a/?'               => 'a/_/',
       '??/a/??'           => '_/a/_/',
       'a/??/c'            => 'a/_/c/',
       'a/?b/c'            => 'a/b/c/',
       'a/b?/c'            => 'a/b/c/',
+      'a - b'             => 'a-b/',
+      'a[b]'              => 'a_b/',
+      'ab!'               => 'ab!/',
     );
 
     foreach ($slugs as $slug => $normal) {
       $this->assertEqual(
         $normal,
         PhabricatorSlug::normalize($slug),
         pht("Normalization of '%s'", $slug));
     }
   }
 
+  public function testProjectSlugs() {
+    $slugs = array(
+      'a:b' => 'a_b',
+      'a!b' => 'a_b',
+      'a - b' => 'a-b',
+      '' => '',
+      'Demonology: HSA (Hexes, Signs, Alchemy)' =>
+        'demonology_hsa_hexes_signs_alchemy',
+    );
+
+    foreach ($slugs as $slug => $normal) {
+      $this->assertEqual(
+        $normal,
+        PhabricatorSlug::normalizeProjectSlug($slug),
+        pht('Hashtag normalization of "%s"', $slug));
+    }
+  }
+
   public function testSlugAncestry() {
     $slugs = array(
       '/'                   => array(),
       'pokemon/'            => array('/'),
       'pokemon/squirtle/'   => array('/', 'pokemon/'),
     );
 
     foreach ($slugs as $slug => $ancestry) {
       $this->assertEqual(
         $ancestry,
         PhabricatorSlug::getAncestry($slug),
         pht("Ancestry of '%s'", $slug));
     }
   }
 
   public function testSlugDepth() {
     $slugs = array(
       '/'       => 0,
       'a/'      => 1,
       'a/b/'    => 2,
       'a////b/' => 2,
     );
 
     foreach ($slugs as $slug => $depth) {
       $this->assertEqual(
         $depth,
         PhabricatorSlug::getDepth($slug),
         pht("Depth of '%s'", $slug));
     }
   }
 }