diff --git a/resources/sql/autopatches/20140821.harbormasterbuildgen.1.sql b/resources/sql/autopatches/20140821.harbormasterbuildgen.1.sql
new file mode 100644
index 0000000000..a687146f60
--- /dev/null
+++ b/resources/sql/autopatches/20140821.harbormasterbuildgen.1.sql
@@ -0,0 +1,5 @@
+ALTER TABLE {$NAMESPACE}_harbormaster.harbormaster_build
+  ADD COLUMN `buildGeneration` INT UNSIGNED NOT NULL DEFAULT 0;
+
+ALTER TABLE {$NAMESPACE}_harbormaster.harbormaster_buildtarget
+  ADD COLUMN `buildGeneration` INT UNSIGNED NOT NULL DEFAULT 0;
diff --git a/src/applications/harbormaster/controller/HarbormasterBuildViewController.php b/src/applications/harbormaster/controller/HarbormasterBuildViewController.php
index 63c5685a45..3ec0d9b1d8 100644
--- a/src/applications/harbormaster/controller/HarbormasterBuildViewController.php
+++ b/src/applications/harbormaster/controller/HarbormasterBuildViewController.php
@@ -1,514 +1,523 @@
 <?php
 
 final class HarbormasterBuildViewController
   extends HarbormasterController {
 
   private $id;
 
   public function willProcessRequest(array $data) {
     $this->id = $data['id'];
   }
 
   public function processRequest() {
     $request = $this->getRequest();
     $viewer = $request->getUser();
 
     $id = $this->id;
+    $generation = $request->getInt('g');
 
     $build = id(new HarbormasterBuildQuery())
       ->setViewer($viewer)
       ->withIDs(array($id))
       ->executeOne();
     if (!$build) {
       return new Aphront404Response();
     }
 
     require_celerity_resource('harbormaster-css');
 
     $title = pht('Build %d', $id);
 
     $header = id(new PHUIHeaderView())
       ->setHeader($title)
       ->setUser($viewer)
       ->setPolicyObject($build);
 
     if ($build->isRestarting()) {
       $header->setStatus('fa-exclamation-triangle', 'red', pht('Restarting'));
     } else if ($build->isStopping()) {
       $header->setStatus('fa-exclamation-triangle', 'red', pht('Pausing'));
     } else if ($build->isResuming()) {
       $header->setStatus('fa-exclamation-triangle', 'red', pht('Resuming'));
     }
 
     $box = id(new PHUIObjectBoxView())
       ->setHeader($header);
 
     $actions = $this->buildActionList($build);
     $this->buildPropertyLists($box, $build, $actions);
 
     $crumbs = $this->buildApplicationCrumbs();
     $crumbs->addTextCrumb(
       $build->getBuildable()->getMonogram(),
       '/'.$build->getBuildable()->getMonogram());
     $crumbs->addTextCrumb($title);
 
+    if ($generation === null || $generation > $build->getBuildGeneration() ||
+      $generation < 0) {
+      $generation = $build->getBuildGeneration();
+    }
+
     $build_targets = id(new HarbormasterBuildTargetQuery())
       ->setViewer($viewer)
       ->needBuildSteps(true)
       ->withBuildPHIDs(array($build->getPHID()))
+      ->withBuildGenerations(array($generation))
       ->execute();
 
-
     if ($build_targets) {
       $messages = id(new HarbormasterBuildMessageQuery())
         ->setViewer($viewer)
         ->withBuildTargetPHIDs(mpull($build_targets, 'getPHID'))
         ->execute();
       $messages = mgroup($messages, 'getBuildTargetPHID');
     } else {
       $messages = array();
     }
 
     $targets = array();
     foreach ($build_targets as $build_target) {
       $header = id(new PHUIHeaderView())
         ->setHeader($build_target->getName())
         ->setUser($viewer);
 
       $target_box = id(new PHUIObjectBoxView())
         ->setHeader($header);
 
       $properties = new PHUIPropertyListView();
       $status_view = new PHUIStatusListView();
 
       $item = new PHUIStatusItemView();
 
       $status = $build_target->getTargetStatus();
       $status_name =
         HarbormasterBuildTarget::getBuildTargetStatusName($status);
       $icon = HarbormasterBuildTarget::getBuildTargetStatusIcon($status);
       $color = HarbormasterBuildTarget::getBuildTargetStatusColor($status);
 
       $item->setTarget($status_name);
       $item->setIcon($icon, $color);
       $status_view->addItem($item);
 
       $properties->addProperty(pht('Name'), $build_target->getName());
 
       if ($build_target->getDateStarted() !== null) {
         $properties->addProperty(
           pht('Started'),
           phabricator_datetime($build_target->getDateStarted(), $viewer));
         if ($build_target->isComplete()) {
           $properties->addProperty(
             pht('Completed'),
             phabricator_datetime($build_target->getDateCompleted(), $viewer));
           $properties->addProperty(
             pht('Duration'),
             phutil_format_relative_time_detailed(
               $build_target->getDateCompleted() -
               $build_target->getDateStarted()));
         } else {
           $properties->addProperty(
             pht('Elapsed'),
             phutil_format_relative_time_detailed(
               time() - $build_target->getDateStarted()));
         }
       }
 
       $properties->addProperty(pht('Status'), $status_view);
 
       $target_box->addPropertyList($properties, pht('Overview'));
 
       $description = $build_target->getBuildStep()->getDescription();
       if ($description) {
         $rendered = PhabricatorMarkupEngine::renderOneObject(
           id(new PhabricatorMarkupOneOff())
             ->setContent($description)
             ->setPreserveLinebreaks(true),
           'default',
           $viewer);
 
         $properties->addSectionHeader(pht('Description'));
         $properties->addTextContent($rendered);
       }
 
       $details = $build_target->getDetails();
       if ($details) {
         $properties = new PHUIPropertyListView();
         foreach ($details as $key => $value) {
           $properties->addProperty($key, $value);
         }
         $target_box->addPropertyList($properties, pht('Configuration'));
       }
 
       $variables = $build_target->getVariables();
       if ($variables) {
         $properties = new PHUIPropertyListView();
         foreach ($variables as $key => $value) {
           $properties->addProperty($key, $value);
         }
         $target_box->addPropertyList($properties, pht('Variables'));
       }
 
       $artifacts = $this->buildArtifacts($build_target);
       if ($artifacts) {
         $properties = new PHUIPropertyListView();
         $properties->addRawContent($artifacts);
         $target_box->addPropertyList($properties, pht('Artifacts'));
       }
 
       $build_messages = idx($messages, $build_target->getPHID(), array());
       if ($build_messages) {
         $properties = new PHUIPropertyListView();
         $properties->addRawContent($this->buildMessages($build_messages));
         $target_box->addPropertyList($properties, pht('Messages'));
       }
 
       $properties = new PHUIPropertyListView();
       $properties->addProperty('Build Target ID', $build_target->getID());
       $target_box->addPropertyList($properties, pht('Metadata'));
 
       $targets[] = $target_box;
 
       $targets[] = $this->buildLog($build, $build_target);
     }
 
     $xactions = id(new HarbormasterBuildTransactionQuery())
       ->setViewer($viewer)
       ->withObjectPHIDs(array($build->getPHID()))
       ->execute();
     $timeline = id(new PhabricatorApplicationTransactionView())
       ->setUser($viewer)
       ->setObjectPHID($build->getPHID())
       ->setTransactions($xactions);
 
     return $this->buildApplicationPage(
       array(
         $crumbs,
         $box,
         $targets,
         $timeline,
       ),
       array(
         'title' => $title,
       ));
   }
 
   private function buildArtifacts(
     HarbormasterBuildTarget $build_target) {
 
     $request = $this->getRequest();
     $viewer = $request->getUser();
 
     $artifacts = id(new HarbormasterBuildArtifactQuery())
       ->setViewer($viewer)
       ->withBuildTargetPHIDs(array($build_target->getPHID()))
       ->execute();
 
     if (count($artifacts) === 0) {
       return null;
     }
 
     $list = id(new PHUIObjectItemListView())
       ->setFlush(true);
 
     foreach ($artifacts as $artifact) {
       $item = $artifact->getObjectItemView($viewer);
       if ($item !== null) {
         $list->addItem($item);
       }
     }
 
     return $list;
   }
 
   private function buildLog(
     HarbormasterBuild $build,
     HarbormasterBuildTarget $build_target) {
 
     $request = $this->getRequest();
     $viewer = $request->getUser();
     $limit = $request->getInt('l', 25);
 
     $logs = id(new HarbormasterBuildLogQuery())
       ->setViewer($viewer)
       ->withBuildTargetPHIDs(array($build_target->getPHID()))
       ->execute();
 
     $empty_logs = array();
 
     $log_boxes = array();
     foreach ($logs as $log) {
       $start = 1;
       $lines = preg_split("/\r\n|\r|\n/", $log->getLogText());
       if ($limit !== 0) {
         $start = count($lines) - $limit;
         if ($start >= 1) {
           $lines = array_slice($lines, -$limit, $limit);
         } else {
           $start = 1;
         }
       }
 
       $id = null;
       $is_empty = false;
       if (count($lines) === 1 && trim($lines[0]) === '') {
         // Prevent Harbormaster from showing empty build logs.
         $id = celerity_generate_unique_node_id();
         $empty_logs[] = $id;
         $is_empty = true;
       }
 
       $log_view = new ShellLogView();
       $log_view->setLines($lines);
       $log_view->setStart($start);
 
       $header = id(new PHUIHeaderView())
         ->setHeader(pht(
           'Build Log %d (%s - %s)',
           $log->getID(),
           $log->getLogSource(),
           $log->getLogType()))
         ->setSubheader($this->createLogHeader($build, $log))
         ->setUser($viewer);
 
       $log_box = id(new PHUIObjectBoxView())
         ->setHeader($header)
         ->setForm($log_view);
 
       if ($is_empty) {
         $log_box = phutil_tag(
           'div',
           array(
             'style' => 'display: none',
             'id' => $id),
           $log_box);
       }
 
       $log_boxes[] = $log_box;
     }
 
     if ($empty_logs) {
       $hide_id = celerity_generate_unique_node_id();
 
       Javelin::initBehavior('phabricator-reveal-content');
 
       $expand = phutil_tag(
         'div',
         array(
           'id' => $hide_id,
           'class' => 'harbormaster-empty-logs-are-hidden mlr mlt mll',
         ),
         array(
           pht(
             '%s empty logs are hidden.',
             new PhutilNumber(count($empty_logs))),
           ' ',
           javelin_tag(
             'a',
             array(
               'href' => '#',
               'sigil' => 'reveal-content',
               'meta' => array(
                 'showIDs' => $empty_logs,
                 'hideIDs' => array($hide_id),
               ),
             ),
             pht('Show all logs.')),
         ));
 
       array_unshift($log_boxes, $expand);
     }
 
     return $log_boxes;
   }
 
   private function createLogHeader($build, $log) {
     $request = $this->getRequest();
     $limit = $request->getInt('l', 25);
 
     $lines_25 = $this->getApplicationURI('/build/'.$build->getID().'/?l=25');
     $lines_50 = $this->getApplicationURI('/build/'.$build->getID().'/?l=50');
     $lines_100 =
       $this->getApplicationURI('/build/'.$build->getID().'/?l=100');
     $lines_0 = $this->getApplicationURI('/build/'.$build->getID().'/?l=0');
 
     $link_25 = phutil_tag('a', array('href' => $lines_25), pht('25'));
     $link_50 = phutil_tag('a', array('href' => $lines_50), pht('50'));
     $link_100 = phutil_tag('a', array('href' => $lines_100), pht('100'));
     $link_0 = phutil_tag('a', array('href' => $lines_0), pht('Unlimited'));
 
     if ($limit === 25) {
       $link_25 = phutil_tag('strong', array(), $link_25);
     } else if ($limit === 50) {
       $link_50 = phutil_tag('strong', array(), $link_50);
     } else if ($limit === 100) {
       $link_100 = phutil_tag('strong', array(), $link_100);
     } else if ($limit === 0) {
       $link_0 = phutil_tag('strong', array(), $link_0);
     }
 
     return phutil_tag(
       'span',
       array(),
       array(
         $link_25,
         ' - ',
         $link_50,
         ' - ',
         $link_100,
         ' - ',
         $link_0,
         ' Lines'));
   }
 
   private function buildActionList(HarbormasterBuild $build) {
     $request = $this->getRequest();
     $viewer = $request->getUser();
     $id = $build->getID();
 
     $list = id(new PhabricatorActionListView())
       ->setUser($viewer)
       ->setObject($build)
       ->setObjectURI("/build/{$id}");
 
     $can_restart = $build->canRestartBuild();
     $can_stop = $build->canStopBuild();
     $can_resume = $build->canResumeBuild();
 
     $list->addAction(
       id(new PhabricatorActionView())
         ->setName(pht('Restart Build'))
         ->setIcon('fa-repeat')
         ->setHref($this->getApplicationURI('/build/restart/'.$id.'/'))
         ->setDisabled(!$can_restart)
         ->setWorkflow(true));
 
     if ($build->canResumeBuild()) {
       $list->addAction(
         id(new PhabricatorActionView())
           ->setName(pht('Resume Build'))
           ->setIcon('fa-play')
           ->setHref($this->getApplicationURI('/build/resume/'.$id.'/'))
           ->setDisabled(!$can_resume)
           ->setWorkflow(true));
     } else {
       $list->addAction(
         id(new PhabricatorActionView())
           ->setName(pht('Pause Build'))
           ->setIcon('fa-pause')
           ->setHref($this->getApplicationURI('/build/stop/'.$id.'/'))
           ->setDisabled(!$can_stop)
           ->setWorkflow(true));
     }
 
     return $list;
   }
 
   private function buildPropertyLists(
     PHUIObjectBoxView $box,
     HarbormasterBuild $build,
     PhabricatorActionListView $actions) {
     $request = $this->getRequest();
     $viewer = $request->getUser();
 
     $properties = id(new PHUIPropertyListView())
       ->setUser($viewer)
       ->setObject($build)
       ->setActionList($actions);
     $box->addPropertyList($properties);
 
     $handles = id(new PhabricatorHandleQuery())
       ->setViewer($viewer)
       ->withPHIDs(array(
         $build->getBuildablePHID(),
         $build->getBuildPlanPHID()))
       ->execute();
 
     $properties->addProperty(
       pht('Buildable'),
       $handles[$build->getBuildablePHID()]->renderLink());
 
     $properties->addProperty(
       pht('Build Plan'),
       $handles[$build->getBuildPlanPHID()]->renderLink());
 
+    $properties->addProperty(
+      pht('Restarts'),
+      $build->getBuildGeneration());
+
     $properties->addProperty(
       pht('Status'),
       $this->getStatus($build));
-
   }
 
   private function getStatus(HarbormasterBuild $build) {
     $status_view = new PHUIStatusListView();
 
     $item = new PHUIStatusItemView();
 
     if ($build->isStopping()) {
       $status_name = pht('Pausing');
       $icon = PHUIStatusItemView::ICON_RIGHT;
       $color = 'dark';
     } else {
       $status = $build->getBuildStatus();
       $status_name =
         HarbormasterBuild::getBuildStatusName($status);
       $icon = HarbormasterBuild::getBuildStatusIcon($status);
       $color = HarbormasterBuild::getBuildStatusColor($status);
     }
 
     $item->setTarget($status_name);
     $item->setIcon($icon, $color);
     $status_view->addItem($item);
 
     return $status_view;
   }
 
   private function buildMessages(array $messages) {
     $viewer = $this->getRequest()->getUser();
 
     if ($messages) {
       $handles = id(new PhabricatorHandleQuery())
         ->setViewer($viewer)
         ->withPHIDs(mpull($messages, 'getAuthorPHID'))
         ->execute();
     } else {
       $handles = array();
     }
 
     $rows = array();
     foreach ($messages as $message) {
       $rows[] = array(
         $message->getID(),
         $handles[$message->getAuthorPHID()]->renderLink(),
         $message->getType(),
         $message->getIsConsumed() ? pht('Consumed') : null,
         phabricator_datetime($message->getDateCreated(), $viewer),
       );
     }
 
     $table = new AphrontTableView($rows);
     $table->setNoDataString(pht('No messages for this build target.'));
     $table->setHeaders(
       array(
         pht('ID'),
         pht('From'),
         pht('Type'),
         pht('Consumed'),
         pht('Received'),
       ));
     $table->setColumnClasses(
       array(
         '',
         '',
         'wide',
         '',
         'date',
       ));
 
     return $table;
   }
 
 
 
 }
diff --git a/src/applications/harbormaster/engine/HarbormasterBuildEngine.php b/src/applications/harbormaster/engine/HarbormasterBuildEngine.php
index ee2b0acfef..a3faf45314 100644
--- a/src/applications/harbormaster/engine/HarbormasterBuildEngine.php
+++ b/src/applications/harbormaster/engine/HarbormasterBuildEngine.php
@@ -1,476 +1,467 @@
 <?php
 
 /**
  * Moves a build forward by queuing build tasks, canceling or restarting the
  * build, or failing it in response to task failures.
  */
 final class HarbormasterBuildEngine extends Phobject {
 
   private $build;
   private $viewer;
   private $newBuildTargets = array();
   private $forceBuildableUpdate;
 
   public function setForceBuildableUpdate($force_buildable_update) {
     $this->forceBuildableUpdate = $force_buildable_update;
     return $this;
   }
 
   public function shouldForceBuildableUpdate() {
     return $this->forceBuildableUpdate;
   }
 
   public function queueNewBuildTarget(HarbormasterBuildTarget $target) {
     $this->newBuildTargets[] = $target;
     return $this;
   }
 
   public function getNewBuildTargets() {
     return $this->newBuildTargets;
   }
 
   public function setViewer(PhabricatorUser $viewer) {
     $this->viewer = $viewer;
     return $this;
   }
 
   public function getViewer() {
     return $this->viewer;
   }
 
   public function setBuild(HarbormasterBuild $build) {
     $this->build = $build;
     return $this;
   }
 
   public function getBuild() {
     return $this->build;
   }
 
   public function continueBuild() {
     $build = $this->getBuild();
 
     $lock_key = 'harbormaster.build:'.$build->getID();
     $lock = PhabricatorGlobalLock::newLock($lock_key)->lock(15);
 
     $build->reload();
     $old_status = $build->getBuildStatus();
 
     try {
       $this->updateBuild($build);
     } catch (Exception $ex) {
       // If any exception is raised, the build is marked as a failure and the
       // exception is re-thrown (this ensures we don't leave builds in an
       // inconsistent state).
       $build->setBuildStatus(HarbormasterBuild::STATUS_ERROR);
       $build->save();
 
       $lock->unlock();
 
       $this->releaseAllArtifacts($build);
 
       throw $ex;
     }
 
     $lock->unlock();
 
     // NOTE: We queue new targets after releasing the lock so that in-process
     // execution via `bin/harbormaster` does not reenter the locked region.
     foreach ($this->getNewBuildTargets() as $target) {
       $task = PhabricatorWorker::scheduleTask(
         'HarbormasterTargetWorker',
         array(
           'targetID' => $target->getID(),
         ));
     }
 
     // If the build changed status, we might need to update the overall status
     // on the buildable.
     $new_status = $build->getBuildStatus();
     if ($new_status != $old_status || $this->shouldForceBuildableUpdate()) {
       $this->updateBuildable($build->getBuildable());
     }
 
     // If we are no longer building for any reason, release all artifacts.
     if (!$build->isBuilding()) {
       $this->releaseAllArtifacts($build);
     }
   }
 
   private function updateBuild(HarbormasterBuild $build) {
     if (($build->getBuildStatus() == HarbormasterBuild::STATUS_PENDING) ||
         ($build->isRestarting())) {
-      $this->destroyBuildTargets($build);
+      $this->restartBuild($build);
       $build->setBuildStatus(HarbormasterBuild::STATUS_BUILDING);
       $build->save();
     }
 
     if ($build->isResuming()) {
       $build->setBuildStatus(HarbormasterBuild::STATUS_BUILDING);
       $build->save();
     }
 
     if ($build->isStopping() && !$build->isComplete()) {
       $build->setBuildStatus(HarbormasterBuild::STATUS_STOPPED);
       $build->save();
     }
 
     $build->deleteUnprocessedCommands();
 
     if ($build->getBuildStatus() == HarbormasterBuild::STATUS_BUILDING) {
       $this->updateBuildSteps($build);
     }
   }
 
-  private function destroyBuildTargets(HarbormasterBuild $build) {
-    $this->releaseAllArtifacts($build);
-
-    $targets = id(new HarbormasterBuildTargetQuery())
-      ->setViewer($this->getViewer())
-      ->withBuildPHIDs(array($build->getPHID()))
-      ->execute();
+  private function restartBuild(HarbormasterBuild $build) {
 
-    if (!$targets) {
-      return;
-    }
-
-    $target_phids = mpull($targets, 'getPHID');
+    // We're restarting the build, so release all previous artifacts.
+    $this->releaseAllArtifacts($build);
 
-    $artifacts = id(new HarbormasterBuildArtifactQuery())
-      ->setViewer($this->getViewer())
-      ->withBuildTargetPHIDs($target_phids)
-      ->execute();
+    // Increment the build generation counter on the build.
+    $build->setBuildGeneration($build->getBuildGeneration() + 1);
 
-    foreach ($artifacts as $artifact) {
-      $artifact->delete();
-    }
+    // TODO: Currently running targets should periodically check their build
+    // generation (which won't have changed) against the build's generation.
+    // If it is different, they should automatically stop what they're doing
+    // and abort.
 
-    foreach ($targets as $target) {
-      $target->delete();
-    }
+    // Previously we used to delete targets, logs and artifacts here.  Instead
+    // leave them around so users can view previous generations of this build.
   }
 
   private function updateBuildSteps(HarbormasterBuild $build) {
     $targets = id(new HarbormasterBuildTargetQuery())
       ->setViewer($this->getViewer())
       ->withBuildPHIDs(array($build->getPHID()))
+      ->withBuildGenerations(array($build->getBuildGeneration()))
       ->execute();
 
     $this->updateWaitingTargets($targets);
 
     $targets = mgroup($targets, 'getBuildStepPHID');
 
     $steps = id(new HarbormasterBuildStepQuery())
       ->setViewer($this->getViewer())
       ->withBuildPlanPHIDs(array($build->getBuildPlan()->getPHID()))
       ->execute();
 
     // Identify steps which are in various states.
 
     $queued = array();
     $underway = array();
     $waiting = array();
     $complete = array();
     $failed = array();
     foreach ($steps as $step) {
       $step_targets = idx($targets, $step->getPHID(), array());
 
       if ($step_targets) {
         $is_queued = false;
 
         $is_underway = false;
         foreach ($step_targets as $target) {
           if ($target->isUnderway()) {
             $is_underway = true;
             break;
           }
         }
 
         $is_waiting = false;
         foreach ($step_targets as $target) {
           if ($target->isWaiting()) {
             $is_waiting = true;
             break;
           }
         }
 
         $is_complete = true;
         foreach ($step_targets as $target) {
           if (!$target->isComplete()) {
             $is_complete = false;
             break;
           }
         }
 
         $is_failed = false;
         foreach ($step_targets as $target) {
           if ($target->isFailed()) {
             $is_failed = true;
             break;
           }
         }
       } else {
         $is_queued = true;
         $is_underway = false;
         $is_waiting = false;
         $is_complete = false;
         $is_failed = false;
       }
 
       if ($is_queued) {
         $queued[$step->getPHID()] = true;
       }
 
       if ($is_underway) {
         $underway[$step->getPHID()] = true;
       }
 
       if ($is_waiting) {
         $waiting[$step->getPHID()] = true;
       }
 
       if ($is_complete) {
         $complete[$step->getPHID()] = true;
       }
 
       if ($is_failed) {
         $failed[$step->getPHID()] = true;
       }
     }
 
     // If any step failed, fail the whole build, then bail.
     if (count($failed)) {
       $build->setBuildStatus(HarbormasterBuild::STATUS_FAILED);
       $build->save();
       return;
     }
 
     // If every step is complete, we're done with this build. Mark it passed
     // and bail.
     if (count($complete) == count($steps)) {
       $build->setBuildStatus(HarbormasterBuild::STATUS_PASSED);
       $build->save();
       return;
     }
 
     // Identify all the steps which are ready to run (because all their
     // dependencies are complete).
 
     $runnable = array();
     foreach ($steps as $step) {
       $dependencies = $step->getStepImplementation()->getDependencies($step);
 
       if (isset($queued[$step->getPHID()])) {
         $can_run = true;
         foreach ($dependencies as $dependency) {
           if (empty($complete[$dependency])) {
             $can_run = false;
             break;
           }
         }
 
         if ($can_run) {
           $runnable[] = $step;
         }
       }
     }
 
     if (!$runnable && !$waiting && !$underway) {
       // This means the build is deadlocked, and the user has configured
       // circular dependencies.
       $build->setBuildStatus(HarbormasterBuild::STATUS_DEADLOCKED);
       $build->save();
       return;
     }
 
     foreach ($runnable as $runnable_step) {
       $target = HarbormasterBuildTarget::initializeNewBuildTarget(
         $build,
         $runnable_step,
         $build->retrieveVariablesFromBuild());
       $target->save();
 
       $this->queueNewBuildTarget($target);
     }
   }
 
 
   /**
    * Process messages which were sent to these targets, kicking applicable
    * targets out of "Waiting" and into either "Passed" or "Failed".
    *
    * @param list<HarbormasterBuildTarget> List of targets to process.
    * @return void
    */
   private function updateWaitingTargets(array $targets) {
     assert_instances_of($targets, 'HarbormasterBuildTarget');
 
     // We only care about messages for targets which are actually in a waiting
     // state.
     $waiting_targets = array();
     foreach ($targets as $target) {
       if ($target->isWaiting()) {
         $waiting_targets[$target->getPHID()] = $target;
       }
     }
 
     if (!$waiting_targets) {
       return;
     }
 
     $messages = id(new HarbormasterBuildMessageQuery())
       ->setViewer($this->getViewer())
       ->withBuildTargetPHIDs(array_keys($waiting_targets))
       ->withConsumed(false)
       ->execute();
 
     foreach ($messages as $message) {
       $target = $waiting_targets[$message->getBuildTargetPHID()];
 
       $new_status = null;
       switch ($message->getType()) {
         case 'pass':
           $new_status = HarbormasterBuildTarget::STATUS_PASSED;
           break;
         case 'fail':
           $new_status = HarbormasterBuildTarget::STATUS_FAILED;
           break;
       }
 
       if ($new_status !== null) {
         $message->setIsConsumed(true);
         $message->save();
 
         $target->setTargetStatus($new_status);
         $target->save();
       }
     }
   }
 
 
   /**
    * Update the overall status of the buildable this build is attached to.
    *
    * After a build changes state (for example, passes or fails) it may affect
    * the overall state of the associated buildable. Compute the new aggregate
    * state and save it on the buildable.
    *
    * @param   HarbormasterBuild The buildable to update.
    * @return  void
    */
   private function updateBuildable(HarbormasterBuildable $buildable) {
     $viewer = $this->getViewer();
 
     $lock_key = 'harbormaster.buildable:'.$buildable->getID();
     $lock = PhabricatorGlobalLock::newLock($lock_key)->lock(15);
 
     $buildable = id(new HarbormasterBuildableQuery())
       ->setViewer($viewer)
       ->withIDs(array($buildable->getID()))
       ->needBuilds(true)
       ->executeOne();
 
     $all_pass = true;
     $any_fail = false;
     foreach ($buildable->getBuilds() as $build) {
       if ($build->getBuildStatus() != HarbormasterBuild::STATUS_PASSED) {
         $all_pass = false;
       }
       if ($build->getBuildStatus() == HarbormasterBuild::STATUS_FAILED ||
           $build->getBuildStatus() == HarbormasterBuild::STATUS_ERROR ||
           $build->getBuildStatus() == HarbormasterBuild::STATUS_DEADLOCKED) {
         $any_fail = true;
       }
     }
 
     if ($any_fail) {
       $new_status = HarbormasterBuildable::STATUS_FAILED;
     } else if ($all_pass) {
       $new_status = HarbormasterBuildable::STATUS_PASSED;
     } else {
       $new_status = HarbormasterBuildable::STATUS_BUILDING;
     }
 
     $old_status = $buildable->getBuildableStatus();
     $did_update = ($old_status != $new_status);
     if ($did_update) {
       $buildable->setBuildableStatus($new_status);
       $buildable->save();
     }
 
     $lock->unlock();
 
     // If we changed the buildable status, try to post a transaction to the
     // object about it. We can safely do this outside of the locked region.
 
     // NOTE: We only post transactions for automatic buildables, not for
     // manual ones: manual builds are test builds, whoever is doing tests
     // can look at the results themselves, and other users generally don't
     // care about the outcome.
 
     $should_publish = $did_update &&
                       $new_status != HarbormasterBuildable::STATUS_BUILDING &&
                       !$buildable->getIsManualBuildable();
     if ($should_publish) {
       $object = id(new PhabricatorObjectQuery())
         ->setViewer($viewer)
         ->withPHIDs(array($buildable->getBuildablePHID()))
         ->executeOne();
 
       if ($object instanceof PhabricatorApplicationTransactionInterface) {
         $template = $object->getApplicationTransactionTemplate();
         if ($template) {
           $template
             ->setTransactionType(PhabricatorTransactions::TYPE_BUILDABLE)
             ->setMetadataValue(
               'harbormaster:buildablePHID',
               $buildable->getPHID())
             ->setOldValue($old_status)
             ->setNewValue($new_status);
 
           $harbormaster_phid = id(new PhabricatorHarbormasterApplication())
             ->getPHID();
 
           $daemon_source = PhabricatorContentSource::newForSource(
             PhabricatorContentSource::SOURCE_DAEMON,
             array());
 
           $editor = $object->getApplicationTransactionEditor()
             ->setActor($viewer)
             ->setActingAsPHID($harbormaster_phid)
             ->setContentSource($daemon_source)
             ->setContinueOnNoEffect(true)
             ->setContinueOnMissingFields(true);
 
           $editor->applyTransactions(
             $object->getApplicationTransactionObject(),
             array($template));
         }
       }
     }
   }
 
   private function releaseAllArtifacts(HarbormasterBuild $build) {
     $targets = id(new HarbormasterBuildTargetQuery())
       ->setViewer(PhabricatorUser::getOmnipotentUser())
       ->withBuildPHIDs(array($build->getPHID()))
+      ->withBuildGenerations(array($build->getBuildGeneration()))
       ->execute();
 
     if (count($targets) === 0) {
       return;
     }
 
     $target_phids = mpull($targets, 'getPHID');
 
     $artifacts = id(new HarbormasterBuildArtifactQuery())
       ->setViewer(PhabricatorUser::getOmnipotentUser())
       ->withBuildTargetPHIDs($target_phids)
       ->execute();
 
     foreach ($artifacts as $artifact) {
       $artifact->release();
     }
 
   }
 
 }
diff --git a/src/applications/harbormaster/query/HarbormasterBuildQuery.php b/src/applications/harbormaster/query/HarbormasterBuildQuery.php
index bfa18f14c3..0daf5ac906 100644
--- a/src/applications/harbormaster/query/HarbormasterBuildQuery.php
+++ b/src/applications/harbormaster/query/HarbormasterBuildQuery.php
@@ -1,179 +1,186 @@
 <?php
 
 final class HarbormasterBuildQuery
   extends PhabricatorCursorPagedPolicyAwareQuery {
 
   private $ids;
   private $phids;
   private $buildStatuses;
   private $buildablePHIDs;
   private $buildPlanPHIDs;
   private $needBuildTargets;
 
   public function withIDs(array $ids) {
     $this->ids = $ids;
     return $this;
   }
 
   public function withPHIDs(array $phids) {
     $this->phids = $phids;
     return $this;
   }
 
   public function withBuildStatuses(array $build_statuses) {
     $this->buildStatuses = $build_statuses;
     return $this;
   }
 
   public function withBuildablePHIDs(array $buildable_phids) {
     $this->buildablePHIDs = $buildable_phids;
     return $this;
   }
 
   public function withBuildPlanPHIDs(array $build_plan_phids) {
     $this->buildPlanPHIDs = $build_plan_phids;
     return $this;
   }
 
   public function needBuildTargets($need_targets) {
     $this->needBuildTargets = $need_targets;
     return $this;
   }
 
   protected function loadPage() {
     $table = new HarbormasterBuild();
     $conn_r = $table->establishConnection('r');
 
     $data = queryfx_all(
       $conn_r,
       'SELECT * FROM %T %Q %Q %Q',
       $table->getTableName(),
       $this->buildWhereClause($conn_r),
       $this->buildOrderClause($conn_r),
       $this->buildLimitClause($conn_r));
 
     return $table->loadAllFromArray($data);
   }
 
   protected function willFilterPage(array $page) {
     $buildables = array();
 
     $buildable_phids = array_filter(mpull($page, 'getBuildablePHID'));
     if ($buildable_phids) {
       $buildables = id(new PhabricatorObjectQuery())
         ->setViewer($this->getViewer())
         ->withPHIDs($buildable_phids)
         ->setParentQuery($this)
         ->execute();
       $buildables = mpull($buildables, null, 'getPHID');
     }
 
     foreach ($page as $key => $build) {
       $buildable_phid = $build->getBuildablePHID();
       if (empty($buildables[$buildable_phid])) {
         unset($page[$key]);
         continue;
       }
       $build->attachBuildable($buildables[$buildable_phid]);
     }
 
     return $page;
   }
 
   protected function didFilterPage(array $page) {
     $plans = array();
 
     $plan_phids = array_filter(mpull($page, 'getBuildPlanPHID'));
     if ($plan_phids) {
       $plans = id(new PhabricatorObjectQuery())
         ->setViewer($this->getViewer())
         ->withPHIDs($plan_phids)
         ->setParentQuery($this)
         ->execute();
       $plans = mpull($plans, null, 'getPHID');
     }
 
     foreach ($page as $key => $build) {
       $plan_phid = $build->getBuildPlanPHID();
       $build->attachBuildPlan(idx($plans, $plan_phid));
     }
 
     $build_phids = mpull($page, 'getPHID');
     $commands = id(new HarbormasterBuildCommand())->loadAllWhere(
       'targetPHID IN (%Ls) ORDER BY id ASC',
       $build_phids);
     $commands = mgroup($commands, 'getTargetPHID');
     foreach ($page as $build) {
       $unprocessed_commands = idx($commands, $build->getPHID(), array());
       $build->attachUnprocessedCommands($unprocessed_commands);
     }
 
     if ($this->needBuildTargets) {
       $targets = id(new HarbormasterBuildTargetQuery())
         ->setViewer($this->getViewer())
         ->setParentQuery($this)
         ->withBuildPHIDs($build_phids)
         ->execute();
 
       // TODO: Some day, when targets have dependencies, we should toposort
       // these. For now, just put them into chronological order.
       $targets = array_reverse($targets);
 
       $targets = mgroup($targets, 'getBuildPHID');
       foreach ($page as $build) {
         $build_targets = idx($targets, $build->getPHID(), array());
+
+        foreach ($build_targets as $phid => $target) {
+          if ($target->getBuildGeneration() !== $build->getBuildGeneration()) {
+            unset($build_targets[$phid]);
+          }
+        }
+
         $build->attachBuildTargets($build_targets);
       }
     }
 
     return $page;
   }
 
   private function buildWhereClause(AphrontDatabaseConnection $conn_r) {
     $where = array();
 
     if ($this->ids !== null) {
       $where[] = qsprintf(
         $conn_r,
         'id IN (%Ld)',
         $this->ids);
     }
 
     if ($this->phids !== null) {
       $where[] = qsprintf(
         $conn_r,
         'phid in (%Ls)',
         $this->phids);
     }
 
     if ($this->buildStatuses !== null) {
       $where[] = qsprintf(
         $conn_r,
         'buildStatus in (%Ls)',
         $this->buildStatuses);
     }
 
     if ($this->buildablePHIDs !== null) {
       $where[] = qsprintf(
         $conn_r,
         'buildablePHID IN (%Ls)',
         $this->buildablePHIDs);
     }
 
     if ($this->buildPlanPHIDs !== null) {
       $where[] = qsprintf(
         $conn_r,
         'buildPlanPHID IN (%Ls)',
         $this->buildPlanPHIDs);
     }
 
     $where[] = $this->buildPagingClause($conn_r);
 
     return $this->formatWhereClause($where);
   }
 
   public function getQueryApplicationClass() {
     return 'PhabricatorHarbormasterApplication';
   }
 
 }
diff --git a/src/applications/harbormaster/query/HarbormasterBuildTargetQuery.php b/src/applications/harbormaster/query/HarbormasterBuildTargetQuery.php
index 88c51f5e36..133bb6c0e2 100644
--- a/src/applications/harbormaster/query/HarbormasterBuildTargetQuery.php
+++ b/src/applications/harbormaster/query/HarbormasterBuildTargetQuery.php
@@ -1,129 +1,142 @@
 <?php
 
 final class HarbormasterBuildTargetQuery
   extends PhabricatorCursorPagedPolicyAwareQuery {
 
   private $ids;
   private $phids;
   private $buildPHIDs;
+  private $buildGenerations;
   private $needBuildSteps;
 
   public function withIDs(array $ids) {
     $this->ids = $ids;
     return $this;
   }
 
   public function withPHIDs(array $phids) {
     $this->phids = $phids;
     return $this;
   }
 
   public function withBuildPHIDs(array $build_phids) {
     $this->buildPHIDs = $build_phids;
     return $this;
   }
 
+  public function withBuildGenerations(array $build_generations) {
+    $this->buildGenerations = $build_generations;
+    return $this;
+  }
+
   public function needBuildSteps($need_build_steps) {
     $this->needBuildSteps = $need_build_steps;
     return $this;
   }
 
   protected function loadPage() {
     $table = new HarbormasterBuildTarget();
     $conn_r = $table->establishConnection('r');
 
     $data = queryfx_all(
       $conn_r,
       'SELECT * FROM %T %Q %Q %Q',
       $table->getTableName(),
       $this->buildWhereClause($conn_r),
       $this->buildOrderClause($conn_r),
       $this->buildLimitClause($conn_r));
 
     return $table->loadAllFromArray($data);
   }
 
   private function buildWhereClause(AphrontDatabaseConnection $conn_r) {
     $where = array();
 
     if ($this->ids) {
       $where[] = qsprintf(
         $conn_r,
         'id IN (%Ld)',
         $this->ids);
     }
 
     if ($this->phids) {
       $where[] = qsprintf(
         $conn_r,
         'phid in (%Ls)',
         $this->phids);
     }
 
     if ($this->buildPHIDs) {
       $where[] = qsprintf(
         $conn_r,
         'buildPHID in (%Ls)',
         $this->buildPHIDs);
     }
 
+    if ($this->buildGenerations) {
+      $where[] = qsprintf(
+        $conn_r,
+        'buildGeneration in (%Ld)',
+        $this->buildGenerations);
+    }
+
     $where[] = $this->buildPagingClause($conn_r);
 
     return $this->formatWhereClause($where);
   }
 
   protected function didFilterPage(array $page) {
     if ($this->needBuildSteps) {
       $step_phids = array();
 
       foreach ($page as $target) {
         $step_phids[] = $target->getBuildStepPHID();
       }
 
       $steps = id(new HarbormasterBuildStepQuery())
         ->setViewer($this->getViewer())
         ->setParentQuery($this)
         ->withPHIDs($step_phids)
         ->execute();
 
       $steps = mpull($steps, null, 'getPHID');
 
       foreach ($page as $target) {
         $target->attachBuildStep(
           $steps[$target->getBuildStepPHID()]);
       }
     }
 
     return $page;
   }
 
   protected function willFilterPage(array $page) {
     $builds = array();
 
     $build_phids = array_filter(mpull($page, 'getBuildPHID'));
     if ($build_phids) {
       $builds = id(new PhabricatorObjectQuery())
         ->setViewer($this->getViewer())
         ->withPHIDs($build_phids)
         ->setParentQuery($this)
         ->execute();
       $builds = mpull($builds, null, 'getPHID');
     }
 
     foreach ($page as $key => $build_target) {
       $build_phid = $build_target->getBuildPHID();
       if (empty($builds[$build_phid])) {
         unset($page[$key]);
         continue;
       }
       $build_target->attachBuild($builds[$build_phid]);
     }
 
     return $page;
   }
 
   public function getQueryApplicationClass() {
     return 'PhabricatorHarbormasterApplication';
   }
 
 }
diff --git a/src/applications/harbormaster/storage/build/HarbormasterBuild.php b/src/applications/harbormaster/storage/build/HarbormasterBuild.php
index 3395052efa..d90cac554f 100644
--- a/src/applications/harbormaster/storage/build/HarbormasterBuild.php
+++ b/src/applications/harbormaster/storage/build/HarbormasterBuild.php
@@ -1,406 +1,407 @@
 <?php
 
 final class HarbormasterBuild extends HarbormasterDAO
   implements PhabricatorPolicyInterface {
 
   protected $buildablePHID;
   protected $buildPlanPHID;
   protected $buildStatus;
+  protected $buildGeneration;
 
   private $buildable = self::ATTACHABLE;
   private $buildPlan = self::ATTACHABLE;
   private $buildTargets = self::ATTACHABLE;
   private $unprocessedCommands = self::ATTACHABLE;
 
   /**
    * Not currently being built.
    */
   const STATUS_INACTIVE = 'inactive';
 
   /**
    * Pending pick up by the Harbormaster daemon.
    */
   const STATUS_PENDING = 'pending';
 
   /**
    * Current building the buildable.
    */
   const STATUS_BUILDING = 'building';
 
   /**
    * The build has passed.
    */
   const STATUS_PASSED = 'passed';
 
   /**
    * The build has failed.
    */
   const STATUS_FAILED = 'failed';
 
   /**
    * The build encountered an unexpected error.
    */
   const STATUS_ERROR = 'error';
 
   /**
    * The build has been stopped.
    */
   const STATUS_STOPPED = 'stopped';
 
   /**
    * The build has been deadlocked.
    */
   const STATUS_DEADLOCKED = 'deadlocked';
 
 
   /**
    * Get a human readable name for a build status constant.
    *
    * @param  const  Build status constant.
    * @return string Human-readable name.
    */
   public static function getBuildStatusName($status) {
     switch ($status) {
       case self::STATUS_INACTIVE:
         return pht('Inactive');
       case self::STATUS_PENDING:
         return pht('Pending');
       case self::STATUS_BUILDING:
         return pht('Building');
       case self::STATUS_PASSED:
         return pht('Passed');
       case self::STATUS_FAILED:
         return pht('Failed');
       case self::STATUS_ERROR:
         return pht('Unexpected Error');
       case self::STATUS_STOPPED:
         return pht('Paused');
       case self::STATUS_DEADLOCKED:
         return pht('Deadlocked');
       default:
         return pht('Unknown');
     }
   }
 
   public static function getBuildStatusIcon($status) {
     switch ($status) {
       case self::STATUS_INACTIVE:
       case self::STATUS_PENDING:
         return PHUIStatusItemView::ICON_OPEN;
       case self::STATUS_BUILDING:
         return PHUIStatusItemView::ICON_RIGHT;
       case self::STATUS_PASSED:
         return PHUIStatusItemView::ICON_ACCEPT;
       case self::STATUS_FAILED:
         return PHUIStatusItemView::ICON_REJECT;
       case self::STATUS_ERROR:
         return PHUIStatusItemView::ICON_MINUS;
       case self::STATUS_STOPPED:
         return PHUIStatusItemView::ICON_MINUS;
       case self::STATUS_DEADLOCKED:
         return PHUIStatusItemView::ICON_WARNING;
       default:
         return PHUIStatusItemView::ICON_QUESTION;
     }
   }
 
   public static function getBuildStatusColor($status) {
     switch ($status) {
       case self::STATUS_INACTIVE:
         return 'dark';
       case self::STATUS_PENDING:
       case self::STATUS_BUILDING:
         return 'blue';
       case self::STATUS_PASSED:
         return 'green';
       case self::STATUS_FAILED:
       case self::STATUS_ERROR:
       case self::STATUS_DEADLOCKED:
         return 'red';
       case self::STATUS_STOPPED:
         return 'dark';
       default:
         return 'bluegrey';
     }
   }
 
   public static function initializeNewBuild(PhabricatorUser $actor) {
     return id(new HarbormasterBuild())
       ->setBuildStatus(self::STATUS_INACTIVE);
   }
 
   public function delete() {
     $this->openTransaction();
       $this->deleteUnprocessedCommands();
       $result = parent::delete();
     $this->saveTransaction();
 
     return $result;
   }
 
   public function getConfiguration() {
     return array(
       self::CONFIG_AUX_PHID => true,
     ) + parent::getConfiguration();
   }
 
   public function generatePHID() {
     return PhabricatorPHID::generateNewPHID(
       HarbormasterBuildPHIDType::TYPECONST);
   }
 
   public function attachBuildable(HarbormasterBuildable $buildable) {
     $this->buildable = $buildable;
     return $this;
   }
 
   public function getBuildable() {
     return $this->assertAttached($this->buildable);
   }
 
   public function getName() {
     if ($this->getBuildPlan()) {
       return $this->getBuildPlan()->getName();
     }
     return pht('Build');
   }
 
   public function attachBuildPlan(
     HarbormasterBuildPlan $build_plan = null) {
     $this->buildPlan = $build_plan;
     return $this;
   }
 
   public function getBuildPlan() {
     return $this->assertAttached($this->buildPlan);
   }
 
   public function getBuildTargets() {
     return $this->assertAttached($this->buildTargets);
   }
 
   public function attachBuildTargets(array $targets) {
     $this->buildTargets = $targets;
     return $this;
   }
 
   public function isBuilding() {
     return $this->getBuildStatus() === self::STATUS_PENDING ||
       $this->getBuildStatus() === self::STATUS_BUILDING;
   }
 
   public function createLog(
     HarbormasterBuildTarget $build_target,
     $log_source,
     $log_type) {
 
     $log_source = phutil_utf8_shorten($log_source, 250);
 
     $log = HarbormasterBuildLog::initializeNewBuildLog($build_target)
       ->setLogSource($log_source)
       ->setLogType($log_type)
       ->save();
 
     return $log;
   }
 
   public function createArtifact(
     HarbormasterBuildTarget $build_target,
     $artifact_key,
     $artifact_type) {
 
     $artifact =
       HarbormasterBuildArtifact::initializeNewBuildArtifact($build_target);
     $artifact->setArtifactKey($this->getPHID(), $artifact_key);
     $artifact->setArtifactType($artifact_type);
     $artifact->save();
     return $artifact;
   }
 
   public function loadArtifact($name) {
     $artifact = id(new HarbormasterBuildArtifactQuery())
       ->setViewer(PhabricatorUser::getOmnipotentUser())
       ->withArtifactKeys(
         $this->getPHID(),
         array($name))
       ->executeOne();
     if ($artifact === null) {
       throw new Exception('Artifact not found!');
     }
     return $artifact;
   }
 
   public function retrieveVariablesFromBuild() {
     $results = array(
       'buildable.diff' => null,
       'buildable.revision' => null,
       'buildable.commit' => null,
       'repository.callsign' => null,
       'repository.vcs' => null,
       'repository.uri' => null,
       'step.timestamp' => null,
       'build.id' => null,
     );
 
     $buildable = $this->getBuildable();
     $object = $buildable->getBuildableObject();
 
     $object_variables = $object->getBuildVariables();
 
     $results = $object_variables + $results;
 
     $results['step.timestamp'] = time();
     $results['build.id'] = $this->getID();
 
     return $results;
   }
 
   public static function getAvailableBuildVariables() {
     $objects = id(new PhutilSymbolLoader())
       ->setAncestorClass('HarbormasterBuildableInterface')
       ->loadObjects();
 
     $variables = array();
     $variables[] = array(
       'step.timestamp' => pht('The current UNIX timestamp.'),
       'build.id' => pht('The ID of the current build.'),
       'target.phid' => pht('The PHID of the current build target.'),
     );
 
     foreach ($objects as $object) {
       $variables[] = $object->getAvailableBuildVariables();
     }
 
     $variables = array_mergev($variables);
     return $variables;
   }
 
   public function isComplete() {
     switch ($this->getBuildStatus()) {
       case self::STATUS_PASSED:
       case self::STATUS_FAILED:
       case self::STATUS_ERROR:
       case self::STATUS_STOPPED:
         return true;
     }
 
     return false;
   }
 
   public function isStopped() {
     return ($this->getBuildStatus() == self::STATUS_STOPPED);
   }
 
 
 /* -(  Build Commands  )----------------------------------------------------- */
 
 
   private function getUnprocessedCommands() {
     return $this->assertAttached($this->unprocessedCommands);
   }
 
   public function attachUnprocessedCommands(array $commands) {
     $this->unprocessedCommands = $commands;
     return $this;
   }
 
   public function canRestartBuild() {
     return !$this->isRestarting();
   }
 
   public function canStopBuild() {
     return !$this->isComplete() &&
            !$this->isStopped() &&
            !$this->isStopping();
   }
 
   public function canResumeBuild() {
     return $this->isStopped() &&
            !$this->isResuming();
   }
 
   public function isStopping() {
     $is_stopping = false;
     foreach ($this->getUnprocessedCommands() as $command_object) {
       $command = $command_object->getCommand();
       switch ($command) {
         case HarbormasterBuildCommand::COMMAND_STOP:
           $is_stopping = true;
           break;
         case HarbormasterBuildCommand::COMMAND_RESUME:
         case HarbormasterBuildCommand::COMMAND_RESTART:
           $is_stopping = false;
           break;
       }
     }
 
     return $is_stopping;
   }
 
   public function isResuming() {
     $is_resuming = false;
     foreach ($this->getUnprocessedCommands() as $command_object) {
       $command = $command_object->getCommand();
       switch ($command) {
         case HarbormasterBuildCommand::COMMAND_RESTART:
         case HarbormasterBuildCommand::COMMAND_RESUME:
           $is_resuming = true;
           break;
         case HarbormasterBuildCommand::COMMAND_STOP:
           $is_resuming = false;
           break;
       }
     }
 
     return $is_resuming;
   }
 
   public function isRestarting() {
     $is_restarting = false;
     foreach ($this->getUnprocessedCommands() as $command_object) {
       $command = $command_object->getCommand();
       switch ($command) {
         case HarbormasterBuildCommand::COMMAND_RESTART:
           $is_restarting = true;
           break;
       }
     }
 
     return $is_restarting;
   }
 
   public function deleteUnprocessedCommands() {
     foreach ($this->getUnprocessedCommands() as $key => $command_object) {
       $command_object->delete();
       unset($this->unprocessedCommands[$key]);
     }
 
     return $this;
   }
 
 
 /* -(  PhabricatorPolicyInterface  )----------------------------------------- */
 
 
   public function getCapabilities() {
     return array(
       PhabricatorPolicyCapability::CAN_VIEW,
       PhabricatorPolicyCapability::CAN_EDIT,
     );
   }
 
   public function getPolicy($capability) {
     return $this->getBuildable()->getPolicy($capability);
   }
 
   public function hasAutomaticCapability($capability, PhabricatorUser $viewer) {
     return $this->getBuildable()->hasAutomaticCapability(
       $capability,
       $viewer);
   }
 
   public function describeAutomaticCapability($capability) {
     return pht('A build inherits policies from its buildable.');
   }
 
 }
diff --git a/src/applications/harbormaster/storage/build/HarbormasterBuildTarget.php b/src/applications/harbormaster/storage/build/HarbormasterBuildTarget.php
index e07d219f88..3271903d70 100644
--- a/src/applications/harbormaster/storage/build/HarbormasterBuildTarget.php
+++ b/src/applications/harbormaster/storage/build/HarbormasterBuildTarget.php
@@ -1,240 +1,242 @@
 <?php
 
 final class HarbormasterBuildTarget extends HarbormasterDAO
   implements PhabricatorPolicyInterface {
 
   protected $name;
   protected $buildPHID;
   protected $buildStepPHID;
   protected $className;
   protected $details;
   protected $variables;
   protected $targetStatus;
   protected $dateStarted;
   protected $dateCompleted;
+  protected $buildGeneration;
 
   const STATUS_PENDING = 'target/pending';
   const STATUS_BUILDING = 'target/building';
   const STATUS_WAITING = 'target/waiting';
   const STATUS_PASSED = 'target/passed';
   const STATUS_FAILED = 'target/failed';
 
   private $build = self::ATTACHABLE;
   private $buildStep = self::ATTACHABLE;
   private $implementation;
 
   public static function getBuildTargetStatusName($status) {
     switch ($status) {
       case self::STATUS_PENDING:
         return pht('Pending');
       case self::STATUS_BUILDING:
         return pht('Building');
       case self::STATUS_WAITING:
         return pht('Waiting for Message');
       case self::STATUS_PASSED:
         return pht('Passed');
       case self::STATUS_FAILED:
         return pht('Failed');
       default:
         return pht('Unknown');
     }
   }
 
   public static function getBuildTargetStatusIcon($status) {
     switch ($status) {
       case self::STATUS_PENDING:
         return PHUIStatusItemView::ICON_OPEN;
       case self::STATUS_BUILDING:
       case self::STATUS_WAITING:
         return PHUIStatusItemView::ICON_RIGHT;
       case self::STATUS_PASSED:
         return PHUIStatusItemView::ICON_ACCEPT;
       case self::STATUS_FAILED:
         return PHUIStatusItemView::ICON_REJECT;
       default:
         return PHUIStatusItemView::ICON_QUESTION;
     }
   }
 
   public static function getBuildTargetStatusColor($status) {
     switch ($status) {
       case self::STATUS_PENDING:
       case self::STATUS_BUILDING:
       case self::STATUS_WAITING:
         return 'blue';
       case self::STATUS_PASSED:
         return 'green';
       case self::STATUS_FAILED:
         return 'red';
       default:
         return 'bluegrey';
     }
   }
 
   public static function initializeNewBuildTarget(
     HarbormasterBuild $build,
     HarbormasterBuildStep $build_step,
     array $variables) {
     return id(new HarbormasterBuildTarget())
       ->setName($build_step->getName())
       ->setBuildPHID($build->getPHID())
       ->setBuildStepPHID($build_step->getPHID())
       ->setClassName($build_step->getClassName())
       ->setDetails($build_step->getDetails())
       ->setTargetStatus(self::STATUS_PENDING)
-      ->setVariables($variables);
+      ->setVariables($variables)
+      ->setBuildGeneration($build->getBuildGeneration());
   }
 
   public function getConfiguration() {
     return array(
       self::CONFIG_AUX_PHID => true,
       self::CONFIG_SERIALIZATION => array(
         'details' => self::SERIALIZATION_JSON,
         'variables' => self::SERIALIZATION_JSON,
       )
     ) + parent::getConfiguration();
   }
 
   public function generatePHID() {
     return PhabricatorPHID::generateNewPHID(
       HarbormasterBuildTargetPHIDType::TYPECONST);
   }
 
   public function attachBuild(HarbormasterBuild $build) {
     $this->build = $build;
     return $this;
   }
 
   public function getBuild() {
     return $this->assertAttached($this->build);
   }
 
   public function attachBuildStep(HarbormasterBuildStep $step) {
     $this->buildStep = $step;
     return $this;
   }
 
   public function getBuildStep() {
     return $this->assertAttached($this->buildStep);
   }
 
   public function getDetail($key, $default = null) {
     return idx($this->details, $key, $default);
   }
 
   public function setDetail($key, $value) {
     $this->details[$key] = $value;
     return $this;
   }
 
   public function getVariables() {
     return parent::getVariables() + $this->getBuildTargetVariables();
   }
 
   public function getVariable($key, $default = null) {
     return idx($this->variables, $key, $default);
   }
 
   public function setVariable($key, $value) {
     $this->variables[$key] = $value;
     return $this;
   }
 
   public function getImplementation() {
     if ($this->implementation === null) {
       $obj = HarbormasterBuildStepImplementation::requireImplementation(
         $this->className);
       $obj->loadSettings($this);
       $this->implementation = $obj;
     }
 
     return $this->implementation;
   }
 
   public function getName() {
     if (strlen($this->name)) {
       return $this->name;
     }
 
     try {
       return $this->getImplementation()->getName();
     } catch (Exception $e) {
       return $this->getClassName();
     }
   }
 
   private function getBuildTargetVariables() {
     return array(
       'target.phid' => $this->getPHID(),
     );
   }
 
 
 /* -(  Status  )------------------------------------------------------------- */
 
 
   public function isComplete() {
     switch ($this->getTargetStatus()) {
       case self::STATUS_PASSED:
       case self::STATUS_FAILED:
         return true;
     }
 
     return false;
   }
 
 
   public function isFailed() {
     switch ($this->getTargetStatus()) {
       case self::STATUS_FAILED:
         return true;
     }
 
     return false;
   }
 
 
   public function isWaiting() {
     switch ($this->getTargetStatus()) {
       case self::STATUS_WAITING:
         return true;
     }
 
     return false;
   }
 
   public function isUnderway() {
     switch ($this->getTargetStatus()) {
       case self::STATUS_PENDING:
       case self::STATUS_BUILDING:
         return true;
     }
 
     return false;
   }
 
 
 /* -(  PhabricatorPolicyInterface  )----------------------------------------- */
 
 
   public function getCapabilities() {
     return array(
       PhabricatorPolicyCapability::CAN_VIEW,
     );
   }
 
   public function getPolicy($capability) {
     return $this->getBuild()->getPolicy($capability);
   }
 
   public function hasAutomaticCapability($capability, PhabricatorUser $viewer) {
     return $this->getBuild()->hasAutomaticCapability(
       $capability,
       $viewer);
   }
 
   public function describeAutomaticCapability($capability) {
     return pht('Users must be able to see a build to view its build targets.');
   }
 
 }