diff --git a/src/applications/differential/conduit/DifferentialCreateDiffConduitAPIMethod.php b/src/applications/differential/conduit/DifferentialCreateDiffConduitAPIMethod.php
index 91b5ca8653..686f7cba83 100644
--- a/src/applications/differential/conduit/DifferentialCreateDiffConduitAPIMethod.php
+++ b/src/applications/differential/conduit/DifferentialCreateDiffConduitAPIMethod.php
@@ -1,167 +1,168 @@
 <?php
 
 final class DifferentialCreateDiffConduitAPIMethod
   extends DifferentialConduitAPIMethod {
 
   public function getAPIMethodName() {
     return 'differential.creatediff';
   }
 
   public function getMethodDescription() {
     return pht('Create a new Differential diff.');
   }
 
   protected function defineParamTypes() {
     $vcs_const = $this->formatStringConstants(
       array(
         'svn',
         'git',
         'hg',
       ));
 
     $status_const = $this->formatStringConstants(
       array(
         'none',
         'skip',
         'okay',
         'warn',
         'fail',
         'postponed',
       ));
 
     return array(
       'changes'                   => 'required list<dict>',
       'sourceMachine'             => 'required string',
       'sourcePath'                => 'required string',
       'branch'                    => 'required string',
       'bookmark'                  => 'optional string',
       'sourceControlSystem'       => 'required '.$vcs_const,
       'sourceControlPath'         => 'required string',
       'sourceControlBaseRevision' => 'required string',
       'creationMethod'            => 'optional string',
       'arcanistProject'           => 'deprecated',
       'lintStatus'                => 'required '.$status_const,
       'unitStatus'                => 'required '.$status_const,
       'repositoryPHID'            => 'optional phid',
 
       'parentRevisionID'          => 'deprecated',
       'authorPHID'                => 'deprecated',
       'repositoryUUID'            => 'deprecated',
     );
   }
 
   protected function defineReturnType() {
     return 'nonempty dict';
   }
 
   protected function execute(ConduitAPIRequest $request) {
     $viewer = $request->getUser();
     $change_data = $request->getValue('changes');
 
     $changes = array();
     foreach ($change_data as $dict) {
       $changes[] = ArcanistDiffChange::newFromDictionary($dict);
     }
 
     $diff = DifferentialDiff::newFromRawChanges($viewer, $changes);
 
     // TODO: Remove repository UUID eventually; for now continue writing
     // the UUID. Note that we'll overwrite it below if we identify a
     // repository, and `arc` no longer sends it. This stuff is retained for
     // backward compatibility.
 
     $repository_uuid = $request->getValue('repositoryUUID');
     $repository_phid = $request->getValue('repositoryPHID');
     if ($repository_phid) {
       $repository = id(new PhabricatorRepositoryQuery())
         ->setViewer($viewer)
         ->withPHIDs(array($repository_phid))
         ->executeOne();
       if ($repository) {
         $repository_phid = $repository->getPHID();
         $repository_uuid = $repository->getUUID();
       }
     }
 
     switch ($request->getValue('lintStatus')) {
       case 'skip':
         $lint_status = DifferentialLintStatus::LINT_SKIP;
         break;
       case 'okay':
         $lint_status = DifferentialLintStatus::LINT_OKAY;
         break;
       case 'warn':
         $lint_status = DifferentialLintStatus::LINT_WARN;
         break;
       case 'fail':
         $lint_status = DifferentialLintStatus::LINT_FAIL;
         break;
       case 'postponed':
         $lint_status = DifferentialLintStatus::LINT_POSTPONED;
         break;
       case 'none':
       default:
         $lint_status = DifferentialLintStatus::LINT_NONE;
         break;
     }
 
     switch ($request->getValue('unitStatus')) {
       case 'skip':
         $unit_status = DifferentialUnitStatus::UNIT_SKIP;
         break;
       case 'okay':
         $unit_status = DifferentialUnitStatus::UNIT_OKAY;
         break;
       case 'warn':
         $unit_status = DifferentialUnitStatus::UNIT_WARN;
         break;
       case 'fail':
         $unit_status = DifferentialUnitStatus::UNIT_FAIL;
         break;
       case 'postponed':
         $unit_status = DifferentialUnitStatus::UNIT_POSTPONED;
         break;
       case 'none':
       default:
         $unit_status = DifferentialUnitStatus::UNIT_NONE;
         break;
     }
 
     $diff_data_dict = array(
       'sourcePath' => $request->getValue('sourcePath'),
       'sourceMachine' => $request->getValue('sourceMachine'),
       'branch' => $request->getValue('branch'),
       'creationMethod' => $request->getValue('creationMethod'),
       'authorPHID' => $viewer->getPHID(),
       'bookmark' => $request->getValue('bookmark'),
       'repositoryUUID' => $repository_uuid,
       'repositoryPHID' => $repository_phid,
       'sourceControlSystem' => $request->getValue('sourceControlSystem'),
       'sourceControlPath' => $request->getValue('sourceControlPath'),
       'sourceControlBaseRevision' =>
         $request->getValue('sourceControlBaseRevision'),
       'lintStatus' => $lint_status,
       'unitStatus' => $unit_status,
     );
 
     $xactions = array(id(new DifferentialTransaction())
       ->setTransactionType(DifferentialDiffTransaction::TYPE_DIFF_CREATE)
       ->setNewValue($diff_data_dict),
     );
 
     id(new DifferentialDiffEditor())
       ->setActor($viewer)
       ->setContentSourceFromConduitRequest($request)
       ->setContinueOnNoEffect(true)
       ->applyTransactions($diff, $xactions);
 
     $path = '/differential/diff/'.$diff->getID().'/';
     $uri = PhabricatorEnv::getURI($path);
 
     return array(
       'diffid' => $diff->getID(),
-      'uri'    => $uri,
+      'phid' => $diff->getPHID(),
+      'uri' => $uri,
     );
   }
 
 }
diff --git a/src/applications/harbormaster/conduit/HarbormasterSendMessageConduitAPIMethod.php b/src/applications/harbormaster/conduit/HarbormasterSendMessageConduitAPIMethod.php
index f6752f08fb..9590f90cec 100644
--- a/src/applications/harbormaster/conduit/HarbormasterSendMessageConduitAPIMethod.php
+++ b/src/applications/harbormaster/conduit/HarbormasterSendMessageConduitAPIMethod.php
@@ -1,59 +1,82 @@
 <?php
 
 final class HarbormasterSendMessageConduitAPIMethod
   extends HarbormasterConduitAPIMethod {
 
   public function getAPIMethodName() {
     return 'harbormaster.sendmessage';
   }
 
   public function getMethodDescription() {
     return pht(
       'Send a message to a build target, notifying it of results in an '.
       'external system.');
   }
 
   protected function defineParamTypes() {
     $type_const = $this->formatStringConstants(array('pass', 'fail'));
 
     return array(
       'buildTargetPHID' => 'required phid',
-      'type'            => 'required '.$type_const,
+      'lint' => 'optional list<wild>',
+      'unit' => 'optional list<wild>',
+      'type' => 'required '.$type_const,
     );
   }
 
   protected function defineReturnType() {
     return 'void';
   }
 
   protected function execute(ConduitAPIRequest $request) {
     $viewer = $request->getUser();
 
     $build_target_phid = $request->getValue('buildTargetPHID');
     $message_type = $request->getValue('type');
 
     $build_target = id(new HarbormasterBuildTargetQuery())
       ->setViewer($viewer)
       ->withPHIDs(array($build_target_phid))
       ->executeOne();
     if (!$build_target) {
       throw new Exception(pht('No such build target!'));
     }
 
-    $message = HarbormasterBuildMessage::initializeNewMessage($viewer)
+    $save = array();
+
+    $lint_messages = $request->getValue('lint', array());
+    foreach ($lint_messages as $lint) {
+      $save[] = HarbormasterBuildLintMessage::newFromDictionary(
+        $build_target,
+        $lint);
+    }
+
+    $unit_messages = $request->getValue('unit', array());
+    foreach ($unit_messages as $unit) {
+      $save[] = HarbormasterBuildUnitMessage::newFromDictionary(
+        $build_target,
+        $unit);
+    }
+
+    $save[] = HarbormasterBuildMessage::initializeNewMessage($viewer)
       ->setBuildTargetPHID($build_target->getPHID())
-      ->setType($message_type)
-      ->save();
+      ->setType($message_type);
+
+    $build_target->openTransaction();
+    foreach ($save as $object) {
+      $object->save();
+    }
+    $build_target->saveTransaction();
 
     // If the build has completely paused because all steps are blocked on
     // waiting targets, this will resume it.
     PhabricatorWorker::scheduleTask(
       'HarbormasterBuildWorker',
       array(
         'buildID' => $build_target->getBuild()->getID(),
       ));
 
     return null;
   }
 
 }
diff --git a/src/applications/harbormaster/controller/HarbormasterBuildableViewController.php b/src/applications/harbormaster/controller/HarbormasterBuildableViewController.php
index ecb7605657..8fa65d0350 100644
--- a/src/applications/harbormaster/controller/HarbormasterBuildableViewController.php
+++ b/src/applications/harbormaster/controller/HarbormasterBuildableViewController.php
@@ -1,254 +1,260 @@
 <?php
 
 final class HarbormasterBuildableViewController
   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;
 
     $buildable = id(new HarbormasterBuildableQuery())
       ->setViewer($viewer)
       ->withIDs(array($id))
       ->needBuildableHandles(true)
       ->needContainerHandles(true)
       ->executeOne();
     if (!$buildable) {
       return new Aphront404Response();
     }
 
     // Pull builds and build targets.
     $builds = id(new HarbormasterBuildQuery())
       ->setViewer($viewer)
       ->withBuildablePHIDs(array($buildable->getPHID()))
       ->needBuildTargets(true)
       ->execute();
 
     $buildable->attachBuilds($builds);
 
     $build_list = $this->buildBuildList($buildable);
 
     $title = pht('Buildable %d', $id);
 
     $header = id(new PHUIHeaderView())
       ->setHeader($title)
       ->setUser($viewer)
       ->setPolicyObject($buildable);
 
     $box = id(new PHUIObjectBoxView())
       ->setHeader($header);
 
     $timeline = $this->buildTransactionTimeline(
       $buildable,
       new HarbormasterBuildableTransactionQuery());
     $timeline->setShouldTerminate(true);
 
     $actions = $this->buildActionList($buildable);
     $this->buildPropertyLists($box, $buildable, $actions);
 
     $crumbs = $this->buildApplicationCrumbs();
     $crumbs->addTextCrumb("B{$id}");
 
     return $this->buildApplicationPage(
       array(
         $crumbs,
         $box,
         $build_list,
         $timeline,
       ),
       array(
         'title' => $title,
       ));
   }
 
   private function buildActionList(HarbormasterBuildable $buildable) {
     $request = $this->getRequest();
     $viewer = $request->getUser();
     $id = $buildable->getID();
 
     $list = id(new PhabricatorActionListView())
       ->setUser($viewer)
       ->setObject($buildable)
       ->setObjectURI($buildable->getMonogram());
 
     $can_edit = PhabricatorPolicyFilter::hasCapability(
       $viewer,
       $buildable,
       PhabricatorPolicyCapability::CAN_EDIT);
 
     $can_restart = false;
     $can_resume = false;
     $can_stop = false;
 
     foreach ($buildable->getBuilds() as $build) {
       if ($build->canRestartBuild()) {
         $can_restart = true;
       }
       if ($build->canResumeBuild()) {
         $can_resume = true;
       }
       if ($build->canStopBuild()) {
         $can_stop = true;
       }
     }
 
     $restart_uri = "buildable/{$id}/restart/";
     $stop_uri = "buildable/{$id}/stop/";
     $resume_uri = "buildable/{$id}/resume/";
 
     $list->addAction(
       id(new PhabricatorActionView())
         ->setIcon('fa-repeat')
         ->setName(pht('Restart All Builds'))
         ->setHref($this->getApplicationURI($restart_uri))
         ->setWorkflow(true)
         ->setDisabled(!$can_restart || !$can_edit));
 
     $list->addAction(
       id(new PhabricatorActionView())
         ->setIcon('fa-pause')
         ->setName(pht('Pause All Builds'))
         ->setHref($this->getApplicationURI($stop_uri))
         ->setWorkflow(true)
         ->setDisabled(!$can_stop || !$can_edit));
 
     $list->addAction(
       id(new PhabricatorActionView())
         ->setIcon('fa-play')
         ->setName(pht('Resume All Builds'))
         ->setHref($this->getApplicationURI($resume_uri))
         ->setWorkflow(true)
         ->setDisabled(!$can_resume || !$can_edit));
 
     return $list;
   }
 
   private function buildPropertyLists(
     PHUIObjectBoxView $box,
     HarbormasterBuildable $buildable,
     PhabricatorActionListView $actions) {
     $request = $this->getRequest();
     $viewer = $request->getUser();
 
     $properties = id(new PHUIPropertyListView())
       ->setUser($viewer)
       ->setObject($buildable)
       ->setActionList($actions);
     $box->addPropertyList($properties);
 
     $properties->addProperty(
       pht('Buildable'),
       $buildable->getBuildableHandle()->renderLink());
 
     if ($buildable->getContainerHandle() !== null) {
       $properties->addProperty(
         pht('Container'),
         $buildable->getContainerHandle()->renderLink());
     }
 
     $properties->addProperty(
       pht('Origin'),
       $buildable->getIsManualBuildable()
         ? pht('Manual Buildable')
         : pht('Automatic Buildable'));
 
   }
 
   private function buildBuildList(HarbormasterBuildable $buildable) {
     $viewer = $this->getRequest()->getUser();
 
     $build_list = id(new PHUIObjectItemListView())
       ->setUser($viewer);
     foreach ($buildable->getBuilds() as $build) {
       $view_uri = $this->getApplicationURI('/build/'.$build->getID().'/');
       $item = id(new PHUIObjectItemView())
         ->setObjectName(pht('Build %d', $build->getID()))
         ->setHeader($build->getName())
         ->setHref($view_uri);
 
       $status = $build->getBuildStatus();
       $item->setBarColor(HarbormasterBuild::getBuildStatusColor($status));
 
       $item->addAttribute(HarbormasterBuild::getBuildStatusName($status));
 
       if ($build->isRestarting()) {
         $item->addIcon('fa-repeat', pht('Restarting'));
       } else if ($build->isStopping()) {
         $item->addIcon('fa-pause', pht('Pausing'));
       } else if ($build->isResuming()) {
         $item->addIcon('fa-play', pht('Resuming'));
       }
 
       $build_id = $build->getID();
 
       $restart_uri = "build/restart/{$build_id}/buildable/";
       $resume_uri = "build/resume/{$build_id}/buildable/";
       $stop_uri = "build/stop/{$build_id}/buildable/";
 
       $item->addAction(
         id(new PHUIListItemView())
           ->setIcon('fa-repeat')
           ->setName(pht('Restart'))
           ->setHref($this->getApplicationURI($restart_uri))
           ->setWorkflow(true)
           ->setDisabled(!$build->canRestartBuild()));
 
       if ($build->canResumeBuild()) {
         $item->addAction(
           id(new PHUIListItemView())
             ->setIcon('fa-play')
             ->setName(pht('Resume'))
             ->setHref($this->getApplicationURI($resume_uri))
             ->setWorkflow(true));
       } else {
         $item->addAction(
           id(new PHUIListItemView())
             ->setIcon('fa-pause')
             ->setName(pht('Pause'))
             ->setHref($this->getApplicationURI($stop_uri))
             ->setWorkflow(true)
             ->setDisabled(!$build->canStopBuild()));
       }
 
       $targets = $build->getBuildTargets();
 
       if ($targets) {
         $target_list = id(new PHUIStatusListView());
         foreach ($targets as $target) {
           $status = $target->getTargetStatus();
           $icon = HarbormasterBuildTarget::getBuildTargetStatusIcon($status);
           $color = HarbormasterBuildTarget::getBuildTargetStatusColor($status);
           $status_name =
             HarbormasterBuildTarget::getBuildTargetStatusName($status);
 
           $name = $target->getName();
 
           $target_list->addItem(
             id(new PHUIStatusItemView())
               ->setIcon($icon, $color, $status_name)
               ->setTarget(pht('Target %d', $target->getID()))
               ->setNote($name));
         }
 
         $target_box = id(new PHUIBoxView())
           ->addPadding(PHUI::PADDING_SMALL)
           ->appendChild($target_list);
 
         $item->appendChild($target_box);
       }
 
       $build_list->addItem($item);
     }
 
-    return $build_list;
+    $build_list->setFlush(true);
+
+    $box = id(new PHUIObjectBoxView())
+      ->setHeaderText(pht('Builds'))
+      ->appendChild($build_list);
+
+    return $box;
   }
 
 }