diff --git a/src/applications/owners/query/PhabricatorOwnersPackageQuery.php b/src/applications/owners/query/PhabricatorOwnersPackageQuery.php
index 4fbd717a2a..d99768acbb 100644
--- a/src/applications/owners/query/PhabricatorOwnersPackageQuery.php
+++ b/src/applications/owners/query/PhabricatorOwnersPackageQuery.php
@@ -1,408 +1,409 @@
 <?php
 
 final class PhabricatorOwnersPackageQuery
   extends PhabricatorCursorPagedPolicyAwareQuery {
 
   private $ids;
   private $phids;
   private $ownerPHIDs;
   private $authorityPHIDs;
   private $repositoryPHIDs;
   private $paths;
   private $statuses;
 
   private $controlMap = array();
   private $controlResults;
 
   private $needPaths;
 
 
   /**
    * Query owner PHIDs exactly. This does not expand authorities, so a user
    * PHID will not match projects the user is a member of.
    */
   public function withOwnerPHIDs(array $phids) {
     $this->ownerPHIDs = $phids;
     return $this;
   }
 
   /**
    * Query owner authority. This will expand authorities, so a user PHID will
    * match both packages they own directly and packages owned by a project they
    * are a member of.
    */
   public function withAuthorityPHIDs(array $phids) {
     $this->authorityPHIDs = $phids;
     return $this;
   }
 
   public function withPHIDs(array $phids) {
     $this->phids = $phids;
     return $this;
   }
 
   public function withIDs(array $ids) {
     $this->ids = $ids;
     return $this;
   }
 
   public function withRepositoryPHIDs(array $phids) {
     $this->repositoryPHIDs = $phids;
     return $this;
   }
 
   public function withPaths(array $paths) {
     $this->paths = $paths;
     return $this;
   }
 
   public function withStatuses(array $statuses) {
     $this->statuses = $statuses;
     return $this;
   }
 
   public function withControl($repository_phid, array $paths) {
     if (empty($this->controlMap[$repository_phid])) {
       $this->controlMap[$repository_phid] = array();
     }
 
     foreach ($paths as $path) {
       $path = (string)$path;
       $this->controlMap[$repository_phid][$path] = $path;
     }
 
     // We need to load paths to execute control queries.
     $this->needPaths = true;
 
     return $this;
   }
 
   public function withNameNgrams($ngrams) {
     return $this->withNgramsConstraint(
       new PhabricatorOwnersPackageNameNgrams(),
       $ngrams);
   }
 
   public function needPaths($need_paths) {
     $this->needPaths = $need_paths;
     return $this;
   }
 
   public function newResultObject() {
     return new PhabricatorOwnersPackage();
   }
 
   protected function willExecute() {
     $this->controlResults = array();
   }
 
   protected function loadPage() {
     return $this->loadStandardPage($this->newResultObject());
   }
 
   protected function willFilterPage(array $packages) {
     $package_ids = mpull($packages, 'getID');
 
     $owners = id(new PhabricatorOwnersOwner())->loadAllWhere(
       'packageID IN (%Ld)',
       $package_ids);
     $owners = mgroup($owners, 'getPackageID');
     foreach ($packages as $package) {
       $package->attachOwners(idx($owners, $package->getID(), array()));
     }
 
     return $packages;
   }
 
   protected function didFilterPage(array $packages) {
     $package_ids = mpull($packages, 'getID');
 
     if ($this->needPaths) {
       $paths = id(new PhabricatorOwnersPath())->loadAllWhere(
         'packageID IN (%Ld)',
         $package_ids);
       $paths = mgroup($paths, 'getPackageID');
 
       foreach ($packages as $package) {
         $package->attachPaths(idx($paths, $package->getID(), array()));
       }
     }
 
     if ($this->controlMap) {
       $this->controlResults += mpull($packages, null, 'getID');
     }
 
     return $packages;
   }
 
   protected function buildJoinClauseParts(AphrontDatabaseConnection $conn) {
     $joins = parent::buildJoinClauseParts($conn);
 
     if ($this->shouldJoinOwnersTable()) {
       $joins[] = qsprintf(
         $conn,
         'JOIN %T o ON o.packageID = p.id',
         id(new PhabricatorOwnersOwner())->getTableName());
     }
 
     if ($this->shouldJoinPathTable()) {
       $joins[] = qsprintf(
         $conn,
         'JOIN %T rpath ON rpath.packageID = p.id',
         id(new PhabricatorOwnersPath())->getTableName());
     }
 
     return $joins;
   }
 
   protected function buildWhereClauseParts(AphrontDatabaseConnection $conn) {
     $where = parent::buildWhereClauseParts($conn);
 
     if ($this->phids !== null) {
       $where[] = qsprintf(
         $conn,
         'p.phid IN (%Ls)',
         $this->phids);
     }
 
     if ($this->ids !== null) {
       $where[] = qsprintf(
         $conn,
         'p.id IN (%Ld)',
         $this->ids);
     }
 
     if ($this->repositoryPHIDs !== null) {
       $where[] = qsprintf(
         $conn,
         'rpath.repositoryPHID IN (%Ls)',
         $this->repositoryPHIDs);
     }
 
     if ($this->authorityPHIDs !== null) {
       $authority_phids = $this->expandAuthority($this->authorityPHIDs);
       $where[] = qsprintf(
         $conn,
         'o.userPHID IN (%Ls)',
         $authority_phids);
     }
 
     if ($this->ownerPHIDs !== null) {
       $where[] = qsprintf(
         $conn,
         'o.userPHID IN (%Ls)',
         $this->ownerPHIDs);
     }
 
     if ($this->paths !== null) {
       $where[] = qsprintf(
         $conn,
         'rpath.path IN (%Ls)',
         $this->getFragmentsForPaths($this->paths));
     }
 
     if ($this->statuses !== null) {
       $where[] = qsprintf(
         $conn,
         'p.status IN (%Ls)',
         $this->statuses);
     }
 
     if ($this->controlMap) {
       $clauses = array();
       foreach ($this->controlMap as $repository_phid => $paths) {
         $fragments = $this->getFragmentsForPaths($paths);
 
         $clauses[] = qsprintf(
           $conn,
           '(rpath.repositoryPHID = %s AND rpath.path IN (%Ls))',
           $repository_phid,
           $fragments);
       }
       $where[] = implode(' OR ', $clauses);
     }
 
     return $where;
   }
 
   protected function shouldGroupQueryResultRows() {
     if ($this->shouldJoinOwnersTable()) {
       return true;
     }
 
     if ($this->shouldJoinPathTable()) {
       return true;
     }
 
     return parent::shouldGroupQueryResultRows();
   }
 
   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',
         'type' => 'string',
         'unique' => true,
         'reverse' => true,
       ),
     );
   }
 
   protected function getPagingValueMap($cursor, array $keys) {
     $package = $this->loadCursorObject($cursor);
     return array(
       'id' => $package->getID(),
       'name' => $package->getName(),
     );
   }
 
   public function getQueryApplicationClass() {
     return 'PhabricatorOwnersApplication';
   }
 
   protected function getPrimaryTableAlias() {
     return 'p';
   }
 
   private function shouldJoinOwnersTable() {
     if ($this->ownerPHIDs !== null) {
       return true;
     }
 
     if ($this->authorityPHIDs !== null) {
       return true;
     }
 
     return false;
   }
 
   private function shouldJoinPathTable() {
     if ($this->repositoryPHIDs !== null) {
       return true;
     }
 
     if ($this->paths !== null) {
       return true;
     }
 
     if ($this->controlMap) {
       return true;
     }
 
     return false;
   }
 
   private function expandAuthority(array $phids) {
     $projects = id(new PhabricatorProjectQuery())
       ->setViewer($this->getViewer())
       ->withMemberPHIDs($phids)
       ->execute();
     $project_phids = mpull($projects, 'getPHID');
 
     return array_fuse($phids) + array_fuse($project_phids);
   }
 
   private function getFragmentsForPaths(array $paths) {
     $fragments = array();
 
     foreach ($paths as $path) {
       foreach (PhabricatorOwnersPackage::splitPath($path) as $fragment) {
         $fragments[$fragment] = $fragment;
       }
     }
 
     return $fragments;
   }
 
 
 /* -(  Path Control  )------------------------------------------------------- */
 
 
   /**
    * Get a list of all packages which control a path or its parent directories,
    * ordered from weakest to strongest.
    *
    * The first package has the most specific claim on the path; the last
    * package has the most general claim. Multiple packages may have claims of
    * equal strength, so this ordering is primarily one of usability and
    * convenience.
    *
    * @return list<PhabricatorOwnersPackage> List of controlling packages.
    */
   public function getControllingPackagesForPath($repository_phid, $path) {
     $path = (string)$path;
 
     if (!isset($this->controlMap[$repository_phid][$path])) {
       throw new PhutilInvalidStateException('withControl');
     }
 
     if ($this->controlResults === null) {
       throw new PhutilInvalidStateException('execute');
     }
 
     $packages = $this->controlResults;
     $weak_dominion = PhabricatorOwnersPackage::DOMINION_WEAK;
 
+    $path_fragments = PhabricatorOwnersPackage::splitPath($path);
+    $fragment_count = count($path_fragments);
+
     $matches = array();
     foreach ($packages as $package_id => $package) {
       $best_match = null;
       $include = false;
 
       // If this package is archived, it's no longer a controlling package
       // for the given path. In particular, it can not force active packages
       // with weak dominion to give up control.
       if ($package->isArchived()) {
         continue;
       }
 
-      foreach ($package->getPaths() as $package_path) {
-        if ($package_path->getRepositoryPHID() != $repository_phid) {
-          // If this path is for some other repository, skip it.
-          continue;
-        }
-
-        $strength = $package_path->getPathMatchStrength($path);
+      $repository_paths = $package->getPathsForRepository($repository_phid);
+      foreach ($repository_paths as $package_path) {
+        $strength = $package_path->getPathMatchStrength(
+          $path_fragments,
+          $fragment_count);
         if ($strength > $best_match) {
           $best_match = $strength;
           $include = !$package_path->getExcluded();
         }
       }
 
       if ($best_match && $include) {
         $matches[$package_id] = array(
           'strength' => $best_match,
           'weak' => ($package->getDominion() == $weak_dominion),
           'package' => $package,
         );
       }
     }
 
     $matches = isort($matches, 'strength');
     $matches = array_reverse($matches);
 
     $first_id = null;
     foreach ($matches as $package_id => $match) {
       if ($first_id === null) {
         $first_id = $package_id;
         continue;
       }
 
       if ($match['weak']) {
         unset($matches[$package_id]);
       }
     }
 
     return array_values(ipull($matches, 'package'));
   }
 
 }
diff --git a/src/applications/owners/storage/PhabricatorOwnersPackage.php b/src/applications/owners/storage/PhabricatorOwnersPackage.php
index f2290d2866..1b12365e4f 100644
--- a/src/applications/owners/storage/PhabricatorOwnersPackage.php
+++ b/src/applications/owners/storage/PhabricatorOwnersPackage.php
@@ -1,584 +1,606 @@
 <?php
 
 final class PhabricatorOwnersPackage
   extends PhabricatorOwnersDAO
   implements
     PhabricatorPolicyInterface,
     PhabricatorApplicationTransactionInterface,
     PhabricatorCustomFieldInterface,
     PhabricatorDestructibleInterface,
     PhabricatorConduitResultInterface,
     PhabricatorFulltextInterface,
     PhabricatorNgramsInterface {
 
   protected $name;
   protected $originalName;
   protected $auditingEnabled;
   protected $autoReview;
   protected $description;
   protected $primaryOwnerPHID;
   protected $mailKey;
   protected $status;
   protected $viewPolicy;
   protected $editPolicy;
   protected $dominion;
 
   private $paths = self::ATTACHABLE;
   private $owners = self::ATTACHABLE;
   private $customFields = self::ATTACHABLE;
+  private $pathRepositoryMap = array();
 
   const STATUS_ACTIVE = 'active';
   const STATUS_ARCHIVED = 'archived';
 
   const AUTOREVIEW_NONE = 'none';
   const AUTOREVIEW_SUBSCRIBE = 'subscribe';
   const AUTOREVIEW_REVIEW = 'review';
   const AUTOREVIEW_BLOCK = 'block';
 
   const DOMINION_STRONG = 'strong';
   const DOMINION_WEAK = 'weak';
 
   public static function initializeNewPackage(PhabricatorUser $actor) {
     $app = id(new PhabricatorApplicationQuery())
       ->setViewer($actor)
       ->withClasses(array('PhabricatorOwnersApplication'))
       ->executeOne();
 
     $view_policy = $app->getPolicy(
       PhabricatorOwnersDefaultViewCapability::CAPABILITY);
     $edit_policy = $app->getPolicy(
       PhabricatorOwnersDefaultEditCapability::CAPABILITY);
 
     return id(new PhabricatorOwnersPackage())
       ->setAuditingEnabled(0)
       ->setAutoReview(self::AUTOREVIEW_NONE)
       ->setDominion(self::DOMINION_STRONG)
       ->setViewPolicy($view_policy)
       ->setEditPolicy($edit_policy)
       ->attachPaths(array())
       ->setStatus(self::STATUS_ACTIVE)
       ->attachOwners(array())
       ->setDescription('');
   }
 
   public static function getStatusNameMap() {
     return array(
       self::STATUS_ACTIVE => pht('Active'),
       self::STATUS_ARCHIVED => pht('Archived'),
     );
   }
 
   public static function getAutoreviewOptionsMap() {
     return array(
       self::AUTOREVIEW_NONE => array(
         'name' => pht('No Autoreview'),
       ),
       self::AUTOREVIEW_SUBSCRIBE => array(
         'name' => pht('Subscribe to Changes'),
       ),
       self::AUTOREVIEW_REVIEW => array(
         'name' => pht('Review Changes'),
       ),
       self::AUTOREVIEW_BLOCK => array(
         'name' => pht('Review Changes (Blocking)'),
       ),
     );
   }
 
   public static function getDominionOptionsMap() {
     return array(
       self::DOMINION_STRONG => array(
         'name' => pht('Strong (Control All Paths)'),
         'short' => pht('Strong'),
       ),
       self::DOMINION_WEAK => array(
         'name' => pht('Weak (Control Unowned Paths)'),
         'short' => pht('Weak'),
       ),
     );
   }
 
   protected function getConfiguration() {
     return array(
       // This information is better available from the history table.
       self::CONFIG_TIMESTAMPS => false,
       self::CONFIG_AUX_PHID => true,
       self::CONFIG_COLUMN_SCHEMA => array(
         'name' => 'sort128',
         'originalName' => 'text255',
         'description' => 'text',
         'primaryOwnerPHID' => 'phid?',
         'auditingEnabled' => 'bool',
         'mailKey' => 'bytes20',
         'status' => 'text32',
         'autoReview' => 'text32',
         'dominion' => 'text32',
       ),
     ) + parent::getConfiguration();
   }
 
   public function generatePHID() {
     return PhabricatorPHID::generateNewPHID(
       PhabricatorOwnersPackagePHIDType::TYPECONST);
   }
 
   public function save() {
     if (!$this->getMailKey()) {
       $this->setMailKey(Filesystem::readRandomCharacters(20));
     }
 
     return parent::save();
   }
 
   public function isArchived() {
     return ($this->getStatus() == self::STATUS_ARCHIVED);
   }
 
   public function setName($name) {
     $this->name = $name;
     if (!$this->getID()) {
       $this->originalName = $name;
     }
     return $this;
   }
 
   public function loadOwners() {
     if (!$this->getID()) {
       return array();
     }
     return id(new PhabricatorOwnersOwner())->loadAllWhere(
       'packageID = %d',
       $this->getID());
   }
 
   public function loadPaths() {
     if (!$this->getID()) {
       return array();
     }
     return id(new PhabricatorOwnersPath())->loadAllWhere(
       'packageID = %d',
       $this->getID());
   }
 
   public static function loadAffectedPackages(
     PhabricatorRepository $repository,
     array $paths) {
 
     if (!$paths) {
       return array();
     }
 
     return self::loadPackagesForPaths($repository, $paths);
   }
 
   public static function loadOwningPackages($repository, $path) {
     if (empty($path)) {
       return array();
     }
 
     return self::loadPackagesForPaths($repository, array($path), 1);
   }
 
   private static function loadPackagesForPaths(
     PhabricatorRepository $repository,
     array $paths,
     $limit = 0) {
 
     $fragments = array();
     foreach ($paths as $path) {
       foreach (self::splitPath($path) as $fragment) {
         $fragments[$fragment][$path] = true;
       }
     }
 
     $package = new PhabricatorOwnersPackage();
     $path = new PhabricatorOwnersPath();
     $conn = $package->establishConnection('r');
 
     $repository_clause = qsprintf(
       $conn,
       'AND p.repositoryPHID = %s',
       $repository->getPHID());
 
     // NOTE: The list of $paths may be very large if we're coming from
     // the OwnersWorker and processing, e.g., an SVN commit which created a new
     // branch. Break it apart so that it will fit within 'max_allowed_packet',
     // and then merge results in PHP.
 
     $rows = array();
     foreach (array_chunk(array_keys($fragments), 128) as $chunk) {
       $rows[] = queryfx_all(
         $conn,
         'SELECT pkg.id, pkg.dominion, p.excluded, p.path
           FROM %T pkg JOIN %T p ON p.packageID = pkg.id
           WHERE p.path IN (%Ls) AND pkg.status IN (%Ls) %Q',
         $package->getTableName(),
         $path->getTableName(),
         $chunk,
         array(
           self::STATUS_ACTIVE,
         ),
         $repository_clause);
     }
     $rows = array_mergev($rows);
 
     $ids = self::findLongestPathsPerPackage($rows, $fragments);
 
     if (!$ids) {
       return array();
     }
 
     arsort($ids);
     if ($limit) {
       $ids = array_slice($ids, 0, $limit, $preserve_keys = true);
     }
     $ids = array_keys($ids);
 
     $packages = $package->loadAllWhere('id in (%Ld)', $ids);
     $packages = array_select_keys($packages, $ids);
 
     return $packages;
   }
 
   public static function loadPackagesForRepository($repository) {
     $package = new PhabricatorOwnersPackage();
     $ids = ipull(
       queryfx_all(
         $package->establishConnection('r'),
         'SELECT DISTINCT packageID FROM %T WHERE repositoryPHID = %s',
         id(new PhabricatorOwnersPath())->getTableName(),
         $repository->getPHID()),
       'packageID');
 
     return $package->loadAllWhere('id in (%Ld)', $ids);
   }
 
   public static function findLongestPathsPerPackage(array $rows, array $paths) {
 
     // Build a map from each path to all the package paths which match it.
     $path_hits = array();
     $weak = array();
     foreach ($rows as $row) {
       $id = $row['id'];
       $path = $row['path'];
       $length = strlen($path);
       $excluded = $row['excluded'];
 
       if ($row['dominion'] === self::DOMINION_WEAK) {
         $weak[$id] = true;
       }
 
       $matches = $paths[$path];
       foreach ($matches as $match => $ignored) {
         $path_hits[$match][] = array(
           'id' => $id,
           'excluded' => $excluded,
           'length' => $length,
         );
       }
     }
 
     // For each path, process the matching package paths to figure out which
     // packages actually own it.
     $path_packages = array();
     foreach ($path_hits as $match => $hits) {
       $hits = isort($hits, 'length');
 
       $packages = array();
       foreach ($hits as $hit) {
         $package_id = $hit['id'];
         if ($hit['excluded']) {
           unset($packages[$package_id]);
         } else {
           $packages[$package_id] = $hit;
         }
       }
 
       $path_packages[$match] = $packages;
     }
 
     // Remove packages with weak dominion rules that should cede control to
     // a more specific package.
     if ($weak) {
       foreach ($path_packages as $match => $packages) {
         $packages = isort($packages, 'length');
         $packages = array_reverse($packages, true);
 
         $first = null;
         foreach ($packages as $package_id => $package) {
           // If this is the first package we've encountered, note it and
           // continue. We're iterating over the packages from longest to
           // shortest match, so this package always has the strongest claim
           // on the path.
           if ($first === null) {
             $first = $package_id;
             continue;
           }
 
           // If this is the first package we saw, its claim stands even if it
           // is a weak package.
           if ($first === $package_id) {
             continue;
           }
 
           // If this is a weak package and not the first package we saw,
           // cede its claim to the stronger package.
           if (isset($weak[$package_id])) {
             unset($packages[$package_id]);
           }
         }
 
         $path_packages[$match] = $packages;
       }
     }
 
     // For each package that owns at least one path, identify the longest
     // path it owns.
     $package_lengths = array();
     foreach ($path_packages as $match => $hits) {
       foreach ($hits as $hit) {
         $length = $hit['length'];
         $id = $hit['id'];
         if (empty($package_lengths[$id])) {
           $package_lengths[$id] = $length;
         } else {
           $package_lengths[$id] = max($package_lengths[$id], $length);
         }
       }
     }
 
     return $package_lengths;
   }
 
   public static function splitPath($path) {
     $trailing_slash = preg_match('@/$@', $path) ? '/' : '';
     $path = trim($path, '/');
     $parts = explode('/', $path);
 
     $result = array();
     while (count($parts)) {
       $result[] = '/'.implode('/', $parts).$trailing_slash;
       $trailing_slash = '/';
       array_pop($parts);
     }
     $result[] = '/';
 
     return array_reverse($result);
   }
 
   public function attachPaths(array $paths) {
     assert_instances_of($paths, 'PhabricatorOwnersPath');
     $this->paths = $paths;
+
+    // Drop this cache if we're attaching new paths.
+    $this->pathRepositoryMap = array();
+
     return $this;
   }
 
   public function getPaths() {
     return $this->assertAttached($this->paths);
   }
 
+  public function getPathsForRepository($repository_phid) {
+    if (isset($this->pathRepositoryMap[$repository_phid])) {
+      return $this->pathRepositoryMap[$repository_phid];
+    }
+
+    $map = array();
+    foreach ($this->getPaths() as $path) {
+      if ($path->getRepositoryPHID() == $repository_phid) {
+        $map[] = $path;
+      }
+    }
+
+    $this->pathRepositoryMap[$repository_phid] = $map;
+
+    return $this->pathRepositoryMap[$repository_phid];
+  }
+
   public function attachOwners(array $owners) {
     assert_instances_of($owners, 'PhabricatorOwnersOwner');
     $this->owners = $owners;
     return $this;
   }
 
   public function getOwners() {
     return $this->assertAttached($this->owners);
   }
 
   public function getOwnerPHIDs() {
     return mpull($this->getOwners(), 'getUserPHID');
   }
 
   public function isOwnerPHID($phid) {
     if (!$phid) {
       return false;
     }
 
     $owner_phids = $this->getOwnerPHIDs();
     $owner_phids = array_fuse($owner_phids);
 
     return isset($owner_phids[$phid]);
   }
 
   public function getMonogram() {
     return 'O'.$this->getID();
   }
 
   public function getURI() {
     // TODO: Move these to "/O123" for consistency.
     return '/owners/package/'.$this->getID().'/';
   }
 
 /* -(  PhabricatorPolicyInterface  )----------------------------------------- */
 
 
   public function getCapabilities() {
     return array(
       PhabricatorPolicyCapability::CAN_VIEW,
       PhabricatorPolicyCapability::CAN_EDIT,
     );
   }
 
   public function getPolicy($capability) {
     switch ($capability) {
       case PhabricatorPolicyCapability::CAN_VIEW:
         return $this->getViewPolicy();
       case PhabricatorPolicyCapability::CAN_EDIT:
         return $this->getEditPolicy();
     }
   }
 
   public function hasAutomaticCapability($capability, PhabricatorUser $viewer) {
     switch ($capability) {
       case PhabricatorPolicyCapability::CAN_VIEW:
         if ($this->isOwnerPHID($viewer->getPHID())) {
           return true;
         }
         break;
     }
 
     return false;
   }
 
   public function describeAutomaticCapability($capability) {
     return pht('Owners of a package may always view it.');
   }
 
 
 /* -(  PhabricatorApplicationTransactionInterface  )------------------------- */
 
 
   public function getApplicationTransactionEditor() {
     return new PhabricatorOwnersPackageTransactionEditor();
   }
 
   public function getApplicationTransactionObject() {
     return $this;
   }
 
   public function getApplicationTransactionTemplate() {
     return new PhabricatorOwnersPackageTransaction();
   }
 
   public function willRenderTimeline(
     PhabricatorApplicationTransactionView $timeline,
     AphrontRequest $request) {
     return $timeline;
   }
 
 
 /* -(  PhabricatorCustomFieldInterface  )------------------------------------ */
 
 
   public function getCustomFieldSpecificationForRole($role) {
     return PhabricatorEnv::getEnvConfig('owners.fields');
   }
 
   public function getCustomFieldBaseClass() {
     return 'PhabricatorOwnersCustomField';
   }
 
   public function getCustomFields() {
     return $this->assertAttached($this->customFields);
   }
 
   public function attachCustomFields(PhabricatorCustomFieldAttachment $fields) {
     $this->customFields = $fields;
     return $this;
   }
 
 
 /* -(  PhabricatorDestructibleInterface  )----------------------------------- */
 
 
   public function destroyObjectPermanently(
     PhabricatorDestructionEngine $engine) {
 
     $this->openTransaction();
       $conn_w = $this->establishConnection('w');
 
       queryfx(
         $conn_w,
         'DELETE FROM %T WHERE packageID = %d',
         id(new PhabricatorOwnersPath())->getTableName(),
         $this->getID());
 
       queryfx(
         $conn_w,
         'DELETE FROM %T WHERE packageID = %d',
         id(new PhabricatorOwnersOwner())->getTableName(),
         $this->getID());
 
       $this->delete();
     $this->saveTransaction();
   }
 
 
 /* -(  PhabricatorConduitResultInterface  )---------------------------------- */
 
 
   public function getFieldSpecificationsForConduit() {
     return array(
       id(new PhabricatorConduitSearchFieldSpecification())
         ->setKey('name')
         ->setType('string')
         ->setDescription(pht('The name of the package.')),
       id(new PhabricatorConduitSearchFieldSpecification())
         ->setKey('description')
         ->setType('string')
         ->setDescription(pht('The package description.')),
       id(new PhabricatorConduitSearchFieldSpecification())
         ->setKey('status')
         ->setType('string')
         ->setDescription(pht('Active or archived status of the package.')),
       id(new PhabricatorConduitSearchFieldSpecification())
         ->setKey('owners')
         ->setType('list<map<string, wild>>')
         ->setDescription(pht('List of package owners.')),
     );
   }
 
   public function getFieldValuesForConduit() {
     $owner_list = array();
     foreach ($this->getOwners() as $owner) {
       $owner_list[] = array(
         'ownerPHID' => $owner->getUserPHID(),
       );
     }
 
     return array(
       'name' => $this->getName(),
       'description' => $this->getDescription(),
       'status' => $this->getStatus(),
       'owners' => $owner_list,
     );
   }
 
   public function getConduitSearchAttachments() {
     return array(
       id(new PhabricatorOwnersPathsSearchEngineAttachment())
         ->setAttachmentKey('paths'),
     );
   }
 
 
 /* -(  PhabricatorFulltextInterface  )--------------------------------------- */
 
 
   public function newFulltextEngine() {
     return new PhabricatorOwnersPackageFulltextEngine();
   }
 
 
 /* -(  PhabricatorNgramsInterface  )----------------------------------------- */
 
 
   public function newNgrams() {
     return array(
       id(new PhabricatorOwnersPackageNameNgrams())
         ->setValue($this->getName()),
     );
   }
 
 }
diff --git a/src/applications/owners/storage/PhabricatorOwnersPath.php b/src/applications/owners/storage/PhabricatorOwnersPath.php
index b552a7fb0d..f240db2851 100644
--- a/src/applications/owners/storage/PhabricatorOwnersPath.php
+++ b/src/applications/owners/storage/PhabricatorOwnersPath.php
@@ -1,105 +1,110 @@
 <?php
 
 final class PhabricatorOwnersPath extends PhabricatorOwnersDAO {
 
   protected $packageID;
   protected $repositoryPHID;
   protected $path;
   protected $excluded;
 
+  private $fragments;
+  private $fragmentCount;
+
   protected function getConfiguration() {
     return array(
       self::CONFIG_TIMESTAMPS => false,
       self::CONFIG_COLUMN_SCHEMA => array(
         'path' => 'text255',
         'excluded' => 'bool',
       ),
       self::CONFIG_KEY_SCHEMA => array(
         'packageID' => array(
           'columns' => array('packageID'),
         ),
       ),
     ) + parent::getConfiguration();
   }
 
 
   public static function newFromRef(array $ref) {
     $path = new PhabricatorOwnersPath();
     $path->repositoryPHID = $ref['repositoryPHID'];
     $path->path = $ref['path'];
     $path->excluded = $ref['excluded'];
     return $path;
   }
 
   public function getRef() {
     return array(
       'repositoryPHID' => $this->getRepositoryPHID(),
       'path' => $this->getPath(),
       'excluded' => (int)$this->getExcluded(),
     );
   }
 
   public static function getTransactionValueChanges(array $old, array $new) {
     return array(
       self::getTransactionValueDiff($old, $new),
       self::getTransactionValueDiff($new, $old),
     );
   }
 
   private static function getTransactionValueDiff(array $u, array $v) {
     $set = self::getSetFromTransactionValue($v);
 
     foreach ($u as $key => $ref) {
       if (self::isRefInSet($ref, $set)) {
         unset($u[$key]);
       }
     }
 
     return $u;
   }
 
   public static function getSetFromTransactionValue(array $v) {
     $set = array();
     foreach ($v as $ref) {
       $set[$ref['repositoryPHID']][$ref['path']][$ref['excluded']] = true;
     }
     return $set;
   }
 
   public static function isRefInSet(array $ref, array $set) {
     return isset($set[$ref['repositoryPHID']][$ref['path']][$ref['excluded']]);
   }
 
   /**
    * Get the number of directory matches between this path specification and
    * some real path.
    */
-  public function getPathMatchStrength($path) {
-    $this_path = $this->getPath();
+  public function getPathMatchStrength($path_fragments, $path_count) {
+    $this_path = $this->path;
 
     if ($this_path === '/') {
       // The root path "/" just matches everything with strength 1.
       return 1;
     }
 
-    $self_fragments = PhabricatorOwnersPackage::splitPath($this_path);
-    $path_fragments = PhabricatorOwnersPackage::splitPath($path);
+    if ($this->fragments === null) {
+      $this->fragments = PhabricatorOwnersPackage::splitPath($this_path);
+      $this->fragmentCount = count($this->fragments);
+    }
 
-    $self_count = count($self_fragments);
-    $path_count = count($path_fragments);
+    $self_fragments = $this->fragments;
+    $self_count = $this->fragmentCount;
     if ($self_count > $path_count) {
       // If this path is longer (and therefore more specific) than the target
       // path, we don't match it at all.
       return 0;
     }
 
     for ($ii = 0; $ii < $self_count; $ii++) {
       if ($self_fragments[$ii] != $path_fragments[$ii]) {
         return 0;
       }
     }
 
     return $self_count;
   }
 
 }