diff --git a/src/applications/calendar/application/PhabricatorCalendarApplication.php b/src/applications/calendar/application/PhabricatorCalendarApplication.php
index 465bb2ae5c..38bd7f9d0a 100644
--- a/src/applications/calendar/application/PhabricatorCalendarApplication.php
+++ b/src/applications/calendar/application/PhabricatorCalendarApplication.php
@@ -1,97 +1,97 @@
 <?php
 
 final class PhabricatorCalendarApplication extends PhabricatorApplication {
 
   public function getName() {
     return pht('Calendar');
   }
 
   public function getShortDescription() {
     return pht('Upcoming Events');
   }
 
   public function getFlavorText() {
     return pht('Never miss an episode ever again.');
   }
 
   public function getBaseURI() {
     return '/calendar/';
   }
 
   public function getFontIcon() {
     return 'fa-calendar';
   }
 
   public function getTitleGlyph() {
     // Unicode has a calendar character but it's in some distant code plane,
     // use "keyboard" since it looks vaguely similar.
     return "\xE2\x8C\xA8";
   }
 
   public function isPrototype() {
     return true;
   }
 
   public function getRemarkupRules() {
     return array(
       new PhabricatorCalendarRemarkupRule(),
     );
   }
 
   public function getRoutes() {
     return array(
       '/E(?P<id>[1-9]\d*)(?:/(?P<sequence>\d+))?'
         => 'PhabricatorCalendarEventViewController',
       '/calendar/' => array(
         '(?:query/(?P<queryKey>[^/]+)/(?:(?P<year>\d+)/'.
           '(?P<month>\d+)/)?(?:(?P<day>\d+)/)?)?'
           => 'PhabricatorCalendarEventListController',
         'icon/(?P<id>[1-9]\d*)/'
           => 'PhabricatorCalendarEventEditIconController',
         'icon/'
           => 'PhabricatorCalendarEventEditIconController',
         'event/' => array(
           'create/'
             => 'PhabricatorCalendarEventEditController',
-          'edit/(?P<id>[1-9]\d*)/'
+          'edit/(?P<id>[1-9]\d*)/(?:(?P<sequence>\d+)/)?'
             => 'PhabricatorCalendarEventEditController',
           'drag/(?P<id>[1-9]\d*)/'
             => 'PhabricatorCalendarEventDragController',
           'cancel/(?P<id>[1-9]\d*)/'
             => 'PhabricatorCalendarEventCancelController',
           '(?P<action>join|decline|accept)/(?P<id>[1-9]\d*)/'
             => 'PhabricatorCalendarEventJoinController',
           'comment/(?P<id>[1-9]\d*)/'
             => 'PhabricatorCalendarEventCommentController',
         ),
       ),
     );
   }
 
   public function getQuickCreateItems(PhabricatorUser $viewer) {
     $items = array();
 
     $item = id(new PHUIListItemView())
       ->setName(pht('Calendar Event'))
       ->setIcon('fa-calendar')
       ->setHref($this->getBaseURI().'event/create/');
     $items[] = $item;
 
     return $items;
   }
 
   public function getMailCommandObjects() {
     return array(
       'event' => array(
         'name' => pht('Email Commands: Events'),
         'header' => pht('Interacting with Calendar Events'),
         'object' => new PhabricatorCalendarEvent(),
         'summary' => pht(
           'This page documents the commands you can use to interact with '.
           'events in Calendar. These commands work when creating new tasks '.
           'via email and when replying to existing tasks.'),
       ),
     );
   }
 
 }
diff --git a/src/applications/calendar/controller/PhabricatorCalendarEventEditController.php b/src/applications/calendar/controller/PhabricatorCalendarEventEditController.php
index 0710b56907..489b4e6d25 100644
--- a/src/applications/calendar/controller/PhabricatorCalendarEventEditController.php
+++ b/src/applications/calendar/controller/PhabricatorCalendarEventEditController.php
@@ -1,467 +1,513 @@
 <?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_start_date = true;
     $error_end_date = true;
     $validation_exception = null;
 
     $is_recurring_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);
       }
 
 
       $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());
 
       $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');
       $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);
 
       $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_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);
 
         $event->setViewPolicy($view_policy);
         $event->setEditPolicy($edit_policy);
       }
     }
 
     $name = id(new AphrontFormTextControl())
       ->setLabel(pht('Name'))
       ->setName('name')
       ->setValue($name)
       ->setError($error_name);
 
     Javelin::initBehavior('recurring-edit', array(
       'isRecurring' => $is_recurring_id,
       'frequency' => $frequency_id,
     ));
 
     $is_recurring_checkbox = id(new AphrontFormCheckboxControl())
       ->addCheckbox(
         'isRecurring',
         1,
         pht('Recurring Event'),
         $is_recurring,
         $is_recurring_id);
 
     $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)
       ->appendChild($is_recurring_checkbox)
       ->appendChild($recurrence_frequency_select)
       ->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 07f2762f63..3ef692b9a8 100644
--- a/src/applications/calendar/controller/PhabricatorCalendarEventViewController.php
+++ b/src/applications/calendar/controller/PhabricatorCalendarEventViewController.php
@@ -1,302 +1,314 @@
 <?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->getIsGhostEvent()) {
+    if (($event->getIsRecurring() && $event->getIsGhostEvent())) {
+      $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->getIsGhostEvent()) {
+      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/query/PhabricatorCalendarEventQuery.php b/src/applications/calendar/query/PhabricatorCalendarEventQuery.php
index 4ed222b3d7..23dd2a2cf9 100644
--- a/src/applications/calendar/query/PhabricatorCalendarEventQuery.php
+++ b/src/applications/calendar/query/PhabricatorCalendarEventQuery.php
@@ -1,290 +1,346 @@
 <?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;
       $duration = $event->getDateTo() - $event->getDateFrom();
 
-      if ($event->getIsRecurring()) {
+      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);
 
         if ($this->rangeEnd) {
           $end = $this->rangeEnd;
           $instance_count = $sequence_start;
 
           while ($date < $end) {
             $instance_count++;
             $datetime = PhabricatorTime::getDateTimeFromEpoch($date, $viewer);
             $datetime->modify($modify_key);
             $date = $datetime->format('U');
           }
         } else {
           $instance_count = $this->getRawResultLimit();
         }
 
         $sequence_start = max(1, $sequence_start);
 
         $max_sequence = $sequence_start + $instance_count;
         for ($index = $sequence_start; $index < $max_sequence; $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/storage/PhabricatorCalendarEvent.php b/src/applications/calendar/storage/PhabricatorCalendarEvent.php
index 3207e9897f..979fec1444 100644
--- a/src/applications/calendar/storage/PhabricatorCalendarEvent.php
+++ b/src/applications/calendar/storage/PhabricatorCalendarEvent.php
@@ -1,476 +1,477 @@
 <?php
 
 final class PhabricatorCalendarEvent extends PhabricatorCalendarDAO
   implements PhabricatorPolicyInterface,
   PhabricatorMarkupInterface,
   PhabricatorApplicationTransactionInterface,
   PhabricatorSubscribableInterface,
   PhabricatorTokenReceiverInterface,
   PhabricatorDestructibleInterface,
   PhabricatorMentionableInterface,
   PhabricatorFlaggableInterface {
 
   protected $name;
   protected $userPHID;
   protected $dateFrom;
   protected $dateTo;
   protected $description;
   protected $isCancelled;
   protected $isAllDay;
   protected $icon;
   protected $mailKey;
 
   protected $isRecurring = 0;
   protected $recurrenceFrequency = array();
   protected $recurrenceEndDate;
 
   private $isGhostEvent = false;
   protected $instanceOfEventPHID;
   protected $sequenceIndex;
 
   protected $viewPolicy;
   protected $editPolicy;
 
   const DEFAULT_ICON = 'fa-calendar';
 
   private $invitees = self::ATTACHABLE;
   private $appliedViewer;
 
   public static function initializeNewCalendarEvent(
     PhabricatorUser $actor,
     $mode) {
     $app = id(new PhabricatorApplicationQuery())
       ->setViewer($actor)
       ->withClasses(array('PhabricatorCalendarApplication'))
       ->executeOne();
 
     $view_policy = null;
     $is_recurring = 0;
 
     if ($mode == 'public') {
       $view_policy = PhabricatorPolicies::getMostOpenPolicy();
     } else if ($mode == 'recurring') {
       $is_recurring = true;
     } else {
       $view_policy = $actor->getPHID();
     }
 
     return id(new PhabricatorCalendarEvent())
       ->setUserPHID($actor->getPHID())
       ->setIsCancelled(0)
       ->setIsAllDay(0)
       ->setIsRecurring($is_recurring)
       ->setIcon(self::DEFAULT_ICON)
       ->setViewPolicy($view_policy)
       ->setEditPolicy($actor->getPHID())
       ->attachInvitees(array())
       ->applyViewerTimezone($actor);
   }
 
   public function applyViewerTimezone(PhabricatorUser $viewer) {
     if ($this->appliedViewer) {
       throw new Exception(pht('Viewer timezone is already applied!'));
     }
 
     $this->appliedViewer = $viewer;
 
     if (!$this->getIsAllDay()) {
       return $this;
     }
 
     $zone = $viewer->getTimeZone();
 
 
     $this->setDateFrom(
       $this->getDateEpochForTimeZone(
         $this->getDateFrom(),
         new DateTimeZone('Pacific/Kiritimati'),
         'Y-m-d',
         null,
         $zone));
 
     $this->setDateTo(
       $this->getDateEpochForTimeZone(
         $this->getDateTo(),
         new DateTimeZone('Pacific/Midway'),
         'Y-m-d 23:59:00',
         '-1 day',
         $zone));
 
     return $this;
   }
 
 
   public function removeViewerTimezone(PhabricatorUser $viewer) {
     if (!$this->appliedViewer) {
       throw new Exception(pht('Viewer timezone is not applied!'));
     }
 
     if ($viewer->getPHID() != $this->appliedViewer->getPHID()) {
       throw new Exception(pht('Removed viewer must match applied viewer!'));
     }
 
     $this->appliedViewer = null;
 
     if (!$this->getIsAllDay()) {
       return $this;
     }
 
     $zone = $viewer->getTimeZone();
 
     $this->setDateFrom(
       $this->getDateEpochForTimeZone(
         $this->getDateFrom(),
         $zone,
         'Y-m-d',
         null,
         new DateTimeZone('Pacific/Kiritimati')));
 
     $this->setDateTo(
       $this->getDateEpochForTimeZone(
         $this->getDateTo(),
         $zone,
         'Y-m-d',
         '+1 day',
         new DateTimeZone('Pacific/Midway')));
 
     return $this;
   }
 
   private function getDateEpochForTimeZone(
     $epoch,
     $src_zone,
     $format,
     $adjust,
     $dst_zone) {
 
     $src = new DateTime('@'.$epoch);
     $src->setTimeZone($src_zone);
 
     if (strlen($adjust)) {
       $adjust = ' '.$adjust;
     }
 
     $dst = new DateTime($src->format($format).$adjust, $dst_zone);
     return $dst->format('U');
   }
 
   public function save() {
     if ($this->appliedViewer) {
       throw new Exception(
         pht(
           'Can not save event with viewer timezone still applied!'));
     }
 
     if (!$this->mailKey) {
       $this->mailKey = Filesystem::readRandomCharacters(20);
     }
 
     return parent::save();
   }
 
   /**
    * Get the event start epoch for evaluating invitee availability.
    *
    * When assessing availability, we pretend events start earlier than they
    * really. 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 getDateFromForCache() {
     return ($this->getDateFrom() - phutil_units('15 minutes in seconds'));
   }
 
   protected function getConfiguration() {
     return array(
       self::CONFIG_AUX_PHID => true,
       self::CONFIG_COLUMN_SCHEMA => array(
         'name' => 'text',
         'dateFrom' => 'epoch',
         'dateTo' => 'epoch',
         'description' => 'text',
         'isCancelled' => 'bool',
         'isAllDay' => 'bool',
         'icon' => 'text32',
         'mailKey' => 'bytes20',
         'isRecurring' => 'bool',
         'recurrenceEndDate' => 'epoch?',
         'instanceOfEventPHID' => 'phid?',
         'sequenceIndex' => 'uint32?',
       ),
       self::CONFIG_KEY_SCHEMA => array(
         'userPHID_dateFrom' => array(
           'columns' => array('userPHID', 'dateTo'),
         ),
+        'key_instance' => array(
+          'columns' => array('instanceOfEventPHID', 'sequenceIndex'),
+          'unique' => true,
+        ),
       ),
       self::CONFIG_SERIALIZATION => array(
         'recurrenceFrequency' => self::SERIALIZATION_JSON,
       ),
     ) + parent::getConfiguration();
   }
 
   public function generatePHID() {
     return PhabricatorPHID::generateNewPHID(
       PhabricatorCalendarEventPHIDType::TYPECONST);
   }
 
   public function getMonogram() {
     return 'E'.$this->getID();
   }
 
   public function getInvitees() {
     return $this->assertAttached($this->invitees);
   }
 
   public function attachInvitees(array $invitees) {
     $this->invitees = $invitees;
     return $this;
   }
 
   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 generateNthGhost(
     $sequence_index,
     PhabricatorUser $actor) {
 
     $frequency = $this->getFrequencyUnit();
     $modify_key = '+'.$sequence_index.' '.$frequency;
 
     $date = $this->dateFrom;
     $date_time = PhabricatorTime::getDateTimeFromEpoch($date, $actor);
     $date_time->modify($modify_key);
     $date = $date_time->format('U');
 
     $duration = $this->dateTo - $this->dateFrom;
 
     $edit_policy = PhabricatorPolicies::POLICY_NOONE;
 
     $ghost_event = id(clone $this)
       ->setIsGhostEvent(true)
       ->setDateFrom($date)
       ->setDateTo($date + $duration)
       ->setIsRecurring(true)
       ->setRecurrenceFrequency($this->recurrenceFrequency)
       ->setInstanceOfEventPHID($this->getPHID())
       ->setSequenceIndex($sequence_index)
       ->setEditPolicy($edit_policy);
 
     return $ghost_event;
   }
 
   public function getFrequencyUnit() {
     $frequency = idx($this->recurrenceFrequency, 'rule');
 
     switch ($frequency) {
       case 'daily':
         return 'day';
       case 'weekly':
         return 'week';
       case 'monthly':
         return 'month';
       case 'yearly':
         return 'yearly';
       default:
         return 'day';
     }
   }
 
   public function getURI() {
     $uri = '/'.$this->getMonogram();
     if ($this->isGhostEvent) {
       $uri = $uri.'/'.$this->sequenceIndex;
     }
     return $uri;
   }
 
 /* -(  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:
         return $this->getEditPolicy();
     }
   }
 
   public function hasAutomaticCapability($capability, PhabricatorUser $viewer) {
     // The owner of a task can always view and edit it.
     $user_phid = $this->getUserPHID();
-    if ($this->isGhostEvent) {
-      return false;
-    }
     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) {
     return pht('The owner of an event can always view and edit it,
       and invitees can always view it, except if the event is an
       instance of a recurring event.');
   }
 
 /* -(  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->getUserPHID());
   }
 
   public function shouldShowSubscribersProperty() {
     return true;
   }
 
   public function shouldAllowSubscription($phid) {
     return true;
   }
 
 /* -(  PhabricatorTokenReceiverInterface  )---------------------------------- */
 
 
   public function getUsersToNotifyOfTokenGiven() {
     return array($this->getUserPHID());
   }
 
 /* -(  PhabricatorDestructibleInterface  )----------------------------------- */
 
 
   public function destroyObjectPermanently(
     PhabricatorDestructionEngine $engine) {
 
     $this->openTransaction();
     $this->delete();
     $this->saveTransaction();
   }
 }