diff --git a/src/applications/calendar/editor/PhabricatorCalendarEventEditEngine.php b/src/applications/calendar/editor/PhabricatorCalendarEventEditEngine.php
index c56cd7febb..5b31afbe1a 100644
--- a/src/applications/calendar/editor/PhabricatorCalendarEventEditEngine.php
+++ b/src/applications/calendar/editor/PhabricatorCalendarEventEditEngine.php
@@ -1,401 +1,409 @@
 <?php
 
 final class PhabricatorCalendarEventEditEngine
   extends PhabricatorEditEngine {
 
   const ENGINECONST = 'calendar.event';
 
   private $rawTransactions;
   private $seriesEditMode = self::MODE_THIS;
 
   const MODE_THIS = 'this';
   const MODE_FUTURE = 'future';
 
   public function setSeriesEditMode($series_edit_mode) {
     $this->seriesEditMode = $series_edit_mode;
     return $this;
   }
 
   public function getSeriesEditMode() {
     return $this->seriesEditMode;
   }
 
   public function getEngineName() {
     return pht('Calendar Events');
   }
 
   public function getSummaryHeader() {
     return pht('Configure Calendar Event Forms');
   }
 
   public function getSummaryText() {
     return pht('Configure how users create and edit events.');
   }
 
   public function getEngineApplicationClass() {
     return 'PhabricatorCalendarApplication';
   }
 
   protected function newEditableObject() {
     return PhabricatorCalendarEvent::initializeNewCalendarEvent(
       $this->getViewer());
   }
 
   protected function newObjectQuery() {
     return new PhabricatorCalendarEventQuery();
   }
 
   protected function getObjectCreateTitleText($object) {
     return pht('Create New Event');
   }
 
   protected function getObjectEditTitleText($object) {
     return pht('Edit Event: %s', $object->getName());
   }
 
   protected function getObjectEditShortText($object) {
     return $object->getMonogram();
   }
 
   protected function getObjectCreateShortText() {
     return pht('Create Event');
   }
 
   protected function getObjectName() {
     return pht('Event');
   }
 
   protected function getObjectViewURI($object) {
     return $object->getURI();
   }
 
   protected function getEditorURI() {
     return $this->getApplication()->getApplicationURI('event/edit/');
   }
 
   protected function buildCustomEditFields($object) {
     $viewer = $this->getViewer();
 
     if ($this->getIsCreate()) {
       $invitee_phids = array($viewer->getPHID());
     } else {
       $invitee_phids = $object->getInviteePHIDsForEdit();
     }
 
     $frequency_map = PhabricatorCalendarEvent::getFrequencyMap();
     $frequency_options = ipull($frequency_map, 'label');
 
     $rrule = $object->newRecurrenceRule();
     if ($rrule) {
       $frequency = $rrule->getFrequency();
     } else {
       $frequency = null;
     }
 
     // At least for now, just hide "Invitees" when editing all future events.
     // This may eventually deserve a more nuanced approach.
-    $hide_invitees = ($this->getSeriesEditMode() == self::MODE_FUTURE);
+    $is_future = ($this->getSeriesEditMode() == self::MODE_FUTURE);
 
     $fields = array(
       id(new PhabricatorTextEditField())
         ->setKey('name')
         ->setLabel(pht('Name'))
         ->setDescription(pht('Name of the event.'))
         ->setIsRequired(true)
         ->setTransactionType(
           PhabricatorCalendarEventNameTransaction::TRANSACTIONTYPE)
         ->setConduitDescription(pht('Rename the event.'))
         ->setConduitTypeDescription(pht('New event name.'))
         ->setValue($object->getName()),
       id(new PhabricatorBoolEditField())
         ->setKey('isAllDay')
         ->setOptions(pht('Normal Event'), pht('All Day Event'))
         ->setAsCheckbox(true)
         ->setTransactionType(
           PhabricatorCalendarEventAllDayTransaction::TRANSACTIONTYPE)
         ->setDescription(pht('Marks this as an all day event.'))
         ->setConduitDescription(pht('Make the event an all day event.'))
         ->setConduitTypeDescription(pht('Mark the event as an all day event.'))
         ->setValue($object->getIsAllDay()),
       id(new PhabricatorEpochEditField())
         ->setKey('start')
         ->setLabel(pht('Start'))
         ->setIsLockable(false)
         ->setIsDefaultable(false)
         ->setTransactionType(
           PhabricatorCalendarEventStartDateTransaction::TRANSACTIONTYPE)
         ->setDescription(pht('Start time of the event.'))
         ->setConduitDescription(pht('Change the start time of the event.'))
         ->setConduitTypeDescription(pht('New event start time.'))
         ->setValue($object->getStartDateTimeEpoch()),
       id(new PhabricatorEpochEditField())
         ->setKey('end')
         ->setLabel(pht('End'))
         ->setIsLockable(false)
         ->setIsDefaultable(false)
         ->setTransactionType(
           PhabricatorCalendarEventEndDateTransaction::TRANSACTIONTYPE)
         ->setDescription(pht('End time of the event.'))
         ->setConduitDescription(pht('Change the end time of the event.'))
         ->setConduitTypeDescription(pht('New event end time.'))
         ->setValue($object->newEndDateTimeForEdit()->getEpoch()),
       id(new PhabricatorBoolEditField())
         ->setKey('cancelled')
         ->setOptions(pht('Active'), pht('Cancelled'))
         ->setLabel(pht('Cancelled'))
         ->setDescription(pht('Cancel the event.'))
         ->setTransactionType(
           PhabricatorCalendarEventCancelTransaction::TRANSACTIONTYPE)
         ->setIsConduitOnly(true)
         ->setConduitDescription(pht('Cancel or restore the event.'))
         ->setConduitTypeDescription(pht('True to cancel the event.'))
         ->setValue($object->getIsCancelled()),
       id(new PhabricatorUsersEditField())
         ->setKey('hostPHID')
         ->setAliases(array('host'))
         ->setLabel(pht('Host'))
         ->setDescription(pht('Host of the event.'))
         ->setTransactionType(
           PhabricatorCalendarEventHostTransaction::TRANSACTIONTYPE)
         ->setIsConduitOnly($this->getIsCreate())
         ->setConduitDescription(pht('Change the host of the event.'))
         ->setConduitTypeDescription(pht('New event host.'))
         ->setSingleValue($object->getHostPHID()),
       id(new PhabricatorDatasourceEditField())
-        ->setIsHidden($hide_invitees)
+        ->setIsHidden($is_future)
         ->setKey('inviteePHIDs')
         ->setAliases(array('invite', 'invitee', 'invitees', 'inviteePHID'))
         ->setLabel(pht('Invitees'))
         ->setDatasource(new PhabricatorMetaMTAMailableDatasource())
         ->setTransactionType(
           PhabricatorCalendarEventInviteTransaction::TRANSACTIONTYPE)
         ->setDescription(pht('Users invited to the event.'))
         ->setConduitDescription(pht('Change invited users.'))
         ->setConduitTypeDescription(pht('New event invitees.'))
         ->setValue($invitee_phids)
         ->setCommentActionLabel(pht('Change Invitees')),
       id(new PhabricatorRemarkupEditField())
         ->setKey('description')
         ->setLabel(pht('Description'))
         ->setDescription(pht('Description of the event.'))
         ->setTransactionType(
           PhabricatorCalendarEventDescriptionTransaction::TRANSACTIONTYPE)
         ->setConduitDescription(pht('Update the event description.'))
         ->setConduitTypeDescription(pht('New event description.'))
         ->setValue($object->getDescription()),
       id(new PhabricatorIconSetEditField())
         ->setKey('icon')
         ->setLabel(pht('Icon'))
         ->setIconSet(new PhabricatorCalendarIconSet())
         ->setTransactionType(
           PhabricatorCalendarEventIconTransaction::TRANSACTIONTYPE)
         ->setDescription(pht('Event icon.'))
         ->setConduitDescription(pht('Change the event icon.'))
         ->setConduitTypeDescription(pht('New event icon.'))
         ->setValue($object->getIcon()),
+
+      // NOTE: We're being a little sneaky here. This field is hidden and
+      // always has the value "true", so it makes the event recurring when you
+      // submit a form which contains the field. Then we put the the field on
+      // the "recurring" page in the "Make Recurring" dialog to simplify the
+      // workflow. This is still normal, explicit field from the perspective
+      // of the API.
+
       id(new PhabricatorBoolEditField())
-        ->setIsHidden($object->getIsRecurring())
+        ->setIsHidden(true)
         ->setKey('isRecurring')
         ->setLabel(pht('Recurring'))
         ->setOptions(pht('One-Time Event'), pht('Recurring Event'))
         ->setTransactionType(
           PhabricatorCalendarEventRecurringTransaction::TRANSACTIONTYPE)
         ->setDescription(pht('One time or recurring event.'))
         ->setConduitDescription(pht('Make the event recurring.'))
         ->setConduitTypeDescription(pht('Mark the event as a recurring event.'))
-        ->setValue($object->getIsRecurring()),
+        ->setValue(true),
       id(new PhabricatorSelectEditField())
         ->setKey('frequency')
         ->setLabel(pht('Frequency'))
         ->setOptions($frequency_options)
         ->setTransactionType(
           PhabricatorCalendarEventFrequencyTransaction::TRANSACTIONTYPE)
         ->setDescription(pht('Recurring event frequency.'))
         ->setConduitDescription(pht('Change the event frequency.'))
         ->setConduitTypeDescription(pht('New event frequency.'))
         ->setValue($frequency),
       id(new PhabricatorEpochEditField())
         ->setIsLockable(false)
         ->setIsDefaultable(false)
         ->setAllowNull(true)
         ->setHideTime($object->getIsAllDay())
         ->setKey('until')
         ->setLabel(pht('Repeat Until'))
         ->setTransactionType(
           PhabricatorCalendarEventUntilDateTransaction::TRANSACTIONTYPE)
         ->setDescription(pht('Last instance of the event.'))
         ->setConduitDescription(pht('Change when the event repeats until.'))
         ->setConduitTypeDescription(pht('New final event time.'))
         ->setValue($object->getUntilDateTimeEpoch()),
     );
 
     return $fields;
   }
 
   protected function willBuildEditForm($object, array $fields) {
     $all_day_field = idx($fields, 'isAllDay');
     $start_field = idx($fields, 'start');
     $end_field = idx($fields, 'end');
 
     if ($all_day_field) {
       $is_all_day = $all_day_field->getValueForTransaction();
 
       $control_ids = array();
       if ($start_field) {
         $control_ids[] = $start_field->getControlID();
       }
       if ($end_field) {
         $control_ids[] = $end_field->getControlID();
       }
 
       Javelin::initBehavior(
         'event-all-day',
         array(
           'allDayID' => $all_day_field->getControlID(),
           'controlIDs' => $control_ids,
         ));
 
     } else {
       $is_all_day = $object->getIsAllDay();
     }
 
     if ($is_all_day) {
       if ($start_field) {
         $start_field->setHideTime(true);
       }
 
       if ($end_field) {
         $end_field->setHideTime(true);
       }
     }
 
     return $fields;
   }
 
   protected function newPages($object) {
     // Controls for event recurrence behavior go on a separate page which we
     // put in a dialog. This simplifies event creation in the common case.
 
     return array(
       id(new PhabricatorEditPage())
         ->setKey('core')
         ->setLabel(pht('Core'))
         ->setIsDefault(true),
       id(new PhabricatorEditPage())
         ->setKey('recurring')
         ->setLabel(pht('Recurrence'))
         ->setFieldKeys(
           array(
             'isRecurring',
             'frequency',
             'until',
           )),
     );
   }
 
   protected function willApplyTransactions($object, array $xactions) {
     $viewer = $this->getViewer();
-    $this->rawTransactions = $this->cloneTransactions($xactions);
 
     $is_parent = $object->isParentEvent();
     $is_child = $object->isChildEvent();
     $is_future = ($this->getSeriesEditMode() === self::MODE_FUTURE);
 
+    // Figure out which transactions we can apply to the whole series of events.
+    // Some transactions (like comments) can never be bulk applied.
+    $inherited_xactions = array();
+    foreach ($xactions as $xaction) {
+      $modular_type = $xaction->getModularType();
+      if (!($modular_type instanceof PhabricatorCalendarEventTransactionType)) {
+        continue;
+      }
+
+      $inherited_edit = $modular_type->isInheritedEdit();
+      if ($inherited_edit) {
+        $inherited_xactions[] = $xaction;
+      }
+    }
+    $this->rawTransactions = $this->cloneTransactions($inherited_xactions);
+
     $must_fork = ($is_child && $is_future) ||
                  ($is_parent && !$is_future);
 
+    // We don't need to fork when editing a parent event if none of the edits
+    // can transfer to child events. For example, commenting on a parent is
+    // fine.
     if ($is_parent && !$is_future) {
-      // We don't necessarily need to fork if whatever we're editing is not
-      // inherited by children. For example, we can add a comment to the parent
-      // event without needing to fork. Test all the stuff we're doing and see
-      // if anything is actually inherited.
-
-      $inherited_edit = false;
-      foreach ($xactions as $xaction) {
-        $modular_type = $xaction->getTransactionImplementation();
-        if ($modular_type instanceof PhabricatorCalendarEventTransactionType) {
-          $inherited_edit = $modular_type->isInheritedEdit();
-          if ($inherited_edit) {
-            break;
-          }
-        }
-      }
-
-      // Nothing the user is trying to do requires us to fork, so we can just
-      // apply the changes normally.
-      if (!$inherited_edit) {
+      if (!$inherited_xactions) {
         $must_fork = false;
       }
     }
 
     if ($must_fork) {
       $fork_target = $object->loadForkTarget($viewer);
       if ($fork_target) {
         $fork_xaction = id(new PhabricatorCalendarEventTransaction())
           ->setTransactionType(
             PhabricatorCalendarEventForkTransaction::TRANSACTIONTYPE)
           ->setNewValue(true);
 
         if ($fork_target->getPHID() == $object->getPHID()) {
           // We're forking the object itself, so just slip it into the
           // transactions we're going to apply.
           array_unshift($xactions, $fork_xaction);
         } else {
           // Otherwise, we're forking a different object, so we have to
           // apply that separately.
           $this->applyTransactions($fork_target, array($fork_xaction));
         }
       }
     }
 
     return $xactions;
   }
 
   protected function didApplyTransactions($object, array $xactions) {
     $viewer = $this->getViewer();
 
     if ($this->getSeriesEditMode() !== self::MODE_FUTURE) {
       return;
     }
 
     $targets = $object->loadFutureEvents($viewer);
     if (!$targets) {
       return;
     }
 
     foreach ($targets as $target) {
       $apply = $this->cloneTransactions($this->rawTransactions);
       $this->applyTransactions($target, $apply);
     }
   }
 
   private function applyTransactions($target, array $xactions) {
     $viewer = $this->getViewer();
 
     // TODO: This isn't the most accurate source we could use, but this mode
     // is web-only for now.
     $content_source = PhabricatorContentSource::newForSource(
       PhabricatorWebContentSource::SOURCECONST);
 
     $editor = id(new PhabricatorCalendarEventEditor())
       ->setActor($viewer)
       ->setContentSource($content_source)
       ->setContinueOnNoEffect(true)
       ->setContinueOnMissingFields(true);
 
     try {
       $editor->applyTransactions($target, $xactions);
     } catch (PhabricatorApplicationTransactionValidationException $ex) {
       // Just ignore any issues we run into.
     }
   }
 
   private function cloneTransactions(array $xactions) {
     $result = array();
     foreach ($xactions as $xaction) {
       $result[] = clone $xaction;
     }
     return $result;
   }
 
 }
diff --git a/src/applications/calendar/storage/PhabricatorCalendarEvent.php b/src/applications/calendar/storage/PhabricatorCalendarEvent.php
index 2863ee64e8..440e35f980 100644
--- a/src/applications/calendar/storage/PhabricatorCalendarEvent.php
+++ b/src/applications/calendar/storage/PhabricatorCalendarEvent.php
@@ -1,1361 +1,1365 @@
 <?php
 
 final class PhabricatorCalendarEvent extends PhabricatorCalendarDAO
   implements
     PhabricatorPolicyInterface,
     PhabricatorExtendedPolicyInterface,
     PhabricatorProjectInterface,
     PhabricatorMarkupInterface,
     PhabricatorApplicationTransactionInterface,
     PhabricatorSubscribableInterface,
     PhabricatorTokenReceiverInterface,
     PhabricatorDestructibleInterface,
     PhabricatorMentionableInterface,
     PhabricatorFlaggableInterface,
     PhabricatorSpacesInterface,
     PhabricatorFulltextInterface,
     PhabricatorConduitResultInterface {
 
   protected $name;
   protected $hostPHID;
   protected $description;
   protected $isCancelled;
   protected $isAllDay;
   protected $icon;
   protected $mailKey;
   protected $isStub;
 
   protected $isRecurring = 0;
 
   protected $seriesParentPHID;
   protected $instanceOfEventPHID;
   protected $sequenceIndex;
 
   protected $viewPolicy;
   protected $editPolicy;
 
   protected $spacePHID;
 
   protected $utcInitialEpoch;
   protected $utcUntilEpoch;
   protected $utcInstanceEpoch;
   protected $parameters = array();
 
   protected $importAuthorPHID;
   protected $importSourcePHID;
   protected $importUIDIndex;
   protected $importUID;
 
   private $parentEvent = self::ATTACHABLE;
   private $invitees = self::ATTACHABLE;
   private $importSource = self::ATTACHABLE;
 
   private $viewerTimezone;
 
   private $isGhostEvent = false;
   private $stubInvitees;
 
   public static function initializeNewCalendarEvent(PhabricatorUser $actor) {
     $app = id(new PhabricatorApplicationQuery())
       ->setViewer($actor)
       ->withClasses(array('PhabricatorCalendarApplication'))
       ->executeOne();
 
     $view_default = PhabricatorCalendarEventDefaultViewCapability::CAPABILITY;
     $edit_default = PhabricatorCalendarEventDefaultEditCapability::CAPABILITY;
     $view_policy = $app->getPolicy($view_default);
     $edit_policy = $app->getPolicy($edit_default);
 
     $now = PhabricatorTime::getNow();
 
     $default_icon = 'fa-calendar';
 
     $datetime_defaults = self::newDefaultEventDateTimes(
       $actor,
       $now);
     list($datetime_start, $datetime_end) = $datetime_defaults;
 
     return id(new PhabricatorCalendarEvent())
       ->setDescription('')
       ->setHostPHID($actor->getPHID())
       ->setIsCancelled(0)
       ->setIsAllDay(0)
       ->setIsStub(0)
       ->setIsRecurring(0)
       ->setIcon($default_icon)
       ->setViewPolicy($view_policy)
       ->setEditPolicy($edit_policy)
       ->setSpacePHID($actor->getDefaultSpacePHID())
       ->attachInvitees(array())
       ->setStartDateTime($datetime_start)
       ->setEndDateTime($datetime_end)
       ->attachImportSource(null)
       ->applyViewerTimezone($actor);
   }
 
   public static function newDefaultEventDateTimes(
     PhabricatorUser $viewer,
     $now) {
 
     $datetime_start = PhutilCalendarAbsoluteDateTime::newFromEpoch(
       $now,
       $viewer->getTimezoneIdentifier());
 
     // Advance the time by an hour, then round downwards to the nearest hour.
     // For example, if it is currently 3:25 PM, we suggest a default start time
     // of 4 PM.
     $datetime_start = $datetime_start
       ->newRelativeDateTime('PT1H')
       ->newAbsoluteDateTime();
     $datetime_start->setMinute(0);
     $datetime_start->setSecond(0);
 
     // Default the end time to an hour after the start time.
     $datetime_end = $datetime_start
       ->newRelativeDateTime('PT1H')
       ->newAbsoluteDateTime();
 
     return array($datetime_start, $datetime_end);
   }
 
   private function newChild(
     PhabricatorUser $actor,
     $sequence,
     PhutilCalendarDateTime $start = null) {
     if (!$this->isParentEvent()) {
       throw new Exception(
         pht(
           'Unable to generate a new child event for an event which is not '.
           'a recurring parent event!'));
     }
 
     $series_phid = $this->getSeriesParentPHID();
     if (!$series_phid) {
       $series_phid = $this->getPHID();
     }
 
     $child = id(new self())
       ->setIsCancelled(0)
       ->setIsStub(0)
       ->setInstanceOfEventPHID($this->getPHID())
       ->setSeriesParentPHID($series_phid)
       ->setSequenceIndex($sequence)
       ->setIsRecurring(true)
       ->attachParentEvent($this)
       ->attachImportSource(null);
 
     return $child->copyFromParent($actor, $start);
   }
 
   protected function readField($field) {
     static $inherit = array(
       'hostPHID' => true,
       'isAllDay' => true,
       'icon' => true,
       'spacePHID' => true,
       'viewPolicy' => true,
       'editPolicy' => true,
       'name' => true,
       'description' => true,
       'isCancelled' => true,
     );
 
     // Read these fields from the parent event instead of this event. For
     // example, we want any changes to the parent event's name to apply to
     // the child.
     if (isset($inherit[$field])) {
       if ($this->getIsStub()) {
         // TODO: This should be unconditional, but the execution order of
         // CalendarEventQuery and applyViewerTimezone() are currently odd.
         if ($this->parentEvent !== self::ATTACHABLE) {
           return $this->getParentEvent()->readField($field);
         }
       }
     }
 
     return parent::readField($field);
   }
 
 
   public function copyFromParent(
     PhabricatorUser $actor,
     PhutilCalendarDateTime $start = null) {
 
     if (!$this->isChildEvent()) {
       throw new Exception(
         pht(
           'Unable to copy from parent event: this is not a child event.'));
     }
 
     $parent = $this->getParentEvent();
 
     $this
       ->setHostPHID($parent->getHostPHID())
       ->setIsAllDay($parent->getIsAllDay())
       ->setIcon($parent->getIcon())
       ->setSpacePHID($parent->getSpacePHID())
       ->setViewPolicy($parent->getViewPolicy())
       ->setEditPolicy($parent->getEditPolicy())
       ->setName($parent->getName())
       ->setDescription($parent->getDescription())
       ->setIsCancelled($parent->getIsCancelled());
 
     if ($start) {
       $start_datetime = $start;
     } else {
       $sequence = $this->getSequenceIndex();
       $start_datetime = $parent->newSequenceIndexDateTime($sequence);
 
       if (!$start_datetime) {
         throw new Exception(
           pht(
             'Sequence "%s" is not valid for event!',
             $sequence));
       }
     }
 
     $duration = $parent->newDuration();
     $end_datetime = $start_datetime->newRelativeDateTime($duration);
 
     $this
       ->setStartDateTime($start_datetime)
       ->setEndDateTime($end_datetime);
 
     if ($parent->isImportedEvent()) {
       $full_uid = $parent->getImportUID().'/'.$start_datetime->getEpoch();
 
       // NOTE: We don't attach the import source because this gets called
       // from CalendarEventQuery while building ghosts, before we've loaded
       // and attached sources. Possibly this sequence should be flipped.
 
       $this
         ->setImportAuthorPHID($parent->getImportAuthorPHID())
         ->setImportSourcePHID($parent->getImportSourcePHID())
         ->setImportUID($full_uid);
     }
 
     return $this;
   }
 
   public function isValidSequenceIndex(PhabricatorUser $viewer, $sequence) {
     return (bool)$this->newSequenceIndexDateTime($sequence);
   }
 
   public function newSequenceIndexDateTime($sequence) {
     $set = $this->newRecurrenceSet();
     if (!$set) {
       return null;
     }
 
     $limit = $sequence + 1;
     $count = $this->getRecurrenceCount();
     if ($count && ($count < $limit)) {
       return null;
     }
 
     $instances = $set->getEventsBetween(
       null,
       $this->newUntilDateTime(),
       $limit);
 
     return idx($instances, $sequence, null);
   }
 
   public function newStub(PhabricatorUser $actor, $sequence) {
     $stub = $this->newChild($actor, $sequence);
 
     $stub->setIsStub(1);
 
     $unguarded = AphrontWriteGuard::beginScopedUnguardedWrites();
       $stub->save();
     unset($unguarded);
 
     $stub->applyViewerTimezone($actor);
 
     return $stub;
   }
 
   public function newGhost(
     PhabricatorUser $actor,
     $sequence,
     PhutilCalendarDateTime $start = null) {
 
     $ghost = $this->newChild($actor, $sequence, $start);
 
     $ghost
       ->setIsGhostEvent(true)
       ->makeEphemeral();
 
     $ghost->applyViewerTimezone($actor);
 
     return $ghost;
   }
 
   public function applyViewerTimezone(PhabricatorUser $viewer) {
     $this->viewerTimezone = $viewer->getTimezoneIdentifier();
     return $this;
   }
 
   public function getDuration() {
     return ($this->getEndDateTimeEpoch() - $this->getStartDateTimeEpoch());
   }
 
   public function updateUTCEpochs() {
     // The "intitial" epoch is the start time of the event, in UTC.
     $start_date = $this->newStartDateTime()
       ->setViewerTimezone('UTC');
     $start_epoch = $start_date->getEpoch();
     $this->setUTCInitialEpoch($start_epoch);
 
     // The "until" epoch is the last UTC epoch on which any instance of this
     // event occurs. For infinitely recurring events, it is `null`.
 
     if (!$this->getIsRecurring()) {
       $end_date = $this->newEndDateTime()
         ->setViewerTimezone('UTC');
       $until_epoch = $end_date->getEpoch();
     } else {
       $until_epoch = null;
       $until_date = $this->newUntilDateTime();
       if ($until_date) {
         $until_date->setViewerTimezone('UTC');
         $duration = $this->newDuration();
         $until_epoch = id(new PhutilCalendarRelativeDateTime())
           ->setOrigin($until_date)
           ->setDuration($duration)
           ->getEpoch();
       }
     }
     $this->setUTCUntilEpoch($until_epoch);
 
     // The "instance" epoch is a property of instances of recurring events.
     // It's the original UTC epoch on which the instance started. Usually that
     // is the same as the start date, but they may be different if the instance
     // has been edited.
 
     // The ICS format uses this value (original start time) to identify event
     // instances, and must do so because it allows additional arbitrary
     // instances to be added (with "RDATE").
 
     $instance_epoch = null;
     $instance_date = $this->newInstanceDateTime();
     if ($instance_date) {
       $instance_epoch = $instance_date
         ->setViewerTimezone('UTC')
         ->getEpoch();
     }
     $this->setUTCInstanceEpoch($instance_epoch);
 
     return $this;
   }
 
   public function save() {
     if (!$this->mailKey) {
       $this->mailKey = Filesystem::readRandomCharacters(20);
     }
 
     $import_uid = $this->getImportUID();
     if ($import_uid !== null) {
       $index = PhabricatorHash::digestForIndex($import_uid);
     } else {
       $index = null;
     }
     $this->setImportUIDIndex($index);
 
     $this->updateUTCEpochs();
 
     return parent::save();
   }
 
   /**
    * Get the event start epoch for evaluating invitee availability.
    *
    * When assessing availability, we pretend events start earlier than they
    * really do. This allows us to mark users away for the entire duration of a
    * series of back-to-back meetings, even if they don't strictly overlap.
    *
    * @return int Event start date for availability caches.
    */
   public function getStartDateTimeEpochForCache() {
     $epoch = $this->getStartDateTimeEpoch();
     $window = phutil_units('15 minutes in seconds');
     return ($epoch - $window);
   }
 
   protected function getConfiguration() {
     return array(
       self::CONFIG_AUX_PHID => true,
       self::CONFIG_COLUMN_SCHEMA => array(
         'name' => 'text',
         'description' => 'text',
         'isCancelled' => 'bool',
         'isAllDay' => 'bool',
         'icon' => 'text32',
         'mailKey' => 'bytes20',
         'isRecurring' => 'bool',
         'seriesParentPHID' => 'phid?',
         'instanceOfEventPHID' => 'phid?',
         'sequenceIndex' => 'uint32?',
         'isStub' => 'bool',
         'utcInitialEpoch' => 'epoch',
         'utcUntilEpoch' => 'epoch?',
         'utcInstanceEpoch' => 'epoch?',
 
         'importAuthorPHID' => 'phid?',
         'importSourcePHID' => 'phid?',
         'importUIDIndex' => 'bytes12?',
         'importUID' => 'text?',
       ),
       self::CONFIG_KEY_SCHEMA => array(
         'key_instance' => array(
           'columns' => array('instanceOfEventPHID', 'sequenceIndex'),
           'unique' => true,
         ),
         'key_epoch' => array(
           'columns' => array('utcInitialEpoch', 'utcUntilEpoch'),
         ),
         'key_rdate' => array(
           'columns' => array('instanceOfEventPHID', 'utcInstanceEpoch'),
           'unique' => true,
         ),
         'key_series' => array(
           'columns' => array('seriesParentPHID', 'utcInitialEpoch'),
         ),
       ),
       self::CONFIG_SERIALIZATION => array(
         'parameters' => self::SERIALIZATION_JSON,
       ),
     ) + parent::getConfiguration();
   }
 
   public function generatePHID() {
     return PhabricatorPHID::generateNewPHID(
       PhabricatorCalendarEventPHIDType::TYPECONST);
   }
 
   public function getMonogram() {
     return 'E'.$this->getID();
   }
 
   public function getInvitees() {
     if ($this->getIsGhostEvent() || $this->getIsStub()) {
       if ($this->stubInvitees === null) {
         $this->stubInvitees = $this->newStubInvitees();
       }
       return $this->stubInvitees;
     }
 
     return $this->assertAttached($this->invitees);
   }
 
   public static function getFrequencyMap() {
     return array(
       PhutilCalendarRecurrenceRule::FREQUENCY_DAILY => array(
         'label' => pht('Daily'),
       ),
       PhutilCalendarRecurrenceRule::FREQUENCY_WEEKLY => array(
         'label' => pht('Weekly'),
       ),
       PhutilCalendarRecurrenceRule::FREQUENCY_MONTHLY => array(
         'label' => pht('Monthly'),
       ),
       PhutilCalendarRecurrenceRule::FREQUENCY_YEARLY => array(
         'label' => pht('Yearly'),
       ),
     );
   }
 
   private function newStubInvitees() {
     $parent = $this->getParentEvent();
 
     $parent_invitees = $parent->getInvitees();
     $stub_invitees = array();
 
     foreach ($parent_invitees as $invitee) {
       $stub_invitee = id(new PhabricatorCalendarEventInvitee())
         ->setInviteePHID($invitee->getInviteePHID())
         ->setInviterPHID($invitee->getInviterPHID())
         ->setStatus(PhabricatorCalendarEventInvitee::STATUS_INVITED);
 
       $stub_invitees[] = $stub_invitee;
     }
 
     return $stub_invitees;
   }
 
   public function attachInvitees(array $invitees) {
     $this->invitees = $invitees;
     return $this;
   }
 
   public function getInviteePHIDsForEdit() {
     $invitees = array();
 
     foreach ($this->getInvitees() as $invitee) {
       if ($invitee->isUninvited()) {
         continue;
       }
       $invitees[] = $invitee->getInviteePHID();
     }
 
     return $invitees;
   }
 
   public function getUserInviteStatus($phid) {
     $invitees = $this->getInvitees();
     $invitees = mpull($invitees, null, 'getInviteePHID');
 
     $invited = idx($invitees, $phid);
     if (!$invited) {
       return PhabricatorCalendarEventInvitee::STATUS_UNINVITED;
     }
 
     $invited = $invited->getStatus();
     return $invited;
   }
 
   public function getIsUserAttending($phid) {
     $attending_status = PhabricatorCalendarEventInvitee::STATUS_ATTENDING;
 
     $old_status = $this->getUserInviteStatus($phid);
     $is_attending = ($old_status == $attending_status);
 
     return $is_attending;
   }
 
   public function getIsUserInvited($phid) {
     $uninvited_status = PhabricatorCalendarEventInvitee::STATUS_UNINVITED;
     $declined_status = PhabricatorCalendarEventInvitee::STATUS_DECLINED;
     $status = $this->getUserInviteStatus($phid);
     if ($status == $uninvited_status || $status == $declined_status) {
       return false;
     }
     return true;
   }
 
   public function getIsGhostEvent() {
     return $this->isGhostEvent;
   }
 
   public function setIsGhostEvent($is_ghost_event) {
     $this->isGhostEvent = $is_ghost_event;
     return $this;
   }
 
   public function getURI() {
     if ($this->getIsGhostEvent()) {
       $base = $this->getParentEvent()->getURI();
       $sequence = $this->getSequenceIndex();
       return "{$base}/{$sequence}/";
     }
 
     return '/'.$this->getMonogram();
   }
 
   public function getParentEvent() {
     return $this->assertAttached($this->parentEvent);
   }
 
   public function attachParentEvent(PhabricatorCalendarEvent $event = null) {
     $this->parentEvent = $event;
     return $this;
   }
 
   public function isParentEvent() {
     return ($this->getIsRecurring() && !$this->getInstanceOfEventPHID());
   }
 
   public function isChildEvent() {
     return ($this->instanceOfEventPHID !== null);
   }
 
   public function renderEventDate(
     PhabricatorUser $viewer,
     $show_end) {
 
     $start = $this->newStartDateTime();
     $end = $this->newEndDateTime();
 
     if ($show_end) {
       $min_date = $start->newPHPDateTime();
       $max_date = $end->newPHPDateTime();
 
       $min_day = $min_date->format('Y m d');
       $max_day = $max_date->format('Y m d');
 
       $show_end_date = ($min_day != $max_day);
     } else {
       $show_end_date = false;
     }
 
     $min_epoch = $start->getEpoch();
     $max_epoch = $end->getEpoch();
 
     if ($this->getIsAllDay()) {
       if ($show_end_date) {
         return pht(
           '%s - %s, All Day',
           phabricator_date($min_epoch, $viewer),
           phabricator_date($max_epoch, $viewer));
       } else {
         return pht(
           '%s, All Day',
           phabricator_date($min_epoch, $viewer));
       }
     } else if ($show_end_date) {
       return pht(
         '%s - %s',
         phabricator_datetime($min_epoch, $viewer),
         phabricator_datetime($max_epoch, $viewer));
     } else if ($show_end) {
       return pht(
         '%s - %s',
         phabricator_datetime($min_epoch, $viewer),
         phabricator_time($max_epoch, $viewer));
     } else {
       return pht(
         '%s',
         phabricator_datetime($min_epoch, $viewer));
     }
   }
 
 
   public function getDisplayIcon(PhabricatorUser $viewer) {
     if ($this->getIsCancelled()) {
       return 'fa-times';
     }
 
     if ($viewer->isLoggedIn()) {
       $status = $this->getUserInviteStatus($viewer->getPHID());
       switch ($status) {
         case PhabricatorCalendarEventInvitee::STATUS_ATTENDING:
           return 'fa-check-circle';
         case PhabricatorCalendarEventInvitee::STATUS_INVITED:
           return 'fa-user-plus';
         case PhabricatorCalendarEventInvitee::STATUS_DECLINED:
           return 'fa-times';
       }
     }
 
     if ($this->isImportedEvent()) {
       return 'fa-download';
     }
 
     return $this->getIcon();
   }
 
   public function getDisplayIconColor(PhabricatorUser $viewer) {
     if ($this->getIsCancelled()) {
       return 'red';
     }
 
     if ($this->isImportedEvent()) {
       return 'orange';
     }
 
     if ($viewer->isLoggedIn()) {
       $status = $this->getUserInviteStatus($viewer->getPHID());
       switch ($status) {
         case PhabricatorCalendarEventInvitee::STATUS_ATTENDING:
           return 'green';
         case PhabricatorCalendarEventInvitee::STATUS_INVITED:
           return 'green';
         case PhabricatorCalendarEventInvitee::STATUS_DECLINED:
           return 'grey';
       }
     }
 
     return 'bluegrey';
   }
 
   public function getDisplayIconLabel(PhabricatorUser $viewer) {
     if ($this->getIsCancelled()) {
       return pht('Cancelled');
     }
 
     if ($viewer->isLoggedIn()) {
       $status = $this->getUserInviteStatus($viewer->getPHID());
       switch ($status) {
         case PhabricatorCalendarEventInvitee::STATUS_ATTENDING:
           return pht('Attending');
         case PhabricatorCalendarEventInvitee::STATUS_INVITED:
           return pht('Invited');
         case PhabricatorCalendarEventInvitee::STATUS_DECLINED:
           return pht('Declined');
       }
     }
 
     return null;
   }
 
   public function getICSFilename() {
     return $this->getMonogram().'.ics';
   }
 
   public function newIntermediateEventNode(
     PhabricatorUser $viewer,
     array $children) {
 
     $base_uri = new PhutilURI(PhabricatorEnv::getProductionURI('/'));
     $domain = $base_uri->getDomain();
 
     // NOTE: For recurring events, all of the events in the series have the
     // same UID (the UID of the parent). The child event instances are
     // differentiated by the "RECURRENCE-ID" field.
     if ($this->isChildEvent()) {
       $parent = $this->getParentEvent();
       $instance_datetime = PhutilCalendarAbsoluteDateTime::newFromEpoch(
         $this->getUTCInstanceEpoch());
       $recurrence_id = $instance_datetime->getISO8601();
       $rrule = null;
     } else {
       $parent = $this;
       $recurrence_id = null;
       $rrule = $this->newRecurrenceRule();
     }
     $uid = $parent->getPHID().'@'.$domain;
 
     $created = $this->getDateCreated();
     $created = PhutilCalendarAbsoluteDateTime::newFromEpoch($created);
 
     $modified = $this->getDateModified();
     $modified = PhutilCalendarAbsoluteDateTime::newFromEpoch($modified);
 
     $date_start = $this->newStartDateTime();
     $date_end = $this->newEndDateTime();
 
     if ($this->getIsAllDay()) {
       $date_start->setIsAllDay(true);
       $date_end->setIsAllDay(true);
     }
 
     $host_phid = $this->getHostPHID();
 
     $invitees = $this->getInvitees();
     foreach ($invitees as $key => $invitee) {
       if ($invitee->isUninvited()) {
         unset($invitees[$key]);
       }
     }
 
     $phids = array();
     $phids[] = $host_phid;
     foreach ($invitees as $invitee) {
       $phids[] = $invitee->getInviteePHID();
     }
 
     $handles = $viewer->loadHandles($phids);
 
     $host_handle = $handles[$host_phid];
     $host_name = $host_handle->getFullName();
 
     // NOTE: Gmail shows "Who: Unknown Organizer*" if the organizer URI does
     // not look like an email address. Use a synthetic address so it shows
     // the host name instead.
     $install_uri = PhabricatorEnv::getProductionURI('/');
     $install_uri = new PhutilURI($install_uri);
 
     // This should possibly use "metamta.reply-handler-domain" instead, but
     // we do not currently accept mail for users anyway, and that option may
     // not be configured.
     $mail_domain = $install_uri->getDomain();
     $host_uri = "mailto:{$host_phid}@{$mail_domain}";
 
     $organizer = id(new PhutilCalendarUserNode())
       ->setName($host_name)
       ->setURI($host_uri);
 
     $attendees = array();
     foreach ($invitees as $invitee) {
       $invitee_phid = $invitee->getInviteePHID();
       $invitee_handle = $handles[$invitee_phid];
       $invitee_name = $invitee_handle->getFullName();
       $invitee_uri = $invitee_handle->getURI();
       $invitee_uri = PhabricatorEnv::getURI($invitee_uri);
 
       switch ($invitee->getStatus()) {
         case PhabricatorCalendarEventInvitee::STATUS_ATTENDING:
           $status = PhutilCalendarUserNode::STATUS_ACCEPTED;
           break;
         case PhabricatorCalendarEventInvitee::STATUS_DECLINED:
           $status = PhutilCalendarUserNode::STATUS_DECLINED;
           break;
         case PhabricatorCalendarEventInvitee::STATUS_INVITED:
         default:
           $status = PhutilCalendarUserNode::STATUS_INVITED;
           break;
       }
 
       $attendees[] = id(new PhutilCalendarUserNode())
         ->setName($invitee_name)
         ->setURI($invitee_uri)
         ->setStatus($status);
     }
 
     // TODO: Use $children to generate EXDATE/RDATE information.
 
     $node = id(new PhutilCalendarEventNode())
       ->setUID($uid)
       ->setName($this->getName())
       ->setDescription($this->getDescription())
       ->setCreatedDateTime($created)
       ->setModifiedDateTime($modified)
       ->setStartDateTime($date_start)
       ->setEndDateTime($date_end)
       ->setOrganizer($organizer)
       ->setAttendees($attendees);
 
     if ($rrule) {
       $node->setRecurrenceRule($rrule);
     }
 
     if ($recurrence_id) {
       $node->setRecurrenceID($recurrence_id);
     }
 
     return $node;
   }
 
   public function newStartDateTime() {
     $datetime = $this->getParameter('startDateTime');
     return $this->newDateTimeFromDictionary($datetime);
   }
 
   public function getStartDateTimeEpoch() {
     return $this->newStartDateTime()->getEpoch();
   }
 
   public function newEndDateTimeForEdit() {
     $datetime = $this->getParameter('endDateTime');
     return $this->newDateTimeFromDictionary($datetime);
   }
 
   public function newEndDateTime() {
     $datetime = $this->newEndDateTimeForEdit();
 
     // If this is an all day event, we move the end date time forward to the
     // first second of the following day. This is consistent with what users
     // expect: an all day event from "Nov 1" to "Nov 1" lasts the entire day.
     if ($this->getIsAllDay()) {
       $datetime = $datetime
         ->newAbsoluteDateTime()
         ->setHour(0)
         ->setMinute(0)
         ->setSecond(0)
         ->newRelativeDateTime('P1D')
         ->newAbsoluteDateTime();
     }
 
     return $datetime;
   }
 
   public function getEndDateTimeEpoch() {
     return $this->newEndDateTime()->getEpoch();
   }
 
   public function newUntilDateTime() {
     $datetime = $this->getParameter('untilDateTime');
     if ($datetime) {
       return $this->newDateTimeFromDictionary($datetime);
     }
 
     return null;
   }
 
   public function getUntilDateTimeEpoch() {
     $datetime = $this->newUntilDateTime();
 
     if (!$datetime) {
       return null;
     }
 
     return $datetime->getEpoch();
   }
 
   public function newDuration() {
     return id(new PhutilCalendarDuration())
       ->setSeconds($this->getDuration());
   }
 
   public function newInstanceDateTime() {
     if (!$this->getIsRecurring()) {
       return null;
     }
 
     $index = $this->getSequenceIndex();
     if (!$index) {
       return null;
     }
 
     return $this->newSequenceIndexDateTime($index);
   }
 
   private function newDateTimeFromEpoch($epoch) {
     $datetime = PhutilCalendarAbsoluteDateTime::newFromEpoch($epoch);
 
     if ($this->getIsAllDay()) {
       $datetime->setIsAllDay(true);
     }
 
     return $this->newDateTimeFromDateTime($datetime);
   }
 
   private function newDateTimeFromDictionary(array $dict) {
     $datetime = PhutilCalendarAbsoluteDateTime::newFromDictionary($dict);
     return $this->newDateTimeFromDateTime($datetime);
   }
 
   private function newDateTimeFromDateTime(PhutilCalendarDateTime $datetime) {
     $viewer_timezone = $this->viewerTimezone;
     if ($viewer_timezone) {
       $datetime->setViewerTimezone($viewer_timezone);
     }
 
     return $datetime;
   }
 
   public function getParameter($key, $default = null) {
     return idx($this->parameters, $key, $default);
   }
 
   public function setParameter($key, $value) {
     $this->parameters[$key] = $value;
     return $this;
   }
 
   public function setStartDateTime(PhutilCalendarDateTime $datetime) {
     return $this->setParameter(
       'startDateTime',
       $datetime->newAbsoluteDateTime()->toDictionary());
   }
 
   public function setEndDateTime(PhutilCalendarDateTime $datetime) {
     return $this->setParameter(
       'endDateTime',
       $datetime->newAbsoluteDateTime()->toDictionary());
   }
 
-  public function setUntilDateTime(PhutilCalendarDateTime $datetime) {
-    return $this->setParameter(
-      'untilDateTime',
-      $datetime->newAbsoluteDateTime()->toDictionary());
+  public function setUntilDateTime(PhutilCalendarDateTime $datetime = null) {
+    if ($datetime) {
+      $value = $datetime->newAbsoluteDateTime()->toDictionary();
+    } else {
+      $value = null;
+    }
+
+    return $this->setParameter('untilDateTime', $value);
   }
 
   public function setRecurrenceRule(PhutilCalendarRecurrenceRule $rrule) {
     return $this->setParameter(
       'recurrenceRule',
       $rrule->toDictionary());
   }
 
   public function newRecurrenceRule() {
     if ($this->isChildEvent()) {
       return $this->getParentEvent()->newRecurrenceRule();
     }
 
     if (!$this->getIsRecurring()) {
       return null;
     }
 
     $dict = $this->getParameter('recurrenceRule');
     if (!$dict) {
       return null;
     }
 
     $rrule = PhutilCalendarRecurrenceRule::newFromDictionary($dict);
 
     $start = $this->newStartDateTime();
     $rrule->setStartDateTime($start);
 
     $until = $this->newUntilDateTime();
     if ($until) {
       $rrule->setUntil($until);
     }
 
     $count = $this->getRecurrenceCount();
     if ($count) {
       $rrule->setCount($count);
     }
 
     return $rrule;
   }
 
   public function getRecurrenceCount() {
     $count = (int)$this->getParameter('recurrenceCount');
 
     if (!$count) {
       return null;
     }
 
     return $count;
   }
 
   public function newRecurrenceSet() {
     if ($this->isChildEvent()) {
       return $this->getParentEvent()->newRecurrenceSet();
     }
 
     $set = new PhutilCalendarRecurrenceSet();
 
     $rrule = $this->newRecurrenceRule();
     if (!$rrule) {
       return null;
     }
 
     $set->addSource($rrule);
 
     return $set;
   }
 
   public function isImportedEvent() {
     return (bool)$this->getImportSourcePHID();
   }
 
   public function getImportSource() {
     return $this->assertAttached($this->importSource);
   }
 
   public function attachImportSource(
     PhabricatorCalendarImport $import = null) {
     $this->importSource = $import;
     return $this;
   }
 
   public function loadForkTarget(PhabricatorUser $viewer) {
     if (!$this->getIsRecurring()) {
       // Can't fork an event which isn't recurring.
       return null;
     }
 
     if ($this->isChildEvent()) {
       // If this is a child event, this is the fork target.
       return $this;
     }
 
     if (!$this->isValidSequenceIndex($viewer, 1)) {
       // This appears to be a "recurring" event with no valid instances: for
       // example, its "until" date is before the second instance would occur.
       // This can happen if we already forked the event or if users entered
       // silly stuff. Just edit the event directly without forking anything.
       return null;
     }
 
 
     $next_event = id(new PhabricatorCalendarEventQuery())
       ->setViewer($viewer)
       ->withInstanceSequencePairs(
         array(
           array($this->getPHID(), 1),
         ))
       ->requireCapabilities(
         array(
           PhabricatorPolicyCapability::CAN_VIEW,
           PhabricatorPolicyCapability::CAN_EDIT,
         ))
       ->executeOne();
 
     if (!$next_event) {
       $next_event = $this->newStub($viewer, 1);
     }
 
     return $next_event;
   }
 
   public function loadFutureEvents(PhabricatorUser $viewer) {
     // NOTE: If you can't edit some of the future events, we just
     // don't try to update them. This seems like it's probably what
     // users are likely to expect.
 
     // NOTE: This only affects events that are currently in the same
     // series, not all events that were ever in the original series.
     // We could use series PHIDs instead of parent PHIDs to affect more
     // events if this turns out to be counterintuitive. Other
     // applications differ in their behavior.
 
     return id(new PhabricatorCalendarEventQuery())
       ->setViewer($viewer)
       ->withParentEventPHIDs(array($this->getPHID()))
       ->withUTCInitialEpochBetween($this->getUTCInitialEpoch(), null)
       ->requireCapabilities(
         array(
           PhabricatorPolicyCapability::CAN_VIEW,
           PhabricatorPolicyCapability::CAN_EDIT,
         ))
       ->execute();
   }
 
   public function getNotificationPHIDs() {
     $phids = array();
     if ($this->getPHID()) {
       $phids[] = $this->getPHID();
     }
 
     if ($this->getSeriesParentPHID()) {
       $phids[] = $this->getSeriesParentPHID();
     }
 
     return $phids;
   }
 
 
 /* -(  Markup Interface  )--------------------------------------------------- */
 
 
   /**
    * @task markup
    */
   public function getMarkupFieldKey($field) {
     $hash = PhabricatorHash::digest($this->getMarkupText($field));
     $id = $this->getID();
     return "calendar:T{$id}:{$field}:{$hash}";
   }
 
 
   /**
    * @task markup
    */
   public function getMarkupText($field) {
     return $this->getDescription();
   }
 
 
   /**
    * @task markup
    */
   public function newMarkupEngine($field) {
     return PhabricatorMarkupEngine::newCalendarMarkupEngine();
   }
 
 
   /**
    * @task markup
    */
   public function didMarkupText(
     $field,
     $output,
     PhutilMarkupEngine $engine) {
     return $output;
   }
 
 
   /**
    * @task markup
    */
   public function shouldUseMarkupCache($field) {
     return (bool)$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:
         if ($this->getImportSource()) {
           return PhabricatorPolicies::POLICY_NOONE;
         } else {
           return $this->getEditPolicy();
         }
     }
   }
 
   public function hasAutomaticCapability($capability, PhabricatorUser $viewer) {
     if ($this->getImportSource()) {
       return false;
     }
 
     // The host of an event can always view and edit it.
     $user_phid = $this->getHostPHID();
     if ($user_phid) {
       $viewer_phid = $viewer->getPHID();
       if ($viewer_phid == $user_phid) {
         return true;
       }
     }
 
     if ($capability == PhabricatorPolicyCapability::CAN_VIEW) {
       $status = $this->getUserInviteStatus($viewer->getPHID());
       if ($status == PhabricatorCalendarEventInvitee::STATUS_INVITED ||
         $status == PhabricatorCalendarEventInvitee::STATUS_ATTENDING ||
         $status == PhabricatorCalendarEventInvitee::STATUS_DECLINED) {
         return true;
       }
     }
 
     return false;
   }
 
   public function describeAutomaticCapability($capability) {
     if ($this->getImportSource()) {
       return pht(
         'Events imported from external sources can not be edited in '.
         'Phabricator.');
     }
 
     return pht(
       'The host of an event can always view and edit it. Users who are '.
       'invited to an event can always view it.');
   }
 
 
 /* -(  PhabricatorExtendedPolicyInterface  )--------------------------------- */
 
 
   public function getExtendedPolicy($capability, PhabricatorUser $viewer) {
     $extended = array();
 
     switch ($capability) {
       case PhabricatorPolicyCapability::CAN_VIEW:
         $import_source = $this->getImportSource();
         if ($import_source) {
           $extended[] = array(
             $import_source,
             PhabricatorPolicyCapability::CAN_VIEW,
           );
         }
         break;
     }
 
     return $extended;
   }
 
 
 /* -(  PhabricatorApplicationTransactionInterface  )------------------------- */
 
 
   public function getApplicationTransactionEditor() {
     return new PhabricatorCalendarEventEditor();
   }
 
   public function getApplicationTransactionObject() {
     return $this;
   }
 
   public function getApplicationTransactionTemplate() {
     return new PhabricatorCalendarEventTransaction();
   }
 
   public function willRenderTimeline(
     PhabricatorApplicationTransactionView $timeline,
     AphrontRequest $request) {
 
     return $timeline;
   }
 
 /* -(  PhabricatorSubscribableInterface  )----------------------------------- */
 
 
   public function isAutomaticallySubscribed($phid) {
     return ($phid == $this->getHostPHID());
   }
 
 /* -(  PhabricatorTokenReceiverInterface  )---------------------------------- */
 
 
   public function getUsersToNotifyOfTokenGiven() {
     return array($this->getHostPHID());
   }
 
 /* -(  PhabricatorDestructibleInterface  )----------------------------------- */
 
 
   public function destroyObjectPermanently(
     PhabricatorDestructionEngine $engine) {
 
     $this->openTransaction();
     $this->delete();
     $this->saveTransaction();
   }
 
 /* -(  PhabricatorSpacesInterface  )----------------------------------------- */
 
 
   public function getSpacePHID() {
     return $this->spacePHID;
   }
 
 
 /* -(  PhabricatorFulltextInterface  )--------------------------------------- */
 
 
   public function newFulltextEngine() {
     return new PhabricatorCalendarEventFulltextEngine();
   }
 
 
 /* -(  PhabricatorConduitResultInterface  )---------------------------------- */
 
 
   public function getFieldSpecificationsForConduit() {
     return array(
       id(new PhabricatorConduitSearchFieldSpecification())
         ->setKey('name')
         ->setType('string')
         ->setDescription(pht('The name of the event.')),
       id(new PhabricatorConduitSearchFieldSpecification())
         ->setKey('description')
         ->setType('string')
         ->setDescription(pht('The event description.')),
       id(new PhabricatorConduitSearchFieldSpecification())
         ->setKey('isAllDay')
         ->setType('bool')
         ->setDescription(pht('True if the event is an all day event.')),
       id(new PhabricatorConduitSearchFieldSpecification())
         ->setKey('startDateTime')
         ->setType('datetime')
         ->setDescription(pht('Start date and time of the event.')),
       id(new PhabricatorConduitSearchFieldSpecification())
         ->setKey('endDateTime')
         ->setType('datetime')
         ->setDescription(pht('End date and time of the event.')),
     );
   }
 
   public function getFieldValuesForConduit() {
     $start_datetime = $this->newStartDateTime();
     $end_datetime = $this->newEndDateTime();
 
     return array(
       'name' => $this->getName(),
       'description' => $this->getDescription(),
       'isAllDay' => (bool)$this->getIsAllDay(),
       'startDateTime' => $this->getConduitDateTime($start_datetime),
       'endDateTime' => $this->getConduitDateTime($end_datetime),
     );
   }
 
   public function getConduitSearchAttachments() {
     return array();
   }
 
   private function getConduitDateTime($datetime) {
     if (!$datetime) {
       return null;
     }
 
     $epoch = $datetime->getEpoch();
 
     // TODO: Possibly pass the actual viewer in from the Conduit stuff, or
     // retain it when setting the viewer timezone?
     $viewer = id(new PhabricatorUser())
       ->overrideTimezoneIdentifier($this->viewerTimezone);
 
     return array(
       'epoch' => (int)$epoch,
       'display' => array(
         'default' => phabricator_datetime($epoch, $viewer),
       ),
       'iso8601' => $datetime->getISO8601(),
       'timezone' => $this->viewerTimezone,
     );
   }
 
 }
diff --git a/src/applications/calendar/xaction/PhabricatorCalendarEventDateTransaction.php b/src/applications/calendar/xaction/PhabricatorCalendarEventDateTransaction.php
index cc2cb59da9..253609a99e 100644
--- a/src/applications/calendar/xaction/PhabricatorCalendarEventDateTransaction.php
+++ b/src/applications/calendar/xaction/PhabricatorCalendarEventDateTransaction.php
@@ -1,31 +1,40 @@
 <?php
 
 abstract class PhabricatorCalendarEventDateTransaction
   extends PhabricatorCalendarEventTransactionType {
 
   abstract protected function getInvalidDateMessage();
 
+  public function isInheritedEdit() {
+    return false;
+  }
+
   public function generateNewValue($object, $value) {
     $editor = $this->getEditor();
+
+    if ($value->isDisabled()) {
+      return null;
+    }
+
     return $value->newPhutilDateTime()
       ->setIsAllDay($editor->getNewIsAllDay())
       ->newAbsoluteDateTime()
       ->toDictionary();
   }
 
   public function validateTransactions($object, array $xactions) {
     $errors = array();
 
     foreach ($xactions as $xaction) {
       if ($xaction->getNewValue()->isValid()) {
         continue;
       }
 
       $message = $this->getInvalidDateMessage();
       $errors[] = $this->newInvalidError($message, $xaction);
     }
 
     return $errors;
   }
 
 }
diff --git a/src/applications/calendar/xaction/PhabricatorCalendarEventIconTransaction.php b/src/applications/calendar/xaction/PhabricatorCalendarEventIconTransaction.php
index d69cf20859..44daa13811 100644
--- a/src/applications/calendar/xaction/PhabricatorCalendarEventIconTransaction.php
+++ b/src/applications/calendar/xaction/PhabricatorCalendarEventIconTransaction.php
@@ -1,44 +1,52 @@
 <?php
 
 final class PhabricatorCalendarEventIconTransaction
   extends PhabricatorCalendarEventTransactionType {
 
   const TRANSACTIONTYPE = 'calendar.icon';
 
   public function generateOldValue($object) {
     return $object->getIcon();
   }
 
   public function applyInternalEffects($object, $value) {
     $object->setIcon($value);
   }
 
+  public function shouldHide() {
+    if ($this->isCreateTransaction()) {
+      return true;
+    }
+
+    return false;
+  }
+
   public function getTitle() {
     $old = $this->getIconLabel($this->getOldValue());
     $new = $this->getIconLabel($this->getNewValue());
 
     return pht(
       '%s changed the event icon from %s to %s.',
       $this->renderAuthor(),
       $this->renderValue($old),
       $this->renderValue($new));
   }
 
   public function getTitleForFeed() {
     $old = $this->getIconLabel($this->getOldValue());
     $new = $this->getIconLabel($this->getNewValue());
 
     return pht(
       '%s changed the icon for %s from %s to %s.',
       $this->renderAuthor(),
       $this->renderObject(),
       $this->renderValue($old),
       $this->renderValue($new));
   }
 
   private function getIconLabel($icon) {
     $set = new PhabricatorCalendarIconSet();
     return $set->getIconLabel($icon);
   }
 
 }
diff --git a/src/applications/calendar/xaction/PhabricatorCalendarEventRecurringTransaction.php b/src/applications/calendar/xaction/PhabricatorCalendarEventRecurringTransaction.php
index 05f312ddc4..9e4904085f 100644
--- a/src/applications/calendar/xaction/PhabricatorCalendarEventRecurringTransaction.php
+++ b/src/applications/calendar/xaction/PhabricatorCalendarEventRecurringTransaction.php
@@ -1,47 +1,58 @@
 <?php
 
 final class PhabricatorCalendarEventRecurringTransaction
   extends PhabricatorCalendarEventTransactionType {
 
   const TRANSACTIONTYPE = 'calendar.recurring';
 
   public function generateOldValue($object) {
     return (int)$object->getIsRecurring();
   }
 
   public function generateNewValue($object, $value) {
     return (int)$value;
   }
 
+  public function isInheritedEdit() {
+    return false;
+  }
+
+  public function shouldHide() {
+    // This event isn't interesting on its own, and is accompanied by an
+    // "alice set this event to repeat weekly." event in normal circumstances
+    // anyway.
+    return true;
+  }
+
   public function applyInternalEffects($object, $value) {
     $object->setIsRecurring($value);
   }
 
   public function validateTransactions($object, array $xactions) {
     $errors = array();
 
     $old = $object->getIsRecurring();
     foreach ($xactions as $xaction) {
       if ($this->isNewObject()) {
         continue;
       }
 
       if ($xaction->getNewValue() == $old) {
         continue;
       }
 
       if ($xaction->getNewValue()) {
         continue;
       }
 
       $errors[] = $this->newInvalidError(
         pht(
           'An event can not be stopped from recurring once it has been '.
           'made recurring. You can cancel the event.'),
         $xaction);
     }
 
     return $errors;
   }
 
 }
diff --git a/src/applications/calendar/xaction/PhabricatorCalendarEventUntilDateTransaction.php b/src/applications/calendar/xaction/PhabricatorCalendarEventUntilDateTransaction.php
index f3d7bf5595..3d0649eab8 100644
--- a/src/applications/calendar/xaction/PhabricatorCalendarEventUntilDateTransaction.php
+++ b/src/applications/calendar/xaction/PhabricatorCalendarEventUntilDateTransaction.php
@@ -1,51 +1,67 @@
 <?php
 
 final class PhabricatorCalendarEventUntilDateTransaction
   extends PhabricatorCalendarEventDateTransaction {
 
   const TRANSACTIONTYPE = 'calendar.recurrenceenddate';
 
   public function generateOldValue($object) {
     $editor = $this->getEditor();
 
     $until = $object->newUntilDateTime();
     if (!$until) {
       return null;
     }
 
     return $until
       ->newAbsoluteDateTime()
       ->setIsAllDay($editor->getOldIsAllDay())
       ->toDictionary();
   }
 
   public function applyInternalEffects($object, $value) {
     $actor = $this->getActor();
     $editor = $this->getEditor();
 
-    $datetime = PhutilCalendarAbsoluteDateTime::newFromDictionary($value);
-    $datetime->setIsAllDay($editor->getNewIsAllDay());
-
-    $object->setUntilDateTime($datetime);
+    if ($value) {
+      $datetime = PhutilCalendarAbsoluteDateTime::newFromDictionary($value);
+      $datetime->setIsAllDay($editor->getNewIsAllDay());
+      $object->setUntilDateTime($datetime);
+    } else {
+      $object->setUntilDateTime(null);
+    }
   }
 
   public function getTitle() {
-    return pht(
-      '%s changed this event to repeat until %s.',
-      $this->renderAuthor(),
-      $this->renderNewDate());
+    if ($this->getNewValue()) {
+      return pht(
+        '%s changed this event to repeat until %s.',
+        $this->renderAuthor(),
+        $this->renderNewDate());
+    } else {
+      return pht(
+        '%s changed this event to repeat forever.',
+        $this->renderAuthor());
+    }
   }
 
   public function getTitleForFeed() {
-    return pht(
-      '%s changed %s to repeat until %s.',
-      $this->renderAuthor(),
-      $this->renderObject(),
-      $this->renderNewDate());
+    if ($this->getNewValue()) {
+      return pht(
+        '%s changed %s to repeat until %s.',
+        $this->renderAuthor(),
+        $this->renderObject(),
+        $this->renderNewDate());
+    } else {
+      return pht(
+        '%s changed %s to repeat forever.',
+        $this->renderAuthor(),
+        $this->renderObject());
+    }
   }
 
   protected function getInvalidDateMessage() {
     return pht('Repeat until date is invalid.');
   }
 
 }
diff --git a/src/applications/transactions/storage/PhabricatorApplicationTransaction.php b/src/applications/transactions/storage/PhabricatorApplicationTransaction.php
index cd0557dafe..cc583d34c2 100644
--- a/src/applications/transactions/storage/PhabricatorApplicationTransaction.php
+++ b/src/applications/transactions/storage/PhabricatorApplicationTransaction.php
@@ -1,1647 +1,1662 @@
 <?php
 
 abstract class PhabricatorApplicationTransaction
   extends PhabricatorLiskDAO
   implements
     PhabricatorPolicyInterface,
     PhabricatorDestructibleInterface {
 
   const TARGET_TEXT = 'text';
   const TARGET_HTML = 'html';
 
   protected $phid;
   protected $objectPHID;
   protected $authorPHID;
   protected $viewPolicy;
   protected $editPolicy;
 
   protected $commentPHID;
   protected $commentVersion = 0;
   protected $transactionType;
   protected $oldValue;
   protected $newValue;
   protected $metadata = array();
 
   protected $contentSource;
 
   private $comment;
   private $commentNotLoaded;
 
   private $handles;
   private $renderingTarget = self::TARGET_HTML;
   private $transactionGroup = array();
   private $viewer = self::ATTACHABLE;
   private $object = self::ATTACHABLE;
   private $oldValueHasBeenSet = false;
 
   private $ignoreOnNoEffect;
 
 
   /**
    * Flag this transaction as a pure side-effect which should be ignored when
    * applying transactions if it has no effect, even if transaction application
    * would normally fail. This both provides users with better error messages
    * and allows transactions to perform optional side effects.
    */
   public function setIgnoreOnNoEffect($ignore) {
     $this->ignoreOnNoEffect = $ignore;
     return $this;
   }
 
   public function getIgnoreOnNoEffect() {
     return $this->ignoreOnNoEffect;
   }
 
   public function shouldGenerateOldValue() {
     switch ($this->getTransactionType()) {
       case PhabricatorTransactions::TYPE_BUILDABLE:
       case PhabricatorTransactions::TYPE_TOKEN:
       case PhabricatorTransactions::TYPE_CUSTOMFIELD:
       case PhabricatorTransactions::TYPE_INLINESTATE:
         return false;
     }
     return true;
   }
 
   abstract public function getApplicationTransactionType();
 
   private function getApplicationObjectTypeName() {
     $types = PhabricatorPHIDType::getAllTypes();
 
     $type = idx($types, $this->getApplicationTransactionType());
     if ($type) {
       return $type->getTypeName();
     }
 
     return pht('Object');
   }
 
   public function getApplicationTransactionCommentObject() {
     throw new PhutilMethodNotImplementedException();
   }
 
   public function getApplicationTransactionViewObject() {
     return new PhabricatorApplicationTransactionView();
   }
 
   public function getMetadataValue($key, $default = null) {
     return idx($this->metadata, $key, $default);
   }
 
   public function setMetadataValue($key, $value) {
     $this->metadata[$key] = $value;
     return $this;
   }
 
   public function generatePHID() {
     $type = PhabricatorApplicationTransactionTransactionPHIDType::TYPECONST;
     $subtype = $this->getApplicationTransactionType();
 
     return PhabricatorPHID::generateNewPHID($type, $subtype);
   }
 
   protected function getConfiguration() {
     return array(
       self::CONFIG_AUX_PHID => true,
       self::CONFIG_SERIALIZATION => array(
         'oldValue' => self::SERIALIZATION_JSON,
         'newValue' => self::SERIALIZATION_JSON,
         'metadata' => self::SERIALIZATION_JSON,
       ),
       self::CONFIG_COLUMN_SCHEMA => array(
         'commentPHID' => 'phid?',
         'commentVersion' => 'uint32',
         'contentSource' => 'text',
         'transactionType' => 'text32',
       ),
       self::CONFIG_KEY_SCHEMA => array(
         'key_object' => array(
           'columns' => array('objectPHID'),
         ),
       ),
     ) + parent::getConfiguration();
   }
 
   public function setContentSource(PhabricatorContentSource $content_source) {
     $this->contentSource = $content_source->serialize();
     return $this;
   }
 
   public function getContentSource() {
     return PhabricatorContentSource::newFromSerialized($this->contentSource);
   }
 
   public function hasComment() {
     return $this->getComment() && strlen($this->getComment()->getContent());
   }
 
   public function getComment() {
     if ($this->commentNotLoaded) {
       throw new Exception(pht('Comment for this transaction was not loaded.'));
     }
     return $this->comment;
   }
 
   public function setIsCreateTransaction($create) {
     return $this->setMetadataValue('core.create', $create);
   }
 
   public function getIsCreateTransaction() {
     return (bool)$this->getMetadataValue('core.create', false);
   }
 
   public function setIsDefaultTransaction($default) {
     return $this->setMetadataValue('core.default', $default);
   }
 
   public function getIsDefaultTransaction() {
     return (bool)$this->getMetadataValue('core.default', false);
   }
 
   public function attachComment(
     PhabricatorApplicationTransactionComment $comment) {
     $this->comment = $comment;
     $this->commentNotLoaded = false;
     return $this;
   }
 
   public function setCommentNotLoaded($not_loaded) {
     $this->commentNotLoaded = $not_loaded;
     return $this;
   }
 
   public function attachObject($object) {
     $this->object = $object;
     return $this;
   }
 
   public function getObject() {
     return $this->assertAttached($this->object);
   }
 
   public function getRemarkupChanges() {
     $changes = $this->newRemarkupChanges();
     assert_instances_of($changes, 'PhabricatorTransactionRemarkupChange');
 
     // Convert older-style remarkup blocks into newer-style remarkup changes.
     // This builds changes that do not have the correct "old value", so rules
     // that operate differently against edits (like @user mentions) won't work
     // properly.
     foreach ($this->getRemarkupBlocks() as $block) {
       $changes[] = $this->newRemarkupChange()
         ->setOldValue(null)
         ->setNewValue($block);
     }
 
     $comment = $this->getComment();
     if ($comment) {
       if ($comment->hasOldComment()) {
         $old_value = $comment->getOldComment()->getContent();
       } else {
         $old_value = null;
       }
 
       $new_value = $comment->getContent();
 
       $changes[] = $this->newRemarkupChange()
         ->setOldValue($old_value)
         ->setNewValue($new_value);
     }
 
     return $changes;
   }
 
   protected function newRemarkupChanges() {
     return array();
   }
 
   protected function newRemarkupChange() {
     return id(new PhabricatorTransactionRemarkupChange())
       ->setTransaction($this);
   }
 
   /**
    * @deprecated
    */
   public function getRemarkupBlocks() {
     $blocks = array();
 
     switch ($this->getTransactionType()) {
       case PhabricatorTransactions::TYPE_CUSTOMFIELD:
         $field = $this->getTransactionCustomField();
         if ($field) {
           $custom_blocks = $field->getApplicationTransactionRemarkupBlocks(
             $this);
           foreach ($custom_blocks as $custom_block) {
             $blocks[] = $custom_block;
           }
         }
         break;
     }
 
     return $blocks;
   }
 
   public function setOldValue($value) {
     $this->oldValueHasBeenSet = true;
     $this->writeField('oldValue', $value);
     return $this;
   }
 
   public function hasOldValue() {
     return $this->oldValueHasBeenSet;
   }
 
 
 /* -(  Rendering  )---------------------------------------------------------- */
 
   public function setRenderingTarget($rendering_target) {
     $this->renderingTarget = $rendering_target;
     return $this;
   }
 
   public function getRenderingTarget() {
     return $this->renderingTarget;
   }
 
   public function attachViewer(PhabricatorUser $viewer) {
     $this->viewer = $viewer;
     return $this;
   }
 
   public function getViewer() {
     return $this->assertAttached($this->viewer);
   }
 
   public function getRequiredHandlePHIDs() {
     $phids = array();
 
     $old = $this->getOldValue();
     $new = $this->getNewValue();
 
     $phids[] = array($this->getAuthorPHID());
     $phids[] = array($this->getObjectPHID());
     switch ($this->getTransactionType()) {
       case PhabricatorTransactions::TYPE_CUSTOMFIELD:
         $field = $this->getTransactionCustomField();
         if ($field) {
           $phids[] = $field->getApplicationTransactionRequiredHandlePHIDs(
             $this);
         }
         break;
       case PhabricatorTransactions::TYPE_SUBSCRIBERS:
         $phids[] = $old;
         $phids[] = $new;
         break;
       case PhabricatorTransactions::TYPE_EDGE:
         $phids[] = ipull($old, 'dst');
         $phids[] = ipull($new, 'dst');
         break;
       case PhabricatorTransactions::TYPE_COLUMNS:
         foreach ($new as $move) {
           $phids[] = array(
             $move['columnPHID'],
             $move['boardPHID'],
           );
           $phids[] = $move['fromColumnPHIDs'];
         }
         break;
       case PhabricatorTransactions::TYPE_EDIT_POLICY:
       case PhabricatorTransactions::TYPE_VIEW_POLICY:
       case PhabricatorTransactions::TYPE_JOIN_POLICY:
         if (!PhabricatorPolicyQuery::isSpecialPolicy($old)) {
           $phids[] = array($old);
         }
         if (!PhabricatorPolicyQuery::isSpecialPolicy($new)) {
           $phids[] = array($new);
         }
         break;
       case PhabricatorTransactions::TYPE_SPACE:
         if ($old) {
           $phids[] = array($old);
         }
         if ($new) {
           $phids[] = array($new);
         }
         break;
       case PhabricatorTransactions::TYPE_TOKEN:
         break;
       case PhabricatorTransactions::TYPE_BUILDABLE:
         $phid = $this->getMetadataValue('harbormaster:buildablePHID');
         if ($phid) {
           $phids[] = array($phid);
         }
         break;
     }
 
     if ($this->getComment()) {
       $phids[] = array($this->getComment()->getAuthorPHID());
     }
 
     return array_mergev($phids);
   }
 
   public function setHandles(array $handles) {
     $this->handles = $handles;
     return $this;
   }
 
   public function getHandle($phid) {
     if (empty($this->handles[$phid])) {
       throw new Exception(
         pht(
           'Transaction ("%s", of type "%s") requires a handle ("%s") that it '.
           'did not load.',
           $this->getPHID(),
           $this->getTransactionType(),
           $phid));
     }
     return $this->handles[$phid];
   }
 
   public function getHandleIfExists($phid) {
     return idx($this->handles, $phid);
   }
 
   public function getHandles() {
     if ($this->handles === null) {
       throw new Exception(
         pht('Transaction requires handles and it did not load them.'));
     }
     return $this->handles;
   }
 
   public function renderHandleLink($phid) {
     if ($this->renderingTarget == self::TARGET_HTML) {
       return $this->getHandle($phid)->renderLink();
     } else {
       return $this->getHandle($phid)->getLinkName();
     }
   }
 
   public function renderHandleList(array $phids) {
     $links = array();
     foreach ($phids as $phid) {
       $links[] = $this->renderHandleLink($phid);
     }
     if ($this->renderingTarget == self::TARGET_HTML) {
       return phutil_implode_html(', ', $links);
     } else {
       return implode(', ', $links);
     }
   }
 
   private function renderSubscriberList(array $phids, $change_type) {
     if ($this->getRenderingTarget() == self::TARGET_TEXT) {
       return $this->renderHandleList($phids);
     } else {
       $handles = array_select_keys($this->getHandles(), $phids);
       return id(new SubscriptionListStringBuilder())
         ->setHandles($handles)
         ->setObjectPHID($this->getPHID())
         ->buildTransactionString($change_type);
     }
   }
 
   protected function renderPolicyName($phid, $state = 'old') {
     $policy = PhabricatorPolicy::newFromPolicyAndHandle(
       $phid,
       $this->getHandleIfExists($phid));
     if ($this->renderingTarget == self::TARGET_HTML) {
       switch ($policy->getType()) {
         case PhabricatorPolicyType::TYPE_CUSTOM:
           $policy->setHref('/transactions/'.$state.'/'.$this->getPHID().'/');
           $policy->setWorkflow(true);
           break;
         default:
           break;
       }
       $output = $policy->renderDescription();
     } else {
       $output = hsprintf('%s', $policy->getFullName());
     }
     return $output;
   }
 
   public function getIcon() {
     switch ($this->getTransactionType()) {
       case PhabricatorTransactions::TYPE_COMMENT:
         $comment = $this->getComment();
         if ($comment && $comment->getIsRemoved()) {
           return 'fa-trash';
         }
         return 'fa-comment';
       case PhabricatorTransactions::TYPE_SUBSCRIBERS:
         $old = $this->getOldValue();
         $new = $this->getNewValue();
         $add = array_diff($new, $old);
         $rem = array_diff($old, $new);
         if ($add && $rem) {
           return 'fa-user';
         } else if ($add) {
           return 'fa-user-plus';
         } else if ($rem) {
           return 'fa-user-times';
         } else {
           return 'fa-user';
         }
       case PhabricatorTransactions::TYPE_VIEW_POLICY:
       case PhabricatorTransactions::TYPE_EDIT_POLICY:
       case PhabricatorTransactions::TYPE_JOIN_POLICY:
         return 'fa-lock';
       case PhabricatorTransactions::TYPE_EDGE:
         return 'fa-link';
       case PhabricatorTransactions::TYPE_BUILDABLE:
         return 'fa-wrench';
       case PhabricatorTransactions::TYPE_TOKEN:
         return 'fa-trophy';
       case PhabricatorTransactions::TYPE_SPACE:
         return 'fa-th-large';
       case PhabricatorTransactions::TYPE_COLUMNS:
         return 'fa-columns';
     }
 
     return 'fa-pencil';
   }
 
   public function getToken() {
     switch ($this->getTransactionType()) {
       case PhabricatorTransactions::TYPE_TOKEN:
         $old = $this->getOldValue();
         $new = $this->getNewValue();
         if ($new) {
           $icon = substr($new, 10);
         } else {
           $icon = substr($old, 10);
         }
         return array($icon, !$this->getNewValue());
     }
 
     return array(null, null);
   }
 
   public function getColor() {
     switch ($this->getTransactionType()) {
       case PhabricatorTransactions::TYPE_COMMENT;
         $comment = $this->getComment();
         if ($comment && $comment->getIsRemoved()) {
           return 'black';
         }
         break;
       case PhabricatorTransactions::TYPE_BUILDABLE:
         switch ($this->getNewValue()) {
           case HarbormasterBuildable::STATUS_PASSED:
             return 'green';
           case HarbormasterBuildable::STATUS_FAILED:
             return 'red';
         }
         break;
     }
     return null;
   }
 
   protected function getTransactionCustomField() {
     switch ($this->getTransactionType()) {
       case PhabricatorTransactions::TYPE_CUSTOMFIELD:
         $key = $this->getMetadataValue('customfield:key');
         if (!$key) {
           return null;
         }
 
         $object = $this->getObject();
 
         if (!($object instanceof PhabricatorCustomFieldInterface)) {
           return null;
         }
 
         $field = PhabricatorCustomField::getObjectField(
           $object,
           PhabricatorCustomField::ROLE_APPLICATIONTRANSACTIONS,
           $key);
         if (!$field) {
           return null;
         }
 
         $field->setViewer($this->getViewer());
         return $field;
     }
 
     return null;
   }
 
   public function shouldHide() {
     // Never hide comments.
     if ($this->hasComment()) {
       return false;
     }
 
     // Hide creation transactions if the old value is empty. These are
     // transactions like "alice set the task tile to: ...", which are
     // essentially never interesting.
     if ($this->getIsCreateTransaction()) {
       switch ($this->getTransactionType()) {
         case PhabricatorTransactions::TYPE_CREATE:
         case PhabricatorTransactions::TYPE_VIEW_POLICY:
         case PhabricatorTransactions::TYPE_EDIT_POLICY:
         case PhabricatorTransactions::TYPE_JOIN_POLICY:
         case PhabricatorTransactions::TYPE_SPACE:
           break;
         default:
           $old = $this->getOldValue();
 
           if (is_array($old) && !$old) {
             return true;
           }
 
           if (!is_array($old)) {
             if (!strlen($old)) {
               return true;
             }
 
             // The integer 0 is also uninteresting by default; this is often
             // an "off" flag for something like "All Day Event".
             if ($old === 0) {
               return true;
             }
           }
 
           break;
       }
     }
 
     // Hide creation transactions setting values to defaults, even if
     // the old value is not empty. For example, tasks may have a global
     // default view policy of "All Users", but a particular form sets the
     // policy to "Administrators". The transaction corresponding to this
     // change is not interesting, since it is the default behavior of the
     // form.
 
     if ($this->getIsCreateTransaction()) {
       if ($this->getIsDefaultTransaction()) {
         return true;
       }
     }
 
     switch ($this->getTransactionType()) {
       case PhabricatorTransactions::TYPE_VIEW_POLICY:
       case PhabricatorTransactions::TYPE_EDIT_POLICY:
       case PhabricatorTransactions::TYPE_JOIN_POLICY:
       case PhabricatorTransactions::TYPE_SPACE:
         if ($this->getIsCreateTransaction()) {
           break;
         }
 
         // TODO: Remove this eventually, this is handling old changes during
         // object creation prior to the introduction of "create" and "default"
         // transaction display flags.
 
         // NOTE: We can also hit this case with Space transactions that later
         // update a default space (`null`) to an explicit space, so handling
         // the Space case may require some finesse.
 
         if ($this->getOldValue() === null) {
           return true;
         } else {
           return false;
         }
         break;
       case PhabricatorTransactions::TYPE_CUSTOMFIELD:
         $field = $this->getTransactionCustomField();
         if ($field) {
           return $field->shouldHideInApplicationTransactions($this);
         }
         break;
       case PhabricatorTransactions::TYPE_COLUMNS:
         return !$this->getInterestingMoves($this->getNewValue());
       case PhabricatorTransactions::TYPE_EDGE:
         $edge_type = $this->getMetadataValue('edge:type');
         switch ($edge_type) {
           case PhabricatorObjectMentionsObjectEdgeType::EDGECONST:
           case ManiphestTaskHasDuplicateTaskEdgeType::EDGECONST:
           case ManiphestTaskIsDuplicateOfTaskEdgeType::EDGECONST:
             return true;
             break;
           case PhabricatorObjectMentionedByObjectEdgeType::EDGECONST:
             $new = ipull($this->getNewValue(), 'dst');
             $old = ipull($this->getOldValue(), 'dst');
             $add = array_diff($new, $old);
             $add_value = reset($add);
             $add_handle = $this->getHandle($add_value);
             if ($add_handle->getPolicyFiltered()) {
               return true;
             }
             return false;
             break;
           default:
             break;
         }
         break;
     }
 
     return false;
   }
 
   public function shouldHideForMail(array $xactions) {
     if ($this->isSelfSubscription()) {
       return true;
     }
 
     switch ($this->getTransactionType()) {
       case PhabricatorTransactions::TYPE_TOKEN:
         return true;
       case PhabricatorTransactions::TYPE_BUILDABLE:
         switch ($this->getNewValue()) {
           case HarbormasterBuildable::STATUS_FAILED:
             // For now, only ever send mail when builds fail. We might let
             // you customize this later, but in most cases this is probably
             // completely uninteresting.
             return false;
         }
         return true;
      case PhabricatorTransactions::TYPE_EDGE:
         $edge_type = $this->getMetadataValue('edge:type');
         switch ($edge_type) {
           case PhabricatorObjectMentionsObjectEdgeType::EDGECONST:
           case PhabricatorObjectMentionedByObjectEdgeType::EDGECONST:
             return true;
           case PhabricatorProjectObjectHasProjectEdgeType::EDGECONST:
             // When an object is first created, we hide any corresponding
             // project transactions in the web UI because you can just look at
             // the UI element elsewhere on screen to see which projects it
             // is tagged with. However, in mail there's no other way to get
             // this information, and it has some amount of value to users, so
             // we keep the transaction. See T10493.
             return false;
           default:
             break;
         }
         break;
     }
 
     if ($this->isInlineCommentTransaction()) {
       $inlines = array();
 
       // If there's a normal comment, we don't need to publish the inline
       // transaction, since the normal comment covers things.
       foreach ($xactions as $xaction) {
         if ($xaction->isInlineCommentTransaction()) {
           $inlines[] = $xaction;
           continue;
         }
 
         // We found a normal comment, so hide this inline transaction.
         if ($xaction->hasComment()) {
           return true;
         }
       }
 
       // If there are several inline comments, only publish the first one.
       if ($this !== head($inlines)) {
         return true;
       }
     }
 
     return $this->shouldHide();
   }
 
   public function shouldHideForFeed() {
     if ($this->isSelfSubscription()) {
       return true;
     }
 
     switch ($this->getTransactionType()) {
       case PhabricatorTransactions::TYPE_TOKEN:
         return true;
       case PhabricatorTransactions::TYPE_BUILDABLE:
         switch ($this->getNewValue()) {
           case HarbormasterBuildable::STATUS_FAILED:
             // For now, don't notify on build passes either. These are pretty
             // high volume and annoying, with very little present value. We
             // might want to turn them back on in the specific case of
             // build successes on the current document?
             return false;
         }
         return true;
      case PhabricatorTransactions::TYPE_EDGE:
         $edge_type = $this->getMetadataValue('edge:type');
         switch ($edge_type) {
           case PhabricatorObjectMentionsObjectEdgeType::EDGECONST:
           case PhabricatorObjectMentionedByObjectEdgeType::EDGECONST:
             return true;
             break;
           default:
             break;
         }
         break;
      case PhabricatorTransactions::TYPE_INLINESTATE:
        return true;
     }
 
     return $this->shouldHide();
   }
 
   public function getTitleForMail() {
     return id(clone $this)->setRenderingTarget('text')->getTitle();
   }
 
   public function getTitleForHTMLMail() {
     $title = $this->getTitleForMail();
     if ($title === null) {
       return null;
     }
 
     if ($this->hasChangeDetails()) {
       $details_uri = $this->getChangeDetailsURI();
       $details_uri = PhabricatorEnv::getProductionURI($details_uri);
 
       $show_details = phutil_tag(
         'a',
         array(
           'href' => $details_uri,
         ),
         pht('(Show Details)'));
 
       $title = array($title, ' ', $show_details);
     }
 
     return $title;
   }
 
   public function getChangeDetailsURI() {
     return '/transactions/detail/'.$this->getPHID().'/';
   }
 
   public function getBodyForMail() {
     if ($this->isInlineCommentTransaction()) {
       // We don't return inline comment content as mail body content, because
       // applications need to contextualize it (by adding line numbers, for
       // example) in order for it to make sense.
       return null;
     }
 
     $comment = $this->getComment();
     if ($comment && strlen($comment->getContent())) {
       return $comment->getContent();
     }
 
     return null;
   }
 
   public function getNoEffectDescription() {
 
     switch ($this->getTransactionType()) {
       case PhabricatorTransactions::TYPE_COMMENT:
         return pht('You can not post an empty comment.');
       case PhabricatorTransactions::TYPE_VIEW_POLICY:
         return pht(
           'This %s already has that view policy.',
           $this->getApplicationObjectTypeName());
       case PhabricatorTransactions::TYPE_EDIT_POLICY:
         return pht(
           'This %s already has that edit policy.',
           $this->getApplicationObjectTypeName());
       case PhabricatorTransactions::TYPE_JOIN_POLICY:
         return pht(
           'This %s already has that join policy.',
           $this->getApplicationObjectTypeName());
       case PhabricatorTransactions::TYPE_SUBSCRIBERS:
         return pht(
           'All users are already subscribed to this %s.',
           $this->getApplicationObjectTypeName());
       case PhabricatorTransactions::TYPE_SPACE:
         return pht('This object is already in that space.');
       case PhabricatorTransactions::TYPE_EDGE:
         return pht('Edges already exist; transaction has no effect.');
       case PhabricatorTransactions::TYPE_COLUMNS:
         return pht(
           'You have not moved this object to any columns it is not '.
           'already in.');
     }
 
     return pht(
       'Transaction (of type "%s") has no effect.',
       $this->getTransactionType());
   }
 
   public function getTitle() {
     $author_phid = $this->getAuthorPHID();
 
     $old = $this->getOldValue();
     $new = $this->getNewValue();
 
     switch ($this->getTransactionType()) {
       case PhabricatorTransactions::TYPE_CREATE:
         return pht(
           '%s created this object.',
           $this->renderHandleLink($author_phid));
       case PhabricatorTransactions::TYPE_COMMENT:
         return pht(
           '%s added a comment.',
           $this->renderHandleLink($author_phid));
       case PhabricatorTransactions::TYPE_VIEW_POLICY:
         if ($this->getIsCreateTransaction()) {
           return pht(
             '%s created this object with visibility "%s".',
             $this->renderHandleLink($author_phid),
             $this->renderPolicyName($new, 'new'));
         } else {
           return pht(
             '%s changed the visibility from "%s" to "%s".',
             $this->renderHandleLink($author_phid),
             $this->renderPolicyName($old, 'old'),
             $this->renderPolicyName($new, 'new'));
         }
       case PhabricatorTransactions::TYPE_EDIT_POLICY:
         if ($this->getIsCreateTransaction()) {
           return pht(
             '%s created this object with edit policy "%s".',
             $this->renderHandleLink($author_phid),
             $this->renderPolicyName($new, 'new'));
         } else {
           return pht(
             '%s changed the edit policy from "%s" to "%s".',
             $this->renderHandleLink($author_phid),
             $this->renderPolicyName($old, 'old'),
             $this->renderPolicyName($new, 'new'));
         }
       case PhabricatorTransactions::TYPE_JOIN_POLICY:
         if ($this->getIsCreateTransaction()) {
           return pht(
             '%s created this object with join policy "%s".',
             $this->renderHandleLink($author_phid),
             $this->renderPolicyName($new, 'new'));
         } else {
           return pht(
             '%s changed the join policy from "%s" to "%s".',
             $this->renderHandleLink($author_phid),
             $this->renderPolicyName($old, 'old'),
             $this->renderPolicyName($new, 'new'));
         }
       case PhabricatorTransactions::TYPE_SPACE:
         if ($this->getIsCreateTransaction()) {
           return pht(
             '%s created this object in space %s.',
             $this->renderHandleLink($author_phid),
             $this->renderHandleLink($new));
         } else {
           return pht(
             '%s shifted this object from the %s space to the %s space.',
             $this->renderHandleLink($author_phid),
             $this->renderHandleLink($old),
             $this->renderHandleLink($new));
         }
       case PhabricatorTransactions::TYPE_SUBSCRIBERS:
         $add = array_diff($new, $old);
         $rem = array_diff($old, $new);
 
         if ($add && $rem) {
           return pht(
             '%s edited subscriber(s), added %d: %s; removed %d: %s.',
             $this->renderHandleLink($author_phid),
             count($add),
             $this->renderSubscriberList($add, 'add'),
             count($rem),
             $this->renderSubscriberList($rem, 'rem'));
         } else if ($add) {
           return pht(
             '%s added %d subscriber(s): %s.',
             $this->renderHandleLink($author_phid),
             count($add),
             $this->renderSubscriberList($add, 'add'));
         } else if ($rem) {
           return pht(
             '%s removed %d subscriber(s): %s.',
             $this->renderHandleLink($author_phid),
             count($rem),
             $this->renderSubscriberList($rem, 'rem'));
         } else {
           // This is used when rendering previews, before the user actually
           // selects any CCs.
           return pht(
             '%s updated subscribers...',
             $this->renderHandleLink($author_phid));
         }
         break;
       case PhabricatorTransactions::TYPE_EDGE:
         $new = ipull($new, 'dst');
         $old = ipull($old, 'dst');
         $add = array_diff($new, $old);
         $rem = array_diff($old, $new);
         $type = $this->getMetadata('edge:type');
         $type = head($type);
 
         $type_obj = PhabricatorEdgeType::getByConstant($type);
 
         if ($add && $rem) {
           return $type_obj->getTransactionEditString(
             $this->renderHandleLink($author_phid),
             new PhutilNumber(count($add) + count($rem)),
             phutil_count($add),
             $this->renderHandleList($add),
             phutil_count($rem),
             $this->renderHandleList($rem));
         } else if ($add) {
           return $type_obj->getTransactionAddString(
             $this->renderHandleLink($author_phid),
             phutil_count($add),
             $this->renderHandleList($add));
         } else if ($rem) {
           return $type_obj->getTransactionRemoveString(
             $this->renderHandleLink($author_phid),
             phutil_count($rem),
             $this->renderHandleList($rem));
         } else {
           return $type_obj->getTransactionPreviewString(
             $this->renderHandleLink($author_phid));
         }
 
       case PhabricatorTransactions::TYPE_CUSTOMFIELD:
         $field = $this->getTransactionCustomField();
         if ($field) {
           return $field->getApplicationTransactionTitle($this);
         } else {
           return pht(
             '%s edited a custom field.',
             $this->renderHandleLink($author_phid));
         }
 
       case PhabricatorTransactions::TYPE_TOKEN:
         if ($old && $new) {
           return pht(
             '%s updated a token.',
             $this->renderHandleLink($author_phid));
         } else if ($old) {
           return pht(
             '%s rescinded a token.',
             $this->renderHandleLink($author_phid));
         } else {
           return pht(
             '%s awarded a token.',
             $this->renderHandleLink($author_phid));
         }
 
       case PhabricatorTransactions::TYPE_BUILDABLE:
         switch ($this->getNewValue()) {
           case HarbormasterBuildable::STATUS_BUILDING:
             return pht(
               '%s started building %s.',
               $this->renderHandleLink($author_phid),
               $this->renderHandleLink(
                 $this->getMetadataValue('harbormaster:buildablePHID')));
           case HarbormasterBuildable::STATUS_PASSED:
             return pht(
               '%s completed building %s.',
               $this->renderHandleLink($author_phid),
               $this->renderHandleLink(
                 $this->getMetadataValue('harbormaster:buildablePHID')));
           case HarbormasterBuildable::STATUS_FAILED:
             return pht(
               '%s failed to build %s!',
               $this->renderHandleLink($author_phid),
               $this->renderHandleLink(
                 $this->getMetadataValue('harbormaster:buildablePHID')));
           default:
             return null;
         }
 
       case PhabricatorTransactions::TYPE_INLINESTATE:
         $done = 0;
         $undone = 0;
         foreach ($new as $phid => $state) {
           if ($state == PhabricatorInlineCommentInterface::STATE_DONE) {
             $done++;
           } else {
             $undone++;
           }
         }
         if ($done && $undone) {
           return pht(
             '%s marked %s inline comment(s) as done and %s inline comment(s) '.
             'as not done.',
             $this->renderHandleLink($author_phid),
             new PhutilNumber($done),
             new PhutilNumber($undone));
         } else if ($done) {
           return pht(
             '%s marked %s inline comment(s) as done.',
             $this->renderHandleLink($author_phid),
             new PhutilNumber($done));
         } else {
           return pht(
             '%s marked %s inline comment(s) as not done.',
             $this->renderHandleLink($author_phid),
             new PhutilNumber($undone));
         }
         break;
 
       case PhabricatorTransactions::TYPE_COLUMNS:
         $moves = $this->getInterestingMoves($new);
         if (count($moves) == 1) {
           $move = head($moves);
           $from_columns = $move['fromColumnPHIDs'];
           $to_column = $move['columnPHID'];
           $board_phid = $move['boardPHID'];
           if (count($from_columns) == 1) {
             return pht(
               '%s moved this task from %s to %s on the %s board.',
               $this->renderHandleLink($author_phid),
               $this->renderHandleLink(head($from_columns)),
               $this->renderHandleLink($to_column),
               $this->renderHandleLink($board_phid));
           } else {
             return pht(
               '%s moved this task to %s on the %s board.',
               $this->renderHandleLink($author_phid),
               $this->renderHandleLink($to_column),
               $this->renderHandleLink($board_phid));
           }
         } else {
           $fragments = array();
           foreach ($moves as $move) {
             $fragments[] = pht(
               '%s (%s)',
               $this->renderHandleLink($board_phid),
               $this->renderHandleLink($to_column));
           }
 
           return pht(
             '%s moved this task on %s board(s): %s.',
             $this->renderHandleLink($author_phid),
             phutil_count($moves),
             phutil_implode_html(', ', $fragments));
         }
         break;
 
       default:
-        return pht(
-          '%s edited this %s.',
-          $this->renderHandleLink($author_phid),
-          $this->getApplicationObjectTypeName());
+        // In developer mode, provide a better hint here about which string
+        // we're missing.
+        $developer_mode = 'phabricator.developer-mode';
+        $is_developer = PhabricatorEnv::getEnvConfig($developer_mode);
+        if ($is_developer) {
+          return pht(
+            '%s edited this object (transaction type "%s").',
+            $this->renderHandleLink($author_phid),
+            $this->getTransactionType());
+        } else {
+          return pht(
+            '%s edited this %s.',
+            $this->renderHandleLink($author_phid),
+            $this->getApplicationObjectTypeName());
+        }
     }
   }
 
   public function getTitleForFeed() {
     $author_phid = $this->getAuthorPHID();
     $object_phid = $this->getObjectPHID();
 
     $old = $this->getOldValue();
     $new = $this->getNewValue();
 
     switch ($this->getTransactionType()) {
       case PhabricatorTransactions::TYPE_CREATE:
         return pht(
           '%s created %s.',
           $this->renderHandleLink($author_phid),
           $this->renderHandleLink($object_phid));
       case PhabricatorTransactions::TYPE_COMMENT:
         return pht(
           '%s added a comment to %s.',
           $this->renderHandleLink($author_phid),
           $this->renderHandleLink($object_phid));
       case PhabricatorTransactions::TYPE_VIEW_POLICY:
         return pht(
           '%s changed the visibility for %s.',
           $this->renderHandleLink($author_phid),
           $this->renderHandleLink($object_phid));
       case PhabricatorTransactions::TYPE_EDIT_POLICY:
         return pht(
           '%s changed the edit policy for %s.',
           $this->renderHandleLink($author_phid),
           $this->renderHandleLink($object_phid));
       case PhabricatorTransactions::TYPE_JOIN_POLICY:
         return pht(
           '%s changed the join policy for %s.',
           $this->renderHandleLink($author_phid),
           $this->renderHandleLink($object_phid));
       case PhabricatorTransactions::TYPE_SUBSCRIBERS:
         return pht(
           '%s updated subscribers of %s.',
           $this->renderHandleLink($author_phid),
           $this->renderHandleLink($object_phid));
       case PhabricatorTransactions::TYPE_SPACE:
         return pht(
           '%s shifted %s from the %s space to the %s space.',
           $this->renderHandleLink($author_phid),
           $this->renderHandleLink($object_phid),
           $this->renderHandleLink($old),
           $this->renderHandleLink($new));
       case PhabricatorTransactions::TYPE_EDGE:
         $new = ipull($new, 'dst');
         $old = ipull($old, 'dst');
         $add = array_diff($new, $old);
         $rem = array_diff($old, $new);
         $type = $this->getMetadata('edge:type');
         $type = head($type);
 
         $type_obj = PhabricatorEdgeType::getByConstant($type);
 
         if ($add && $rem) {
           return $type_obj->getFeedEditString(
             $this->renderHandleLink($author_phid),
             $this->renderHandleLink($object_phid),
             new PhutilNumber(count($add) + count($rem)),
             phutil_count($add),
             $this->renderHandleList($add),
             phutil_count($rem),
             $this->renderHandleList($rem));
         } else if ($add) {
           return $type_obj->getFeedAddString(
             $this->renderHandleLink($author_phid),
             $this->renderHandleLink($object_phid),
             phutil_count($add),
             $this->renderHandleList($add));
         } else if ($rem) {
           return $type_obj->getFeedRemoveString(
             $this->renderHandleLink($author_phid),
             $this->renderHandleLink($object_phid),
             phutil_count($rem),
             $this->renderHandleList($rem));
         } else {
           return pht(
             '%s edited edge metadata for %s.',
             $this->renderHandleLink($author_phid),
             $this->renderHandleLink($object_phid));
         }
 
       case PhabricatorTransactions::TYPE_CUSTOMFIELD:
         $field = $this->getTransactionCustomField();
         if ($field) {
           return $field->getApplicationTransactionTitleForFeed($this);
         } else {
           return pht(
             '%s edited a custom field on %s.',
             $this->renderHandleLink($author_phid),
             $this->renderHandleLink($object_phid));
         }
       case PhabricatorTransactions::TYPE_BUILDABLE:
         switch ($this->getNewValue()) {
           case HarbormasterBuildable::STATUS_BUILDING:
             return pht(
               '%s started building %s for %s.',
               $this->renderHandleLink($author_phid),
               $this->renderHandleLink(
                 $this->getMetadataValue('harbormaster:buildablePHID')),
               $this->renderHandleLink($object_phid));
           case HarbormasterBuildable::STATUS_PASSED:
             return pht(
               '%s completed building %s for %s.',
               $this->renderHandleLink($author_phid),
               $this->renderHandleLink(
                 $this->getMetadataValue('harbormaster:buildablePHID')),
               $this->renderHandleLink($object_phid));
           case HarbormasterBuildable::STATUS_FAILED:
             return pht(
               '%s failed to build %s for %s.',
               $this->renderHandleLink($author_phid),
               $this->renderHandleLink(
                 $this->getMetadataValue('harbormaster:buildablePHID')),
               $this->renderHandleLink($object_phid));
           default:
             return null;
         }
 
       case PhabricatorTransactions::TYPE_COLUMNS:
         $moves = $this->getInterestingMoves($new);
         if (count($moves) == 1) {
           $move = head($moves);
           $from_columns = $move['fromColumnPHIDs'];
           $to_column = $move['columnPHID'];
           $board_phid = $move['boardPHID'];
           if (count($from_columns) == 1) {
             return pht(
               '%s moved %s from %s to %s on the %s board.',
               $this->renderHandleLink($author_phid),
               $this->renderHandleLink($object_phid),
               $this->renderHandleLink(head($from_columns)),
               $this->renderHandleLink($to_column),
               $this->renderHandleLink($board_phid));
           } else {
             return pht(
               '%s moved %s to %s on the %s board.',
               $this->renderHandleLink($author_phid),
               $this->renderHandleLink($object_phid),
               $this->renderHandleLink($to_column),
               $this->renderHandleLink($board_phid));
           }
         } else {
           $fragments = array();
           foreach ($moves as $move) {
             $fragments[] = pht(
               '%s (%s)',
               $this->renderHandleLink($board_phid),
               $this->renderHandleLink($to_column));
           }
 
           return pht(
             '%s moved %s on %s board(s): %s.',
             $this->renderHandleLink($author_phid),
             $this->renderHandleLink($object_phid),
             phutil_count($moves),
             phutil_implode_html(', ', $fragments));
         }
         break;
 
     }
 
     return $this->getTitle();
   }
 
   public function getMarkupFieldsForFeed(PhabricatorFeedStory $story) {
     $fields = array();
 
     switch ($this->getTransactionType()) {
       case PhabricatorTransactions::TYPE_COMMENT:
         $text = $this->getComment()->getContent();
         if (strlen($text)) {
           $fields[] = 'comment/'.$this->getID();
         }
         break;
     }
 
     return $fields;
   }
 
   public function getMarkupTextForFeed(PhabricatorFeedStory $story, $field) {
     switch ($this->getTransactionType()) {
       case PhabricatorTransactions::TYPE_COMMENT:
         $text = $this->getComment()->getContent();
         return PhabricatorMarkupEngine::summarize($text);
     }
 
     return null;
   }
 
   public function getBodyForFeed(PhabricatorFeedStory $story) {
     $remarkup = $this->getRemarkupBodyForFeed($story);
     if ($remarkup !== null) {
       $remarkup = PhabricatorMarkupEngine::summarize($remarkup);
       return new PHUIRemarkupView($this->viewer, $remarkup);
     }
 
     $old = $this->getOldValue();
     $new = $this->getNewValue();
 
     $body = null;
 
     switch ($this->getTransactionType()) {
       case PhabricatorTransactions::TYPE_COMMENT:
         $text = $this->getComment()->getContent();
         if (strlen($text)) {
           $body = $story->getMarkupFieldOutput('comment/'.$this->getID());
         }
         break;
     }
 
     return $body;
   }
 
   public function getRemarkupBodyForFeed(PhabricatorFeedStory $story) {
     return null;
   }
 
   public function getActionStrength() {
     if ($this->isInlineCommentTransaction()) {
       return 0.25;
     }
 
     switch ($this->getTransactionType()) {
       case PhabricatorTransactions::TYPE_COMMENT:
         return 0.5;
       case PhabricatorTransactions::TYPE_SUBSCRIBERS:
         if ($this->isSelfSubscription()) {
           // Make this weaker than TYPE_COMMENT.
           return 0.25;
         }
 
         if ($this->isApplicationAuthor()) {
           // When applications (most often: Herald) change subscriptions it
           // is very uninteresting.
           return 0.000000001;
         }
 
         // In other cases, subscriptions are more interesting than comments
         // (which are shown anyway) but less interesting than any other type of
         // transaction.
         return 0.75;
     }
 
     return 1.0;
   }
 
   public function isCommentTransaction() {
     if ($this->hasComment()) {
       return true;
     }
 
     switch ($this->getTransactionType()) {
       case PhabricatorTransactions::TYPE_COMMENT:
         return true;
     }
 
     return false;
   }
 
   public function isInlineCommentTransaction() {
     return false;
   }
 
   public function getActionName() {
     switch ($this->getTransactionType()) {
       case PhabricatorTransactions::TYPE_COMMENT:
         return pht('Commented On');
       case PhabricatorTransactions::TYPE_VIEW_POLICY:
       case PhabricatorTransactions::TYPE_EDIT_POLICY:
       case PhabricatorTransactions::TYPE_JOIN_POLICY:
         return pht('Changed Policy');
       case PhabricatorTransactions::TYPE_SUBSCRIBERS:
         return pht('Changed Subscribers');
       case PhabricatorTransactions::TYPE_BUILDABLE:
         switch ($this->getNewValue()) {
           case HarbormasterBuildable::STATUS_PASSED:
             return pht('Build Passed');
           case HarbormasterBuildable::STATUS_FAILED:
             return pht('Build Failed');
           default:
             return pht('Build Status');
         }
       default:
         return pht('Updated');
     }
   }
 
   public function getMailTags() {
     return array();
   }
 
   public function hasChangeDetails() {
     switch ($this->getTransactionType()) {
       case PhabricatorTransactions::TYPE_CUSTOMFIELD:
         $field = $this->getTransactionCustomField();
         if ($field) {
           return $field->getApplicationTransactionHasChangeDetails($this);
         }
         break;
     }
     return false;
   }
 
   public function hasChangeDetailsForMail() {
     return $this->hasChangeDetails();
   }
 
   public function renderChangeDetailsForMail(PhabricatorUser $viewer) {
     $view = $this->renderChangeDetails($viewer);
     if ($view instanceof PhabricatorApplicationTransactionTextDiffDetailView) {
       return $view->renderForMail();
     }
     return null;
   }
 
   public function renderChangeDetails(PhabricatorUser $viewer) {
     switch ($this->getTransactionType()) {
       case PhabricatorTransactions::TYPE_CUSTOMFIELD:
         $field = $this->getTransactionCustomField();
         if ($field) {
           return $field->getApplicationTransactionChangeDetails($this, $viewer);
         }
         break;
     }
 
     return $this->renderTextCorpusChangeDetails(
       $viewer,
       $this->getOldValue(),
       $this->getNewValue());
   }
 
   public function renderTextCorpusChangeDetails(
     PhabricatorUser $viewer,
     $old,
     $new) {
     return id(new PhabricatorApplicationTransactionTextDiffDetailView())
       ->setUser($viewer)
       ->setOldText($old)
       ->setNewText($new);
   }
 
   public function attachTransactionGroup(array $group) {
     assert_instances_of($group, __CLASS__);
     $this->transactionGroup = $group;
     return $this;
   }
 
   public function getTransactionGroup() {
     return $this->transactionGroup;
   }
 
   /**
    * Should this transaction be visually grouped with an existing transaction
    * group?
    *
    * @param list<PhabricatorApplicationTransaction> List of transactions.
    * @return bool True to display in a group with the other transactions.
    */
   public function shouldDisplayGroupWith(array $group) {
     $this_source = null;
     if ($this->getContentSource()) {
       $this_source = $this->getContentSource()->getSource();
     }
 
     foreach ($group as $xaction) {
       // Don't group transactions by different authors.
       if ($xaction->getAuthorPHID() != $this->getAuthorPHID()) {
         return false;
       }
 
       // Don't group transactions for different objects.
       if ($xaction->getObjectPHID() != $this->getObjectPHID()) {
         return false;
       }
 
       // Don't group anything into a group which already has a comment.
       if ($xaction->isCommentTransaction()) {
         return false;
       }
 
       // Don't group transactions from different content sources.
       $other_source = null;
       if ($xaction->getContentSource()) {
         $other_source = $xaction->getContentSource()->getSource();
       }
 
       if ($other_source != $this_source) {
         return false;
       }
 
       // Don't group transactions which happened more than 2 minutes apart.
       $apart = abs($xaction->getDateCreated() - $this->getDateCreated());
       if ($apart > (60 * 2)) {
         return false;
       }
     }
 
     return true;
   }
 
   public function renderExtraInformationLink() {
     $herald_xscript_id = $this->getMetadataValue('herald:transcriptID');
 
     if ($herald_xscript_id) {
       return phutil_tag(
         'a',
         array(
           'href' => '/herald/transcript/'.$herald_xscript_id.'/',
         ),
         pht('View Herald Transcript'));
     }
 
     return null;
   }
 
   public function renderAsTextForDoorkeeper(
     DoorkeeperFeedStoryPublisher $publisher,
     PhabricatorFeedStory $story,
     array $xactions) {
 
     $text = array();
     $body = array();
 
     foreach ($xactions as $xaction) {
       $xaction_body = $xaction->getBodyForMail();
       if ($xaction_body !== null) {
         $body[] = $xaction_body;
       }
 
       if ($xaction->shouldHideForMail($xactions)) {
         continue;
       }
 
       $old_target = $xaction->getRenderingTarget();
       $new_target = self::TARGET_TEXT;
       $xaction->setRenderingTarget($new_target);
 
       if ($publisher->getRenderWithImpliedContext()) {
         $text[] = $xaction->getTitle();
       } else {
         $text[] = $xaction->getTitleForFeed();
       }
 
       $xaction->setRenderingTarget($old_target);
     }
 
     $text = implode("\n", $text);
     $body = implode("\n\n", $body);
 
     return rtrim($text."\n\n".$body);
   }
 
   /**
    * Test if this transaction is just a user subscribing or unsubscribing
    * themselves.
    */
   private function isSelfSubscription() {
     $type = $this->getTransactionType();
     if ($type != PhabricatorTransactions::TYPE_SUBSCRIBERS) {
       return false;
     }
 
     $old = $this->getOldValue();
     $new = $this->getNewValue();
 
     $add = array_diff($old, $new);
     $rem = array_diff($new, $old);
 
     if ((count($add) + count($rem)) != 1) {
       // More than one user affected.
       return false;
     }
 
     $affected_phid = head(array_merge($add, $rem));
     if ($affected_phid != $this->getAuthorPHID()) {
       // Affected user is someone else.
       return false;
     }
 
     return true;
   }
 
   private function isApplicationAuthor() {
     $author_phid = $this->getAuthorPHID();
     $author_type = phid_get_type($author_phid);
     $application_type = PhabricatorApplicationApplicationPHIDType::TYPECONST;
     return ($author_type == $application_type);
   }
 
 
   private function getInterestingMoves(array $moves) {
     // Remove moves which only shift the position of a task within a column.
     foreach ($moves as $key => $move) {
       $from_phids = array_fuse($move['fromColumnPHIDs']);
       if (isset($from_phids[$move['columnPHID']])) {
         unset($moves[$key]);
       }
     }
 
     return $moves;
   }
 
 
 /* -(  PhabricatorPolicyInterface Implementation  )-------------------------- */
 
 
   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) {
     return ($viewer->getPHID() == $this->getAuthorPHID());
   }
 
   public function describeAutomaticCapability($capability) {
     return pht(
       'Transactions are visible to users that can see the object which was '.
       'acted upon. Some transactions - in particular, comments - are '.
       'editable by the transaction author.');
   }
 
+  public function getModularType() {
+    return null;
+  }
+
 
 /* -(  PhabricatorDestructibleInterface  )----------------------------------- */
 
 
   public function destroyObjectPermanently(
     PhabricatorDestructionEngine $engine) {
 
     $this->openTransaction();
       $comment_template = null;
       try {
         $comment_template = $this->getApplicationTransactionCommentObject();
       } catch (Exception $ex) {
         // Continue; no comments for these transactions.
       }
 
       if ($comment_template) {
         $comments = $comment_template->loadAllWhere(
           'transactionPHID = %s',
           $this->getPHID());
         foreach ($comments as $comment) {
           $engine->destroyObject($comment);
         }
       }
 
       $this->delete();
     $this->saveTransaction();
   }
 
 
 }
diff --git a/src/applications/transactions/storage/PhabricatorModularTransaction.php b/src/applications/transactions/storage/PhabricatorModularTransaction.php
index c93a559108..e62d550bb9 100644
--- a/src/applications/transactions/storage/PhabricatorModularTransaction.php
+++ b/src/applications/transactions/storage/PhabricatorModularTransaction.php
@@ -1,156 +1,160 @@
 <?php
 
 abstract class PhabricatorModularTransaction
   extends PhabricatorApplicationTransaction {
 
   private $implementation;
 
   abstract public function getBaseTransactionClass();
 
+  public function getModularType() {
+    return $this->getTransactionImplementation();
+  }
+
   final protected function getTransactionImplementation() {
     if (!$this->implementation) {
       $this->implementation = $this->newTransactionImplementation();
     }
 
     return $this->implementation;
   }
 
   public function newModularTransactionTypes() {
     $base_class = $this->getBaseTransactionClass();
 
     $types = id(new PhutilClassMapQuery())
       ->setAncestorClass($base_class)
       ->setUniqueMethod('getTransactionTypeConstant')
       ->execute();
 
     // Add core transaction types.
     $types += id(new PhutilClassMapQuery())
       ->setAncestorClass('PhabricatorCoreTransactionType')
       ->setUniqueMethod('getTransactionTypeConstant')
       ->execute();
 
     return $types;
   }
 
   private function newTransactionImplementation() {
     $types = $this->newModularTransactionTypes();
 
     $key = $this->getTransactionType();
 
     if (empty($types[$key])) {
       $type = new PhabricatorCoreVoidTransaction();
     } else {
       $type = clone $types[$key];
     }
 
     $type->setStorage($this);
 
     return $type;
   }
 
   final public function generateOldValue($object) {
     return $this->getTransactionImplementation()->generateOldValue($object);
   }
 
   final public function generateNewValue($object) {
     return $this->getTransactionImplementation()
       ->generateNewValue($object, $this->getNewValue());
   }
 
   final public function willApplyTransactions($object, array $xactions) {
     return $this->getTransactionImplementation()
       ->willApplyTransactions($object, $xactions);
   }
 
   final public function applyInternalEffects($object) {
     return $this->getTransactionImplementation()
       ->applyInternalEffects($object);
   }
 
   final public function applyExternalEffects($object) {
     return $this->getTransactionImplementation()
       ->applyExternalEffects($object);
   }
 
   final public function shouldHide() {
     if ($this->getTransactionImplementation()->shouldHide()) {
       return true;
     }
 
     return parent::shouldHide();
   }
 
   final public function getIcon() {
     $icon = $this->getTransactionImplementation()->getIcon();
     if ($icon !== null) {
       return $icon;
     }
 
     return parent::getIcon();
   }
 
   final public function getTitle() {
     $title = $this->getTransactionImplementation()->getTitle();
     if ($title !== null) {
       return $title;
     }
 
     return parent::getTitle();
   }
 
   public function getTitleForMail() {
     $old_target = $this->getRenderingTarget();
     $new_target = self::TARGET_TEXT;
     $this->setRenderingTarget($new_target);
     $title = $this->getTitle();
     $this->setRenderingTarget($old_target);
     return $title;
   }
 
   final public function getTitleForFeed() {
     $title = $this->getTransactionImplementation()->getTitleForFeed();
     if ($title !== null) {
       return $title;
     }
 
     return parent::getTitleForFeed();
   }
 
   final public function getColor() {
     $color = $this->getTransactionImplementation()->getColor();
     if ($color !== null) {
       return $color;
     }
 
     return parent::getColor();
   }
 
   public function attachViewer(PhabricatorUser $viewer) {
     $this->getTransactionImplementation()->setViewer($viewer);
     return parent::attachViewer($viewer);
   }
 
   final public function hasChangeDetails() {
     if ($this->getTransactionImplementation()->hasChangeDetailView()) {
       return true;
     }
 
     return parent::hasChangeDetails();
   }
 
   final public function renderChangeDetails(PhabricatorUser $viewer) {
     $impl = $this->getTransactionImplementation();
     $impl->setViewer($viewer);
     $view = $impl->newChangeDetailView();
     if ($view !== null) {
       return $view;
     }
 
     return parent::renderChangeDetails($viewer);
   }
 
   final protected function newRemarkupChanges() {
     return $this->getTransactionImplementation()->newRemarkupChanges();
   }
 
 }