diff --git a/src/applications/differential/controller/DifferentialController.php b/src/applications/differential/controller/DifferentialController.php
index 1860a07745..8fe5b5caca 100644
--- a/src/applications/differential/controller/DifferentialController.php
+++ b/src/applications/differential/controller/DifferentialController.php
@@ -1,276 +1,286 @@
 <?php
 
 abstract class DifferentialController extends PhabricatorController {
 
   private $packageChangesetMap;
   private $pathPackageMap;
   private $authorityPackages;
 
   public function buildSideNavView($for_app = false) {
     $viewer = $this->getRequest()->getUser();
 
     $nav = new AphrontSideNavFilterView();
     $nav->setBaseURI(new PhutilURI($this->getApplicationURI()));
 
     id(new DifferentialRevisionSearchEngine())
       ->setViewer($viewer)
       ->addNavigationItems($nav->getMenu());
 
     $nav->selectFilter(null);
 
     return $nav;
   }
 
   public function buildApplicationMenu() {
     return $this->buildSideNavView(true)->getMenu();
   }
 
   protected function buildPackageMaps(array $changesets) {
     assert_instances_of($changesets, 'DifferentialChangeset');
 
     $this->packageChangesetMap = array();
     $this->pathPackageMap = array();
     $this->authorityPackages = array();
 
     if (!$changesets) {
       return;
     }
 
     $viewer = $this->getViewer();
 
     $have_owners = PhabricatorApplication::isClassInstalledForViewer(
       'PhabricatorOwnersApplication',
       $viewer);
     if (!$have_owners) {
       return;
     }
 
     $changeset = head($changesets);
     $diff = $changeset->getDiff();
     $repository_phid = $diff->getRepositoryPHID();
     if (!$repository_phid) {
       return;
     }
 
     if ($viewer->getPHID()) {
       $packages = id(new PhabricatorOwnersPackageQuery())
         ->setViewer($viewer)
         ->withStatuses(array(PhabricatorOwnersPackage::STATUS_ACTIVE))
         ->withAuthorityPHIDs(array($viewer->getPHID()))
         ->execute();
       $this->authorityPackages = $packages;
     }
 
     $paths = mpull($changesets, 'getOwnersFilename');
 
     $control_query = id(new PhabricatorOwnersPackageQuery())
       ->setViewer($viewer)
       ->withStatuses(array(PhabricatorOwnersPackage::STATUS_ACTIVE))
       ->withControl($repository_phid, $paths);
     $control_query->execute();
 
     foreach ($changesets as $changeset) {
       $changeset_path = $changeset->getOwnersFilename();
 
       $packages = $control_query->getControllingPackagesForPath(
         $repository_phid,
         $changeset_path);
 
+      // If this particular changeset is generated code and the package does
+      // not match generated code, remove it from the list.
+      if ($changeset->isGeneratedChangeset()) {
+        foreach ($packages as $key => $package) {
+          if ($package->getMustMatchUngeneratedPaths()) {
+            unset($packages[$key]);
+          }
+        }
+      }
+
       $this->pathPackageMap[$changeset_path] = $packages;
       foreach ($packages as $package) {
         $this->packageChangesetMap[$package->getPHID()][] = $changeset;
       }
     }
   }
 
   protected function getAuthorityPackages() {
     if ($this->authorityPackages === null) {
       throw new PhutilInvalidStateException('buildPackageMaps');
     }
     return $this->authorityPackages;
   }
 
   protected function getChangesetPackages(DifferentialChangeset $changeset) {
     if ($this->pathPackageMap === null) {
       throw new PhutilInvalidStateException('buildPackageMaps');
     }
 
     $path = $changeset->getOwnersFilename();
     return idx($this->pathPackageMap, $path, array());
   }
 
   protected function getPackageChangesets($package_phid) {
     if ($this->packageChangesetMap === null) {
       throw new PhutilInvalidStateException('buildPackageMaps');
     }
 
     return idx($this->packageChangesetMap, $package_phid, array());
   }
 
   protected function buildTableOfContents(
     array $changesets,
     array $visible_changesets,
     array $coverage) {
     $viewer = $this->getViewer();
 
     $toc_view = id(new PHUIDiffTableOfContentsListView())
       ->setViewer($viewer)
       ->setBare(true)
       ->setAuthorityPackages($this->getAuthorityPackages());
 
     foreach ($changesets as $changeset_id => $changeset) {
       $is_visible = isset($visible_changesets[$changeset_id]);
       $anchor = $changeset->getAnchorName();
 
       $filename = $changeset->getFilename();
       $coverage_id = 'differential-mcoverage-'.md5($filename);
 
       $item = id(new PHUIDiffTableOfContentsItemView())
         ->setChangeset($changeset)
         ->setIsVisible($is_visible)
         ->setAnchor($anchor)
         ->setCoverage(idx($coverage, $filename))
         ->setCoverageID($coverage_id);
 
       $packages = $this->getChangesetPackages($changeset);
       $item->setPackages($packages);
 
       $toc_view->addItem($item);
     }
 
     return $toc_view;
   }
 
   protected function loadDiffProperties(array $diffs) {
     $diffs = mpull($diffs, null, 'getID');
 
     $properties = id(new DifferentialDiffProperty())->loadAllWhere(
       'diffID IN (%Ld)',
       array_keys($diffs));
     $properties = mgroup($properties, 'getDiffID');
 
     foreach ($diffs as $id => $diff) {
       $values = idx($properties, $id, array());
       $values = mpull($values, 'getData', 'getName');
       $diff->attachDiffProperties($values);
     }
   }
 
 
   protected function loadHarbormasterData(array $diffs) {
     $viewer = $this->getViewer();
 
     $diffs = mpull($diffs, null, 'getPHID');
 
     $buildables = id(new HarbormasterBuildableQuery())
       ->setViewer($viewer)
       ->withBuildablePHIDs(array_keys($diffs))
       ->withManualBuildables(false)
       ->needBuilds(true)
       ->needTargets(true)
       ->execute();
 
     $buildables = mpull($buildables, null, 'getBuildablePHID');
     foreach ($diffs as $phid => $diff) {
       $diff->attachBuildable(idx($buildables, $phid));
     }
 
     $target_map = array();
     foreach ($diffs as $phid => $diff) {
       $target_map[$phid] = $diff->getBuildTargetPHIDs();
     }
     $all_target_phids = array_mergev($target_map);
 
     if ($all_target_phids) {
       $unit_messages = id(new HarbormasterBuildUnitMessage())->loadAllWhere(
         'buildTargetPHID IN (%Ls)',
         $all_target_phids);
       $unit_messages = mgroup($unit_messages, 'getBuildTargetPHID');
     } else {
       $unit_messages = array();
     }
 
     foreach ($diffs as $phid => $diff) {
       $target_phids = idx($target_map, $phid, array());
       $messages = array_select_keys($unit_messages, $target_phids);
       $messages = array_mergev($messages);
       $diff->attachUnitMessages($messages);
     }
 
     // For diffs with no messages, look for legacy unit messages stored on the
     // diff itself.
     foreach ($diffs as $phid => $diff) {
       if ($diff->getUnitMessages()) {
         continue;
       }
 
       if (!$diff->hasDiffProperty('arc:unit')) {
         continue;
       }
 
       $legacy_messages = $diff->getProperty('arc:unit');
       if (!$legacy_messages) {
         continue;
       }
 
       // Show the top 100 legacy lint messages. Previously, we showed some
       // by default and let the user toggle the rest. With modern messages,
       // we can send the user to the Harbormaster detail page. Just show
       // "a lot" of messages in legacy cases to try to strike a balance
       // between implementation simplicity and compatibility.
       $legacy_messages = array_slice($legacy_messages, 0, 100);
 
       $messages = array();
       foreach ($legacy_messages as $message) {
         $messages[] = HarbormasterBuildUnitMessage::newFromDictionary(
           new HarbormasterBuildTarget(),
           $this->getModernUnitMessageDictionary($message));
       }
 
       $diff->attachUnitMessages($messages);
     }
   }
 
   private function getModernUnitMessageDictionary(array $map) {
     // Strip out `null` values to satisfy stricter typechecks.
     foreach ($map as $key => $value) {
       if ($value === null) {
         unset($map[$key]);
       }
     }
 
     // Cast duration to a float since it used to be a string in some
     // cases.
     if (isset($map['duration'])) {
       $map['duration'] = (double)$map['duration'];
     }
 
     return $map;
   }
 
   protected function getDiffTabLabels(array $diffs) {
     // Make sure we're only going to render unique diffs.
     $diffs = mpull($diffs, null, 'getID');
     $labels = array(pht('Left'), pht('Right'));
 
     $results = array();
 
     foreach ($diffs as $diff) {
       if (count($diffs) == 2) {
         $label = array_shift($labels);
         $label = pht('%s (Diff %d)', $label, $diff->getID());
       } else {
         $label = pht('Diff %d', $diff->getID());
       }
 
       $results[] = array(
         $label,
         $diff,
       );
     }
 
     return $results;
   }
 
 
 }
diff --git a/src/applications/differential/editor/DifferentialTransactionEditor.php b/src/applications/differential/editor/DifferentialTransactionEditor.php
index 82740459b0..3271248ce8 100644
--- a/src/applications/differential/editor/DifferentialTransactionEditor.php
+++ b/src/applications/differential/editor/DifferentialTransactionEditor.php
@@ -1,1694 +1,1706 @@
 <?php
 
 final class DifferentialTransactionEditor
   extends PhabricatorApplicationTransactionEditor {
 
   private $changedPriorToCommitURI;
   private $isCloseByCommit;
   private $repositoryPHIDOverride = false;
   private $didExpandInlineState = false;
-  private $affectedPaths;
   private $firstBroadcast = false;
   private $wasBroadcasting;
   private $isDraftDemotion;
 
+  private $ownersDiff;
+  private $ownersChangesets;
+
   public function getEditorApplicationClass() {
     return 'PhabricatorDifferentialApplication';
   }
 
   public function getEditorObjectsDescription() {
     return pht('Differential Revisions');
   }
 
   public function getCreateObjectTitle($author, $object) {
     return pht('%s created this revision.', $author);
   }
 
   public function getCreateObjectTitleForFeed($author, $object) {
     return pht('%s created %s.', $author, $object);
   }
 
   public function isFirstBroadcast() {
     return $this->firstBroadcast;
   }
 
   public function getDiffUpdateTransaction(array $xactions) {
     $type_update = DifferentialRevisionUpdateTransaction::TRANSACTIONTYPE;
 
     foreach ($xactions as $xaction) {
       if ($xaction->getTransactionType() == $type_update) {
         return $xaction;
       }
     }
 
     return null;
   }
 
   public function setIsCloseByCommit($is_close_by_commit) {
     $this->isCloseByCommit = $is_close_by_commit;
     return $this;
   }
 
   public function getIsCloseByCommit() {
     return $this->isCloseByCommit;
   }
 
   public function setChangedPriorToCommitURI($uri) {
     $this->changedPriorToCommitURI = $uri;
     return $this;
   }
 
   public function getChangedPriorToCommitURI() {
     return $this->changedPriorToCommitURI;
   }
 
   public function setRepositoryPHIDOverride($phid_or_null) {
     $this->repositoryPHIDOverride = $phid_or_null;
     return $this;
   }
 
   public function getTransactionTypes() {
     $types = parent::getTransactionTypes();
 
     $types[] = PhabricatorTransactions::TYPE_COMMENT;
     $types[] = PhabricatorTransactions::TYPE_VIEW_POLICY;
     $types[] = PhabricatorTransactions::TYPE_EDIT_POLICY;
     $types[] = PhabricatorTransactions::TYPE_INLINESTATE;
 
     $types[] = DifferentialTransaction::TYPE_INLINE;
 
     return $types;
   }
 
   protected function getCustomTransactionOldValue(
     PhabricatorLiskDAO $object,
     PhabricatorApplicationTransaction $xaction) {
 
     switch ($xaction->getTransactionType()) {
       case DifferentialTransaction::TYPE_INLINE:
         return null;
     }
 
     return parent::getCustomTransactionOldValue($object, $xaction);
   }
 
   protected function getCustomTransactionNewValue(
     PhabricatorLiskDAO $object,
     PhabricatorApplicationTransaction $xaction) {
 
     switch ($xaction->getTransactionType()) {
       case DifferentialTransaction::TYPE_INLINE:
         return null;
     }
 
     return parent::getCustomTransactionNewValue($object, $xaction);
   }
 
   protected function applyCustomInternalTransaction(
     PhabricatorLiskDAO $object,
     PhabricatorApplicationTransaction $xaction) {
 
     switch ($xaction->getTransactionType()) {
       case DifferentialTransaction::TYPE_INLINE:
         return;
     }
 
     return parent::applyCustomInternalTransaction($object, $xaction);
   }
 
   protected function expandTransactions(
     PhabricatorLiskDAO $object,
     array $xactions) {
 
     foreach ($xactions as $xaction) {
       switch ($xaction->getTransactionType()) {
         case PhabricatorTransactions::TYPE_INLINESTATE:
           // If we have an "Inline State" transaction already, the caller
           // built it for us so we don't need to expand it again.
           $this->didExpandInlineState = true;
           break;
         case DifferentialRevisionPlanChangesTransaction::TRANSACTIONTYPE:
           if ($xaction->getMetadataValue('draft.demote')) {
             $this->isDraftDemotion = true;
           }
           break;
       }
     }
 
     $this->wasBroadcasting = $object->getShouldBroadcast();
 
     return parent::expandTransactions($object, $xactions);
   }
 
   protected function expandTransaction(
     PhabricatorLiskDAO $object,
     PhabricatorApplicationTransaction $xaction) {
 
     $results = parent::expandTransaction($object, $xaction);
 
     $actor = $this->getActor();
     $actor_phid = $this->getActingAsPHID();
     $type_edge = PhabricatorTransactions::TYPE_EDGE;
 
     $edge_ref_task = DifferentialRevisionHasTaskEdgeType::EDGECONST;
 
     $want_downgrade = array();
     $must_downgrade = array();
     if ($this->getIsCloseByCommit()) {
       // Never downgrade reviewers when we're closing a revision after a
       // commit.
     } else {
       switch ($xaction->getTransactionType()) {
         case DifferentialRevisionUpdateTransaction::TRANSACTIONTYPE:
           $want_downgrade[] = DifferentialReviewerStatus::STATUS_ACCEPTED;
           $want_downgrade[] = DifferentialReviewerStatus::STATUS_REJECTED;
           break;
         case DifferentialRevisionRequestReviewTransaction::TRANSACTIONTYPE:
           if (!$object->isChangePlanned()) {
             // If the old state isn't "Changes Planned", downgrade the accepts
             // even if they're sticky.
 
             // We don't downgrade for "Changes Planned" to allow an author to
             // undo a "Plan Changes" by immediately following it up with a
             // "Request Review".
             $want_downgrade[] = DifferentialReviewerStatus::STATUS_ACCEPTED;
             $must_downgrade[] = DifferentialReviewerStatus::STATUS_ACCEPTED;
           }
           $want_downgrade[] = DifferentialReviewerStatus::STATUS_REJECTED;
           break;
       }
     }
 
     if ($want_downgrade) {
       $void_type = DifferentialRevisionVoidTransaction::TRANSACTIONTYPE;
 
       $results[] = id(new DifferentialTransaction())
         ->setTransactionType($void_type)
         ->setIgnoreOnNoEffect(true)
         ->setMetadataValue('void.force', $must_downgrade)
         ->setNewValue($want_downgrade);
     }
 
     $is_commandeer = false;
     switch ($xaction->getTransactionType()) {
       case DifferentialRevisionUpdateTransaction::TRANSACTIONTYPE:
         if ($this->getIsCloseByCommit()) {
           // Don't bother with any of this if this update is a side effect of
           // commit detection.
           break;
         }
 
         // When a revision is updated and the diff comes from a branch named
         // "T123" or similar, automatically associate the commit with the
         // task that the branch names.
 
         $maniphest = 'PhabricatorManiphestApplication';
         if (PhabricatorApplication::isClassInstalled($maniphest)) {
           $diff = $this->requireDiff($xaction->getNewValue());
           $branch = $diff->getBranch();
 
           // No "$", to allow for branches like T123_demo.
           $match = null;
           if (preg_match('/^T(\d+)/i', $branch, $match)) {
             $task_id = $match[1];
             $tasks = id(new ManiphestTaskQuery())
               ->setViewer($this->getActor())
               ->withIDs(array($task_id))
               ->execute();
             if ($tasks) {
               $task = head($tasks);
               $task_phid = $task->getPHID();
 
               $results[] = id(new DifferentialTransaction())
                 ->setTransactionType($type_edge)
                 ->setMetadataValue('edge:type', $edge_ref_task)
                 ->setIgnoreOnNoEffect(true)
                 ->setNewValue(array('+' => array($task_phid => $task_phid)));
             }
           }
         }
         break;
 
       case DifferentialRevisionCommandeerTransaction::TRANSACTIONTYPE:
         $is_commandeer = true;
         break;
     }
 
     if ($is_commandeer) {
       $results[] = $this->newCommandeerReviewerTransaction($object);
     }
 
     if (!$this->didExpandInlineState) {
       switch ($xaction->getTransactionType()) {
         case PhabricatorTransactions::TYPE_COMMENT:
         case DifferentialRevisionUpdateTransaction::TRANSACTIONTYPE:
         case DifferentialTransaction::TYPE_INLINE:
           $this->didExpandInlineState = true;
 
           $actor_phid = $this->getActingAsPHID();
           $actor_is_author = ($object->getAuthorPHID() == $actor_phid);
           if (!$actor_is_author) {
             break;
           }
 
           $state_map = PhabricatorTransactions::getInlineStateMap();
 
           $inlines = id(new DifferentialDiffInlineCommentQuery())
             ->setViewer($this->getActor())
             ->withRevisionPHIDs(array($object->getPHID()))
             ->withFixedStates(array_keys($state_map))
             ->execute();
 
           if (!$inlines) {
             break;
           }
 
           $old_value = mpull($inlines, 'getFixedState', 'getPHID');
           $new_value = array();
           foreach ($old_value as $key => $state) {
             $new_value[$key] = $state_map[$state];
           }
 
           $results[] = id(new DifferentialTransaction())
             ->setTransactionType(PhabricatorTransactions::TYPE_INLINESTATE)
             ->setIgnoreOnNoEffect(true)
             ->setOldValue($old_value)
             ->setNewValue($new_value);
           break;
       }
     }
 
     return $results;
   }
 
   protected function applyCustomExternalTransaction(
     PhabricatorLiskDAO $object,
     PhabricatorApplicationTransaction $xaction) {
 
     switch ($xaction->getTransactionType()) {
       case DifferentialTransaction::TYPE_INLINE:
         $reply = $xaction->getComment()->getReplyToComment();
         if ($reply && !$reply->getHasReplies()) {
           $reply->setHasReplies(1)->save();
         }
         return;
     }
 
     return parent::applyCustomExternalTransaction($object, $xaction);
   }
 
   protected function applyBuiltinExternalTransaction(
     PhabricatorLiskDAO $object,
     PhabricatorApplicationTransaction $xaction) {
 
     switch ($xaction->getTransactionType()) {
       case PhabricatorTransactions::TYPE_INLINESTATE:
         $table = new DifferentialTransactionComment();
         $conn_w = $table->establishConnection('w');
         foreach ($xaction->getNewValue() as $phid => $state) {
           queryfx(
             $conn_w,
             'UPDATE %T SET fixedState = %s WHERE phid = %s',
             $table->getTableName(),
             $state,
             $phid);
         }
         break;
     }
 
     return parent::applyBuiltinExternalTransaction($object, $xaction);
   }
 
   protected function applyFinalEffects(
     PhabricatorLiskDAO $object,
     array $xactions) {
 
     // Load the most up-to-date version of the revision and its reviewers,
     // so we don't need to try to deduce the state of reviewers by examining
     // all the changes made by the transactions. Then, update the reviewers
     // on the object to make sure we're acting on the current reviewer set
     // (and, for example, sending mail to the right people).
 
     $new_revision = id(new DifferentialRevisionQuery())
       ->setViewer($this->getActor())
       ->needReviewers(true)
       ->needActiveDiffs(true)
       ->withIDs(array($object->getID()))
       ->executeOne();
     if (!$new_revision) {
       throw new Exception(
         pht('Failed to load revision from transaction finalization.'));
     }
 
     $object->attachReviewers($new_revision->getReviewers());
     $object->attachActiveDiff($new_revision->getActiveDiff());
     $object->attachRepository($new_revision->getRepository());
 
     foreach ($xactions as $xaction) {
       switch ($xaction->getTransactionType()) {
         case DifferentialRevisionUpdateTransaction::TRANSACTIONTYPE:
           $diff = $this->requireDiff($xaction->getNewValue(), true);
 
           // Update these denormalized index tables when we attach a new
           // diff to a revision.
 
           $this->updateRevisionHashTable($object, $diff);
           $this->updateAffectedPathTable($object, $diff);
           break;
       }
     }
 
     $xactions = $this->updateReviewStatus($object, $xactions);
     $this->markReviewerComments($object, $xactions);
 
     return $xactions;
   }
 
   private function updateReviewStatus(
     DifferentialRevision $revision,
     array $xactions) {
 
     $was_accepted = $revision->isAccepted();
     $was_revision = $revision->isNeedsRevision();
     $was_review = $revision->isNeedsReview();
     if (!$was_accepted && !$was_revision && !$was_review) {
       // Revisions can't transition out of other statuses (like closed or
       // abandoned) as a side effect of reviewer status changes.
       return $xactions;
     }
 
     // Try to move a revision to "accepted". We look for:
     //
     //   - at least one accepting reviewer who is a user; and
     //   - no rejects; and
     //   - no rejects of older diffs; and
     //   - no blocking reviewers.
 
     $has_accepting_user = false;
     $has_rejecting_reviewer = false;
     $has_rejecting_older_reviewer = false;
     $has_blocking_reviewer = false;
 
     $active_diff = $revision->getActiveDiff();
     foreach ($revision->getReviewers() as $reviewer) {
       $reviewer_status = $reviewer->getReviewerStatus();
       switch ($reviewer_status) {
         case DifferentialReviewerStatus::STATUS_REJECTED:
           $active_phid = $active_diff->getPHID();
           if ($reviewer->isRejected($active_phid)) {
             $has_rejecting_reviewer = true;
           } else {
             $has_rejecting_older_reviewer = true;
           }
           break;
         case DifferentialReviewerStatus::STATUS_REJECTED_OLDER:
           $has_rejecting_older_reviewer = true;
           break;
         case DifferentialReviewerStatus::STATUS_BLOCKING:
           $has_blocking_reviewer = true;
           break;
         case DifferentialReviewerStatus::STATUS_ACCEPTED:
           if ($reviewer->isUser()) {
             $active_phid = $active_diff->getPHID();
             if ($reviewer->isAccepted($active_phid)) {
               $has_accepting_user = true;
             }
           }
           break;
       }
     }
 
     $new_status = null;
     if ($has_accepting_user &&
         !$has_rejecting_reviewer &&
         !$has_rejecting_older_reviewer &&
         !$has_blocking_reviewer) {
       $new_status = DifferentialRevisionStatus::ACCEPTED;
     } else if ($has_rejecting_reviewer) {
       // This isn't accepted, and there's at least one rejecting reviewer,
       // so the revision needs changes. This usually happens after a
       // "reject".
       $new_status = DifferentialRevisionStatus::NEEDS_REVISION;
     } else if ($was_accepted) {
       // This revision was accepted, but it no longer satisfies the
       // conditions for acceptance. This usually happens after an accepting
       // reviewer resigns or is removed.
       $new_status = DifferentialRevisionStatus::NEEDS_REVIEW;
     }
 
     if ($new_status === null) {
       return $xactions;
     }
 
     $old_status = $revision->getModernRevisionStatus();
     if ($new_status == $old_status) {
       return $xactions;
     }
 
     $xaction = id(new DifferentialTransaction())
       ->setTransactionType(
           DifferentialRevisionStatusTransaction::TRANSACTIONTYPE)
       ->setOldValue($old_status)
       ->setNewValue($new_status);
 
     $xaction = $this->populateTransaction($revision, $xaction)
       ->save();
     $xactions[] = $xaction;
 
     // Save the status adjustment we made earlier.
     $revision
       ->setModernRevisionStatus($new_status)
       ->save();
 
     return $xactions;
   }
 
   protected function sortTransactions(array $xactions) {
     $xactions = parent::sortTransactions($xactions);
 
     $head = array();
     $tail = array();
 
     foreach ($xactions as $xaction) {
       $type = $xaction->getTransactionType();
       if ($type == DifferentialTransaction::TYPE_INLINE) {
         $tail[] = $xaction;
       } else {
         $head[] = $xaction;
       }
     }
 
     return array_values(array_merge($head, $tail));
   }
 
   protected function shouldPublishFeedStory(
     PhabricatorLiskDAO $object,
     array $xactions) {
 
     if (!$object->getShouldBroadcast()) {
       return false;
     }
 
     return true;
   }
 
   protected function shouldSendMail(
     PhabricatorLiskDAO $object,
     array $xactions) {
     return true;
   }
 
   protected function getMailTo(PhabricatorLiskDAO $object) {
     if ($object->getShouldBroadcast()) {
       $this->requireReviewers($object);
 
       $phids = array();
       $phids[] = $object->getAuthorPHID();
       foreach ($object->getReviewers() as $reviewer) {
         if ($reviewer->isResigned()) {
           continue;
         }
 
         $phids[] = $reviewer->getReviewerPHID();
       }
       return $phids;
     }
 
     // If we're demoting a draft after a build failure, just notify the author.
     if ($this->isDraftDemotion) {
       $author_phid = $object->getAuthorPHID();
       return array(
         $author_phid,
       );
     }
 
     return array();
   }
 
   protected function getMailCC(PhabricatorLiskDAO $object) {
     if (!$object->getShouldBroadcast()) {
       return array();
     }
 
     return parent::getMailCC($object);
   }
 
   protected function newMailUnexpandablePHIDs(PhabricatorLiskDAO $object) {
     $this->requireReviewers($object);
 
     $phids = array();
 
     foreach ($object->getReviewers() as $reviewer) {
       if ($reviewer->isResigned()) {
         $phids[] = $reviewer->getReviewerPHID();
       }
     }
 
     return $phids;
   }
 
   protected function getMailAction(
     PhabricatorLiskDAO $object,
     array $xactions) {
 
     $show_lines = false;
     if ($this->isFirstBroadcast()) {
       $action = pht('Request');
 
       $show_lines = true;
     } else {
       $action = parent::getMailAction($object, $xactions);
 
       $strongest = $this->getStrongestAction($object, $xactions);
       $type_update = DifferentialRevisionUpdateTransaction::TRANSACTIONTYPE;
       if ($strongest->getTransactionType() == $type_update) {
         $show_lines = true;
       }
     }
 
     if ($show_lines) {
       $count = new PhutilNumber($object->getLineCount());
       $action = pht('%s] [%s', $action, $object->getRevisionScaleGlyphs());
     }
 
     return $action;
   }
 
   protected function getMailSubjectPrefix() {
     return PhabricatorEnv::getEnvConfig('metamta.differential.subject-prefix');
   }
 
   protected function getMailThreadID(PhabricatorLiskDAO $object) {
     // This is nonstandard, but retains threading with older messages.
     $phid = $object->getPHID();
     return "differential-rev-{$phid}-req";
   }
 
   protected function buildReplyHandler(PhabricatorLiskDAO $object) {
     return id(new DifferentialReplyHandler())
       ->setMailReceiver($object);
   }
 
   protected function buildMailTemplate(PhabricatorLiskDAO $object) {
     $id = $object->getID();
     $title = $object->getTitle();
     $subject = "D{$id}: {$title}";
 
     return id(new PhabricatorMetaMTAMail())
       ->setSubject($subject);
   }
 
   protected function getTransactionsForMail(
     PhabricatorLiskDAO $object,
     array $xactions) {
     // If this is the first time we're sending mail about this revision, we
     // generate mail for all prior transactions, not just whatever is being
     // applied now. This gets the "added reviewers" lines and other relevant
     // information into the mail.
     if ($this->isFirstBroadcast()) {
       return $this->loadUnbroadcastTransactions($object);
     }
 
     return $xactions;
   }
 
   protected function buildMailBody(
     PhabricatorLiskDAO $object,
     array $xactions) {
 
     $viewer = $this->requireActor();
 
     $body = new PhabricatorMetaMTAMailBody();
     $body->setViewer($this->requireActor());
 
     $revision_uri = PhabricatorEnv::getProductionURI('/D'.$object->getID());
 
     $this->addHeadersAndCommentsToMailBody(
       $body,
       $xactions,
       pht('View Revision'),
       $revision_uri);
 
     $type_inline = DifferentialTransaction::TYPE_INLINE;
 
     $inlines = array();
     foreach ($xactions as $xaction) {
       if ($xaction->getTransactionType() == $type_inline) {
         $inlines[] = $xaction;
       }
     }
 
     if ($inlines) {
       $this->appendInlineCommentsForMail($object, $inlines, $body);
     }
 
     $changed_uri = $this->getChangedPriorToCommitURI();
     if ($changed_uri) {
       $body->addLinkSection(
         pht('CHANGED PRIOR TO COMMIT'),
         $changed_uri);
     }
 
     $this->addCustomFieldsToMailBody($body, $object, $xactions);
 
     $body->addLinkSection(
       pht('REVISION DETAIL'),
       $revision_uri);
 
     $update_xaction = null;
     foreach ($xactions as $xaction) {
       switch ($xaction->getTransactionType()) {
         case DifferentialRevisionUpdateTransaction::TRANSACTIONTYPE:
           $update_xaction = $xaction;
           break;
       }
     }
 
     if ($update_xaction) {
       $diff = $this->requireDiff($update_xaction->getNewValue(), true);
 
       $body->addTextSection(
         pht('AFFECTED FILES'),
         $this->renderAffectedFilesForMail($diff));
 
       $config_key_inline = 'metamta.differential.inline-patches';
       $config_inline = PhabricatorEnv::getEnvConfig($config_key_inline);
 
       $config_key_attach = 'metamta.differential.attach-patches';
       $config_attach = PhabricatorEnv::getEnvConfig($config_key_attach);
 
       if ($config_inline || $config_attach) {
         $body_limit = PhabricatorEnv::getEnvConfig('metamta.email-body-limit');
 
         $patch = $this->buildPatchForMail($diff);
         if ($config_inline) {
           $lines = substr_count($patch, "\n");
           $bytes = strlen($patch);
 
           // Limit the patch size to the smaller of 256 bytes per line or
           // the mail body limit. This prevents degenerate behavior for patches
           // with one line that is 10MB long. See T11748.
           $byte_limits = array();
           $byte_limits[] = (256 * $config_inline);
           $byte_limits[] = $body_limit;
           $byte_limit = min($byte_limits);
 
           $lines_ok = ($lines <= $config_inline);
           $bytes_ok = ($bytes <= $byte_limit);
 
           if ($lines_ok && $bytes_ok) {
             $this->appendChangeDetailsForMail($object, $diff, $patch, $body);
           } else {
             // TODO: Provide a helpful message about the patch being too
             // large or lengthy here.
           }
         }
 
         if ($config_attach) {
           // See T12033, T11767, and PHI55. This is a crude fix to stop the
           // major concrete problems that lackluster email size limits cause.
           if (strlen($patch) < $body_limit) {
             $name = pht('D%s.%s.patch', $object->getID(), $diff->getID());
             $mime_type = 'text/x-patch; charset=utf-8';
             $body->addAttachment(
               new PhabricatorMetaMTAAttachment($patch, $name, $mime_type));
           }
         }
       }
     }
 
     return $body;
   }
 
   public function getMailTagsMap() {
     return array(
       DifferentialTransaction::MAILTAG_REVIEW_REQUEST =>
         pht('A revision is created.'),
       DifferentialTransaction::MAILTAG_UPDATED =>
         pht('A revision is updated.'),
       DifferentialTransaction::MAILTAG_COMMENT =>
         pht('Someone comments on a revision.'),
       DifferentialTransaction::MAILTAG_CLOSED =>
         pht('A revision is closed.'),
       DifferentialTransaction::MAILTAG_REVIEWERS =>
         pht("A revision's reviewers change."),
       DifferentialTransaction::MAILTAG_CC =>
         pht("A revision's CCs change."),
       DifferentialTransaction::MAILTAG_OTHER =>
         pht('Other revision activity not listed above occurs.'),
     );
   }
 
   protected function supportsSearch() {
     return true;
   }
 
   protected function expandCustomRemarkupBlockTransactions(
     PhabricatorLiskDAO $object,
     array $xactions,
     array $changes,
     PhutilMarkupEngine $engine) {
 
     // For "Fixes ..." and "Depends on ...", we're only going to look at
     // content blocks which are part of the revision itself (like "Summary"
     // and  "Test Plan"), not comments.
     $content_parts = array();
     foreach ($changes as $change) {
       if ($change->getTransaction()->isCommentTransaction()) {
         continue;
       }
       $content_parts[] = $change->getNewValue();
     }
     if (!$content_parts) {
       return array();
     }
     $content_block = implode("\n\n", $content_parts);
     $task_map = array();
     $task_refs = id(new ManiphestCustomFieldStatusParser())
       ->parseCorpus($content_block);
     foreach ($task_refs as $match) {
       foreach ($match['monograms'] as $monogram) {
         $task_id = (int)trim($monogram, 'tT');
         $task_map[$task_id] = true;
       }
     }
 
     $rev_map = array();
     $rev_refs = id(new DifferentialCustomFieldDependsOnParser())
       ->parseCorpus($content_block);
     foreach ($rev_refs as $match) {
       foreach ($match['monograms'] as $monogram) {
         $rev_id = (int)trim($monogram, 'dD');
         $rev_map[$rev_id] = true;
       }
     }
 
     $edges = array();
     $task_phids = array();
     $rev_phids = array();
 
     if ($task_map) {
       $tasks = id(new ManiphestTaskQuery())
         ->setViewer($this->getActor())
         ->withIDs(array_keys($task_map))
         ->execute();
 
       if ($tasks) {
         $task_phids = mpull($tasks, 'getPHID', 'getPHID');
         $edge_related = DifferentialRevisionHasTaskEdgeType::EDGECONST;
         $edges[$edge_related] = $task_phids;
       }
     }
 
     if ($rev_map) {
       $revs = id(new DifferentialRevisionQuery())
         ->setViewer($this->getActor())
         ->withIDs(array_keys($rev_map))
         ->execute();
       $rev_phids = mpull($revs, 'getPHID', 'getPHID');
 
       // NOTE: Skip any write attempts if a user cleverly implies a revision
       // depends upon itself.
       unset($rev_phids[$object->getPHID()]);
 
       if ($revs) {
         $depends = DifferentialRevisionDependsOnRevisionEdgeType::EDGECONST;
         $edges[$depends] = $rev_phids;
       }
     }
 
     $revert_refs = id(new DifferentialCustomFieldRevertsParser())
       ->parseCorpus($content_block);
 
     $revert_monograms = array();
     foreach ($revert_refs as $match) {
       foreach ($match['monograms'] as $monogram) {
         $revert_monograms[] = $monogram;
       }
     }
 
     if ($revert_monograms) {
       $revert_objects = id(new PhabricatorObjectQuery())
         ->setViewer($this->getActor())
         ->withNames($revert_monograms)
         ->withTypes(
           array(
             DifferentialRevisionPHIDType::TYPECONST,
             PhabricatorRepositoryCommitPHIDType::TYPECONST,
           ))
         ->execute();
 
       $revert_phids = mpull($revert_objects, 'getPHID', 'getPHID');
 
       // Don't let an object revert itself, although other silly stuff like
       // cycles of objects reverting each other is not prevented.
       unset($revert_phids[$object->getPHID()]);
 
       $revert_type = DiffusionCommitRevertsCommitEdgeType::EDGECONST;
       $edges[$revert_type] = $revert_phids;
     } else {
       $revert_phids = array();
     }
 
     // See PHI574. Respect any unmentionable PHIDs which were set on the
     // Editor by the caller.
     $unmentionable_map = $this->getUnmentionablePHIDMap();
     $unmentionable_map += $task_phids;
     $unmentionable_map += $rev_phids;
     $unmentionable_map += $revert_phids;
     $this->setUnmentionablePHIDMap($unmentionable_map);
 
     $result = array();
     foreach ($edges as $type => $specs) {
       $result[] = id(new DifferentialTransaction())
         ->setTransactionType(PhabricatorTransactions::TYPE_EDGE)
         ->setMetadataValue('edge:type', $type)
         ->setNewValue(array('+' => $specs));
     }
 
     return $result;
   }
 
   private function appendInlineCommentsForMail(
     PhabricatorLiskDAO $object,
     array $inlines,
     PhabricatorMetaMTAMailBody $body) {
 
     $section = id(new DifferentialInlineCommentMailView())
       ->setViewer($this->getActor())
       ->setInlines($inlines)
       ->buildMailSection();
 
     $header = pht('INLINE COMMENTS');
 
     $section_text = "\n".$section->getPlaintext();
 
     $style = array(
       'margin: 6px 0 12px 0;',
     );
 
     $section_html = phutil_tag(
       'div',
       array(
         'style' => implode(' ', $style),
       ),
       $section->getHTML());
 
     $body->addPlaintextSection($header, $section_text, false);
     $body->addHTMLSection($header, $section_html);
   }
 
   private function appendChangeDetailsForMail(
     PhabricatorLiskDAO $object,
     DifferentialDiff $diff,
     $patch,
     PhabricatorMetaMTAMailBody $body) {
 
     $section = id(new DifferentialChangeDetailMailView())
       ->setViewer($this->getActor())
       ->setDiff($diff)
       ->setPatch($patch)
       ->buildMailSection();
 
     $header = pht('CHANGE DETAILS');
 
     $section_text = "\n".$section->getPlaintext();
 
     $style = array(
       'margin: 6px 0 12px 0;',
     );
 
     $section_html = phutil_tag(
       'div',
       array(
         'style' => implode(' ', $style),
       ),
       $section->getHTML());
 
     $body->addPlaintextSection($header, $section_text, false);
     $body->addHTMLSection($header, $section_html);
   }
 
   private function loadDiff($phid, $need_changesets = false) {
     $query = id(new DifferentialDiffQuery())
       ->withPHIDs(array($phid))
       ->setViewer($this->getActor());
 
     if ($need_changesets) {
       $query->needChangesets(true);
     }
 
     return $query->executeOne();
   }
 
   public function requireDiff($phid, $need_changesets = false) {
     $diff = $this->loadDiff($phid, $need_changesets);
     if (!$diff) {
       throw new Exception(pht('Diff "%s" does not exist!', $phid));
     }
 
     return $diff;
   }
 
 /* -(  Herald Integration  )------------------------------------------------- */
 
   protected function shouldApplyHeraldRules(
     PhabricatorLiskDAO $object,
     array $xactions) {
     return true;
   }
 
   protected function didApplyHeraldRules(
     PhabricatorLiskDAO $object,
     HeraldAdapter $adapter,
     HeraldTranscript $transcript) {
 
     $repository = $object->getRepository();
     if (!$repository) {
       return array();
     }
 
-    if (!$this->affectedPaths) {
+    $diff = $this->ownersDiff;
+    $changesets = $this->ownersChangesets;
+
+    $this->ownersDiff = null;
+    $this->ownersChangesets = null;
+
+    if (!$changesets) {
       return array();
     }
 
-    $packages = PhabricatorOwnersPackage::loadAffectedPackages(
+    $packages = PhabricatorOwnersPackage::loadAffectedPackagesForChangesets(
       $repository,
-      $this->affectedPaths);
+      $diff,
+      $changesets);
     if (!$packages) {
       return array();
     }
 
     // Identify the packages with "Non-Owner Author" review rules and remove
     // them if the author has authority over the package.
 
     $autoreview_map = PhabricatorOwnersPackage::getAutoreviewOptionsMap();
     $need_authority = array();
     foreach ($packages as $package) {
       $autoreview_setting = $package->getAutoReview();
 
       $spec = idx($autoreview_map, $autoreview_setting);
       if (!$spec) {
         continue;
       }
 
       if (idx($spec, 'authority')) {
         $need_authority[$package->getPHID()] = $package->getPHID();
       }
     }
 
     if ($need_authority) {
       $authority = id(new PhabricatorOwnersPackageQuery())
         ->setViewer(PhabricatorUser::getOmnipotentUser())
         ->withPHIDs($need_authority)
         ->withAuthorityPHIDs(array($object->getAuthorPHID()))
         ->execute();
       $authority = mpull($authority, null, 'getPHID');
 
       foreach ($packages as $key => $package) {
         $package_phid = $package->getPHID();
         if (isset($authority[$package_phid])) {
           unset($packages[$key]);
           continue;
         }
       }
 
       if (!$packages) {
         return array();
       }
     }
 
     $auto_subscribe = array();
     $auto_review = array();
     $auto_block = array();
 
     foreach ($packages as $package) {
       switch ($package->getAutoReview()) {
         case PhabricatorOwnersPackage::AUTOREVIEW_REVIEW:
         case PhabricatorOwnersPackage::AUTOREVIEW_REVIEW_ALWAYS:
           $auto_review[] = $package;
           break;
         case PhabricatorOwnersPackage::AUTOREVIEW_BLOCK:
         case PhabricatorOwnersPackage::AUTOREVIEW_BLOCK_ALWAYS:
           $auto_block[] = $package;
           break;
         case PhabricatorOwnersPackage::AUTOREVIEW_SUBSCRIBE:
         case PhabricatorOwnersPackage::AUTOREVIEW_SUBSCRIBE_ALWAYS:
           $auto_subscribe[] = $package;
           break;
         case PhabricatorOwnersPackage::AUTOREVIEW_NONE:
         default:
           break;
       }
     }
 
     $owners_phid = id(new PhabricatorOwnersApplication())
       ->getPHID();
 
     $xactions = array();
     if ($auto_subscribe) {
       $xactions[] = $object->getApplicationTransactionTemplate()
         ->setAuthorPHID($owners_phid)
         ->setTransactionType(PhabricatorTransactions::TYPE_SUBSCRIBERS)
         ->setNewValue(
           array(
             '+' => mpull($auto_subscribe, 'getPHID'),
           ));
     }
 
     $specs = array(
       array($auto_review, false),
       array($auto_block, true),
     );
 
     foreach ($specs as $spec) {
       list($reviewers, $blocking) = $spec;
       if (!$reviewers) {
         continue;
       }
 
       $phids = mpull($reviewers, 'getPHID');
       $xaction = $this->newAutoReviewTransaction($object, $phids, $blocking);
       if ($xaction) {
         $xactions[] = $xaction;
       }
     }
 
     return $xactions;
   }
 
   private function newAutoReviewTransaction(
     PhabricatorLiskDAO $object,
     array $phids,
     $is_blocking) {
 
     // TODO: This is substantially similar to DifferentialReviewersHeraldAction
     // and both are needlessly complex. This logic should live in the normal
     // transaction application pipeline. See T10967.
 
     $reviewers = $object->getReviewers();
     $reviewers = mpull($reviewers, null, 'getReviewerPHID');
 
     if ($is_blocking) {
       $new_status = DifferentialReviewerStatus::STATUS_BLOCKING;
     } else {
       $new_status = DifferentialReviewerStatus::STATUS_ADDED;
     }
 
     $new_strength = DifferentialReviewerStatus::getStatusStrength(
       $new_status);
 
     $current = array();
     foreach ($phids as $phid) {
       if (!isset($reviewers[$phid])) {
         continue;
       }
 
       // If we're applying a stronger status (usually, upgrading a reviewer
       // into a blocking reviewer), skip this check so we apply the change.
       $old_strength = DifferentialReviewerStatus::getStatusStrength(
         $reviewers[$phid]->getReviewerStatus());
       if ($old_strength <= $new_strength) {
         continue;
       }
 
       $current[] = $phid;
     }
 
     $phids = array_diff($phids, $current);
 
     if (!$phids) {
       return null;
     }
 
     $phids = array_fuse($phids);
 
     $value = array();
     foreach ($phids as $phid) {
       if ($is_blocking) {
         $value[] = 'blocking('.$phid.')';
       } else {
         $value[] = $phid;
       }
     }
 
     $owners_phid = id(new PhabricatorOwnersApplication())
       ->getPHID();
 
     $reviewers_type = DifferentialRevisionReviewersTransaction::TRANSACTIONTYPE;
 
     return $object->getApplicationTransactionTemplate()
       ->setAuthorPHID($owners_phid)
       ->setTransactionType($reviewers_type)
       ->setNewValue(
         array(
           '+' => $value,
         ));
   }
 
   protected function buildHeraldAdapter(
     PhabricatorLiskDAO $object,
     array $xactions) {
 
     $revision = id(new DifferentialRevisionQuery())
       ->setViewer($this->getActor())
       ->withPHIDs(array($object->getPHID()))
       ->needActiveDiffs(true)
       ->needReviewers(true)
       ->executeOne();
     if (!$revision) {
       throw new Exception(
         pht('Failed to load revision for Herald adapter construction!'));
     }
 
     $adapter = HeraldDifferentialRevisionAdapter::newLegacyAdapter(
       $revision,
       $revision->getActiveDiff());
 
     // If the object is still a draft, prevent "Send me an email" and other
     // similar rules from acting yet.
     if (!$object->getShouldBroadcast()) {
       $adapter->setForbiddenAction(
         HeraldMailableState::STATECONST,
         DifferentialHeraldStateReasons::REASON_DRAFT);
     }
 
     // If this edit didn't actually change the diff (for example, a user
     // edited the title or changed subscribers), prevent "Run build plan"
     // and other similar rules from acting yet, since the build results will
     // not (or, at least, should not) change unless the actual source changes.
     // We also don't run Differential builds if the update was caused by
     // discovering a commit, as the expectation is that Diffusion builds take
     // over once things land.
     $has_update = false;
     $has_commit = false;
 
     $type_update = DifferentialRevisionUpdateTransaction::TRANSACTIONTYPE;
     foreach ($xactions as $xaction) {
       if ($xaction->getTransactionType() != $type_update) {
         continue;
       }
 
       if ($xaction->getMetadataValue('isCommitUpdate')) {
         $has_commit = true;
       } else {
         $has_update = true;
       }
 
       break;
     }
 
     if ($has_commit) {
       $adapter->setForbiddenAction(
         HeraldBuildableState::STATECONST,
         DifferentialHeraldStateReasons::REASON_LANDED);
     } else if (!$has_update) {
       $adapter->setForbiddenAction(
         HeraldBuildableState::STATECONST,
         DifferentialHeraldStateReasons::REASON_UNCHANGED);
     }
 
     return $adapter;
   }
 
   /**
    * Update the table which links Differential revisions to paths they affect,
    * so Diffusion can efficiently find pending revisions for a given file.
    */
   private function updateAffectedPathTable(
     DifferentialRevision $revision,
     DifferentialDiff $diff) {
 
     $repository = $revision->getRepository();
     if (!$repository) {
       // The repository where the code lives is untracked.
       return;
     }
 
     $path_prefix = null;
 
     $local_root = $diff->getSourceControlPath();
     if ($local_root) {
       // We're in a working copy which supports subdirectory checkouts (e.g.,
       // SVN) so we need to figure out what prefix we should add to each path
       // (e.g., trunk/projects/example/) to get the absolute path from the
       // root of the repository. DVCS systems like Git and Mercurial are not
       // affected.
 
       // Normalize both paths and check if the repository root is a prefix of
       // the local root. If so, throw it away. Note that this correctly handles
       // the case where the remote path is "/".
       $local_root = id(new PhutilURI($local_root))->getPath();
       $local_root = rtrim($local_root, '/');
 
       $repo_root = id(new PhutilURI($repository->getRemoteURI()))->getPath();
       $repo_root = rtrim($repo_root, '/');
 
       if (!strncmp($repo_root, $local_root, strlen($repo_root))) {
         $path_prefix = substr($local_root, strlen($repo_root));
       }
     }
 
     $changesets = $diff->getChangesets();
     $paths = array();
     foreach ($changesets as $changeset) {
       $paths[] = $path_prefix.'/'.$changeset->getFilename();
     }
 
-    // Save the affected paths; we'll use them later to query Owners. This
-    // uses the un-expanded paths.
-    $this->affectedPaths = $paths;
+    // If this change affected paths, save the changesets so we can apply
+    // Owners rules to them later.
+    if ($paths) {
+      $this->ownersDiff = $diff;
+      $this->ownersChangesets = $changesets;
+    }
 
     // Mark this as also touching all parent paths, so you can see all pending
     // changes to any file within a directory.
     $all_paths = array();
     foreach ($paths as $local) {
       foreach (DiffusionPathIDQuery::expandPathToRoot($local) as $path) {
         $all_paths[$path] = true;
       }
     }
     $all_paths = array_keys($all_paths);
 
     $path_ids =
       PhabricatorRepositoryCommitChangeParserWorker::lookupOrCreatePaths(
         $all_paths);
 
     $table = new DifferentialAffectedPath();
     $conn_w = $table->establishConnection('w');
 
     $sql = array();
     foreach ($path_ids as $path_id) {
       $sql[] = qsprintf(
         $conn_w,
         '(%d, %d, %d, %d)',
         $repository->getID(),
         $path_id,
         time(),
         $revision->getID());
     }
 
     queryfx(
       $conn_w,
       'DELETE FROM %T WHERE revisionID = %d',
       $table->getTableName(),
       $revision->getID());
     foreach (array_chunk($sql, 256) as $chunk) {
       queryfx(
         $conn_w,
         'INSERT INTO %T (repositoryID, pathID, epoch, revisionID) VALUES %Q',
         $table->getTableName(),
         implode(', ', $chunk));
     }
   }
 
   /**
    * Update the table connecting revisions to DVCS local hashes, so we can
    * identify revisions by commit/tree hashes.
    */
   private function updateRevisionHashTable(
     DifferentialRevision $revision,
     DifferentialDiff $diff) {
 
     $vcs = $diff->getSourceControlSystem();
     if ($vcs == DifferentialRevisionControlSystem::SVN) {
       // Subversion has no local commit or tree hash information, so we don't
       // have to do anything.
       return;
     }
 
     $property = id(new DifferentialDiffProperty())->loadOneWhere(
       'diffID = %d AND name = %s',
       $diff->getID(),
       'local:commits');
     if (!$property) {
       return;
     }
 
     $hashes = array();
 
     $data = $property->getData();
     switch ($vcs) {
       case DifferentialRevisionControlSystem::GIT:
         foreach ($data as $commit) {
           $hashes[] = array(
             ArcanistDifferentialRevisionHash::HASH_GIT_COMMIT,
             $commit['commit'],
           );
           $hashes[] = array(
             ArcanistDifferentialRevisionHash::HASH_GIT_TREE,
             $commit['tree'],
           );
         }
         break;
       case DifferentialRevisionControlSystem::MERCURIAL:
         foreach ($data as $commit) {
           $hashes[] = array(
             ArcanistDifferentialRevisionHash::HASH_MERCURIAL_COMMIT,
             $commit['rev'],
           );
         }
         break;
     }
 
     $conn_w = $revision->establishConnection('w');
 
     $sql = array();
     foreach ($hashes as $info) {
       list($type, $hash) = $info;
       $sql[] = qsprintf(
         $conn_w,
         '(%d, %s, %s)',
         $revision->getID(),
         $type,
         $hash);
     }
 
     queryfx(
       $conn_w,
       'DELETE FROM %T WHERE revisionID = %d',
       ArcanistDifferentialRevisionHash::TABLE_NAME,
       $revision->getID());
 
     if ($sql) {
       queryfx(
         $conn_w,
         'INSERT INTO %T (revisionID, type, hash) VALUES %Q',
         ArcanistDifferentialRevisionHash::TABLE_NAME,
         implode(', ', $sql));
     }
   }
 
   private function renderAffectedFilesForMail(DifferentialDiff $diff) {
     $changesets = $diff->getChangesets();
 
     $filenames = mpull($changesets, 'getDisplayFilename');
     sort($filenames);
 
     $count = count($filenames);
     $max = 250;
     if ($count > $max) {
       $filenames = array_slice($filenames, 0, $max);
       $filenames[] = pht('(%d more files...)', ($count - $max));
     }
 
     return implode("\n", $filenames);
   }
 
   private function renderPatchHTMLForMail($patch) {
     return phutil_tag('pre',
       array('style' => 'font-family: monospace;'), $patch);
   }
 
   private function buildPatchForMail(DifferentialDiff $diff) {
     $format = PhabricatorEnv::getEnvConfig('metamta.differential.patch-format');
 
     return id(new DifferentialRawDiffRenderer())
       ->setViewer($this->getActor())
       ->setFormat($format)
       ->setChangesets($diff->getChangesets())
       ->buildPatch();
   }
 
   protected function willPublish(PhabricatorLiskDAO $object, array $xactions) {
     // Reload to pick up the active diff and reviewer status.
     return id(new DifferentialRevisionQuery())
       ->setViewer($this->getActor())
       ->needReviewers(true)
       ->needActiveDiffs(true)
       ->withIDs(array($object->getID()))
       ->executeOne();
   }
 
   protected function getCustomWorkerState() {
     return array(
       'changedPriorToCommitURI' => $this->changedPriorToCommitURI,
       'firstBroadcast' => $this->firstBroadcast,
       'isDraftDemotion' => $this->isDraftDemotion,
     );
   }
 
   protected function loadCustomWorkerState(array $state) {
     $this->changedPriorToCommitURI = idx($state, 'changedPriorToCommitURI');
     $this->firstBroadcast = idx($state, 'firstBroadcast');
     $this->isDraftDemotion = idx($state, 'isDraftDemotion');
     return $this;
   }
 
   private function newCommandeerReviewerTransaction(
     DifferentialRevision $revision) {
 
     $actor_phid = $this->getActingAsPHID();
     $owner_phid = $revision->getAuthorPHID();
 
     // If the user is commandeering, add the previous owner as a
     // reviewer and remove the actor.
 
     $edits = array(
       '-' => array(
         $actor_phid,
       ),
       '+' => array(
         $owner_phid,
       ),
     );
 
     // NOTE: We're setting setIsCommandeerSideEffect() on this because normally
     // you can't add a revision's author as a reviewer, but this action swaps
     // them after validation executes.
 
     $xaction_type = DifferentialRevisionReviewersTransaction::TRANSACTIONTYPE;
 
     return id(new DifferentialTransaction())
       ->setTransactionType($xaction_type)
       ->setIgnoreOnNoEffect(true)
       ->setIsCommandeerSideEffect(true)
       ->setNewValue($edits);
   }
 
   public function getActiveDiff($object) {
     if ($this->getIsNewObject()) {
       return null;
     } else {
       return $object->getActiveDiff();
     }
   }
 
   /**
    * When a reviewer makes a comment, mark the last revision they commented
    * on.
    *
    * This allows us to show a hint to help authors and other reviewers quickly
    * distinguish between reviewers who have participated in the discussion and
    * reviewers who haven't been part of it.
    */
   private function markReviewerComments($object, array $xactions) {
     $acting_phid = $this->getActingAsPHID();
     if (!$acting_phid) {
       return;
     }
 
     $diff = $this->getActiveDiff($object);
     if (!$diff) {
       return;
     }
 
     $has_comment = false;
     foreach ($xactions as $xaction) {
       if ($xaction->hasComment()) {
         $has_comment = true;
         break;
       }
     }
 
     if (!$has_comment) {
       return;
     }
 
     $reviewer_table = new DifferentialReviewer();
     $conn = $reviewer_table->establishConnection('w');
 
     queryfx(
       $conn,
       'UPDATE %T SET lastCommentDiffPHID = %s
         WHERE revisionPHID = %s
         AND reviewerPHID = %s',
       $reviewer_table->getTableName(),
       $diff->getPHID(),
       $object->getPHID(),
       $acting_phid);
   }
 
   private function loadUnbroadcastTransactions($object) {
     $viewer = $this->requireActor();
 
     $xactions = id(new DifferentialTransactionQuery())
       ->setViewer($viewer)
       ->withObjectPHIDs(array($object->getPHID()))
       ->execute();
 
     return array_reverse($xactions);
   }
 
 
   protected function didApplyTransactions($object, array $xactions) {
     // In a moment, we're going to try to publish draft revisions which have
     // completed all their builds. However, we only want to do that if the
     // actor is either the revision author or an omnipotent user (generally,
     // the Harbormaster application).
 
     // If we let any actor publish the revision as a side effect of other
     // changes then an unlucky third party who innocently comments on the draft
     // can end up racing Harbormaster and promoting the revision. At best, this
     // is confusing. It can also run into validation problems with the "Request
     // Review" transaction. See PHI309 for some discussion.
     $author_phid = $object->getAuthorPHID();
     $viewer = $this->requireActor();
     $can_undraft =
       ($this->getActingAsPHID() === $author_phid) ||
       ($viewer->isOmnipotent());
 
     // If a draft revision has no outstanding builds and we're automatically
     // making drafts public after builds finish, make the revision public.
     if ($can_undraft) {
       $auto_undraft = !$object->getHoldAsDraft();
     } else {
       $auto_undraft = false;
     }
 
     $can_promote = false;
     $can_demote = false;
 
     // "Draft" revisions can promote to "Review Requested" after builds pass,
     // or demote to "Changes Planned" after builds fail.
     if ($object->isDraft()) {
       $can_promote = true;
       $can_demote = true;
     }
 
     // See PHI584. "Changes Planned" revisions which are not yet broadcasting
     // can promote to "Review Requested" if builds pass.
 
     // This pass is presumably the result of someone restarting the builds and
     // having them work this time, perhaps because the builds are not perfectly
     // reliable or perhaps because someone fixed some issue with build hardware
     // or some other dependency.
 
     // Currently, there's no legitimate way to end up in this state except
     // through automatic demotion, so this behavior should not generate an
     // undue level of confusion or ambiguity. Also note that these changes can
     // not demote again since they've already been demoted once.
     if ($object->isChangePlanned()) {
       if (!$object->getShouldBroadcast()) {
         $can_promote = true;
       }
     }
 
     if (($can_promote || $can_demote) && $auto_undraft) {
       $status = $this->loadCompletedBuildableStatus($object);
 
       $is_passed = ($status === HarbormasterBuildableStatus::STATUS_PASSED);
       $is_failed = ($status === HarbormasterBuildableStatus::STATUS_FAILED);
 
       if ($is_passed && $can_promote) {
         // When Harbormaster moves a revision out of the draft state, we
         // attribute the action to the revision author since this is more
         // natural and more useful.
 
         // Additionally, we change the acting PHID for the transaction set
         // to the author if it isn't already a user so that mail comes from
         // the natural author.
         $acting_phid = $this->getActingAsPHID();
         $user_type = PhabricatorPeopleUserPHIDType::TYPECONST;
         if (phid_get_type($acting_phid) != $user_type) {
           $this->setActingAsPHID($author_phid);
         }
 
         $xaction = $object->getApplicationTransactionTemplate()
           ->setAuthorPHID($author_phid)
           ->setTransactionType(
             DifferentialRevisionRequestReviewTransaction::TRANSACTIONTYPE)
           ->setNewValue(true);
 
         // If we're creating this revision and immediately moving it out of
         // the draft state, mark this as a create transaction so it gets
         // hidden in the timeline and mail, since it isn't interesting: it
         // is as though the draft phase never happened.
         if ($this->getIsNewObject()) {
           $xaction->setIsCreateTransaction(true);
         }
 
         // Queue this transaction and apply it separately after the current
         // batch of transactions finishes so that Herald can fire on the new
         // revision state. See T13027 for discussion.
         $this->queueTransaction($xaction);
       } else if ($is_failed && $can_demote) {
         // When demoting a revision, we act as "Harbormaster" instead of
         // the author since this feels a little more natural.
         $harbormaster_phid = id(new PhabricatorHarbormasterApplication())
           ->getPHID();
 
         $xaction = $object->getApplicationTransactionTemplate()
           ->setAuthorPHID($harbormaster_phid)
           ->setMetadataValue('draft.demote', true)
           ->setTransactionType(
             DifferentialRevisionPlanChangesTransaction::TRANSACTIONTYPE)
           ->setNewValue(true);
 
         $this->queueTransaction($xaction);
       }
     }
 
     // If the revision is new or was a draft, and is no longer a draft, we
     // might be sending the first email about it.
 
     // This might mean it was created directly into a non-draft state, or
     // it just automatically undrafted after builds finished, or a user
     // explicitly promoted it out of the draft state with an action like
     // "Request Review".
 
     // If we haven't sent any email about it yet, mark this email as the first
     // email so the mail gets enriched with "SUMMARY" and "TEST PLAN".
 
     $is_new = $this->getIsNewObject();
     $was_broadcasting = $this->wasBroadcasting;
 
     if ($object->getShouldBroadcast()) {
       if (!$was_broadcasting || $is_new) {
         // Mark this as the first broadcast we're sending about the revision
         // so mail can generate specially.
         $this->firstBroadcast = true;
       }
     }
 
     return $xactions;
   }
 
   private function loadCompletedBuildableStatus(
     DifferentialRevision $revision) {
     $viewer = $this->requireActor();
     $builds = $revision->loadImpactfulBuilds($viewer);
     return $revision->newBuildableStatusForBuilds($builds);
   }
 
   private function requireReviewers(DifferentialRevision $revision) {
     if ($revision->hasAttachedReviewers()) {
       return;
     }
 
     $with_reviewers = id(new DifferentialRevisionQuery())
       ->setViewer($this->getActor())
       ->needReviewers(true)
       ->withPHIDs(array($revision->getPHID()))
       ->executeOne();
     if (!$with_reviewers) {
       throw new Exception(
         pht(
           'Failed to reload revision ("%s").',
           $revision->getPHID()));
     }
 
     $revision->attachReviewers($with_reviewers->getReviewers());
   }
 
 
 }
diff --git a/src/applications/differential/herald/HeraldDifferentialRevisionAdapter.php b/src/applications/differential/herald/HeraldDifferentialRevisionAdapter.php
index 9f7f8fe3f2..858a42dbc9 100644
--- a/src/applications/differential/herald/HeraldDifferentialRevisionAdapter.php
+++ b/src/applications/differential/herald/HeraldDifferentialRevisionAdapter.php
@@ -1,157 +1,158 @@
 <?php
 
 final class HeraldDifferentialRevisionAdapter
   extends HeraldDifferentialAdapter
   implements HarbormasterBuildableAdapterInterface {
 
   protected $revision;
 
   protected $affectedPackages;
   protected $changesets;
   private $haveHunks;
 
   private $buildRequests = array();
 
   public function getAdapterApplicationClass() {
     return 'PhabricatorDifferentialApplication';
   }
 
   protected function newObject() {
     return new DifferentialRevision();
   }
 
   public function isTestAdapterForObject($object) {
     return ($object instanceof DifferentialRevision);
   }
 
   public function getAdapterTestDescription() {
     return pht(
       'Test rules which run when a revision is created or updated.');
   }
 
   public function newTestAdapter(PhabricatorUser $viewer, $object) {
     return self::newLegacyAdapter(
       $object,
       $object->loadActiveDiff());
   }
 
   protected function initializeNewAdapter() {
     $this->revision = $this->newObject();
   }
 
   public function getObject() {
     return $this->revision;
   }
 
   public function getAdapterContentType() {
     return 'differential';
   }
 
   public function getAdapterContentName() {
     return pht('Differential Revisions');
   }
 
   public function getAdapterContentDescription() {
     return pht(
       "React to revisions being created or updated.\n".
       "Revision rules can send email, flag revisions, add reviewers, ".
       "and run build plans.");
   }
 
   public function supportsRuleType($rule_type) {
     switch ($rule_type) {
       case HeraldRuleTypeConfig::RULE_TYPE_GLOBAL:
       case HeraldRuleTypeConfig::RULE_TYPE_PERSONAL:
         return true;
       case HeraldRuleTypeConfig::RULE_TYPE_OBJECT:
       default:
         return false;
     }
   }
 
   public static function newLegacyAdapter(
     DifferentialRevision $revision,
     DifferentialDiff $diff) {
     $object = new HeraldDifferentialRevisionAdapter();
 
     // Reload the revision to pick up relationship information.
     $revision = id(new DifferentialRevisionQuery())
       ->withIDs(array($revision->getID()))
       ->setViewer(PhabricatorUser::getOmnipotentUser())
       ->needReviewers(true)
       ->executeOne();
 
     $object->revision = $revision;
     $object->setDiff($diff);
 
     return $object;
   }
 
   public function getHeraldName() {
     return $this->revision->getTitle();
   }
 
   protected function loadChangesets() {
     if ($this->changesets === null) {
       $this->changesets = $this->getDiff()->loadChangesets();
     }
     return $this->changesets;
   }
 
   protected function loadChangesetsWithHunks() {
     $changesets = $this->loadChangesets();
 
     if ($changesets && !$this->haveHunks) {
       $this->haveHunks = true;
 
       id(new DifferentialHunkQuery())
         ->setViewer(PhabricatorUser::getOmnipotentUser())
         ->withChangesets($changesets)
         ->needAttachToChangesets(true)
         ->execute();
     }
 
     return $changesets;
   }
 
   public function loadAffectedPackages() {
     if ($this->affectedPackages === null) {
       $this->affectedPackages = array();
 
       $repository = $this->loadRepository();
       if ($repository) {
-        $packages = PhabricatorOwnersPackage::loadAffectedPackages(
+        $packages = PhabricatorOwnersPackage::loadAffectedPackagesForChangesets(
           $repository,
-          $this->loadAffectedPaths());
+          $this->getDiff(),
+          $this->loadChangesets());
         $this->affectedPackages = $packages;
       }
     }
     return $this->affectedPackages;
   }
 
   public function loadReviewers() {
     return $this->getObject()->getReviewerPHIDs();
   }
 
 
 /* -(  HarbormasterBuildableAdapterInterface  )------------------------------ */
 
 
   public function getHarbormasterBuildablePHID() {
     return $this->getDiff()->getPHID();
   }
 
   public function getHarbormasterContainerPHID() {
     return $this->getObject()->getPHID();
   }
 
   public function getQueuedHarbormasterBuildRequests() {
     return $this->buildRequests;
   }
 
   public function queueHarbormasterBuildRequest(
     HarbormasterBuildRequest $request) {
     $this->buildRequests[] = $request;
   }
 
 }
diff --git a/src/applications/differential/storage/DifferentialDiff.php b/src/applications/differential/storage/DifferentialDiff.php
index cd8364c8aa..f121a1cb67 100644
--- a/src/applications/differential/storage/DifferentialDiff.php
+++ b/src/applications/differential/storage/DifferentialDiff.php
@@ -1,870 +1,872 @@
 <?php
 
 final class DifferentialDiff
   extends DifferentialDAO
   implements
     PhabricatorPolicyInterface,
     PhabricatorExtendedPolicyInterface,
     HarbormasterBuildableInterface,
     HarbormasterCircleCIBuildableInterface,
     HarbormasterBuildkiteBuildableInterface,
     PhabricatorApplicationTransactionInterface,
     PhabricatorDestructibleInterface,
     PhabricatorConduitResultInterface {
 
   protected $revisionID;
   protected $authorPHID;
   protected $repositoryPHID;
   protected $commitPHID;
 
   protected $sourceMachine;
   protected $sourcePath;
 
   protected $sourceControlSystem;
   protected $sourceControlBaseRevision;
   protected $sourceControlPath;
 
   protected $lintStatus;
   protected $unitStatus;
 
   protected $lineCount;
 
   protected $branch;
   protected $bookmark;
 
   protected $creationMethod;
   protected $repositoryUUID;
 
   protected $description;
 
   protected $viewPolicy;
 
   private $unsavedChangesets = array();
   private $changesets = self::ATTACHABLE;
   private $revision = self::ATTACHABLE;
   private $properties = array();
   private $buildable = self::ATTACHABLE;
 
   private $unitMessages = self::ATTACHABLE;
 
   protected function getConfiguration() {
     return array(
       self::CONFIG_AUX_PHID => true,
       self::CONFIG_COLUMN_SCHEMA => array(
         'revisionID' => 'id?',
         'authorPHID' => 'phid?',
         'repositoryPHID' => 'phid?',
         'sourceMachine' => 'text255?',
         'sourcePath' => 'text255?',
         'sourceControlSystem' => 'text64?',
         'sourceControlBaseRevision' => 'text255?',
         'sourceControlPath' => 'text255?',
         'lintStatus' => 'uint32',
         'unitStatus' => 'uint32',
         'lineCount' => 'uint32',
         'branch' => 'text255?',
         'bookmark' => 'text255?',
         'repositoryUUID' => 'text64?',
         'commitPHID' => 'phid?',
 
         // T6203/NULLABILITY
         // These should be non-null; all diffs should have a creation method
         // and the description should just be empty.
         'creationMethod' => 'text255?',
         'description' => 'text255?',
       ),
       self::CONFIG_KEY_SCHEMA => array(
         'revisionID' => array(
           'columns' => array('revisionID'),
         ),
         'key_commit' => array(
           'columns' => array('commitPHID'),
         ),
       ),
     ) + parent::getConfiguration();
   }
 
   public function generatePHID() {
     return PhabricatorPHID::generateNewPHID(
       DifferentialDiffPHIDType::TYPECONST);
   }
 
   public function addUnsavedChangeset(DifferentialChangeset $changeset) {
     if ($this->changesets === null) {
       $this->changesets = array();
     }
     $this->unsavedChangesets[] = $changeset;
     $this->changesets[] = $changeset;
     return $this;
   }
 
   public function attachChangesets(array $changesets) {
     assert_instances_of($changesets, 'DifferentialChangeset');
     $this->changesets = $changesets;
     return $this;
   }
 
   public function getChangesets() {
     return $this->assertAttached($this->changesets);
   }
 
   public function loadChangesets() {
     if (!$this->getID()) {
       return array();
     }
     $changesets = id(new DifferentialChangeset())->loadAllWhere(
       'diffID = %d',
       $this->getID());
 
     foreach ($changesets as $changeset) {
       $changeset->attachDiff($this);
     }
 
     return $changesets;
   }
 
   public function save() {
     $this->openTransaction();
       $ret = parent::save();
       foreach ($this->unsavedChangesets as $changeset) {
         $changeset->setDiffID($this->getID());
         $changeset->save();
       }
     $this->saveTransaction();
     return $ret;
   }
 
   public static function initializeNewDiff(PhabricatorUser $actor) {
     $app = id(new PhabricatorApplicationQuery())
       ->setViewer($actor)
       ->withClasses(array('PhabricatorDifferentialApplication'))
       ->executeOne();
     $view_policy = $app->getPolicy(
       DifferentialDefaultViewCapability::CAPABILITY);
 
     $diff = id(new DifferentialDiff())
       ->setViewPolicy($view_policy);
 
     return $diff;
   }
 
   public static function newFromRawChanges(
     PhabricatorUser $actor,
     array $changes) {
 
     assert_instances_of($changes, 'ArcanistDiffChange');
 
     $diff = self::initializeNewDiff($actor);
     return self::buildChangesetsFromRawChanges($diff, $changes);
   }
 
   public static function newEphemeralFromRawChanges(array $changes) {
     assert_instances_of($changes, 'ArcanistDiffChange');
 
     $diff = id(new DifferentialDiff())->makeEphemeral();
     return self::buildChangesetsFromRawChanges($diff, $changes);
   }
 
   private static function buildChangesetsFromRawChanges(
     DifferentialDiff $diff,
     array $changes) {
 
     // There may not be any changes; initialize the changesets list so that
     // we don't throw later when accessing it.
     $diff->attachChangesets(array());
 
     $lines = 0;
     foreach ($changes as $change) {
       if ($change->getType() == ArcanistDiffChangeType::TYPE_MESSAGE) {
         // If a user pastes a diff into Differential which includes a commit
         // message (e.g., they ran `git show` to generate it), discard that
         // change when constructing a DifferentialDiff.
         continue;
       }
 
       $changeset = new DifferentialChangeset();
       $add_lines = 0;
       $del_lines = 0;
       $first_line = PHP_INT_MAX;
       $hunks = $change->getHunks();
       if ($hunks) {
         foreach ($hunks as $hunk) {
           $dhunk = new DifferentialHunk();
           $dhunk->setOldOffset($hunk->getOldOffset());
           $dhunk->setOldLen($hunk->getOldLength());
           $dhunk->setNewOffset($hunk->getNewOffset());
           $dhunk->setNewLen($hunk->getNewLength());
           $dhunk->setChanges($hunk->getCorpus());
           $changeset->addUnsavedHunk($dhunk);
           $add_lines += $hunk->getAddLines();
           $del_lines += $hunk->getDelLines();
           $added_lines = $hunk->getChangedLines('new');
           if ($added_lines) {
             $first_line = min($first_line, head_key($added_lines));
           }
         }
         $lines += $add_lines + $del_lines;
       } else {
         // This happens when you add empty files.
         $changeset->attachHunks(array());
       }
 
       $metadata = $change->getAllMetadata();
       if ($first_line != PHP_INT_MAX) {
         $metadata['line:first'] = $first_line;
       }
 
       $changeset->setOldFile($change->getOldPath());
       $changeset->setFilename($change->getCurrentPath());
       $changeset->setChangeType($change->getType());
 
       $changeset->setFileType($change->getFileType());
       $changeset->setMetadata($metadata);
       $changeset->setOldProperties($change->getOldProperties());
       $changeset->setNewProperties($change->getNewProperties());
       $changeset->setAwayPaths($change->getAwayPaths());
       $changeset->setAddLines($add_lines);
       $changeset->setDelLines($del_lines);
 
       self::detectGeneratedCode($changeset);
 
       $diff->addUnsavedChangeset($changeset);
     }
     $diff->setLineCount($lines);
 
     $parser = new DifferentialChangesetParser();
     $changesets = $parser->detectCopiedCode(
       $diff->getChangesets(),
       $min_width = 30,
       $min_lines = 3);
     $diff->attachChangesets($changesets);
 
     return $diff;
   }
 
 
   public function getDiffDict() {
     $dict = array(
       'id' => $this->getID(),
       'revisionID' => $this->getRevisionID(),
       'dateCreated' => $this->getDateCreated(),
       'dateModified' => $this->getDateModified(),
       'sourceControlBaseRevision' => $this->getSourceControlBaseRevision(),
       'sourceControlPath' => $this->getSourceControlPath(),
       'sourceControlSystem' => $this->getSourceControlSystem(),
       'branch' => $this->getBranch(),
       'bookmark' => $this->getBookmark(),
       'creationMethod' => $this->getCreationMethod(),
       'description' => $this->getDescription(),
       'unitStatus' => $this->getUnitStatus(),
       'lintStatus' => $this->getLintStatus(),
       'changes' => array(),
     );
 
     $dict['changes'] = $this->buildChangesList();
 
     return $dict + $this->getDiffAuthorshipDict();
   }
 
   public function getDiffAuthorshipDict() {
     $dict = array('properties' => array());
 
     $properties = id(new DifferentialDiffProperty())->loadAllWhere(
       'diffID = %d',
       $this->getID());
     foreach ($properties as $property) {
       $dict['properties'][$property->getName()] = $property->getData();
 
       if ($property->getName() == 'local:commits') {
         foreach ($property->getData() as $commit) {
           $dict['authorName'] = $commit['author'];
           $dict['authorEmail'] = idx($commit, 'authorEmail');
           break;
         }
       }
     }
 
     return $dict;
   }
 
   public function buildChangesList() {
     $changes = array();
     foreach ($this->getChangesets() as $changeset) {
       $hunks = array();
       foreach ($changeset->getHunks() as $hunk) {
         $hunks[] = array(
           'oldOffset' => $hunk->getOldOffset(),
           'newOffset' => $hunk->getNewOffset(),
           'oldLength' => $hunk->getOldLen(),
           'newLength' => $hunk->getNewLen(),
           'addLines'  => null,
           'delLines'  => null,
           'isMissingOldNewline' => null,
           'isMissingNewNewline' => null,
           'corpus'    => $hunk->getChanges(),
         );
       }
       $change = array(
         'id'            => $changeset->getID(),
         'metadata'      => $changeset->getMetadata(),
         'oldPath'       => $changeset->getOldFile(),
         'currentPath'   => $changeset->getFilename(),
         'awayPaths'     => $changeset->getAwayPaths(),
         'oldProperties' => $changeset->getOldProperties(),
         'newProperties' => $changeset->getNewProperties(),
         'type'          => $changeset->getChangeType(),
         'fileType'      => $changeset->getFileType(),
         'commitHash'    => null,
         'addLines'      => $changeset->getAddLines(),
         'delLines'      => $changeset->getDelLines(),
         'hunks'         => $hunks,
       );
       $changes[] = $change;
     }
     return $changes;
   }
 
   public function hasRevision() {
     return $this->revision !== self::ATTACHABLE;
   }
 
   public function getRevision() {
     return $this->assertAttached($this->revision);
   }
 
   public function attachRevision(DifferentialRevision $revision = null) {
     $this->revision = $revision;
     return $this;
   }
 
   public function attachProperty($key, $value) {
     $this->properties[$key] = $value;
     return $this;
   }
 
   public function getProperty($key) {
     return $this->assertAttachedKey($this->properties, $key);
   }
 
   public function hasDiffProperty($key) {
     $properties = $this->getDiffProperties();
     return array_key_exists($key, $properties);
   }
 
   public function attachDiffProperties(array $properties) {
     $this->properties = $properties;
     return $this;
   }
 
   public function getDiffProperties() {
     return $this->assertAttached($this->properties);
   }
 
   public function attachBuildable(HarbormasterBuildable $buildable = null) {
     $this->buildable = $buildable;
     return $this;
   }
 
   public function getBuildable() {
     return $this->assertAttached($this->buildable);
   }
 
   public function getBuildTargetPHIDs() {
     $buildable = $this->getBuildable();
 
     if (!$buildable) {
       return array();
     }
 
     $target_phids = array();
     foreach ($buildable->getBuilds() as $build) {
       foreach ($build->getBuildTargets() as $target) {
         $target_phids[] = $target->getPHID();
       }
     }
 
     return $target_phids;
   }
 
   public function loadCoverageMap(PhabricatorUser $viewer) {
     $target_phids = $this->getBuildTargetPHIDs();
     if (!$target_phids) {
       return array();
     }
 
     $unit = id(new HarbormasterBuildUnitMessage())->loadAllWhere(
       'buildTargetPHID IN (%Ls)',
       $target_phids);
 
     $map = array();
     foreach ($unit as $message) {
       $coverage = $message->getProperty('coverage', array());
       foreach ($coverage as $path => $coverage_data) {
         $map[$path][] = $coverage_data;
       }
     }
 
     foreach ($map as $path => $coverage_items) {
       $map[$path] = ArcanistUnitTestResult::mergeCoverage($coverage_items);
     }
 
     return $map;
   }
 
   public function getURI() {
     $id = $this->getID();
     return "/differential/diff/{$id}/";
   }
 
 
   public function attachUnitMessages(array $unit_messages) {
     $this->unitMessages = $unit_messages;
     return $this;
   }
 
 
   public function getUnitMessages() {
     return $this->assertAttached($this->unitMessages);
   }
 
 
 /* -(  PhabricatorPolicyInterface  )----------------------------------------- */
 
 
   public function getCapabilities() {
     return array(
       PhabricatorPolicyCapability::CAN_VIEW,
     );
   }
 
   public function getPolicy($capability) {
     if ($this->hasRevision()) {
       return PhabricatorPolicies::getMostOpenPolicy();
     }
 
     return $this->viewPolicy;
   }
 
   public function hasAutomaticCapability($capability, PhabricatorUser $viewer) {
     if ($this->hasRevision()) {
       return $this->getRevision()->hasAutomaticCapability($capability, $viewer);
     }
 
     return ($this->getAuthorPHID() == $viewer->getPHID());
   }
 
   public function describeAutomaticCapability($capability) {
     if ($this->hasRevision()) {
       return pht(
         'This diff is attached to a revision, and inherits its policies.');
     }
 
     return pht('The author of a diff can see it.');
   }
 
 
 /* -(  PhabricatorExtendedPolicyInterface  )--------------------------------- */
 
 
   public function getExtendedPolicy($capability, PhabricatorUser $viewer) {
     $extended = array();
 
     switch ($capability) {
       case PhabricatorPolicyCapability::CAN_VIEW:
         if ($this->hasRevision()) {
           $extended[] = array(
             $this->getRevision(),
             PhabricatorPolicyCapability::CAN_VIEW,
           );
         }
         break;
     }
 
     return $extended;
   }
 
 
 /* -(  HarbormasterBuildableInterface  )------------------------------------- */
 
 
   public function getHarbormasterBuildableDisplayPHID() {
     $container_phid = $this->getHarbormasterContainerPHID();
     if ($container_phid) {
       return $container_phid;
     }
 
     return $this->getHarbormasterBuildablePHID();
   }
 
   public function getHarbormasterBuildablePHID() {
     return $this->getPHID();
   }
 
   public function getHarbormasterContainerPHID() {
     if ($this->getRevisionID()) {
       $revision = id(new DifferentialRevision())->load($this->getRevisionID());
       if ($revision) {
         return $revision->getPHID();
       }
     }
 
     return null;
   }
 
   public function getBuildVariables() {
     $results = array();
 
     $results['buildable.diff'] = $this->getID();
     if ($this->revisionID) {
       $revision = $this->getRevision();
       $results['buildable.revision'] = $revision->getID();
       $repo = $revision->getRepository();
 
       if ($repo) {
         $results['repository.callsign'] = $repo->getCallsign();
         $results['repository.phid'] = $repo->getPHID();
         $results['repository.vcs'] = $repo->getVersionControlSystem();
         $results['repository.uri'] = $repo->getPublicCloneURI();
 
         $results['repository.staging.uri'] = $repo->getStagingURI();
         $results['repository.staging.ref'] = $this->getStagingRef();
       }
     }
 
     return $results;
   }
 
   public function getAvailableBuildVariables() {
     return array(
       'buildable.diff' =>
         pht('The differential diff ID, if applicable.'),
       'buildable.revision' =>
         pht('The differential revision ID, if applicable.'),
       'repository.callsign' =>
         pht('The callsign of the repository in Phabricator.'),
       'repository.phid' =>
         pht('The PHID of the repository in Phabricator.'),
       'repository.vcs' =>
         pht('The version control system, either "svn", "hg" or "git".'),
       'repository.uri' =>
         pht('The URI to clone or checkout the repository from.'),
       'repository.staging.uri' =>
         pht('The URI of the staging repository.'),
       'repository.staging.ref' =>
         pht('The ref name for this change in the staging repository.'),
     );
   }
 
   public function newBuildableEngine() {
     return new DifferentialBuildableEngine();
   }
 
 
 /* -(  HarbormasterCircleCIBuildableInterface  )----------------------------- */
 
 
   public function getCircleCIGitHubRepositoryURI() {
     $diff_phid = $this->getPHID();
     $repository_phid = $this->getRepositoryPHID();
     if (!$repository_phid) {
       throw new Exception(
         pht(
           'This diff ("%s") is not associated with a repository. A diff '.
           'must belong to a tracked repository to be built by CircleCI.',
           $diff_phid));
     }
 
     $repository = id(new PhabricatorRepositoryQuery())
       ->setViewer(PhabricatorUser::getOmnipotentUser())
       ->withPHIDs(array($repository_phid))
       ->executeOne();
     if (!$repository) {
       throw new Exception(
         pht(
           'This diff ("%s") is associated with a repository ("%s") which '.
           'could not be loaded.',
           $diff_phid,
           $repository_phid));
     }
 
     $staging_uri = $repository->getStagingURI();
     if (!$staging_uri) {
       throw new Exception(
         pht(
           'This diff ("%s") is associated with a repository ("%s") that '.
           'does not have a Staging Area configured. You must configure a '.
           'Staging Area to use CircleCI integration.',
           $diff_phid,
           $repository_phid));
     }
 
     $path = HarbormasterCircleCIBuildStepImplementation::getGitHubPath(
       $staging_uri);
     if (!$path) {
       throw new Exception(
         pht(
           'This diff ("%s") is associated with a repository ("%s") that '.
           'does not have a Staging Area ("%s") that is hosted on GitHub. '.
           'CircleCI can only build from GitHub, so the Staging Area for '.
           'the repository must be hosted there.',
           $diff_phid,
           $repository_phid,
           $staging_uri));
     }
 
     return $staging_uri;
   }
 
   public function getCircleCIBuildIdentifierType() {
     return 'tag';
   }
 
   public function getCircleCIBuildIdentifier() {
     $ref = $this->getStagingRef();
     $ref = preg_replace('(^refs/tags/)', '', $ref);
     return $ref;
   }
 
 
 /* -(  HarbormasterBuildkiteBuildableInterface  )---------------------------- */
 
   public function getBuildkiteBranch() {
     $ref = $this->getStagingRef();
 
     // NOTE: Circa late January 2017, Buildkite fails with the error message
     // "Tags have been disabled for this project" if we pass the "refs/tags/"
     // prefix via the API and the project doesn't have GitHub tag builds
     // enabled, even if GitHub builds are disabled. The tag builds fine
     // without this prefix.
     $ref = preg_replace('(^refs/tags/)', '', $ref);
 
     return $ref;
   }
 
   public function getBuildkiteCommit() {
     return 'HEAD';
   }
 
 
   public function getStagingRef() {
     // TODO: We're just hoping to get lucky. Instead, `arc` should store
     // where it sent changes and we should only provide staging details
     // if we reasonably believe they are accurate.
     return 'refs/tags/phabricator/diff/'.$this->getID();
   }
 
   public function loadTargetBranch() {
     // TODO: This is sketchy, but just eat the query cost until this can get
     // cleaned up.
 
     // For now, we're only returning a target if there's exactly one and it's
     // a branch, since we don't support landing to more esoteric targets like
     // tags yet.
 
     $property = id(new DifferentialDiffProperty())->loadOneWhere(
       'diffID = %d AND name = %s',
       $this->getID(),
       'arc:onto');
     if (!$property) {
       return null;
     }
 
     $data = $property->getData();
 
     if (!$data) {
       return null;
     }
 
     if (!is_array($data)) {
       return null;
     }
 
     if (count($data) != 1) {
       return null;
     }
 
     $onto = head($data);
     if (!is_array($onto)) {
       return null;
     }
 
     $type = idx($onto, 'type');
     if ($type != 'branch') {
       return null;
     }
 
     return idx($onto, 'name');
   }
 
 
 /* -(  PhabricatorApplicationTransactionInterface  )------------------------- */
 
 
   public function getApplicationTransactionEditor() {
     return new DifferentialDiffEditor();
   }
 
   public function getApplicationTransactionObject() {
     return $this;
   }
 
   public function getApplicationTransactionTemplate() {
     return new DifferentialDiffTransaction();
   }
 
   public function willRenderTimeline(
     PhabricatorApplicationTransactionView $timeline,
     AphrontRequest $request) {
 
     return $timeline;
   }
 
 
 /* -(  PhabricatorDestructibleInterface  )----------------------------------- */
 
 
   public function destroyObjectPermanently(
     PhabricatorDestructionEngine $engine) {
 
     $this->openTransaction();
       $this->delete();
 
       foreach ($this->loadChangesets() as $changeset) {
         $engine->destroyObject($changeset);
       }
 
       $properties = id(new DifferentialDiffProperty())->loadAllWhere(
         'diffID = %d',
         $this->getID());
       foreach ($properties as $prop) {
         $prop->delete();
       }
 
     $this->saveTransaction();
   }
 
 
 /* -(  PhabricatorConduitResultInterface  )---------------------------------- */
 
 
   public function getFieldSpecificationsForConduit() {
     return array(
       id(new PhabricatorConduitSearchFieldSpecification())
         ->setKey('revisionPHID')
         ->setType('phid')
         ->setDescription(pht('Associated revision PHID.')),
       id(new PhabricatorConduitSearchFieldSpecification())
         ->setKey('authorPHID')
         ->setType('phid')
         ->setDescription(pht('Revision author PHID.')),
       id(new PhabricatorConduitSearchFieldSpecification())
         ->setKey('repositoryPHID')
         ->setType('phid')
         ->setDescription(pht('Associated repository PHID.')),
       id(new PhabricatorConduitSearchFieldSpecification())
         ->setKey('refs')
         ->setType('map<string, wild>')
         ->setDescription(pht('List of related VCS references.')),
     );
   }
 
   public function getFieldValuesForConduit() {
     $refs = array();
 
     $branch = $this->getBranch();
     if (strlen($branch)) {
       $refs[] = array(
         'type' => 'branch',
         'name' => $branch,
       );
     }
 
     $onto = $this->loadTargetBranch();
     if (strlen($onto)) {
       $refs[] = array(
         'type' => 'onto',
         'name' => $onto,
       );
     }
 
     $base = $this->getSourceControlBaseRevision();
     if (strlen($base)) {
       $refs[] = array(
         'type' => 'base',
         'identifier' => $base,
       );
     }
 
     $bookmark = $this->getBookmark();
     if (strlen($bookmark)) {
       $refs[] = array(
         'type' => 'bookmark',
         'name' => $bookmark,
       );
     }
 
     $revision_phid = null;
     if ($this->getRevisionID()) {
       $revision_phid = $this->getRevision()->getPHID();
     }
 
     return array(
       'revisionPHID' => $revision_phid,
       'authorPHID' => $this->getAuthorPHID(),
       'repositoryPHID' => $this->getRepositoryPHID(),
       'refs' => $refs,
     );
   }
 
   public function getConduitSearchAttachments() {
     return array(
       id(new DifferentialCommitsSearchEngineAttachment())
         ->setAttachmentKey('commits'),
     );
   }
 
   private static function detectGeneratedCode(
     DifferentialChangeset $changeset) {
 
     $is_generated_trusted = self::isTrustedGeneratedCode($changeset);
-
-    $changeset->setTrustedChangesetAttribute(
-      DifferentialChangeset::ATTRIBUTE_GENERATED,
-      $is_generated_trusted);
+    if ($is_generated_trusted) {
+      $changeset->setTrustedChangesetAttribute(
+        DifferentialChangeset::ATTRIBUTE_GENERATED,
+        $is_generated_trusted);
+    }
 
     $is_generated_untrusted = self::isUntrustedGeneratedCode($changeset);
-
-    $changeset->setUntrustedChangesetAttribute(
-      DifferentialChangeset::ATTRIBUTE_GENERATED,
-      $is_generated_untrusted);
+    if ($is_generated_untrusted) {
+      $changeset->setUntrustedChangesetAttribute(
+        DifferentialChangeset::ATTRIBUTE_GENERATED,
+        $is_generated_untrusted);
+    }
   }
 
   private static function isTrustedGeneratedCode(
     DifferentialChangeset $changeset) {
 
     $filename = $changeset->getFilename();
 
     $paths = PhabricatorEnv::getEnvConfig('differential.generated-paths');
     foreach ($paths as $regexp) {
       if (preg_match($regexp, $filename)) {
         return true;
       }
     }
 
     return false;
   }
 
   private static function isUntrustedGeneratedCode(
     DifferentialChangeset $changeset) {
 
     if ($changeset->getHunks()) {
       $new_data = $changeset->makeNewFile();
       if (strpos($new_data, '@'.'generated') !== false) {
         return true;
       }
     }
 
     return false;
   }
 
 }
diff --git a/src/applications/owners/storage/PhabricatorOwnersPackage.php b/src/applications/owners/storage/PhabricatorOwnersPackage.php
index c76864702c..5e856190ec 100644
--- a/src/applications/owners/storage/PhabricatorOwnersPackage.php
+++ b/src/applications/owners/storage/PhabricatorOwnersPackage.php
@@ -1,715 +1,791 @@
 <?php
 
 final class PhabricatorOwnersPackage
   extends PhabricatorOwnersDAO
   implements
     PhabricatorPolicyInterface,
     PhabricatorApplicationTransactionInterface,
     PhabricatorCustomFieldInterface,
     PhabricatorDestructibleInterface,
     PhabricatorConduitResultInterface,
     PhabricatorFulltextInterface,
     PhabricatorFerretInterface,
     PhabricatorNgramsInterface {
 
   protected $name;
   protected $auditingEnabled;
   protected $autoReview;
   protected $description;
   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_SUBSCRIBE_ALWAYS = 'subscribe-always';
   const AUTOREVIEW_REVIEW = 'review';
   const AUTOREVIEW_REVIEW_ALWAYS = 'review-always';
   const AUTOREVIEW_BLOCK = 'block';
   const AUTOREVIEW_BLOCK_ALWAYS = 'block-always';
 
   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_REVIEW => array(
         'name' => pht('Review Changes With Non-Owner Author'),
         'authority' => true,
       ),
       self::AUTOREVIEW_BLOCK => array(
         'name' => pht('Review Changes With Non-Owner Author (Blocking)'),
         'authority' => true,
       ),
       self::AUTOREVIEW_SUBSCRIBE => array(
         'name' => pht('Subscribe to Changes With Non-Owner Author'),
         'authority' => true,
       ),
       self::AUTOREVIEW_REVIEW_ALWAYS => array(
         'name' => pht('Review All Changes'),
       ),
       self::AUTOREVIEW_BLOCK_ALWAYS => array(
         'name' => pht('Review All Changes (Blocking)'),
       ),
       self::AUTOREVIEW_SUBSCRIBE_ALWAYS => array(
         'name' => pht('Subscribe to All Changes'),
       ),
     );
   }
 
   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' => 'sort',
         'description' => 'text',
         '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;
-    return $this;
+  public function getMustMatchUngeneratedPaths() {
+    // TODO: For now, there's no way to actually configure this.
+    return false;
   }
 
   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 loadAffectedPackagesForChangesets(
+    PhabricatorRepository $repository,
+    DifferentialDiff $diff,
+    array $changesets) {
+    assert_instances_of($changesets, 'DifferentialChangeset');
+
+    $paths_all = array();
+    $paths_ungenerated = array();
+
+    foreach ($changesets as $changeset) {
+      $path = $changeset->getAbsoluteRepositoryPath($repository, $diff);
+
+      $paths_all[] = $path;
+
+      if (!$changeset->isGeneratedChangeset()) {
+        $paths_ungenerated[] = $path;
+      }
+    }
+
+    if (!$paths_all) {
+      return array();
+    }
+
+    $packages_all = self::loadAffectedPackages(
+      $repository,
+      $paths_all);
+
+    // If there are no generated changesets, we can't possibly need to throw
+    // away any packages for matching only generated paths. Just return the
+    // full set of packages.
+    if ($paths_ungenerated === $paths_all) {
+      return $packages_all;
+    }
+
+    $must_match_ungenerated = array();
+    foreach ($packages_all as $package) {
+      if ($package->getMustMatchUngeneratedPaths()) {
+        $must_match_ungenerated[] = $package;
+      }
+    }
+
+    // If no affected packages have the "Ignore Generated Paths" flag set, we
+    // can't possibly need to throw any away.
+    if (!$must_match_ungenerated) {
+      return $packages_all;
+    }
+
+    if ($paths_ungenerated) {
+      $packages_ungenerated = self::loadAffectedPackages(
+        $repository,
+        $paths_ungenerated);
+    } else {
+      $packages_ungenerated = array();
+    }
+
+    // We have some generated paths, and some packages that ignore generated
+    // paths. Take all the packages which:
+    //
+    //   - ignore generated paths; and
+    //   - didn't match any ungenerated paths
+    //
+    // ...and remove them from the list.
+
+    $must_match_ungenerated = mpull($must_match_ungenerated, null, 'getID');
+    $packages_ungenerated = mpull($packages_ungenerated, null, 'getID');
+    $packages_all = mpull($packages_all, null, 'getID');
+
+    foreach ($must_match_ungenerated as $package_id => $package) {
+      if (!isset($packages_ungenerated[$package_id])) {
+        unset($packages_all[$package_id]);
+      }
+    }
+
+    return $packages_all;
+  }
+
   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), 1024) as $chunk) {
       $indexes = array();
       foreach ($chunk as $fragment) {
         $indexes[] = PhabricatorHash::digestForIndex($fragment);
       }
 
       $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.pathIndex IN (%Ls) AND pkg.status IN (%Ls) %Q',
         $package->getTableName(),
         $path->getTableName(),
         $indexes,
         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) {
 
         // Group packages by length.
         $length_map = array();
         foreach ($packages as $package_id => $package) {
           $length_map[$package['length']][$package_id] = $package;
         }
 
         // For each path length, remove all weak packages if there are any
         // strong packages of the same length. This makes sure that if there
         // are one or more strong claims on a particular path, only those
         // claims stand.
         foreach ($length_map as $package_list) {
           $any_strong = false;
           foreach ($package_list as $package_id => $package) {
             if (!isset($weak[$package_id])) {
               $any_strong = true;
               break;
             }
           }
 
           if ($any_strong) {
             foreach ($package_list as $package_id => $package) {
               if (isset($weak[$package_id])) {
                 unset($packages[$package_id]);
               }
             }
           }
         }
 
         $packages = isort($packages, 'length');
         $packages = array_reverse($packages, true);
 
         $best_length = null;
         foreach ($packages as $package_id => $package) {
           // If this is the first package we've encountered, note its length.
           // We're iterating over the packages from longest to shortest match,
           // so packages of this length always have the best claim on the path.
           if ($best_length === null) {
             $best_length = $package['length'];
           }
 
           // If this package has the same length as the best length, its claim
           // stands.
           if ($package['length'] === $best_length) {
             continue;
           }
 
           // If this is a weak package and does not have the best length,
           // 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) {
     $result = array(
       '/',
     );
 
     $parts = explode('/', $path);
     $buffer = '/';
     foreach ($parts as $part) {
       if (!strlen($part)) {
         continue;
       }
 
       $buffer = $buffer.$part.'/';
       $result[] = $buffer;
     }
 
     return $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.')),
       id(new PhabricatorConduitSearchFieldSpecification())
         ->setKey('review')
         ->setType('map<string, wild>')
         ->setDescription(pht('Auto review information.')),
       id(new PhabricatorConduitSearchFieldSpecification())
         ->setKey('audit')
         ->setType('map<string, wild>')
         ->setDescription(pht('Auto audit information.')),
       id(new PhabricatorConduitSearchFieldSpecification())
         ->setKey('dominion')
         ->setType('map<string, wild>')
         ->setDescription(pht('Dominion setting information.')),
     );
   }
 
   public function getFieldValuesForConduit() {
     $owner_list = array();
     foreach ($this->getOwners() as $owner) {
       $owner_list[] = array(
         'ownerPHID' => $owner->getUserPHID(),
       );
     }
 
     $review_map = self::getAutoreviewOptionsMap();
     $review_value = $this->getAutoReview();
     if (isset($review_map[$review_value])) {
       $review_label = $review_map[$review_value]['name'];
     } else {
       $review_label = pht('Unknown ("%s")', $review_value);
     }
 
     $review = array(
       'value' => $review_value,
       'label' => $review_label,
     );
 
     if ($this->getAuditingEnabled()) {
       $audit_value = 'audit';
       $audit_label = pht('Auditing Enabled');
     } else {
       $audit_value = 'none';
       $audit_label = pht('No Auditing');
     }
 
     $audit = array(
       'value' => $audit_value,
       'label' => $audit_label,
     );
 
     $dominion_value = $this->getDominion();
     $dominion_map = self::getDominionOptionsMap();
     if (isset($dominion_map[$dominion_value])) {
       $dominion_label = $dominion_map[$dominion_value]['name'];
       $dominion_short = $dominion_map[$dominion_value]['short'];
     } else {
       $dominion_label = pht('Unknown ("%s")', $dominion_value);
       $dominion_short = pht('Unknown ("%s")', $dominion_value);
     }
 
     $dominion = array(
       'value' => $dominion_value,
       'label' => $dominion_label,
       'short' => $dominion_short,
     );
 
     return array(
       'name' => $this->getName(),
       'description' => $this->getDescription(),
       'status' => $this->getStatus(),
       'owners' => $owner_list,
       'review' => $review,
       'audit' => $audit,
       'dominion' => $dominion,
     );
   }
 
   public function getConduitSearchAttachments() {
     return array(
       id(new PhabricatorOwnersPathsSearchEngineAttachment())
         ->setAttachmentKey('paths'),
     );
   }
 
 
 /* -(  PhabricatorFulltextInterface  )--------------------------------------- */
 
 
   public function newFulltextEngine() {
     return new PhabricatorOwnersPackageFulltextEngine();
   }
 
 
 /* -(  PhabricatorFerretInterface  )----------------------------------------- */
 
 
   public function newFerretEngine() {
     return new PhabricatorOwnersPackageFerretEngine();
   }
 
 
 /* -(  PhabricatorNgramsInterface  )----------------------------------------- */
 
 
   public function newNgrams() {
     return array(
       id(new PhabricatorOwnersPackageNameNgrams())
         ->setValue($this->getName()),
     );
   }
 
 }