diff --git a/src/applications/calendar/controller/PhabricatorCalendarEventEditController.php b/src/applications/calendar/controller/PhabricatorCalendarEventEditController.php
index 69492a416a..5929ca9428 100644
--- a/src/applications/calendar/controller/PhabricatorCalendarEventEditController.php
+++ b/src/applications/calendar/controller/PhabricatorCalendarEventEditController.php
@@ -1,527 +1,560 @@
 <?php
 
 final class PhabricatorCalendarEventEditController
   extends PhabricatorCalendarController {
 
   private $id;
 
   public function willProcessRequest(array $data) {
     $this->id = idx($data, 'id');
   }
 
   public function isCreate() {
     return !$this->id;
   }
 
   public function handleRequest(AphrontRequest $request) {
     $viewer = $request->getViewer();
     $user_phid = $viewer->getPHID();
     $error_name = true;
+    $error_recurrence_end_date = true;
     $error_start_date = true;
     $error_end_date = true;
     $validation_exception = null;
 
     $is_recurring_id = celerity_generate_unique_node_id();
+    $recurrence_end_date_id = celerity_generate_unique_node_id();
     $frequency_id = celerity_generate_unique_node_id();
     $all_day_id = celerity_generate_unique_node_id();
     $start_date_id = celerity_generate_unique_node_id();
     $end_date_id = celerity_generate_unique_node_id();
 
     $next_workflow = $request->getStr('next');
     $uri_query = $request->getStr('query');
 
     if ($this->isCreate()) {
       $mode = $request->getStr('mode');
       $event = PhabricatorCalendarEvent::initializeNewCalendarEvent(
         $viewer,
         $mode);
 
       $create_start_year = $request->getInt('year');
       $create_start_month = $request->getInt('month');
       $create_start_day = $request->getInt('day');
       $create_start_time = $request->getStr('time');
 
       if ($create_start_year) {
         $start = AphrontFormDateControlValue::newFromParts(
           $viewer,
           $create_start_year,
           $create_start_month,
           $create_start_day,
           $create_start_time);
         if (!$start->isValid()) {
           return new Aphront400Response();
         }
         $start_value = AphrontFormDateControlValue::newFromEpoch(
           $viewer,
           $start->getEpoch());
 
         $end = clone $start_value->getDateTime();
         $end->modify('+1 hour');
         $end_value = AphrontFormDateControlValue::newFromEpoch(
           $viewer,
           $end->format('U'));
 
       } else {
         list($start_value, $end_value) = $this->getDefaultTimeValues($viewer);
       }
 
+      $recurrence_end_date_value = clone $end_value;
+      $recurrence_end_date_value->setOptional(true);
 
       $submit_label = pht('Create');
       $page_title = pht('Create Event');
       $redirect = 'created';
       $subscribers = array();
       $invitees = array($user_phid);
       $cancel_uri = $this->getApplicationURI();
     } else {
       $event = id(new PhabricatorCalendarEventQuery())
         ->setViewer($viewer)
         ->withIDs(array($this->id))
         ->requireCapabilities(
           array(
             PhabricatorPolicyCapability::CAN_VIEW,
             PhabricatorPolicyCapability::CAN_EDIT,
           ))
         ->executeOne();
       if (!$event) {
         return new Aphront404Response();
       }
 
       if ($request->getURIData('sequence')) {
         $index = $request->getURIData('sequence');
 
         $result = id(new PhabricatorCalendarEventQuery())
           ->setViewer($viewer)
           ->withInstanceSequencePairs(
             array(
               array(
                 $event->getPHID(),
                 $index,
               ),
             ))
           ->requireCapabilities(
             array(
               PhabricatorPolicyCapability::CAN_VIEW,
               PhabricatorPolicyCapability::CAN_EDIT,
             ))
           ->executeOne();
 
         if ($result) {
           return id(new AphrontRedirectResponse())
             ->setURI('/calendar/event/edit/'.$result->getID().'/');
         }
 
         $invitees = $event->getInvitees();
 
         $new_ghost = $event->generateNthGhost($index, $viewer);
         $unguarded = AphrontWriteGuard::beginScopedUnguardedWrites();
         $new_ghost
           ->setID(null)
           ->setPHID(null)
           ->removeViewerTimezone($viewer)
           ->save();
         $ghost_invitees = array();
         foreach ($invitees as $invitee) {
           $ghost_invitee = clone $invitee;
           $ghost_invitee
             ->setID(null)
             ->setEventPHID($new_ghost->getPHID())
             ->save();
         }
         unset($unguarded);
         return id(new AphrontRedirectResponse())
           ->setURI('/calendar/event/edit/'.$new_ghost->getID().'/');
       }
 
       $end_value = AphrontFormDateControlValue::newFromEpoch(
         $viewer,
         $event->getDateTo());
       $start_value = AphrontFormDateControlValue::newFromEpoch(
         $viewer,
         $event->getDateFrom());
+      $recurrence_end_date_value = id(clone $end_value)
+        ->setOptional(true);
 
       $submit_label = pht('Update');
       $page_title   = pht('Update Event');
 
       $subscribers = PhabricatorSubscribersQuery::loadSubscribersForPHID(
         $event->getPHID());
 
       $invitees = array();
       foreach ($event->getInvitees() as $invitee) {
         if ($invitee->isUninvited()) {
           continue;
         } else {
           $invitees[] = $invitee->getInviteePHID();
         }
       }
 
       $cancel_uri = '/'.$event->getMonogram();
     }
 
     $name = $event->getName();
     $description = $event->getDescription();
     $is_all_day = $event->getIsAllDay();
     $is_recurring = $event->getIsRecurring();
     $frequency = idx($event->getRecurrenceFrequency(), 'rule');
     $icon = $event->getIcon();
 
     $current_policies = id(new PhabricatorPolicyQuery())
       ->setViewer($viewer)
       ->setObject($event)
       ->execute();
 
     if ($request->isFormPost()) {
       $xactions = array();
       $name = $request->getStr('name');
 
       $start_value = AphrontFormDateControlValue::newFromRequest(
         $request,
         'start');
       $end_value = AphrontFormDateControlValue::newFromRequest(
         $request,
         'end');
+      $recurrence_end_date_value = AphrontFormDateControlValue::newFromRequest(
+        $request,
+        'recurrenceEndDate');
+      $recurrence_end_date_value->setOptional(true);
       $description = $request->getStr('description');
       $subscribers = $request->getArr('subscribers');
       $edit_policy = $request->getStr('editPolicy');
       $view_policy = $request->getStr('viewPolicy');
       $is_recurring = $request->getStr('isRecurring') ? 1 : 0;
       $frequency = $request->getStr('frequency');
       $is_all_day = $request->getStr('isAllDay');
       $icon = $request->getStr('icon');
 
       $invitees = $request->getArr('invitees');
       $new_invitees = $this->getNewInviteeList($invitees, $event);
       $status_attending = PhabricatorCalendarEventInvitee::STATUS_ATTENDING;
       if ($this->isCreate()) {
         $status = idx($new_invitees, $viewer->getPHID());
         if ($status) {
           $new_invitees[$viewer->getPHID()] = $status_attending;
         }
       }
 
       $xactions[] = id(new PhabricatorCalendarEventTransaction())
         ->setTransactionType(
           PhabricatorCalendarEventTransaction::TYPE_NAME)
         ->setNewValue($name);
 
       if ($this->isCreate()) {
         $xactions[] = id(new PhabricatorCalendarEventTransaction())
           ->setTransactionType(
             PhabricatorCalendarEventTransaction::TYPE_RECURRING)
           ->setNewValue($is_recurring);
 
         $xactions[] = id(new PhabricatorCalendarEventTransaction())
           ->setTransactionType(
             PhabricatorCalendarEventTransaction::TYPE_FREQUENCY)
           ->setNewValue(array('rule' => $frequency));
+
+        $xactions[] = id(new PhabricatorCalendarEventTransaction())
+          ->setTransactionType(
+            PhabricatorCalendarEventTransaction::TYPE_RECURRENCE_END_DATE)
+          ->setNewValue($recurrence_end_date_value);
       }
 
       $xactions[] = id(new PhabricatorCalendarEventTransaction())
         ->setTransactionType(
           PhabricatorCalendarEventTransaction::TYPE_ALL_DAY)
         ->setNewValue($is_all_day);
 
       $xactions[] = id(new PhabricatorCalendarEventTransaction())
         ->setTransactionType(
           PhabricatorCalendarEventTransaction::TYPE_ICON)
         ->setNewValue($icon);
 
       $xactions[] = id(new PhabricatorCalendarEventTransaction())
         ->setTransactionType(
           PhabricatorCalendarEventTransaction::TYPE_START_DATE)
         ->setNewValue($start_value);
 
       $xactions[] = id(new PhabricatorCalendarEventTransaction())
         ->setTransactionType(
           PhabricatorCalendarEventTransaction::TYPE_END_DATE)
         ->setNewValue($end_value);
 
       $xactions[] = id(new PhabricatorCalendarEventTransaction())
         ->setTransactionType(
           PhabricatorTransactions::TYPE_SUBSCRIBERS)
         ->setNewValue(array('=' => array_fuse($subscribers)));
 
       $xactions[] = id(new PhabricatorCalendarEventTransaction())
         ->setTransactionType(
           PhabricatorCalendarEventTransaction::TYPE_INVITE)
         ->setNewValue($new_invitees);
 
       $xactions[] = id(new PhabricatorCalendarEventTransaction())
         ->setTransactionType(
           PhabricatorCalendarEventTransaction::TYPE_DESCRIPTION)
         ->setNewValue($description);
 
       $xactions[] = id(new PhabricatorCalendarEventTransaction())
         ->setTransactionType(PhabricatorTransactions::TYPE_VIEW_POLICY)
         ->setNewValue($request->getStr('viewPolicy'));
 
       $xactions[] = id(new PhabricatorCalendarEventTransaction())
         ->setTransactionType(PhabricatorTransactions::TYPE_EDIT_POLICY)
         ->setNewValue($request->getStr('editPolicy'));
 
       $editor = id(new PhabricatorCalendarEventEditor())
         ->setActor($viewer)
         ->setContentSourceFromRequest($request)
         ->setContinueOnNoEffect(true);
 
       try {
         $xactions = $editor->applyTransactions($event, $xactions);
         $response = id(new AphrontRedirectResponse());
         switch ($next_workflow) {
           case 'day':
             if (!$uri_query) {
               $uri_query = 'month';
             }
             $year = $start_value->getDateTime()->format('Y');
             $month = $start_value->getDateTime()->format('m');
             $day = $start_value->getDateTime()->format('d');
             $response->setURI(
               '/calendar/query/'.$uri_query.'/'.$year.'/'.$month.'/'.$day.'/');
             break;
           default:
             $response->setURI('/E'.$event->getID());
             break;
         }
         return $response;
       } catch (PhabricatorApplicationTransactionValidationException $ex) {
         $validation_exception = $ex;
         $error_name = $ex->getShortMessage(
             PhabricatorCalendarEventTransaction::TYPE_NAME);
         $error_start_date = $ex->getShortMessage(
             PhabricatorCalendarEventTransaction::TYPE_START_DATE);
         $error_end_date = $ex->getShortMessage(
             PhabricatorCalendarEventTransaction::TYPE_END_DATE);
+        $error_recurrence_end_date = $ex->getShortMessage(
+            PhabricatorCalendarEventTransaction::TYPE_RECURRENCE_END_DATE);
 
         $event->setViewPolicy($view_policy);
         $event->setEditPolicy($edit_policy);
       }
     }
 
     $is_recurring_checkbox = null;
+    $recurrence_end_date_control = null;
     $recurrence_frequency_select = null;
 
     $name = id(new AphrontFormTextControl())
       ->setLabel(pht('Name'))
       ->setName('name')
       ->setValue($name)
       ->setError($error_name);
 
     if ($this->isCreate()) {
       Javelin::initBehavior('recurring-edit', array(
         'isRecurring' => $is_recurring_id,
         'frequency' => $frequency_id,
+        'recurrenceEndDate' => $recurrence_end_date_id,
       ));
 
       $is_recurring_checkbox = id(new AphrontFormCheckboxControl())
         ->addCheckbox(
           'isRecurring',
           1,
           pht('Recurring Event'),
           $is_recurring,
           $is_recurring_id);
 
+      $recurrence_end_date_control = id(new AphrontFormDateControl())
+        ->setUser($viewer)
+        ->setName('recurrenceEndDate')
+        ->setLabel(pht('Recurrence End Date'))
+        ->setError($error_recurrence_end_date)
+        ->setValue($recurrence_end_date_value)
+        ->setID($recurrence_end_date_id)
+        ->setIsTimeDisabled(true)
+        ->setAllowNull(true)
+        ->setIsDisabled(!$is_recurring);
+
       $recurrence_frequency_select = id(new AphrontFormSelectControl())
         ->setName('frequency')
         ->setOptions(array(
             'daily' => pht('Daily'),
             'weekly' => pht('Weekly'),
             'monthly' => pht('Monthly'),
             'yearly' => pht('Yearly'),
           ))
         ->setValue($frequency)
         ->setLabel(pht('Recurring Event Frequency'))
         ->setID($frequency_id)
         ->setDisabled(!$is_recurring);
     }
 
     Javelin::initBehavior('event-all-day', array(
       'allDayID' => $all_day_id,
       'startDateID' => $start_date_id,
       'endDateID' => $end_date_id,
     ));
 
     $all_day_checkbox = id(new AphrontFormCheckboxControl())
       ->addCheckbox(
         'isAllDay',
         1,
         pht('All Day Event'),
         $is_all_day,
         $all_day_id);
 
     $start_control = id(new AphrontFormDateControl())
       ->setUser($viewer)
       ->setName('start')
       ->setLabel(pht('Start'))
       ->setError($error_start_date)
       ->setValue($start_value)
       ->setID($start_date_id)
       ->setIsTimeDisabled($is_all_day)
       ->setEndDateID($end_date_id);
 
     $end_control = id(new AphrontFormDateControl())
       ->setUser($viewer)
       ->setName('end')
       ->setLabel(pht('End'))
       ->setError($error_end_date)
       ->setValue($end_value)
       ->setID($end_date_id)
       ->setIsTimeDisabled($is_all_day);
 
     $description = id(new AphrontFormTextAreaControl())
       ->setLabel(pht('Description'))
       ->setName('description')
       ->setValue($description);
 
     $view_policies = id(new AphrontFormPolicyControl())
       ->setUser($viewer)
       ->setCapability(PhabricatorPolicyCapability::CAN_VIEW)
       ->setPolicyObject($event)
       ->setPolicies($current_policies)
       ->setName('viewPolicy');
     $edit_policies = id(new AphrontFormPolicyControl())
       ->setUser($viewer)
       ->setCapability(PhabricatorPolicyCapability::CAN_EDIT)
       ->setPolicyObject($event)
       ->setPolicies($current_policies)
       ->setName('editPolicy');
 
     $subscribers = id(new AphrontFormTokenizerControl())
       ->setLabel(pht('Subscribers'))
       ->setName('subscribers')
       ->setValue($subscribers)
       ->setUser($viewer)
       ->setDatasource(new PhabricatorMetaMTAMailableDatasource());
 
     $invitees = id(new AphrontFormTokenizerControl())
       ->setLabel(pht('Invitees'))
       ->setName('invitees')
       ->setValue($invitees)
       ->setUser($viewer)
       ->setDatasource(new PhabricatorMetaMTAMailableDatasource());
 
     if ($this->isCreate()) {
       $icon_uri = $this->getApplicationURI('icon/');
     } else {
       $icon_uri = $this->getApplicationURI('icon/'.$event->getID().'/');
     }
     $icon_display = PhabricatorCalendarIcon::renderIconForChooser($icon);
     $icon = id(new AphrontFormChooseButtonControl())
       ->setLabel(pht('Icon'))
       ->setName('icon')
       ->setDisplayValue($icon_display)
       ->setButtonText(pht('Choose Icon...'))
       ->setChooseURI($icon_uri)
       ->setValue($icon);
 
     $form = id(new AphrontFormView())
       ->addHiddenInput('next', $next_workflow)
       ->addHiddenInput('query', $uri_query)
       ->setUser($viewer)
       ->appendChild($name);
 
     if ($is_recurring_checkbox) {
       $form->appendChild($is_recurring_checkbox);
     }
+    if ($recurrence_end_date_control) {
+      $form->appendChild($recurrence_end_date_control);
+    }
     if ($recurrence_frequency_select) {
       $form->appendControl($recurrence_frequency_select);
     }
 
     $form
       ->appendChild($all_day_checkbox)
       ->appendChild($start_control)
       ->appendChild($end_control)
       ->appendControl($view_policies)
       ->appendControl($edit_policies)
       ->appendControl($subscribers)
       ->appendControl($invitees)
       ->appendChild($description)
       ->appendChild($icon);
 
 
     if ($request->isAjax()) {
       return $this->newDialog()
         ->setTitle($page_title)
         ->setWidth(AphrontDialogView::WIDTH_FULL)
         ->appendForm($form)
         ->addCancelButton($cancel_uri)
         ->addSubmitButton($submit_label);
     }
 
     $submit = id(new AphrontFormSubmitControl())
       ->addCancelButton($cancel_uri)
       ->setValue($submit_label);
 
     $form->appendChild($submit);
 
     $form_box = id(new PHUIObjectBoxView())
       ->setHeaderText($page_title)
       ->setForm($form);
 
     $crumbs = $this->buildApplicationCrumbs();
 
     if (!$this->isCreate()) {
       $crumbs->addTextCrumb('E'.$event->getId(), '/E'.$event->getId());
     }
 
     $crumbs->addTextCrumb($page_title);
 
     $object_box = id(new PHUIObjectBoxView())
       ->setHeaderText($page_title)
       ->setValidationException($validation_exception)
       ->appendChild($form);
 
     return $this->buildApplicationPage(
       array(
         $crumbs,
         $object_box,
         ),
       array(
         'title' => $page_title,
       ));
   }
 
 
   public function getNewInviteeList(array $phids, $event) {
     $invitees = $event->getInvitees();
     $invitees = mpull($invitees, null, 'getInviteePHID');
     $invited_status = PhabricatorCalendarEventInvitee::STATUS_INVITED;
     $uninvited_status = PhabricatorCalendarEventInvitee::STATUS_UNINVITED;
     $phids = array_fuse($phids);
 
     $new = array();
     foreach ($phids as $phid) {
       $old_status = $event->getUserInviteStatus($phid);
       if ($old_status != $uninvited_status) {
         continue;
       }
       $new[$phid] = $invited_status;
     }
 
     foreach ($invitees as $invitee) {
       $deleted_invitee = !idx($phids, $invitee->getInviteePHID());
       if ($deleted_invitee) {
         $new[$invitee->getInviteePHID()] = $uninvited_status;
       }
     }
 
     return $new;
   }
 
   private function getDefaultTimeValues($viewer) {
     $start = new DateTime('@'.time());
     $start->setTimeZone($viewer->getTimeZone());
 
     $start->setTime($start->format('H'), 0, 0);
     $start->modify('+1 hour');
     $end = id(clone $start)->modify('+1 hour');
 
     $start_value = AphrontFormDateControlValue::newFromEpoch(
       $viewer,
       $start->format('U'));
     $end_value = AphrontFormDateControlValue::newFromEpoch(
       $viewer,
       $end->format('U'));
 
     return array($start_value, $end_value);
   }
 
 }
diff --git a/src/applications/calendar/controller/PhabricatorCalendarEventViewController.php b/src/applications/calendar/controller/PhabricatorCalendarEventViewController.php
index 37411c9786..777a81cff3 100644
--- a/src/applications/calendar/controller/PhabricatorCalendarEventViewController.php
+++ b/src/applications/calendar/controller/PhabricatorCalendarEventViewController.php
@@ -1,314 +1,321 @@
 <?php
 
 final class PhabricatorCalendarEventViewController
   extends PhabricatorCalendarController {
 
   private $id;
 
   public function shouldAllowPublic() {
     return true;
   }
 
   public function willProcessRequest(array $data) {
     $this->id = $data['id'];
   }
 
   public function processRequest() {
     $request = $this->getRequest();
     $viewer = $request->getUser();
 
     $sequence = $request->getURIData('sequence');
 
     $event = id(new PhabricatorCalendarEventQuery())
       ->setViewer($viewer)
       ->withIDs(array($this->id))
       ->executeOne();
     if (!$event) {
       return new Aphront404Response();
     }
 
     if ($sequence && $event->getIsRecurring()) {
       $event = $event->generateNthGhost($sequence, $viewer);
     } else if ($sequence) {
       return new Aphront404Response();
     }
 
     $title = 'E'.$event->getID();
     $page_title = $title.' '.$event->getName();
     $crumbs = $this->buildApplicationCrumbs();
     $crumbs->addTextCrumb($title, '/E'.$event->getID());
 
     $timeline = $this->buildTransactionTimeline(
       $event,
       new PhabricatorCalendarEventTransactionQuery());
 
     $header = $this->buildHeaderView($event);
     $actions = $this->buildActionView($event);
     $properties = $this->buildPropertyView($event);
 
     $properties->setActionList($actions);
     $box = id(new PHUIObjectBoxView())
       ->setHeader($header)
       ->addPropertyList($properties);
 
     $is_serious = PhabricatorEnv::getEnvConfig('phabricator.serious-business');
     $add_comment_header = $is_serious
       ? pht('Add Comment')
       : pht('Add To Plate');
     $draft = PhabricatorDraft::newFromUserAndKey($viewer, $event->getPHID());
     $add_comment_form = id(new PhabricatorApplicationTransactionCommentView())
       ->setUser($viewer)
       ->setObjectPHID($event->getPHID())
       ->setDraft($draft)
       ->setHeaderText($add_comment_header)
       ->setAction(
         $this->getApplicationURI('/event/comment/'.$event->getID().'/'))
       ->setSubmitButtonName(pht('Add Comment'));
 
     return $this->buildApplicationPage(
       array(
         $crumbs,
         $box,
         $timeline,
         $add_comment_form,
       ),
       array(
         'title' => $page_title,
       ));
   }
 
   private function buildHeaderView(PhabricatorCalendarEvent $event) {
     $viewer = $this->getRequest()->getUser();
     $id = $event->getID();
 
     $is_cancelled = $event->getIsCancelled();
     $icon = $is_cancelled ? ('fa-times') : ('fa-calendar');
     $color = $is_cancelled ? ('grey') : ('green');
     $status = $is_cancelled ? pht('Cancelled') : pht('Active');
 
     $invite_status = $event->getUserInviteStatus($viewer->getPHID());
     $status_invited = PhabricatorCalendarEventInvitee::STATUS_INVITED;
     $is_invite_pending = ($invite_status == $status_invited);
 
     $header = id(new PHUIHeaderView())
       ->setUser($viewer)
       ->setHeader($event->getName())
       ->setStatus($icon, $color, $status)
       ->setPolicyObject($event);
 
     if ($is_invite_pending) {
       $decline_button = id(new PHUIButtonView())
         ->setTag('a')
         ->setIcon(id(new PHUIIconView())
           ->setIconFont('fa-times grey'))
         ->setHref($this->getApplicationURI("/event/decline/{$id}/"))
         ->setWorkflow(true)
         ->setText(pht('Decline'));
 
       $accept_button = id(new PHUIButtonView())
         ->setTag('a')
         ->setIcon(id(new PHUIIconView())
           ->setIconFont('fa-check green'))
         ->setHref($this->getApplicationURI("/event/accept/{$id}/"))
         ->setWorkflow(true)
         ->setText(pht('Accept'));
 
       $header->addActionLink($decline_button)
         ->addActionLink($accept_button);
     }
     return $header;
   }
 
   private function buildActionView(PhabricatorCalendarEvent $event) {
     $viewer = $this->getRequest()->getUser();
     $id = $event->getID();
     $is_cancelled = $event->getIsCancelled();
     $is_attending = $event->getIsUserAttending($viewer->getPHID());
 
     $actions = id(new PhabricatorActionListView())
       ->setObjectURI($this->getApplicationURI('event/'.$id.'/'))
       ->setUser($viewer)
       ->setObject($event);
 
     $can_edit = PhabricatorPolicyFilter::hasCapability(
       $viewer,
       $event,
       PhabricatorPolicyCapability::CAN_EDIT);
 
-    if ($event->getIsRecurring() && $event->getIsGhostEvent()) {
+    if ($event->getIsRecurring() && $event->getInstanceOfEventPHID()) {
       $index = $event->getSequenceIndex();
 
       $actions->addAction(
         id(new PhabricatorActionView())
           ->setName(pht('Edit This Instance'))
           ->setIcon('fa-pencil')
           ->setHref($this->getApplicationURI("event/edit/{$id}/{$index}/"))
           ->setDisabled(!$can_edit)
           ->setWorkflow(!$can_edit));
     }
 
     if (!$event->getIsRecurring() && !$event->getIsGhostEvent()) {
       $actions->addAction(
         id(new PhabricatorActionView())
           ->setName(pht('Edit Event'))
           ->setIcon('fa-pencil')
           ->setHref($this->getApplicationURI("event/edit/{$id}/"))
           ->setDisabled(!$can_edit)
           ->setWorkflow(!$can_edit));
     }
 
     if ($is_attending) {
       $actions->addAction(
         id(new PhabricatorActionView())
           ->setName(pht('Decline Event'))
           ->setIcon('fa-user-times')
           ->setHref($this->getApplicationURI("event/join/{$id}/"))
           ->setWorkflow(true));
     } else {
       $actions->addAction(
         id(new PhabricatorActionView())
           ->setName(pht('Join Event'))
           ->setIcon('fa-user-plus')
           ->setHref($this->getApplicationURI("event/join/{$id}/"))
           ->setWorkflow(true));
     }
 
     if ($is_cancelled) {
       $actions->addAction(
         id(new PhabricatorActionView())
           ->setName(pht('Reinstate Event'))
           ->setIcon('fa-plus')
           ->setHref($this->getApplicationURI("event/cancel/{$id}/"))
           ->setDisabled(!$can_edit)
           ->setWorkflow(true));
     } else {
       $actions->addAction(
         id(new PhabricatorActionView())
           ->setName(pht('Cancel Event'))
           ->setIcon('fa-times')
           ->setHref($this->getApplicationURI("event/cancel/{$id}/"))
           ->setDisabled(!$can_edit)
           ->setWorkflow(true));
     }
 
     return $actions;
   }
 
   private function buildPropertyView(PhabricatorCalendarEvent $event) {
     $viewer = $this->getRequest()->getUser();
 
     $properties = id(new PHUIPropertyListView())
       ->setUser($viewer)
       ->setObject($event);
 
     if ($event->getIsAllDay()) {
       $date_start = phabricator_date($event->getDateFrom(), $viewer);
       $date_end = phabricator_date($event->getDateTo(), $viewer);
 
       if ($date_start == $date_end) {
         $properties->addProperty(
           pht('Time'),
           phabricator_date($event->getDateFrom(), $viewer));
       } else {
         $properties->addProperty(
           pht('Starts'),
           phabricator_date($event->getDateFrom(), $viewer));
         $properties->addProperty(
           pht('Ends'),
           phabricator_date($event->getDateTo(), $viewer));
       }
     } else {
       $properties->addProperty(
         pht('Starts'),
         phabricator_datetime($event->getDateFrom(), $viewer));
 
       $properties->addProperty(
         pht('Ends'),
         phabricator_datetime($event->getDateTo(), $viewer));
     }
 
     if ($event->getIsRecurring()) {
       $properties->addProperty(
         pht('Recurs'),
         ucwords(idx($event->getRecurrenceFrequency(), 'rule')));
+
+      if ($event->getRecurrenceEndDate()) {
+        $properties->addProperty(
+          pht('Recurrence Ends'),
+          phabricator_datetime($event->getRecurrenceEndDate(), $viewer));
+      }
+
       if ($event->getInstanceOfEventPHID()) {
         $properties->addProperty(
           pht('Recurrence of Event'),
           $viewer->renderHandle($event->getInstanceOfEventPHID()));
       }
     }
 
     $properties->addProperty(
       pht('Host'),
       $viewer->renderHandle($event->getUserPHID()));
 
     $invitees = $event->getInvitees();
     foreach ($invitees as $key => $invitee) {
       if ($invitee->isUninvited()) {
         unset($invitees[$key]);
       }
     }
 
     if ($invitees) {
       $invitee_list = new PHUIStatusListView();
 
       $icon_invited = PHUIStatusItemView::ICON_OPEN;
       $icon_attending = PHUIStatusItemView::ICON_ACCEPT;
       $icon_declined = PHUIStatusItemView::ICON_REJECT;
 
       $status_invited = PhabricatorCalendarEventInvitee::STATUS_INVITED;
       $status_attending = PhabricatorCalendarEventInvitee::STATUS_ATTENDING;
       $status_declined = PhabricatorCalendarEventInvitee::STATUS_DECLINED;
 
       $icon_map = array(
         $status_invited => $icon_invited,
         $status_attending => $icon_attending,
         $status_declined => $icon_declined,
       );
 
       $icon_color_map = array(
         $status_invited => null,
         $status_attending => 'green',
         $status_declined => 'red',
       );
 
       foreach ($invitees as $invitee) {
         $item = new PHUIStatusItemView();
         $invitee_phid = $invitee->getInviteePHID();
         $status = $invitee->getStatus();
         $target = $viewer->renderHandle($invitee_phid);
         $icon = $icon_map[$status];
         $icon_color = $icon_color_map[$status];
 
         $item->setIcon($icon, $icon_color)
           ->setTarget($target);
         $invitee_list->addItem($item);
       }
     } else {
       $invitee_list = phutil_tag(
         'em',
         array(),
         pht('None'));
     }
 
     $properties->addProperty(
       pht('Invitees'),
       $invitee_list);
 
     $properties->invokeWillRenderEvent();
 
     $icon_display = PhabricatorCalendarIcon::renderIconForChooser(
       $event->getIcon());
     $properties->addProperty(
       pht('Icon'),
       $icon_display);
 
     $properties->addSectionHeader(
       pht('Description'),
       PHUIPropertyListView::ICON_SUMMARY);
     $properties->addTextContent($event->getDescription());
 
     return $properties;
   }
 
 }
diff --git a/src/applications/calendar/editor/PhabricatorCalendarEventEditor.php b/src/applications/calendar/editor/PhabricatorCalendarEventEditor.php
index ea0b886b35..712dd8945d 100644
--- a/src/applications/calendar/editor/PhabricatorCalendarEventEditor.php
+++ b/src/applications/calendar/editor/PhabricatorCalendarEventEditor.php
@@ -1,429 +1,431 @@
 <?php
 
 final class PhabricatorCalendarEventEditor
   extends PhabricatorApplicationTransactionEditor {
 
   public function getEditorApplicationClass() {
     return 'PhabricatorCalendarApplication';
   }
 
   public function getEditorObjectsDescription() {
     return pht('Calendar');
   }
 
   public function getTransactionTypes() {
     $types = parent::getTransactionTypes();
 
     $types[] = PhabricatorCalendarEventTransaction::TYPE_NAME;
     $types[] = PhabricatorCalendarEventTransaction::TYPE_START_DATE;
     $types[] = PhabricatorCalendarEventTransaction::TYPE_END_DATE;
     $types[] = PhabricatorCalendarEventTransaction::TYPE_DESCRIPTION;
     $types[] = PhabricatorCalendarEventTransaction::TYPE_CANCEL;
     $types[] = PhabricatorCalendarEventTransaction::TYPE_INVITE;
     $types[] = PhabricatorCalendarEventTransaction::TYPE_ALL_DAY;
     $types[] = PhabricatorCalendarEventTransaction::TYPE_ICON;
 
     $types[] = PhabricatorCalendarEventTransaction::TYPE_RECURRING;
     $types[] = PhabricatorCalendarEventTransaction::TYPE_FREQUENCY;
     $types[] = PhabricatorCalendarEventTransaction::TYPE_RECURRENCE_END_DATE;
     $types[] = PhabricatorCalendarEventTransaction::TYPE_INSTANCE_OF_EVENT;
     $types[] = PhabricatorCalendarEventTransaction::TYPE_SEQUENCE_INDEX;
 
     $types[] = PhabricatorTransactions::TYPE_COMMENT;
     $types[] = PhabricatorTransactions::TYPE_VIEW_POLICY;
     $types[] = PhabricatorTransactions::TYPE_EDIT_POLICY;
 
     return $types;
   }
 
   protected function getCustomTransactionOldValue(
     PhabricatorLiskDAO $object,
     PhabricatorApplicationTransaction $xaction) {
     switch ($xaction->getTransactionType()) {
       case PhabricatorCalendarEventTransaction::TYPE_RECURRING:
         return $object->getIsRecurring();
       case PhabricatorCalendarEventTransaction::TYPE_FREQUENCY:
         return $object->getRecurrenceFrequency();
       case PhabricatorCalendarEventTransaction::TYPE_RECURRENCE_END_DATE:
         return $object->getRecurrenceEndDate();
       case PhabricatorCalendarEventTransaction::TYPE_INSTANCE_OF_EVENT:
         return $object->getInstanceOfEventPHID();
       case PhabricatorCalendarEventTransaction::TYPE_SEQUENCE_INDEX:
         return $object->getSequenceIndex();
       case PhabricatorCalendarEventTransaction::TYPE_NAME:
         return $object->getName();
       case PhabricatorCalendarEventTransaction::TYPE_START_DATE:
         return $object->getDateFrom();
       case PhabricatorCalendarEventTransaction::TYPE_END_DATE:
         return $object->getDateTo();
       case PhabricatorCalendarEventTransaction::TYPE_DESCRIPTION:
         return $object->getDescription();
       case PhabricatorCalendarEventTransaction::TYPE_CANCEL:
         return $object->getIsCancelled();
       case PhabricatorCalendarEventTransaction::TYPE_ALL_DAY:
         return (int)$object->getIsAllDay();
       case PhabricatorCalendarEventTransaction::TYPE_ICON:
         return $object->getIcon();
       case PhabricatorCalendarEventTransaction::TYPE_INVITE:
         $map = $xaction->getNewValue();
         $phids = array_keys($map);
         $invitees = mpull($object->getInvitees(), null, 'getInviteePHID');
 
         $old = array();
         foreach ($phids as $phid) {
           $invitee = idx($invitees, $phid);
           if ($invitee) {
             $old[$phid] = $invitee->getStatus();
           } else {
             $old[$phid] = PhabricatorCalendarEventInvitee::STATUS_UNINVITED;
           }
         }
         return $old;
     }
 
     return parent::getCustomTransactionOldValue($object, $xaction);
   }
 
   protected function getCustomTransactionNewValue(
     PhabricatorLiskDAO $object,
     PhabricatorApplicationTransaction $xaction) {
     switch ($xaction->getTransactionType()) {
       case PhabricatorCalendarEventTransaction::TYPE_RECURRING:
       case PhabricatorCalendarEventTransaction::TYPE_FREQUENCY:
-      case PhabricatorCalendarEventTransaction::TYPE_RECURRENCE_END_DATE:
       case PhabricatorCalendarEventTransaction::TYPE_INSTANCE_OF_EVENT:
       case PhabricatorCalendarEventTransaction::TYPE_SEQUENCE_INDEX:
       case PhabricatorCalendarEventTransaction::TYPE_NAME:
       case PhabricatorCalendarEventTransaction::TYPE_DESCRIPTION:
       case PhabricatorCalendarEventTransaction::TYPE_CANCEL:
       case PhabricatorCalendarEventTransaction::TYPE_INVITE:
       case PhabricatorCalendarEventTransaction::TYPE_ICON:
         return $xaction->getNewValue();
       case PhabricatorCalendarEventTransaction::TYPE_ALL_DAY:
         return (int)$xaction->getNewValue();
+      case PhabricatorCalendarEventTransaction::TYPE_RECURRENCE_END_DATE:
       case PhabricatorCalendarEventTransaction::TYPE_START_DATE:
       case PhabricatorCalendarEventTransaction::TYPE_END_DATE:
         return $xaction->getNewValue()->getEpoch();
     }
 
     return parent::getCustomTransactionNewValue($object, $xaction);
   }
 
   protected function applyCustomInternalTransaction(
     PhabricatorLiskDAO $object,
     PhabricatorApplicationTransaction $xaction) {
 
     switch ($xaction->getTransactionType()) {
       case PhabricatorCalendarEventTransaction::TYPE_RECURRING:
         return $object->setIsRecurring($xaction->getNewValue());
       case PhabricatorCalendarEventTransaction::TYPE_FREQUENCY:
         return $object->setRecurrenceFrequency($xaction->getNewValue());
-      case PhabricatorCalendarEventTransaction::TYPE_RECURRENCE_END_DATE:
-        return $object->setRecurrenceEndDate($xaction->getNewValue());
       case PhabricatorCalendarEventTransaction::TYPE_INSTANCE_OF_EVENT:
         return $object->setInstanceOfEventPHID($xaction->getNewValue());
       case PhabricatorCalendarEventTransaction::TYPE_SEQUENCE_INDEX:
         return $object->setSequenceIndex($xaction->getNewValue());
       case PhabricatorCalendarEventTransaction::TYPE_NAME:
         $object->setName($xaction->getNewValue());
         return;
       case PhabricatorCalendarEventTransaction::TYPE_START_DATE:
         $object->setDateFrom($xaction->getNewValue());
         return;
       case PhabricatorCalendarEventTransaction::TYPE_END_DATE:
         $object->setDateTo($xaction->getNewValue());
         return;
+      case PhabricatorCalendarEventTransaction::TYPE_RECURRENCE_END_DATE:
+        $object->setRecurrenceEndDate($xaction->getNewValue());
+        return;
       case PhabricatorCalendarEventTransaction::TYPE_DESCRIPTION:
         $object->setDescription($xaction->getNewValue());
         return;
       case PhabricatorCalendarEventTransaction::TYPE_CANCEL:
         $object->setIsCancelled((int)$xaction->getNewValue());
         return;
       case PhabricatorCalendarEventTransaction::TYPE_ALL_DAY:
         $object->setIsAllDay((int)$xaction->getNewValue());
         return;
       case PhabricatorCalendarEventTransaction::TYPE_ICON:
         $object->setIcon($xaction->getNewValue());
         return;
       case PhabricatorCalendarEventTransaction::TYPE_INVITE:
         return;
     }
 
     return parent::applyCustomInternalTransaction($object, $xaction);
   }
 
   protected function applyCustomExternalTransaction(
     PhabricatorLiskDAO $object,
     PhabricatorApplicationTransaction $xaction) {
 
     switch ($xaction->getTransactionType()) {
       case PhabricatorCalendarEventTransaction::TYPE_RECURRING:
       case PhabricatorCalendarEventTransaction::TYPE_FREQUENCY:
       case PhabricatorCalendarEventTransaction::TYPE_RECURRENCE_END_DATE:
       case PhabricatorCalendarEventTransaction::TYPE_INSTANCE_OF_EVENT:
       case PhabricatorCalendarEventTransaction::TYPE_SEQUENCE_INDEX:
       case PhabricatorCalendarEventTransaction::TYPE_NAME:
       case PhabricatorCalendarEventTransaction::TYPE_START_DATE:
       case PhabricatorCalendarEventTransaction::TYPE_END_DATE:
       case PhabricatorCalendarEventTransaction::TYPE_DESCRIPTION:
       case PhabricatorCalendarEventTransaction::TYPE_CANCEL:
       case PhabricatorCalendarEventTransaction::TYPE_ALL_DAY:
       case PhabricatorCalendarEventTransaction::TYPE_ICON:
         return;
       case PhabricatorCalendarEventTransaction::TYPE_INVITE:
         $map = $xaction->getNewValue();
         $phids = array_keys($map);
         $invitees = $object->getInvitees();
         $invitees = mpull($invitees, null, 'getInviteePHID');
 
         foreach ($phids as $phid) {
           $invitee = idx($invitees, $phid);
           if (!$invitee) {
             $invitee = id(new PhabricatorCalendarEventInvitee())
               ->setEventPHID($object->getPHID())
               ->setInviteePHID($phid)
               ->setInviterPHID($this->getActingAsPHID());
             $invitees[] = $invitee;
           }
           $invitee->setStatus($map[$phid])
             ->save();
         }
         $object->attachInvitees($invitees);
         return;
     }
 
     return parent::applyCustomExternalTransaction($object, $xaction);
   }
 
   protected function didApplyInternalEffects(
     PhabricatorLiskDAO $object,
     array $xactions) {
 
     $object->removeViewerTimezone($this->requireActor());
 
     return $xactions;
   }
 
   protected function applyFinalEffects(
     PhabricatorLiskDAO $object,
     array $xactions) {
 
     // Clear the availability caches for users whose availability is affected
     // by this edit.
 
     $invalidate_all = false;
     $invalidate_phids = array();
     foreach ($xactions as $xaction) {
       switch ($xaction->getTransactionType()) {
         case PhabricatorCalendarEventTransaction::TYPE_ICON:
           break;
         case PhabricatorCalendarEventTransaction::TYPE_RECURRING:
         case PhabricatorCalendarEventTransaction::TYPE_FREQUENCY:
         case PhabricatorCalendarEventTransaction::TYPE_RECURRENCE_END_DATE:
         case PhabricatorCalendarEventTransaction::TYPE_INSTANCE_OF_EVENT:
         case PhabricatorCalendarEventTransaction::TYPE_SEQUENCE_INDEX:
         case PhabricatorCalendarEventTransaction::TYPE_START_DATE:
         case PhabricatorCalendarEventTransaction::TYPE_END_DATE:
         case PhabricatorCalendarEventTransaction::TYPE_CANCEL:
         case PhabricatorCalendarEventTransaction::TYPE_ALL_DAY:
           // For these kinds of changes, we need to invalidate the availabilty
           // caches for all attendees.
           $invalidate_all = true;
           break;
         case PhabricatorCalendarEventTransaction::TYPE_INVITE:
           foreach ($xaction->getNewValue() as $phid => $ignored) {
             $invalidate_phids[$phid] = $phid;
           }
           break;
       }
     }
 
     $phids = mpull($object->getInvitees(), 'getInviteePHID');
     $phids = array_fuse($phids);
 
     if (!$invalidate_all) {
       $phids = array_select_keys($phids, $invalidate_phids);
     }
 
     if ($phids) {
       $user = new PhabricatorUser();
       $conn_w = $user->establishConnection('w');
       queryfx(
         $conn_w,
         'UPDATE %T SET availabilityCacheTTL = NULL
           WHERE phid IN (%Ls) AND availabilityCacheTTL >= %d',
         $user->getTableName(),
         $phids,
         $object->getDateFromForCache());
     }
 
     return $xactions;
   }
 
 
   protected function validateAllTransactions(
     PhabricatorLiskDAO $object,
     array $xactions) {
     $start_date_xaction = PhabricatorCalendarEventTransaction::TYPE_START_DATE;
     $end_date_xaction = PhabricatorCalendarEventTransaction::TYPE_END_DATE;
     $start_date = $object->getDateFrom();
     $end_date = $object->getDateTo();
     $errors = array();
 
     foreach ($xactions as $xaction) {
       if ($xaction->getTransactionType() == $start_date_xaction) {
         $start_date = $xaction->getNewValue()->getEpoch();
       } else if ($xaction->getTransactionType() == $end_date_xaction) {
         $end_date = $xaction->getNewValue()->getEpoch();
       }
     }
     if ($start_date > $end_date) {
       $type = PhabricatorCalendarEventTransaction::TYPE_END_DATE;
       $errors[] = new PhabricatorApplicationTransactionValidationError(
         $type,
         pht('Invalid'),
         pht('End date must be after start date.'),
         null);
     }
 
     return $errors;
   }
 
   protected function validateTransaction(
     PhabricatorLiskDAO $object,
     $type,
     array $xactions) {
 
     $errors = parent::validateTransaction($object, $type, $xactions);
 
     switch ($type) {
       case PhabricatorCalendarEventTransaction::TYPE_NAME:
         $missing = $this->validateIsEmptyTextField(
           $object->getName(),
           $xactions);
 
         if ($missing) {
           $error = new PhabricatorApplicationTransactionValidationError(
             $type,
             pht('Required'),
             pht('Event name is required.'),
             nonempty(last($xactions), null));
 
           $error->setIsMissingFieldError(true);
           $errors[] = $error;
         }
         break;
+      case PhabricatorCalendarEventTransaction::TYPE_RECURRENCE_END_DATE:
       case PhabricatorCalendarEventTransaction::TYPE_START_DATE:
       case PhabricatorCalendarEventTransaction::TYPE_END_DATE:
         foreach ($xactions as $xaction) {
           $date_value = $xaction->getNewValue();
           if (!$date_value->isValid()) {
             $errors[] = new PhabricatorApplicationTransactionValidationError(
               $type,
               pht('Invalid'),
               pht('Invalid date.'),
               $xaction);
           }
         }
         break;
     }
 
     return $errors;
   }
 
   protected function shouldPublishFeedStory(
     PhabricatorLiskDAO $object,
     array $xactions) {
     return true;
   }
 
   protected function supportsSearch() {
     return true;
   }
 
   protected function shouldSendMail(
     PhabricatorLiskDAO $object,
     array $xactions) {
 
     $xactions = mfilter($xactions, 'shouldHide', true);
     return $xactions;
   }
 
   protected function getMailSubjectPrefix() {
     return pht('[Calendar]');
   }
 
   protected function getMailTo(PhabricatorLiskDAO $object) {
     $phids = array();
 
     if ($object->getUserPHID()) {
       $phids[] = $object->getUserPHID();
     }
     $phids[] = $this->getActingAsPHID();
 
     $invitees = $object->getInvitees();
     foreach ($invitees as $invitee) {
       $status = $invitee->getStatus();
       if ($status === PhabricatorCalendarEventInvitee::STATUS_ATTENDING
         || $status === PhabricatorCalendarEventInvitee::STATUS_INVITED) {
         $phids[] = $invitee->getInviteePHID();
       }
     }
 
     $phids = array_unique($phids);
 
     return $phids;
   }
 
   public function getMailTagsMap() {
     return array(
       PhabricatorCalendarEventTransaction::MAILTAG_CONTENT =>
         pht(
           "An event's name, status, invite list, ".
           "icon, and description changes."),
       PhabricatorCalendarEventTransaction::MAILTAG_RESCHEDULE =>
         pht(
           "An event's start and end date ".
           "and cancellation status changes."),
       PhabricatorCalendarEventTransaction::MAILTAG_OTHER =>
         pht('Other event activity not listed above occurs.'),
     );
   }
 
   protected function buildReplyHandler(PhabricatorLiskDAO $object) {
     return id(new PhabricatorCalendarReplyHandler())
       ->setMailReceiver($object);
   }
 
   protected function buildMailTemplate(PhabricatorLiskDAO $object) {
     $id = $object->getID();
     $name = $object->getName();
 
     return id(new PhabricatorMetaMTAMail())
       ->setSubject("E{$id}: {$name}")
       ->addHeader('Thread-Topic', "E{$id}: ".$object->getName());
   }
 
   protected function buildMailBody(
     PhabricatorLiskDAO $object,
     array $xactions) {
 
     $description = $object->getDescription();
     $body = parent::buildMailBody($object, $xactions);
 
     if (strlen($description)) {
       $body->addTextSection(
         pht('EVENT DESCRIPTION'),
         $object->getDescription());
     }
 
     $body->addLinkSection(
       pht('EVENT DETAIL'),
       PhabricatorEnv::getProductionURI('/E'.$object->getID()));
 
 
     return $body;
   }
 
 
 }
diff --git a/src/applications/calendar/query/PhabricatorCalendarEventQuery.php b/src/applications/calendar/query/PhabricatorCalendarEventQuery.php
index 23dd2a2cf9..d8374e4726 100644
--- a/src/applications/calendar/query/PhabricatorCalendarEventQuery.php
+++ b/src/applications/calendar/query/PhabricatorCalendarEventQuery.php
@@ -1,346 +1,350 @@
 <?php
 
 final class PhabricatorCalendarEventQuery
   extends PhabricatorCursorPagedPolicyAwareQuery {
 
   private $ids;
   private $phids;
   private $rangeBegin;
   private $rangeEnd;
   private $inviteePHIDs;
   private $creatorPHIDs;
   private $isCancelled;
   private $instanceSequencePairs;
 
 
   private $generateGhosts = false;
 
   public function setGenerateGhosts($generate_ghosts) {
     $this->generateGhosts = $generate_ghosts;
     return $this;
   }
 
   public function withIDs(array $ids) {
     $this->ids = $ids;
     return $this;
   }
 
   public function withPHIDs(array $phids) {
     $this->phids = $phids;
     return $this;
   }
 
   public function withDateRange($begin, $end) {
     $this->rangeBegin = $begin;
     $this->rangeEnd = $end;
     return $this;
   }
 
   public function withInvitedPHIDs(array $phids) {
     $this->inviteePHIDs = $phids;
     return $this;
   }
 
   public function withCreatorPHIDs(array $phids) {
     $this->creatorPHIDs = $phids;
     return $this;
   }
 
   public function withIsCancelled($is_cancelled) {
     $this->isCancelled = $is_cancelled;
     return $this;
   }
 
   public function withInstanceSequencePairs(array $pairs) {
     $this->instanceSequencePairs = $pairs;
     return $this;
   }
 
   protected function getDefaultOrderVector() {
     return array('start', 'id');
   }
 
   public function getOrderableColumns() {
     return array(
       'start' => array(
         'table' => $this->getPrimaryTableAlias(),
         'column' => 'dateFrom',
         'reverse' => true,
         'type' => 'int',
         'unique' => false,
       ),
     ) + parent::getOrderableColumns();
   }
 
   protected function getPagingValueMap($cursor, array $keys) {
     $event = $this->loadCursorObject($cursor);
     return array(
       'start' => $event->getDateFrom(),
       'id' => $event->getID(),
     );
   }
 
   protected function loadPage() {
     $table = new PhabricatorCalendarEvent();
     $conn_r = $table->establishConnection('r');
     $viewer = $this->getViewer();
 
     $data = queryfx_all(
       $conn_r,
       'SELECT event.* FROM %T event %Q %Q %Q %Q %Q',
       $table->getTableName(),
       $this->buildJoinClause($conn_r),
       $this->buildWhereClause($conn_r),
       $this->buildGroupClause($conn_r),
       $this->buildOrderClause($conn_r),
       $this->buildLimitClause($conn_r));
 
     $events = $table->loadAllFromArray($data);
 
     foreach ($events as $event) {
       $event->applyViewerTimezone($this->getViewer());
     }
 
     if (!$this->generateGhosts) {
       return $events;
     }
 
     $map = array();
     $instance_sequence_pairs = array();
 
     foreach ($events as $event) {
       $sequence_start = 0;
-      $instance_count = null;
+      $sequence_end = null;
       $duration = $event->getDateTo() - $event->getDateFrom();
+      $end = null;
 
       if ($event->getIsRecurring() && !$event->getInstanceOfEventPHID()) {
         $frequency = $event->getFrequencyUnit();
         $modify_key = '+1 '.$frequency;
 
         if ($this->rangeBegin && $this->rangeBegin > $event->getDateFrom()) {
           $max_date = $this->rangeBegin - $duration;
           $date = $event->getDateFrom();
           $datetime = PhabricatorTime::getDateTimeFromEpoch($date, $viewer);
 
           while ($date < $max_date) {
             // TODO: optimize this to not loop through all off-screen events
             $sequence_start++;
             $datetime = PhabricatorTime::getDateTimeFromEpoch($date, $viewer);
             $date = $datetime->modify($modify_key)->format('U');
           }
 
           $start = $this->rangeBegin;
         } else {
           $start = $event->getDateFrom() - $duration;
         }
 
         $date = $start;
-        $start_datetime = PhabricatorTime::getDateTimeFromEpoch(
-          $start,
-          $viewer);
+        $datetime = PhabricatorTime::getDateTimeFromEpoch($date, $viewer);
 
-        if ($this->rangeEnd) {
+        if (($this->rangeEnd && $event->getRecurrenceEndDate()) &&
+          $this->rangeEnd < $event->getRecurrenceEndDate()) {
           $end = $this->rangeEnd;
-          $instance_count = $sequence_start;
+        } else if ($event->getRecurrenceEndDate()) {
+          $end = $event->getRecurrenceEndDate();
+        } else if ($this->rangeEnd) {
+          $end = $this->rangeEnd;
+        }
 
+        if ($end) {
+          $sequence_end = $sequence_start;
           while ($date < $end) {
-            $instance_count++;
-            $datetime = PhabricatorTime::getDateTimeFromEpoch($date, $viewer);
+            $sequence_end++;
             $datetime->modify($modify_key);
             $date = $datetime->format('U');
           }
         } else {
-          $instance_count = $this->getRawResultLimit();
+          $sequence_end = $this->getRawResultLimit() + $sequence_start;
         }
 
         $sequence_start = max(1, $sequence_start);
 
-        $max_sequence = $sequence_start + $instance_count;
-        for ($index = $sequence_start; $index < $max_sequence; $index++) {
+        for ($index = $sequence_start; $index < $sequence_end; $index++) {
           $instance_sequence_pairs[] = array($event->getPHID(), $index);
           $events[] = $event->generateNthGhost($index, $viewer);
 
           $key = last_key($events);
           $map[$event->getPHID()][$index] = $key;
         }
       }
     }
 
     if (count($instance_sequence_pairs) > 0) {
       $sub_query = id(new PhabricatorCalendarEventQuery())
         ->setViewer($viewer)
         ->setParentQuery($this)
         ->withInstanceSequencePairs($instance_sequence_pairs)
         ->execute();
 
       foreach ($sub_query as $edited_ghost) {
         $indexes = idx($map, $edited_ghost->getInstanceOfEventPHID());
         $key = idx($indexes, $edited_ghost->getSequenceIndex());
         $events[$key] = $edited_ghost;
       }
 
       $id_map = array();
       foreach ($events as $key => $event) {
         if ($event->getIsGhostEvent()) {
           continue;
         }
         if (isset($id_map[$event->getID()])) {
           unset($events[$key]);
         } else {
           $id_map[$event->getID()] = true;
         }
       }
     }
 
     return $events;
   }
 
   protected function buildJoinClauseParts(AphrontDatabaseConnection $conn_r) {
     $parts = parent::buildJoinClauseParts($conn_r);
     if ($this->inviteePHIDs !== null) {
       $parts[] = qsprintf(
         $conn_r,
         'JOIN %T invitee ON invitee.eventPHID = event.phid
           AND invitee.status != %s',
         id(new PhabricatorCalendarEventInvitee())->getTableName(),
         PhabricatorCalendarEventInvitee::STATUS_UNINVITED);
     }
     return $parts;
   }
 
   protected function buildWhereClause(AphrontDatabaseConnection $conn_r) {
     $where = array();
 
     if ($this->ids) {
       $where[] = qsprintf(
         $conn_r,
         'event.id IN (%Ld)',
         $this->ids);
     }
 
     if ($this->phids) {
       $where[] = qsprintf(
         $conn_r,
         'event.phid IN (%Ls)',
         $this->phids);
     }
 
     if ($this->rangeBegin) {
       $where[] = qsprintf(
         $conn_r,
         'event.dateTo >= %d OR event.isRecurring = 1',
         $this->rangeBegin);
     }
 
     if ($this->rangeEnd) {
       $where[] = qsprintf(
         $conn_r,
         'event.dateFrom <= %d',
         $this->rangeEnd);
     }
 
     if ($this->inviteePHIDs !== null) {
       $where[] = qsprintf(
         $conn_r,
         'invitee.inviteePHID IN (%Ls)',
         $this->inviteePHIDs);
     }
 
     if ($this->creatorPHIDs) {
       $where[] = qsprintf(
         $conn_r,
         'event.userPHID IN (%Ls)',
         $this->creatorPHIDs);
     }
 
     if ($this->isCancelled !== null) {
       $where[] = qsprintf(
         $conn_r,
         'event.isCancelled = %d',
         (int)$this->isCancelled);
     }
 
     if ($this->instanceSequencePairs !== null) {
       $sql = array();
 
       foreach ($this->instanceSequencePairs as $pair) {
         $sql[] = qsprintf(
           $conn_r,
           '(event.instanceOfEventPHID = %s AND event.sequenceIndex = %d)',
           $pair[0],
           $pair[1]);
       }
       $where[] = qsprintf(
         $conn_r,
         '%Q',
         implode(' OR ', $sql));
     }
 
     $where[] = $this->buildPagingClause($conn_r);
 
     return $this->formatWhereClause($where);
   }
 
   protected function getPrimaryTableAlias() {
     return 'event';
   }
 
   protected function shouldGroupQueryResultRows() {
     if ($this->inviteePHIDs !== null) {
       return true;
     }
     return parent::shouldGroupQueryResultRows();
   }
 
   protected function getApplicationSearchObjectPHIDColumn() {
     return 'event.phid';
   }
 
   public function getQueryApplicationClass() {
     return 'PhabricatorCalendarApplication';
   }
 
 
   protected function willFilterPage(array $events) {
     $range_start = $this->rangeBegin;
     $range_end = $this->rangeEnd;
 
     foreach ($events as $key => $event) {
       $event_start = $event->getDateFrom();
       $event_end = $event->getDateTo();
 
       if ($range_start && $event_end < $range_start) {
         unset($events[$key]);
       }
       if ($range_end && $event_start > $range_end) {
         unset($events[$key]);
       }
     }
 
     $phids = array();
 
     foreach ($events as $event) {
       $phids[] = $event->getPHID();
     }
 
     if ($events) {
       $invitees = id(new PhabricatorCalendarEventInviteeQuery())
         ->setViewer($this->getViewer())
         ->withEventPHIDs($phids)
         ->execute();
       $invitees = mgroup($invitees, 'getEventPHID');
     } else {
       $invitees = array();
     }
 
     foreach ($events as $event) {
       $event_invitees = idx($invitees, $event->getPHID(), array());
       $event->attachInvitees($event_invitees);
     }
 
     $events = msort($events, 'getDateFrom');
 
     return $events;
   }
 
 }
diff --git a/src/applications/calendar/query/PhabricatorCalendarEventSearchEngine.php b/src/applications/calendar/query/PhabricatorCalendarEventSearchEngine.php
index 24c77b096e..321e0e1439 100644
--- a/src/applications/calendar/query/PhabricatorCalendarEventSearchEngine.php
+++ b/src/applications/calendar/query/PhabricatorCalendarEventSearchEngine.php
@@ -1,514 +1,513 @@
 <?php
 
 final class PhabricatorCalendarEventSearchEngine
   extends PhabricatorApplicationSearchEngine {
 
   private $calendarYear;
   private $calendarMonth;
   private $calendarDay;
 
   public function getResultTypeDescription() {
     return pht('Calendar Events');
   }
 
   public function getApplicationClassName() {
     return 'PhabricatorCalendarApplication';
   }
 
   public function buildSavedQueryFromRequest(AphrontRequest $request) {
     $saved = new PhabricatorSavedQuery();
 
     $saved->setParameter(
       'rangeStart',
       $this->readDateFromRequest($request, 'rangeStart'));
 
     $saved->setParameter(
       'rangeEnd',
       $this->readDateFromRequest($request, 'rangeEnd'));
 
     $saved->setParameter(
       'upcoming',
       $this->readBoolFromRequest($request, 'upcoming'));
 
     $saved->setParameter(
       'invitedPHIDs',
       $this->readUsersFromRequest($request, 'invited'));
 
     $saved->setParameter(
       'creatorPHIDs',
       $this->readUsersFromRequest($request, 'creators'));
 
     $saved->setParameter(
       'isCancelled',
       $request->getStr('isCancelled'));
 
     $saved->setParameter(
       'display',
       $request->getStr('display'));
 
     return $saved;
   }
 
   public function buildQueryFromSavedQuery(PhabricatorSavedQuery $saved) {
     $query = id(new PhabricatorCalendarEventQuery())
       ->setGenerateGhosts(true);
     $viewer = $this->requireViewer();
     $timezone = new DateTimeZone($viewer->getTimezoneIdentifier());
 
     $min_range = $this->getDateFrom($saved)->getEpoch();
     $max_range = $this->getDateTo($saved)->getEpoch();
 
     if ($this->isMonthView($saved) ||
       $this->isDayView($saved)) {
       list($start_year, $start_month, $start_day) =
         $this->getDisplayYearAndMonthAndDay($saved);
 
       $start_day = new DateTime(
         "{$start_year}-{$start_month}-{$start_day}",
         $timezone);
       $next = clone $start_day;
 
       if ($this->isMonthView($saved)) {
         $next->modify('+1 month');
       } else if ($this->isDayView($saved)) {
         $next->modify('+6 day');
       }
 
       $display_start = $start_day->format('U');
       $display_end = $next->format('U');
 
       $preferences = $viewer->loadPreferences();
       $pref_week_day = PhabricatorUserPreferences::PREFERENCE_WEEK_START_DAY;
 
       $start_of_week = $preferences->getPreference($pref_week_day, 0);
       $end_of_week = ($start_of_week + 6) % 7;
 
       $first_of_month = $start_day->format('w');
       $last_of_month = id(clone $next)->modify('-1 day')->format('w');
 
       if (!$min_range || ($min_range < $display_start)) {
         $min_range = $display_start;
 
         if ($this->isMonthView($saved) &&
           $first_of_month !== $start_of_week) {
           $interim_day_num = ($first_of_month + 7 - $start_of_week) % 7;
           $min_range = id(clone $start_day)
             ->modify('-'.$interim_day_num.' days')
             ->format('U');
         }
       }
       if (!$max_range || ($max_range > $display_end)) {
         $max_range = $display_end;
 
         if ($this->isMonthView($saved) &&
           $last_of_month !== $end_of_week) {
           $interim_day_num = ($end_of_week + 7 - $last_of_month) % 7;
           $max_range = id(clone $next)
             ->modify('+'.$interim_day_num.' days')
             ->format('U');
         }
 
       }
     }
 
     if ($saved->getParameter('upcoming')) {
       if ($min_range) {
         $min_range = max(time(), $min_range);
       } else {
         $min_range = time();
       }
     }
 
     if ($min_range || $max_range) {
       $query->withDateRange($min_range, $max_range);
     }
 
     $invited_phids = $saved->getParameter('invitedPHIDs');
     if ($invited_phids) {
       $query->withInvitedPHIDs($invited_phids);
     }
 
     $creator_phids = $saved->getParameter('creatorPHIDs');
     if ($creator_phids) {
       $query->withCreatorPHIDs($creator_phids);
     }
 
     $is_cancelled = $saved->getParameter('isCancelled', 'active');
 
     switch ($is_cancelled) {
       case 'active':
         $query->withIsCancelled(false);
         break;
       case 'cancelled':
         $query->withIsCancelled(true);
         break;
     }
 
     return $query;
   }
 
   public function buildSearchForm(
     AphrontFormView $form,
     PhabricatorSavedQuery $saved) {
 
     $range_start = $this->getDateFrom($saved);
     $e_start = null;
 
     $range_end = $this->getDateTo($saved);
     $e_end = null;
 
     if (!$range_start->isValid()) {
       $this->addError(pht('Start date is not valid.'));
       $e_start = pht('Invalid');
     }
 
     if (!$range_end->isValid()) {
       $this->addError(pht('End date is not valid.'));
       $e_end = pht('Invalid');
     }
 
     $start_epoch = $range_start->getEpoch();
     $end_epoch = $range_end->getEpoch();
 
     if ($start_epoch && $end_epoch && ($start_epoch > $end_epoch)) {
       $this->addError(pht('End date must be after start date.'));
       $e_start = pht('Invalid');
       $e_end = pht('Invalid');
     }
 
     $upcoming = $saved->getParameter('upcoming');
     $is_cancelled = $saved->getParameter('isCancelled', 'active');
     $display = $saved->getParameter('display', 'month');
 
     $invited_phids = $saved->getParameter('invitedPHIDs', array());
     $creator_phids = $saved->getParameter('creatorPHIDs', array());
     $resolution_types = array(
       'active' => pht('Active Events Only'),
       'cancelled' => pht('Cancelled Events Only'),
       'both' => pht('Both Cancelled and Active Events'),
     );
     $display_options = array(
       'month' => pht('Month View'),
       'day' => pht('Day View (beta)'),
       'list' => pht('List View'),
     );
 
     $form
       ->appendControl(
         id(new AphrontFormTokenizerControl())
           ->setDatasource(new PhabricatorPeopleDatasource())
           ->setName('creators')
           ->setLabel(pht('Created By'))
           ->setValue($creator_phids))
       ->appendControl(
         id(new AphrontFormTokenizerControl())
           ->setDatasource(new PhabricatorPeopleDatasource())
           ->setName('invited')
           ->setLabel(pht('Invited'))
           ->setValue($invited_phids))
       ->appendChild(
         id(new AphrontFormDateControl())
           ->setLabel(pht('Occurs After'))
           ->setUser($this->requireViewer())
           ->setName('rangeStart')
           ->setError($e_start)
           ->setValue($range_start))
       ->appendChild(
         id(new AphrontFormDateControl())
           ->setLabel(pht('Occurs Before'))
           ->setUser($this->requireViewer())
           ->setName('rangeEnd')
           ->setError($e_end)
           ->setValue($range_end))
       ->appendChild(
         id(new AphrontFormCheckboxControl())
           ->addCheckbox(
             'upcoming',
             1,
             pht('Show only upcoming events.'),
             $upcoming))
       ->appendChild(
         id(new AphrontFormSelectControl())
           ->setLabel(pht('Cancelled Events'))
           ->setName('isCancelled')
           ->setValue($is_cancelled)
           ->setOptions($resolution_types))
       ->appendChild(
         id(new AphrontFormSelectControl())
           ->setLabel(pht('Display Options'))
           ->setName('display')
           ->setValue($display)
           ->setOptions($display_options));
   }
 
   protected function getURI($path) {
     return '/calendar/'.$path;
   }
 
   protected function getBuiltinQueryNames() {
     $names = array(
       'month' => pht('Month View'),
       'day' => pht('Day View'),
       'upcoming' => pht('Upcoming Events'),
       'all' => pht('All Events'),
     );
 
     return $names;
   }
 
   public function setCalendarYearAndMonthAndDay($year, $month, $day = null) {
     $this->calendarYear = $year;
     $this->calendarMonth = $month;
     $this->calendarDay = $day;
 
     return $this;
   }
 
   public function buildSavedQueryFromBuiltin($query_key) {
     $query = $this->newSavedQuery();
     $query->setQueryKey($query_key);
 
     switch ($query_key) {
       case 'month':
         return $query->setParameter('display', 'month');
       case 'day':
         return $query->setParameter('display', 'day');
       case 'upcoming':
         return $query->setParameter('upcoming', true);
       case 'all':
         return $query;
     }
 
     return parent::buildSavedQueryFromBuiltin($query_key);
   }
 
   protected function getRequiredHandlePHIDsForResultList(
     array $objects,
     PhabricatorSavedQuery $query) {
     $phids = array();
     foreach ($objects as $event) {
       $phids[$event->getUserPHID()] = 1;
     }
     return array_keys($phids);
   }
 
   protected function renderResultList(
     array $events,
     PhabricatorSavedQuery $query,
     array $handles) {
 
     if ($this->isMonthView($query)) {
       return $this->buildCalendarView($events, $query, $handles);
     } else if ($this->isDayView($query)) {
       return $this->buildCalendarDayView($events, $query, $handles);
     }
 
     assert_instances_of($events, 'PhabricatorCalendarEvent');
     $viewer = $this->requireViewer();
     $list = new PHUIObjectItemListView();
     foreach ($events as $event) {
       $from = phabricator_datetime($event->getDateFrom(), $viewer);
       $to = phabricator_datetime($event->getDateTo(), $viewer);
       $creator_handle = $handles[$event->getUserPHID()];
 
       $item = id(new PHUIObjectItemView())
         ->setHeader($event->getName())
         ->setHref($event->getURI())
         ->addByline(pht('Creator: %s', $creator_handle->renderLink()))
         ->addAttribute(pht('From %s to %s', $from, $to))
         ->addAttribute(id(new PhutilUTF8StringTruncator())
           ->setMaximumGlyphs(64)
           ->truncateString($event->getDescription()));
 
       $list->addItem($item);
     }
 
     return $list;
   }
 
   private function buildCalendarView(
     array $statuses,
     PhabricatorSavedQuery $query,
     array $handles) {
     $viewer = $this->requireViewer();
     $now = time();
 
     list($start_year, $start_month) =
       $this->getDisplayYearAndMonthAndDay($query);
 
     $now_year  = phabricator_format_local_time($now, $viewer, 'Y');
     $now_month = phabricator_format_local_time($now, $viewer, 'm');
     $now_day   = phabricator_format_local_time($now, $viewer, 'j');
 
     if ($start_month == $now_month && $start_year == $now_year) {
       $month_view = new PHUICalendarMonthView(
         $this->getDateFrom($query),
         $this->getDateTo($query),
         $start_month,
         $start_year,
         $now_day);
     } else {
       $month_view = new PHUICalendarMonthView(
         $this->getDateFrom($query),
         $this->getDateTo($query),
         $start_month,
         $start_year);
     }
 
     $month_view->setUser($viewer);
 
     $phids = mpull($statuses, 'getUserPHID');
 
     foreach ($statuses as $status) {
       $viewer_is_invited = $status->getIsUserInvited($viewer->getPHID());
 
       $event = new AphrontCalendarEventView();
       $event->setEpochRange($status->getDateFrom(), $status->getDateTo());
       $event->setIsAllDay($status->getIsAllDay());
       $event->setIcon($status->getIcon());
 
       $name_text = $handles[$status->getUserPHID()]->getName();
       $status_text = $status->getName();
       $event->setUserPHID($status->getUserPHID());
       $event->setDescription(pht('%s (%s)', $name_text, $status_text));
       $event->setName($status_text);
       $event->setURI($status->getURI());
-      // $event->setEventID($status->getID());
       $event->setViewerIsInvited($viewer_is_invited);
       $month_view->addEvent($event);
     }
 
     $month_view->setBrowseURI(
       $this->getURI('query/'.$query->getQueryKey().'/'));
 
     return $month_view;
   }
 
   private function buildCalendarDayView(
     array $statuses,
     PhabricatorSavedQuery $query,
     array $handles) {
     $viewer = $this->requireViewer();
     list($start_year, $start_month, $start_day) =
       $this->getDisplayYearAndMonthAndDay($query);
 
     $day_view = id(new PHUICalendarDayView(
       $this->getDateFrom($query),
       $this->getDateTo($query),
       $start_year,
       $start_month,
       $start_day))
       ->setQuery($query->getQueryKey());
 
     $day_view->setUser($viewer);
 
     $phids = mpull($statuses, 'getUserPHID');
 
     foreach ($statuses as $status) {
       if ($status->getIsCancelled()) {
         continue;
       }
 
       $viewer_is_invited = $status->getIsUserInvited($viewer->getPHID());
 
       $can_edit = PhabricatorPolicyFilter::hasCapability(
         $viewer,
         $status,
         PhabricatorPolicyCapability::CAN_EDIT);
 
       $event = new AphrontCalendarEventView();
       $event->setCanEdit($can_edit);
       $event->setEventID($status->getID());
       $event->setEpochRange($status->getDateFrom(), $status->getDateTo());
       $event->setIsAllDay($status->getIsAllDay());
       $event->setIcon($status->getIcon());
       $event->setViewerIsInvited($viewer_is_invited);
 
       $event->setName($status->getName());
       $event->setURI($status->getURI());
       $day_view->addEvent($event);
     }
 
     $day_view->setBrowseURI(
       $this->getURI('query/'.$query->getQueryKey().'/'));
 
     return $day_view;
   }
 
   private function getDisplayYearAndMonthAndDay(
     PhabricatorSavedQuery $query) {
     $viewer = $this->requireViewer();
     if ($this->calendarYear && $this->calendarMonth) {
       $start_year = $this->calendarYear;
       $start_month = $this->calendarMonth;
       $start_day = $this->calendarDay ? $this->calendarDay : 1;
     } else {
       $epoch = $this->getDateFrom($query)->getEpoch();
       if (!$epoch) {
         $epoch = $this->getDateTo($query)->getEpoch();
         if (!$epoch) {
           $epoch = time();
         }
       }
       if ($this->isMonthView($query)) {
         $day = 1;
       } else {
         $day = phabricator_format_local_time($epoch, $viewer, 'd');
       }
       $start_year = phabricator_format_local_time($epoch, $viewer, 'Y');
       $start_month = phabricator_format_local_time($epoch, $viewer, 'm');
       $start_day = $day;
     }
     return array($start_year, $start_month, $start_day);
   }
 
   public function getPageSize(PhabricatorSavedQuery $saved) {
     return $saved->getParameter('limit', 1000);
   }
 
   private function getDateFrom(PhabricatorSavedQuery $saved) {
     return $this->getDate($saved, 'rangeStart');
   }
 
   private function getDateTo(PhabricatorSavedQuery $saved) {
     return $this->getDate($saved, 'rangeEnd');
   }
 
   private function getDate(PhabricatorSavedQuery $saved, $key) {
     $viewer = $this->requireViewer();
 
     $wild = $saved->getParameter($key);
     if ($wild) {
       $value = AphrontFormDateControlValue::newFromWild($viewer, $wild);
     } else {
       $value = AphrontFormDateControlValue::newFromEpoch(
         $viewer,
         PhabricatorTime::getTodayMidnightDateTime($viewer)->format('U'));
       $value->setEnabled(false);
     }
 
     $value->setOptional(true);
 
     return $value;
   }
 
   private function isMonthView(PhabricatorSavedQuery $query) {
     if ($this->isDayView($query)) {
       return false;
     }
     if ($query->getParameter('display') == 'month') {
       return true;
     }
   }
 
   private function isDayView(PhabricatorSavedQuery $query) {
     if ($query->getParameter('display') == 'day') {
       return true;
     }
     if ($this->calendarDay) {
       return true;
     }
 
     return false;
   }
 }
diff --git a/src/view/form/control/AphrontFormDateControl.php b/src/view/form/control/AphrontFormDateControl.php
index ac026d410b..7a742efaf1 100644
--- a/src/view/form/control/AphrontFormDateControl.php
+++ b/src/view/form/control/AphrontFormDateControl.php
@@ -1,334 +1,339 @@
 <?php
 
 final class AphrontFormDateControl extends AphrontFormControl {
 
   private $initialTime;
   private $zone;
 
   private $valueDate;
   private $valueTime;
   private $allowNull;
   private $continueOnInvalidDate = false;
   private $isTimeDisabled;
   private $isDisabled;
   private $endDateID;
 
   public function setAllowNull($allow_null) {
     $this->allowNull = $allow_null;
     return $this;
   }
 
   public function setIsTimeDisabled($is_disabled) {
     $this->isTimeDisabled = $is_disabled;
     return $this;
   }
 
+  public function setIsDisabled($is_datepicker_disabled) {
+    $this->isDisabled = $is_datepicker_disabled;
+    return $this;
+  }
+
   public function setEndDateID($value) {
     $this->endDateID = $value;
     return $this;
   }
 
   const TIME_START_OF_DAY         = 'start-of-day';
   const TIME_END_OF_DAY           = 'end-of-day';
   const TIME_START_OF_BUSINESS    = 'start-of-business';
   const TIME_END_OF_BUSINESS      = 'end-of-business';
 
   public function setInitialTime($time) {
     $this->initialTime = $time;
     return $this;
   }
 
   public function readValueFromRequest(AphrontRequest $request) {
     $date = $request->getStr($this->getDateInputName());
     $time = $request->getStr($this->getTimeInputName());
     $enabled = $request->getBool($this->getCheckboxInputName());
 
     if ($this->allowNull && !$enabled) {
       $this->setError(null);
       $this->setValue(null);
       return;
     }
 
     $err = $this->getError();
 
     if ($date || $time) {
       $this->valueDate = $date;
       $this->valueTime = $time;
 
       // Assume invalid.
       $err = 'Invalid';
 
       $zone = $this->getTimezone();
 
       try {
         $datetime = new DateTime("{$date} {$time}", $zone);
         $value = $datetime->format('U');
       } catch (Exception $ex) {
         $value = null;
       }
 
       if ($value) {
         $this->setValue($value);
         $err = null;
       } else {
         $this->setValue(null);
       }
     } else {
       $value = $this->getInitialValue();
       if ($value) {
         $this->setValue($value);
       } else {
         $this->setValue(null);
       }
     }
 
     $this->setError($err);
 
     return $this->getValue();
   }
 
   protected function getCustomControlClass() {
     return 'aphront-form-control-date';
   }
 
   public function setValue($epoch) {
     if ($epoch instanceof AphrontFormDateControlValue) {
       $this->continueOnInvalidDate = true;
       $this->valueDate = $epoch->getValueDate();
       $this->valueTime  = $epoch->getValueTime();
       $this->allowNull = $epoch->getOptional();
       $this->isDisabled = $epoch->isDisabled();
 
       return parent::setValue($epoch->getEpoch());
     }
 
     $result = parent::setValue($epoch);
 
     if ($epoch === null) {
       return $result;
     }
 
     $readable = $this->formatTime($epoch, 'Y!m!d!g:i A');
     $readable = explode('!', $readable, 4);
 
     $year  = $readable[0];
     $month = $readable[1];
     $day   = $readable[2];
 
     $this->valueDate = $month.'/'.$day.'/'.$year;
     $this->valueTime  = $readable[3];
 
     return $result;
   }
 
   private function getDateInputValue() {
     return $this->valueDate;
   }
 
   private function getTimeInputValue() {
     return $this->valueTime;
   }
 
   private function formatTime($epoch, $fmt) {
     return phabricator_format_local_time(
       $epoch,
       $this->user,
       $fmt);
   }
 
   private function getDateInputName() {
     return $this->getName().'_d';
   }
 
   private function getTimeInputName() {
     return $this->getName().'_t';
   }
 
   private function getCheckboxInputName() {
     return $this->getName().'_e';
   }
 
   protected function renderInput() {
 
     $disabled = null;
     if ($this->getValue() === null && !$this->continueOnInvalidDate) {
       $this->setValue($this->getInitialValue());
       if ($this->allowNull) {
         $disabled = 'disabled';
       }
     }
 
     if ($this->isDisabled) {
       $disabled = 'disabled';
     }
 
     $checkbox = null;
     if ($this->allowNull) {
       $checkbox = javelin_tag(
         'input',
         array(
           'type' => 'checkbox',
           'name' => $this->getCheckboxInputName(),
           'sigil' => 'calendar-enable',
           'class' => 'aphront-form-date-enabled-input',
           'value' => 1,
           'checked' => ($disabled === null ? 'checked' : null),
         ));
     }
 
     $date_sel = javelin_tag(
       'input',
       array(
         'autocomplete' => 'off',
         'name'  => $this->getDateInputName(),
         'sigil' => 'date-input',
         'value' => $this->getDateInputValue(),
         'type'  => 'text',
         'class' => 'aphront-form-date-input',
       ),
       '');
 
     $date_div = javelin_tag(
       'div',
       array(
         'class' => 'aphront-form-date-input-container',
       ),
       $date_sel);
 
     $cicon = id(new PHUIIconView())
       ->setIconFont('fa-calendar');
 
     $cal_icon = javelin_tag(
       'a',
       array(
         'href'  => '#',
         'class' => 'calendar-button',
         'sigil' => 'calendar-button',
       ),
       $cicon);
 
     $values = $this->getTimeTypeaheadValues();
 
     $time_id = celerity_generate_unique_node_id();
     Javelin::initBehavior('time-typeahead', array(
       'startTimeID' => $time_id,
       'endTimeID' => $this->endDateID,
       'timeValues' => $values,
       ));
 
 
     $time_sel = javelin_tag(
       'input',
       array(
         'autocomplete' => 'off',
         'name'  => $this->getTimeInputName(),
         'sigil' => 'time-input',
         'value' => $this->getTimeInputValue(),
         'type'  => 'text',
         'class' => 'aphront-form-time-input',
       ),
       '');
 
     $time_div = javelin_tag(
       'div',
       array(
         'id' => $time_id,
         'class' => 'aphront-form-time-input-container',
       ),
       $time_sel);
 
     Javelin::initBehavior('fancy-datepicker', array());
 
     $classes = array();
     $classes[] = 'aphront-form-date-container';
     if ($disabled) {
       $classes[] = 'datepicker-disabled';
     }
     if ($this->isTimeDisabled) {
       $classes[] = 'no-time';
     }
 
     return javelin_tag(
       'div',
       array(
         'class' => implode(' ', $classes),
         'sigil' => 'phabricator-date-control',
         'meta'  => array(
           'disabled' => (bool)$disabled,
         ),
         'id' => $this->getID(),
       ),
       array(
         $checkbox,
         $date_div,
         $cal_icon,
         $time_div,
       ));
   }
 
   private function getTimezone() {
     if ($this->zone) {
       return $this->zone;
     }
 
     $user = $this->getUser();
     if (!$this->getUser()) {
       throw new PhutilInvalidStateException('setUser');
     }
 
     $user_zone = $user->getTimezoneIdentifier();
     $this->zone = new DateTimeZone($user_zone);
     return $this->zone;
   }
 
   private function getInitialValue() {
     $zone = $this->getTimezone();
 
     // TODO: We could eventually allow these to be customized per install or
     // per user or both, but let's wait and see.
     switch ($this->initialTime) {
       case self::TIME_START_OF_DAY:
       default:
         $time = '12:00 AM';
         break;
       case self::TIME_START_OF_BUSINESS:
         $time = '9:00 AM';
         break;
       case self::TIME_END_OF_BUSINESS:
         $time = '5:00 PM';
         break;
       case self::TIME_END_OF_DAY:
         $time = '11:59 PM';
         break;
     }
 
     $today = $this->formatTime(time(), 'Y-m-d');
     try {
       $date = new DateTime("{$today} {$time}", $zone);
       $value = $date->format('U');
     } catch (Exception $ex) {
       $value = null;
     }
 
     return $value;
   }
 
   private function getTimeTypeaheadValues() {
     $times = array();
     $am_pm_list = array('AM', 'PM');
 
     foreach ($am_pm_list as $am_pm) {
       for ($hour = 0; $hour < 12; $hour++) {
         $actual_hour = ($hour == 0) ? 12 : $hour;
         $times[] = $actual_hour.':00 '.$am_pm;
         $times[] = $actual_hour.':30 '.$am_pm;
       }
     }
 
     foreach ($times as $key => $time) {
       $times[$key] = array($key, $time);
     }
     return $times;
   }
 
 }
diff --git a/webroot/rsrc/js/application/calendar/behavior-recurring-edit.js b/webroot/rsrc/js/application/calendar/behavior-recurring-edit.js
index ee5c916d2c..6ce29bdf6b 100644
--- a/webroot/rsrc/js/application/calendar/behavior-recurring-edit.js
+++ b/webroot/rsrc/js/application/calendar/behavior-recurring-edit.js
@@ -1,14 +1,21 @@
 /**
  * @provides javelin-behavior-recurring-edit
  */
 
 
 JX.behavior('recurring-edit', function(config) {
   var checkbox = JX.$(config.isRecurring);
+
   JX.DOM.listen(checkbox, 'change', null, function() {
     var frequency = JX.$(config.frequency);
+    var end_date = JX.$(config.recurrenceEndDate);
 
     frequency.disabled = checkbox.checked ? false : true;
+    end_date.disabled = checkbox.checked ? false : true;
+
+    if (end_date.disabled) {
+      JX.DOM.alterClass(end_date, 'datepicker-disabled', !checkbox.checked);
+    }
   });
 
 });