diff --git a/src/applications/maniphest/controller/ManiphestTaskDetailController.php b/src/applications/maniphest/controller/ManiphestTaskDetailController.php
index 4e72012bd1..dbd2e20bb5 100644
--- a/src/applications/maniphest/controller/ManiphestTaskDetailController.php
+++ b/src/applications/maniphest/controller/ManiphestTaskDetailController.php
@@ -1,610 +1,612 @@
 <?php
 
 /**
  * @group maniphest
  */
 final class ManiphestTaskDetailController extends ManiphestController {
 
   private $id;
 
   public function willProcessRequest(array $data) {
     $this->id = $data['id'];
   }
 
   public function processRequest() {
 
     $request = $this->getRequest();
     $user = $request->getUser();
 
     $e_title = null;
 
     $priority_map = ManiphestTaskPriority::getTaskPriorityMap();
 
     $task = id(new ManiphestTaskQuery())
       ->setViewer($user)
       ->withIDs(array($this->id))
       ->executeOne();
     if (!$task) {
       return new Aphront404Response();
     }
 
     $workflow = $request->getStr('workflow');
     $parent_task = null;
     if ($workflow && is_numeric($workflow)) {
       $parent_task = id(new ManiphestTaskQuery())
         ->setViewer($user)
         ->withIDs(array($workflow))
         ->executeOne();
     }
 
     $transactions = id(new ManiphestTransactionQuery())
       ->setViewer($user)
       ->withObjectPHIDs(array($task->getPHID()))
       ->needComments(true)
       ->execute();
 
     $field_list = PhabricatorCustomField::getObjectFields(
       $task,
       PhabricatorCustomField::ROLE_VIEW);
 
     foreach ($field_list->getFields() as $field) {
       $field->setObject($task);
       $field->setViewer($user);
     }
 
     $field_list->readFieldsFromStorage($task);
 
     $aux_fields = $field_list->getFields();
 
     $e_commit = PhabricatorEdgeConfig::TYPE_TASK_HAS_COMMIT;
     $e_dep_on = PhabricatorEdgeConfig::TYPE_TASK_DEPENDS_ON_TASK;
     $e_dep_by = PhabricatorEdgeConfig::TYPE_TASK_DEPENDED_ON_BY_TASK;
     $e_rev    = PhabricatorEdgeConfig::TYPE_TASK_HAS_RELATED_DREV;
     $e_mock   = PhabricatorEdgeConfig::TYPE_TASK_HAS_MOCK;
 
     $phid = $task->getPHID();
 
     $query = id(new PhabricatorEdgeQuery())
       ->withSourcePHIDs(array($phid))
       ->withEdgeTypes(
         array(
           $e_commit,
           $e_dep_on,
           $e_dep_by,
           $e_rev,
           $e_mock,
         ));
     $edges = idx($query->execute(), $phid);
     $phids = array_fill_keys($query->getDestinationPHIDs(), true);
 
     foreach ($task->getCCPHIDs() as $phid) {
       $phids[$phid] = true;
     }
     foreach ($task->getProjectPHIDs() as $phid) {
       $phids[$phid] = true;
     }
     if ($task->getOwnerPHID()) {
       $phids[$task->getOwnerPHID()] = true;
     }
     $phids[$task->getAuthorPHID()] = true;
 
     $attached = $task->getAttached();
     foreach ($attached as $type => $list) {
       foreach ($list as $phid => $info) {
         $phids[$phid] = true;
       }
     }
 
     if ($parent_task) {
       $phids[$parent_task->getPHID()] = true;
     }
 
     $phids = array_keys($phids);
 
     $this->loadHandles($phids);
 
     $handles = $this->getLoadedHandles();
 
     $context_bar = null;
 
     if ($parent_task) {
       $context_bar = new AphrontContextBarView();
       $context_bar->addButton(phutil_tag(
       'a',
       array(
         'href' => '/maniphest/task/create/?parent='.$parent_task->getID(),
         'class' => 'green button',
       ),
       pht('Create Another Subtask')));
       $context_bar->appendChild(hsprintf(
         'Created a subtask of <strong>%s</strong>',
         $this->getHandle($parent_task->getPHID())->renderLink()));
     } else if ($workflow == 'create') {
       $context_bar = new AphrontContextBarView();
       $context_bar->addButton(phutil_tag('label', array(), 'Create Another'));
       $context_bar->addButton(phutil_tag(
         'a',
         array(
           'href' => '/maniphest/task/create/?template='.$task->getID(),
           'class' => 'green button',
         ),
         pht('Similar Task')));
       $context_bar->addButton(phutil_tag(
         'a',
         array(
           'href' => '/maniphest/task/create/',
           'class' => 'green button',
         ),
         pht('Empty Task')));
       $context_bar->appendChild(pht('New task created.'));
     }
 
     $engine = new PhabricatorMarkupEngine();
     $engine->setViewer($user);
     $engine->addObject($task, ManiphestTask::MARKUP_FIELD_DESCRIPTION);
     foreach ($transactions as $modern_xaction) {
       if ($modern_xaction->getComment()) {
         $engine->addObject(
           $modern_xaction->getComment(),
           PhabricatorApplicationTransactionComment::MARKUP_FIELD_COMMENT);
       }
     }
 
     $engine->process();
 
     $resolution_types = ManiphestTaskStatus::getTaskStatusMap();
 
     $transaction_types = array(
       PhabricatorTransactions::TYPE_COMMENT => pht('Comment'),
       ManiphestTransaction::TYPE_STATUS     => pht('Close Task'),
       ManiphestTransaction::TYPE_OWNER      => pht('Reassign / Claim'),
       ManiphestTransaction::TYPE_CCS        => pht('Add CCs'),
       ManiphestTransaction::TYPE_PRIORITY   => pht('Change Priority'),
       ManiphestTransaction::TYPE_ATTACH     => pht('Upload File'),
       ManiphestTransaction::TYPE_PROJECTS   => pht('Associate Projects'),
     );
 
     if ($task->getStatus() == ManiphestTaskStatus::STATUS_OPEN) {
       $resolution_types = array_select_keys(
         $resolution_types,
         array(
           ManiphestTaskStatus::STATUS_CLOSED_RESOLVED,
           ManiphestTaskStatus::STATUS_CLOSED_WONTFIX,
           ManiphestTaskStatus::STATUS_CLOSED_INVALID,
           ManiphestTaskStatus::STATUS_CLOSED_SPITE,
         ));
     } else {
       $resolution_types = array(
         ManiphestTaskStatus::STATUS_OPEN => 'Reopened',
       );
       $transaction_types[ManiphestTransaction::TYPE_STATUS] =
         'Reopen Task';
       unset($transaction_types[ManiphestTransaction::TYPE_PRIORITY]);
       unset($transaction_types[ManiphestTransaction::TYPE_OWNER]);
     }
 
     $default_claim = array(
       $user->getPHID() => $user->getUsername().' ('.$user->getRealName().')',
     );
 
     $draft = id(new PhabricatorDraft())->loadOneWhere(
       'authorPHID = %s AND draftKey = %s',
       $user->getPHID(),
       $task->getPHID());
     if ($draft) {
       $draft_text = $draft->getDraft();
     } else {
       $draft_text = null;
     }
 
     $is_serious = PhabricatorEnv::getEnvConfig('phabricator.serious-business');
 
     if ($is_serious) {
       // Prevent tasks from being closed "out of spite" in serious business
       // installs.
       unset($resolution_types[ManiphestTaskStatus::STATUS_CLOSED_SPITE]);
     }
 
     $comment_form = new AphrontFormView();
     $comment_form
       ->setUser($user)
       ->setShaded(true)
       ->setAction('/maniphest/transaction/save/')
       ->setEncType('multipart/form-data')
       ->addHiddenInput('taskID', $task->getID())
       ->appendChild(
         id(new AphrontFormSelectControl())
           ->setLabel(pht('Action'))
           ->setName('action')
           ->setOptions($transaction_types)
           ->setID('transaction-action'))
       ->appendChild(
         id(new AphrontFormSelectControl())
           ->setLabel(pht('Resolution'))
           ->setName('resolution')
           ->setControlID('resolution')
           ->setControlStyle('display: none')
           ->setOptions($resolution_types))
       ->appendChild(
         id(new AphrontFormTokenizerControl())
           ->setLabel(pht('Assign To'))
           ->setName('assign_to')
           ->setControlID('assign_to')
           ->setControlStyle('display: none')
           ->setID('assign-tokenizer')
           ->setDisableBehavior(true))
       ->appendChild(
         id(new AphrontFormTokenizerControl())
           ->setLabel(pht('CCs'))
           ->setName('ccs')
           ->setControlID('ccs')
           ->setControlStyle('display: none')
           ->setID('cc-tokenizer')
           ->setDisableBehavior(true))
       ->appendChild(
         id(new AphrontFormSelectControl())
           ->setLabel(pht('Priority'))
           ->setName('priority')
           ->setOptions($priority_map)
           ->setControlID('priority')
           ->setControlStyle('display: none')
           ->setValue($task->getPriority()))
       ->appendChild(
         id(new AphrontFormTokenizerControl())
           ->setLabel(pht('Projects'))
           ->setName('projects')
           ->setControlID('projects')
           ->setControlStyle('display: none')
           ->setID('projects-tokenizer')
           ->setDisableBehavior(true))
       ->appendChild(
         id(new AphrontFormFileControl())
           ->setLabel(pht('File'))
           ->setName('file')
           ->setControlID('file')
           ->setControlStyle('display: none'))
       ->appendChild(
         id(new PhabricatorRemarkupControl())
           ->setLabel(pht('Comments'))
           ->setName('comments')
           ->setValue($draft_text)
           ->setID('transaction-comments')
           ->setUser($user))
       ->appendChild(
         id(new AphrontFormSubmitControl())
           ->setValue($is_serious ? pht('Submit') : pht('Avast!')));
 
     $control_map = array(
       ManiphestTransaction::TYPE_STATUS   => 'resolution',
       ManiphestTransaction::TYPE_OWNER    => 'assign_to',
       ManiphestTransaction::TYPE_CCS      => 'ccs',
       ManiphestTransaction::TYPE_PRIORITY => 'priority',
       ManiphestTransaction::TYPE_PROJECTS => 'projects',
       ManiphestTransaction::TYPE_ATTACH   => 'file',
     );
 
     $tokenizer_map = array(
       ManiphestTransaction::TYPE_PROJECTS => array(
         'id'          => 'projects-tokenizer',
         'src'         => '/typeahead/common/projects/',
         'ondemand'    => PhabricatorEnv::getEnvConfig('tokenizer.ondemand'),
         'placeholder' => pht('Type a project name...'),
       ),
       ManiphestTransaction::TYPE_OWNER => array(
         'id'          => 'assign-tokenizer',
         'src'         => '/typeahead/common/users/',
         'value'       => $default_claim,
         'limit'       => 1,
         'ondemand'    => PhabricatorEnv::getEnvConfig('tokenizer.ondemand'),
         'placeholder' => pht('Type a user name...'),
       ),
       ManiphestTransaction::TYPE_CCS => array(
         'id'          => 'cc-tokenizer',
         'src'         => '/typeahead/common/mailable/',
         'ondemand'    => PhabricatorEnv::getEnvConfig('tokenizer.ondemand'),
         'placeholder' => pht('Type a user or mailing list...'),
       ),
     );
 
     Javelin::initBehavior('maniphest-transaction-controls', array(
       'select'     => 'transaction-action',
       'controlMap' => $control_map,
       'tokenizers' => $tokenizer_map,
     ));
 
     Javelin::initBehavior('maniphest-transaction-preview', array(
       'uri'        => '/maniphest/transaction/preview/'.$task->getID().'/',
       'preview'    => 'transaction-preview',
       'comments'   => 'transaction-comments',
       'action'     => 'transaction-action',
       'map'        => $control_map,
       'tokenizers' => $tokenizer_map,
     ));
 
     $comment_header = id(new PHUIHeaderView())
       ->setHeader($is_serious ? pht('Add Comment') : pht('Weigh In'));
 
     $preview_panel = hsprintf(
       '<div class="aphront-panel-preview">
         <div id="transaction-preview">
           <div class="aphront-panel-preview-loading-text">%s</div>
         </div>
       </div>',
       pht('Loading preview...'));
 
     $timeline = id(new PhabricatorApplicationTransactionView())
       ->setUser($user)
       ->setObjectPHID($task->getPHID())
       ->setTransactions($transactions)
       ->setMarkupEngine($engine);
 
     $object_name = 'T'.$task->getID();
     $actions = $this->buildActionView($task);
 
     $crumbs = $this->buildApplicationCrumbs();
     $crumbs->addCrumb(
       id(new PhabricatorCrumbView())
         ->setName($object_name)
         ->setHref('/'.$object_name))
       ->setActionList($actions);
 
     $header = $this->buildHeaderView($task);
     $properties = $this->buildPropertyView($task, $field_list, $edges, $engine);
 
     return $this->buildApplicationPage(
       array(
         $crumbs,
         $context_bar,
         $header,
         $actions,
         $properties,
         $timeline,
         $comment_header,
         $comment_form,
         $preview_panel,
       ),
       array(
         'title' => 'T'.$task->getID().' '.$task->getTitle(),
         'pageObjects' => array($task->getPHID()),
         'device' => true,
       ));
   }
 
   private function buildHeaderView(ManiphestTask $task) {
     $view = id(new PHUIHeaderView())
-      ->setHeader($task->getTitle());
+      ->setHeader($task->getTitle())
+      ->setUser($this->getRequest()->getUser())
+      ->setPolicyObject($task);
 
     $status = $task->getStatus();
     $status_name = ManiphestTaskStatus::renderFullDescription($status);
 
     $view->addProperty(PHUIHeaderView::PROPERTY_STATUS, $status_name);
 
     return $view;
   }
 
 
   private function buildActionView(ManiphestTask $task) {
     $viewer = $this->getRequest()->getUser();
     $viewer_phid = $viewer->getPHID();
     $viewer_is_cc = in_array($viewer_phid, $task->getCCPHIDs());
 
     $id = $task->getID();
     $phid = $task->getPHID();
 
     $view = id(new PhabricatorActionListView())
       ->setUser($viewer)
       ->setObject($task)
       ->setObjectURI($this->getRequest()->getRequestURI())
       ->addAction(
       id(new PhabricatorActionView())
         ->setName(pht('Edit Task'))
         ->setIcon('edit')
         ->setHref($this->getApplicationURI("/task/edit/{$id}/")));
 
     if ($task->getOwnerPHID() === $viewer_phid) {
       $view->addAction(
         id(new PhabricatorActionView())
           ->setName(pht('Automatically Subscribed'))
           ->setDisabled(true)
           ->setIcon('enable'));
     } else {
       $action = $viewer_is_cc ? 'rem' : 'add';
       $name   = $viewer_is_cc ? pht('Unsubscribe') : pht('Subscribe');
       $icon   = $viewer_is_cc ? 'disable' : 'check';
 
       $view->addAction(
         id(new PhabricatorActionView())
           ->setName($name)
           ->setHref("/maniphest/subscribe/{$action}/{$id}/")
           ->setRenderAsForm(true)
           ->setUser($viewer)
           ->setIcon($icon));
     }
 
     $view->addAction(
       id(new PhabricatorActionView())
         ->setName(pht('Merge Duplicates In'))
         ->setHref("/search/attach/{$phid}/TASK/merge/")
         ->setWorkflow(true)
         ->setIcon('merge'));
 
     $view->addAction(
       id(new PhabricatorActionView())
         ->setName(pht('Create Subtask'))
         ->setHref($this->getApplicationURI("/task/create/?parent={$id}"))
         ->setIcon('fork'));
 
     $view->addAction(
       id(new PhabricatorActionView())
         ->setName(pht('Edit Dependencies'))
         ->setHref("/search/attach/{$phid}/TASK/dependencies/")
         ->setWorkflow(true)
         ->setIcon('link'));
 
     $view->addAction(
       id(new PhabricatorActionView())
         ->setName(pht('Edit Differential Revisions'))
         ->setHref("/search/attach/{$phid}/DREV/")
         ->setWorkflow(true)
         ->setIcon('attach'));
 
     $pholio_app =
       PhabricatorApplication::getByClass('PhabricatorApplicationPholio');
     if ($pholio_app->isInstalled()) {
       $view->addAction(
         id(new PhabricatorActionView())
         ->setName(pht('Edit Pholio Mocks'))
         ->setHref("/search/attach/{$phid}/MOCK/edge/")
         ->setWorkflow(true)
         ->setIcon('attach'));
     }
 
     return $view;
   }
 
   private function buildPropertyView(
     ManiphestTask $task,
     PhabricatorCustomFieldList $field_list,
     array $edges,
     PhabricatorMarkupEngine $engine) {
 
     $viewer = $this->getRequest()->getUser();
 
     $view = id(new PhabricatorPropertyListView())
       ->setUser($viewer)
       ->setObject($task);
 
     $view->addProperty(
       pht('Assigned To'),
       $task->getOwnerPHID()
       ? $this->getHandle($task->getOwnerPHID())->renderLink()
       : phutil_tag('em', array(), pht('None')));
 
     $view->addProperty(
       pht('Priority'),
       ManiphestTaskPriority::getTaskPriorityName($task->getPriority()));
 
     $view->addProperty(
       pht('Subscribers'),
       $task->getCCPHIDs()
       ? $this->renderHandlesForPHIDs($task->getCCPHIDs(), ',')
       : phutil_tag('em', array(), pht('None')));
 
     $view->addProperty(
       pht('Author'),
       $this->getHandle($task->getAuthorPHID())->renderLink());
 
     $source = $task->getOriginalEmailSource();
     if ($source) {
       $subject = '[T'.$task->getID().'] '.$task->getTitle();
       $view->addProperty(
         pht('From Email'),
         phutil_tag(
           'a',
           array(
             'href' => 'mailto:'.$source.'?subject='.$subject
           ),
           $source));
     }
 
     $view->addProperty(
       pht('Projects'),
       $task->getProjectPHIDs()
       ? $this->renderHandlesForPHIDs($task->getProjectPHIDs(), ',')
       : phutil_tag('em', array(), pht('None')));
 
     $edge_types = array(
       PhabricatorEdgeConfig::TYPE_TASK_DEPENDED_ON_BY_TASK
       => pht('Dependent Tasks'),
       PhabricatorEdgeConfig::TYPE_TASK_DEPENDS_ON_TASK
       => pht('Depends On'),
       PhabricatorEdgeConfig::TYPE_TASK_HAS_RELATED_DREV
       => pht('Differential Revisions'),
       PhabricatorEdgeConfig::TYPE_TASK_HAS_MOCK
       => pht('Pholio Mocks'),
     );
 
     $revisions_commits = array();
     $handles = $this->getLoadedHandles();
 
     $commit_phids = array_keys(
       $edges[PhabricatorEdgeConfig::TYPE_TASK_HAS_COMMIT]);
     if ($commit_phids) {
       $commit_drev = PhabricatorEdgeConfig::TYPE_COMMIT_HAS_DREV;
       $drev_edges = id(new PhabricatorEdgeQuery())
         ->withSourcePHIDs($commit_phids)
         ->withEdgeTypes(array($commit_drev))
         ->execute();
 
       foreach ($commit_phids as $phid) {
         $revisions_commits[$phid] = $handles[$phid]->renderLink();
         $revision_phid = key($drev_edges[$phid][$commit_drev]);
         $revision_handle = idx($handles, $revision_phid);
         if ($revision_handle) {
           $task_drev = PhabricatorEdgeConfig::TYPE_TASK_HAS_RELATED_DREV;
           unset($edges[$task_drev][$revision_phid]);
           $revisions_commits[$phid] = hsprintf(
             '%s / %s',
             $revision_handle->renderLink($revision_handle->getName()),
             $revisions_commits[$phid]);
         }
       }
     }
 
     foreach ($edge_types as $edge_type => $edge_name) {
       if ($edges[$edge_type]) {
         $view->addProperty(
           $edge_name,
           $this->renderHandlesForPHIDs(array_keys($edges[$edge_type])));
       }
     }
 
     if ($revisions_commits) {
       $view->addProperty(
         pht('Commits'),
         phutil_implode_html(phutil_tag('br'), $revisions_commits));
     }
 
     $attached = $task->getAttached();
     if (!is_array($attached)) {
       $attached = array();
     }
 
     $file_infos = idx($attached, PhabricatorFilePHIDTypeFile::TYPECONST);
     if ($file_infos) {
       $file_phids = array_keys($file_infos);
 
       $files = id(new PhabricatorFile())->loadAllWhere(
         'phid IN (%Ls)',
         $file_phids);
 
       $file_view = new PhabricatorFileLinkListView();
       $file_view->setFiles($files);
 
       $view->addProperty(
         pht('Files'),
         $file_view->render());
     }
 
     $field_list->appendFieldsToPropertyList(
       $task,
       $viewer,
       $view);
 
     $view->invokeWillRenderEvent();
 
     if (strlen($task->getDescription())) {
       $view->addSectionHeader(pht('Description'));
       $view->addTextContent(
         phutil_tag(
           'div',
           array(
             'class' => 'phabricator-remarkup',
           ),
           $engine->getOutput($task, ManiphestTask::MARKUP_FIELD_DESCRIPTION)));
     }
 
     return $view;
   }
 
 }
diff --git a/src/applications/maniphest/controller/ManiphestTaskEditController.php b/src/applications/maniphest/controller/ManiphestTaskEditController.php
index 16a556c376..5735c50417 100644
--- a/src/applications/maniphest/controller/ManiphestTaskEditController.php
+++ b/src/applications/maniphest/controller/ManiphestTaskEditController.php
@@ -1,576 +1,604 @@
 <?php
 
 /**
  * @group maniphest
  */
 final class ManiphestTaskEditController extends ManiphestController {
 
   private $id;
 
   public function willProcessRequest(array $data) {
     $this->id = idx($data, 'id');
   }
 
   public function processRequest() {
 
     $request = $this->getRequest();
     $user = $request->getUser();
 
     $files = array();
     $parent_task = null;
     $template_id = null;
 
     if ($this->id) {
       $task = id(new ManiphestTaskQuery())
         ->setViewer($user)
         ->requireCapabilities(
           array(
             PhabricatorPolicyCapability::CAN_VIEW,
             PhabricatorPolicyCapability::CAN_EDIT,
           ))
         ->withIDs(array($this->id))
         ->executeOne();
       if (!$task) {
         return new Aphront404Response();
       }
     } else {
       $task = new ManiphestTask();
       $task->setPriority(ManiphestTaskPriority::getDefaultPriority());
       $task->setAuthorPHID($user->getPHID());
 
       // These allow task creation with defaults.
       if (!$request->isFormPost()) {
         $task->setTitle($request->getStr('title'));
 
         $default_projects = $request->getStr('projects');
         if ($default_projects) {
           $task->setProjectPHIDs(explode(';', $default_projects));
         }
 
         $task->setDescription($request->getStr('description'));
 
         $assign = $request->getStr('assign');
         if (strlen($assign)) {
           $assign_user = id(new PhabricatorUser())->loadOneWhere(
             'username = %s',
             $assign);
           if ($assign_user) {
             $task->setOwnerPHID($assign_user->getPHID());
           }
         }
       }
 
       $file_phids = $request->getArr('files', array());
       if (!$file_phids) {
         // Allow a single 'file' key instead, mostly since Mac OS X urlencodes
         // square brackets in URLs when passed to 'open', so you can't 'open'
         // a URL like '?files[]=xyz' and have PHP interpret it correctly.
         $phid = $request->getStr('file');
         if ($phid) {
           $file_phids = array($phid);
         }
       }
 
       if ($file_phids) {
         $files = id(new PhabricatorFile())->loadAllWhere(
           'phid IN (%Ls)',
           $file_phids);
       }
 
       $template_id = $request->getInt('template');
 
       // You can only have a parent task if you're creating a new task.
       $parent_id = $request->getInt('parent');
       if ($parent_id) {
         $parent_task = id(new ManiphestTaskQuery())
           ->setViewer($user)
           ->withIDs(array($parent_id))
           ->executeOne();
         if (!$template_id) {
           $template_id = $parent_id;
         }
       }
     }
 
     $errors = array();
     $e_title = true;
 
     $field_list = PhabricatorCustomField::getObjectFields(
       $task,
       PhabricatorCustomField::ROLE_EDIT);
 
     foreach ($field_list->getFields() as $field) {
       $field->setObject($task);
       $field->setViewer($user);
     }
 
     $field_list->readFieldsFromStorage($task);
 
     $aux_fields = $field_list->getFields();
 
     if ($request->isFormPost()) {
       $changes = array();
 
       $new_title = $request->getStr('title');
       $new_desc = $request->getStr('description');
       $new_status = $request->getStr('status');
 
       if (!$task->getID()) {
         $workflow = 'create';
       } else {
         $workflow = '';
       }
 
       $changes[ManiphestTransaction::TYPE_TITLE] = $new_title;
       $changes[ManiphestTransaction::TYPE_DESCRIPTION] = $new_desc;
       $changes[ManiphestTransaction::TYPE_STATUS] = $new_status;
 
       $owner_tokenizer = $request->getArr('assigned_to');
       $owner_phid = reset($owner_tokenizer);
 
       if (!strlen($new_title)) {
         $e_title = pht('Required');
         $errors[] = pht('Title is required.');
       }
 
       $old_values = array();
       foreach ($aux_fields as $aux_arr_key => $aux_field) {
         // TODO: This should be buildFieldTransactionsFromRequest() once we
         // switch to ApplicationTransactions properly.
 
         $aux_old_value = $aux_field->getOldValueForApplicationTransactions();
         $aux_field->readValueFromRequest($request);
         $aux_new_value = $aux_field->getNewValueForApplicationTransactions();
 
         // TODO: We're faking a call to the ApplicaitonTransaction validation
         // logic here. We need valid objects to pass, but they aren't used
         // in a meaningful way. For now, build User objects. Once the Maniphest
         // objects exist, this will switch over automatically. This is a big
         // hack but shouldn't be long for this world.
         $placeholder_editor = new PhabricatorUserProfileEditor();
 
         $field_errors = $aux_field->validateApplicationTransactions(
           $placeholder_editor,
           PhabricatorTransactions::TYPE_CUSTOMFIELD,
           array(
             id(new ManiphestTransaction())
               ->setOldValue($aux_old_value)
               ->setNewValue($aux_new_value),
           ));
 
         foreach ($field_errors as $error) {
           $errors[] = $error->getMessage();
         }
 
         $old_values[$aux_field->getFieldKey()] = $aux_old_value;
       }
 
       if ($errors) {
         $task->setTitle($new_title);
         $task->setDescription($new_desc);
         $task->setPriority($request->getInt('priority'));
         $task->setOwnerPHID($owner_phid);
         $task->setCCPHIDs($request->getArr('cc'));
         $task->setProjectPHIDs($request->getArr('projects'));
       } else {
 
         $changes[ManiphestTransaction::TYPE_PRIORITY] =
           $request->getInt('priority');
         $changes[ManiphestTransaction::TYPE_OWNER] = $owner_phid;
         $changes[ManiphestTransaction::TYPE_CCS] = $request->getArr('cc');
         $changes[ManiphestTransaction::TYPE_PROJECTS] =
           $request->getArr('projects');
 
+        $changes[PhabricatorTransactions::TYPE_VIEW_POLICY] =
+          $request->getStr('viewPolicy');
+        $changes[PhabricatorTransactions::TYPE_EDIT_POLICY] =
+          $request->getStr('editPolicy');
+
         if ($files) {
           $file_map = mpull($files, 'getPHID');
           $file_map = array_fill_keys($file_map, array());
           $changes[ManiphestTransaction::TYPE_ATTACH] = array(
             PhabricatorFilePHIDTypeFile::TYPECONST => $file_map,
           );
         }
 
         $template = new ManiphestTransaction();
         $transactions = array();
 
         foreach ($changes as $type => $value) {
           $transaction = clone $template;
           $transaction->setTransactionType($type);
           $transaction->setNewValue($value);
           $transactions[] = $transaction;
         }
 
         if ($aux_fields) {
           foreach ($aux_fields as $aux_field) {
             $transaction = clone $template;
             $transaction->setTransactionType(
               PhabricatorTransactions::TYPE_CUSTOMFIELD);
             $aux_key = $aux_field->getFieldKey();
             $transaction->setMetadataValue('customfield:key', $aux_key);
             $old = idx($old_values, $aux_key);
             $new = $aux_field->getNewValueForApplicationTransactions();
 
             $transaction->setOldValue($old);
             $transaction->setNewValue($new);
 
             $transactions[] = $transaction;
           }
         }
 
         if ($transactions) {
           $is_new = !$task->getID();
 
           $event = new PhabricatorEvent(
             PhabricatorEventType::TYPE_MANIPHEST_WILLEDITTASK,
             array(
               'task'          => $task,
               'new'           => $is_new,
               'transactions'  => $transactions,
             ));
           $event->setUser($user);
           $event->setAphrontRequest($request);
           PhutilEventEngine::dispatchEvent($event);
 
           $task = $event->getValue('task');
           $transactions = $event->getValue('transactions');
 
           $editor = id(new ManiphestTransactionEditorPro())
             ->setActor($user)
             ->setContentSourceFromRequest($request)
             ->setContinueOnNoEffect(true)
             ->applyTransactions($task, $transactions);
 
           $event = new PhabricatorEvent(
             PhabricatorEventType::TYPE_MANIPHEST_DIDEDITTASK,
             array(
               'task'          => $task,
               'new'           => $is_new,
               'transactions'  => $transactions,
             ));
           $event->setUser($user);
           $event->setAphrontRequest($request);
           PhutilEventEngine::dispatchEvent($event);
         }
 
 
         if ($parent_task) {
           id(new PhabricatorEdgeEditor())
             ->setActor($user)
             ->addEdge(
               $parent_task->getPHID(),
               PhabricatorEdgeConfig::TYPE_TASK_DEPENDS_ON_TASK,
               $task->getPHID())
             ->save();
           $workflow = $parent_task->getID();
         }
 
         if ($request->isAjax()) {
           return id(new AphrontAjaxResponse())->setContent(
             array(
               'tasks' => $this->renderSingleTask($task),
             ));
         }
 
         $redirect_uri = '/T'.$task->getID();
 
         if ($workflow) {
           $redirect_uri .= '?workflow='.$workflow;
         }
 
         return id(new AphrontRedirectResponse())
           ->setURI($redirect_uri);
       }
     } else {
       if (!$task->getID()) {
         $task->setCCPHIDs(array(
           $user->getPHID(),
         ));
         if ($template_id) {
           $template_task = id(new ManiphestTaskQuery())
             ->setViewer($user)
             ->withIDs(array($template_id))
             ->executeOne();
           if ($template_task) {
             $task->setCCPHIDs($template_task->getCCPHIDs());
             $task->setProjectPHIDs($template_task->getProjectPHIDs());
             $task->setOwnerPHID($template_task->getOwnerPHID());
             $task->setPriority($template_task->getPriority());
 
             $template_fields = PhabricatorCustomField::getObjectFields(
               $template_task,
               PhabricatorCustomField::ROLE_EDIT);
 
             $fields = $template_fields->getFields();
             foreach ($fields as $key => $field) {
               if (!$field->shouldCopyWhenCreatingSimilarTask()) {
                 unset($fields[$key]);
               }
               if (empty($aux_fields[$key])) {
                 unset($fields[$key]);
               }
             }
 
             if ($fields) {
               id(new PhabricatorCustomFieldList($fields))
                 ->readFieldsFromStorage($template_task);
 
               foreach ($fields as $key => $field) {
                 $aux_fields[$key]->setValueFromStorage(
                   $field->getValueForStorage());
               }
             }
           }
         }
       }
     }
 
     $phids = array_merge(
       array($task->getOwnerPHID()),
       $task->getCCPHIDs(),
       $task->getProjectPHIDs());
 
     if ($parent_task) {
       $phids[] = $parent_task->getPHID();
     }
 
     $phids = array_filter($phids);
     $phids = array_unique($phids);
 
     $handles = $this->loadViewerHandles($phids);
 
     $tvalues = mpull($handles, 'getFullName', 'getPHID');
 
     $error_view = null;
     if ($errors) {
       $error_view = new AphrontErrorView();
       $error_view->setErrors($errors);
       $error_view->setTitle(pht('Form Errors'));
     }
 
     $priority_map = ManiphestTaskPriority::getTaskPriorityMap();
 
     if ($task->getOwnerPHID()) {
       $assigned_value = array(
         $task->getOwnerPHID() => $handles[$task->getOwnerPHID()]->getFullName(),
       );
     } else {
       $assigned_value = array();
     }
 
     if ($task->getCCPHIDs()) {
       $cc_value = array_select_keys($tvalues, $task->getCCPHIDs());
     } else {
       $cc_value = array();
     }
 
     if ($task->getProjectPHIDs()) {
       $projects_value = array_select_keys($tvalues, $task->getProjectPHIDs());
     } else {
       $projects_value = array();
     }
 
     $cancel_id = nonempty($task->getID(), $template_id);
     if ($cancel_id) {
       $cancel_uri = '/T'.$cancel_id;
     } else {
       $cancel_uri = '/maniphest/';
     }
 
     if ($task->getID()) {
       $button_name = pht('Save Task');
       $header_name = pht('Edit Task');
     } else if ($parent_task) {
       $cancel_uri = '/T'.$parent_task->getID();
       $button_name = pht('Create Task');
       $header_name = pht('Create New Subtask');
     } else {
       $button_name = pht('Create Task');
       $header_name = pht('Create New Task');
     }
 
     require_celerity_resource('maniphest-task-edit-css');
 
     $project_tokenizer_id = celerity_generate_unique_node_id();
 
     if ($request->isAjax()) {
       $form = new PHUIFormLayoutView();
     } else {
       $form = new AphrontFormView();
       $form
         ->setUser($user)
         ->addHiddenInput('template', $template_id);
     }
 
     if ($parent_task) {
       $form
         ->appendChild(
           id(new AphrontFormStaticControl())
             ->setLabel(pht('Parent Task'))
             ->setValue($handles[$parent_task->getPHID()]->getFullName()))
         ->addHiddenInput('parent', $parent_task->getID());
     }
 
     $form
       ->appendChild(
         id(new AphrontFormTextAreaControl())
           ->setLabel(pht('Title'))
           ->setName('title')
           ->setError($e_title)
           ->setHeight(AphrontFormTextAreaControl::HEIGHT_VERY_SHORT)
           ->setValue($task->getTitle()));
 
     if ($task->getID()) {
       // Only show this in "edit" mode, not "create" mode, since creating a
       // non-open task is kind of silly and it would just clutter up the
       // "create" interface.
       $form
         ->appendChild(
           id(new AphrontFormSelectControl())
             ->setLabel(pht('Status'))
             ->setName('status')
             ->setValue($task->getStatus())
             ->setOptions(ManiphestTaskStatus::getTaskStatusMap()));
     }
 
+    $policies = id(new PhabricatorPolicyQuery())
+      ->setViewer($user)
+      ->setObject($task)
+      ->execute();
+
     $form
       ->appendChild(
         id(new AphrontFormTokenizerControl())
           ->setLabel(pht('Assigned To'))
           ->setName('assigned_to')
           ->setValue($assigned_value)
           ->setUser($user)
           ->setDatasource('/typeahead/common/users/')
           ->setLimit(1))
       ->appendChild(
         id(new AphrontFormTokenizerControl())
           ->setLabel(pht('CC'))
           ->setName('cc')
           ->setValue($cc_value)
           ->setUser($user)
           ->setDatasource('/typeahead/common/mailable/'))
       ->appendChild(
         id(new AphrontFormSelectControl())
           ->setLabel(pht('Priority'))
           ->setName('priority')
           ->setOptions($priority_map)
           ->setValue($task->getPriority()))
+      ->appendChild(
+        id(new AphrontFormPolicyControl())
+          ->setUser($user)
+          ->setCapability(PhabricatorPolicyCapability::CAN_VIEW)
+          ->setPolicyObject($task)
+          ->setPolicies($policies)
+          ->setName('viewPolicy'))
+      ->appendChild(
+        id(new AphrontFormPolicyControl())
+          ->setUser($user)
+          ->setCapability(PhabricatorPolicyCapability::CAN_EDIT)
+          ->setPolicyObject($task)
+          ->setPolicies($policies)
+          ->setCaption(
+            pht(
+              'NOTE: These policy controls still have some rough edges and '.
+              'are not yet fully functional.'))
+          ->setName('editPolicy'))
       ->appendChild(
         id(new AphrontFormTokenizerControl())
           ->setLabel(pht('Projects'))
           ->setName('projects')
           ->setValue($projects_value)
           ->setID($project_tokenizer_id)
           ->setCaption(
             javelin_tag(
               'a',
               array(
                 'href'        => '/project/create/',
                 'mustcapture' => true,
                 'sigil'       => 'project-create',
               ),
               pht('Create New Project')))
           ->setDatasource('/typeahead/common/projects/'));
 
     foreach ($aux_fields as $aux_field) {
       $aux_control = $aux_field->renderEditControl();
       $form->appendChild($aux_control);
     }
 
     require_celerity_resource('aphront-error-view-css');
 
     Javelin::initBehavior('project-create', array(
       'tokenizerID' => $project_tokenizer_id,
     ));
 
     if ($files) {
       $file_display = mpull($files, 'getName');
       $file_display = phutil_implode_html(phutil_tag('br'), $file_display);
 
       $form->appendChild(
         id(new AphrontFormMarkupControl())
           ->setLabel(pht('Files'))
           ->setValue($file_display));
 
       foreach ($files as $ii => $file) {
         $form->addHiddenInput('files['.$ii.']', $file->getPHID());
       }
     }
 
 
     $description_control = new PhabricatorRemarkupControl();
     // "Upsell" creating tasks via email in create flows if the instance is
     // configured for this awesomeness.
     $email_create = PhabricatorEnv::getEnvConfig(
       'metamta.maniphest.public-create-email');
     if (!$task->getID() && $email_create) {
       $email_hint = pht(
         'You can also create tasks by sending an email to: %s',
         phutil_tag('tt', array(), $email_create));
       $description_control->setCaption($email_hint);
     }
 
     $description_control
       ->setLabel(pht('Description'))
       ->setName('description')
       ->setID('description-textarea')
       ->setValue($task->getDescription())
       ->setUser($user);
 
     $form
       ->appendChild($description_control);
 
 
     if ($request->isAjax()) {
       $dialog = id(new AphrontDialogView())
         ->setUser($user)
         ->setWidth(AphrontDialogView::WIDTH_FULL)
         ->setTitle($header_name)
         ->appendChild(
           array(
             $error_view,
             $form,
           ))
         ->addCancelButton($cancel_uri)
         ->addSubmitButton($button_name);
       return id(new AphrontDialogResponse())->setDialog($dialog);
     }
 
     $form
       ->appendChild(
         id(new AphrontFormSubmitControl())
           ->addCancelButton($cancel_uri)
           ->setValue($button_name));
 
     $form_box = id(new PHUIObjectBoxView())
       ->setHeaderText($header_name)
       ->setFormError($error_view)
       ->setForm($form);
 
     $preview = id(new PHUIRemarkupPreviewPanel())
       ->setHeader(pht('Description Preview'))
       ->setControlID('description-textarea')
       ->setPreviewURI($this->getApplicationURI('task/descriptionpreview/'));
 
     if ($task->getID()) {
       $page_objects = array( $task->getPHID() );
     } else {
       $page_objects = array();
     }
 
     $crumbs = $this->buildApplicationCrumbs();
     $crumbs->addCrumb(
       id(new PhabricatorCrumbView())
         ->setName($header_name));
 
     return $this->buildApplicationPage(
       array(
         $crumbs,
         $form_box,
         $preview,
       ),
       array(
         'title' => $header_name,
         'pageObjects' => $page_objects,
         'device' => true,
       ));
   }
 }
diff --git a/src/applications/maniphest/editor/ManiphestTransactionEditorPro.php b/src/applications/maniphest/editor/ManiphestTransactionEditorPro.php
index 65f9888991..ac830a0d2b 100644
--- a/src/applications/maniphest/editor/ManiphestTransactionEditorPro.php
+++ b/src/applications/maniphest/editor/ManiphestTransactionEditorPro.php
@@ -1,218 +1,220 @@
 <?php
 
 final class ManiphestTransactionEditorPro
   extends PhabricatorApplicationTransactionEditor {
 
   public function getTransactionTypes() {
     $types = parent::getTransactionTypes();
 
     $types[] = PhabricatorTransactions::TYPE_COMMENT;
     $types[] = ManiphestTransaction::TYPE_PRIORITY;
     $types[] = ManiphestTransaction::TYPE_STATUS;
     $types[] = ManiphestTransaction::TYPE_TITLE;
     $types[] = ManiphestTransaction::TYPE_DESCRIPTION;
     $types[] = ManiphestTransaction::TYPE_OWNER;
     $types[] = ManiphestTransaction::TYPE_CCS;
     $types[] = ManiphestTransaction::TYPE_PROJECTS;
     $types[] = ManiphestTransaction::TYPE_ATTACH;
     $types[] = ManiphestTransaction::TYPE_EDGE;
+    $types[] = PhabricatorTransactions::TYPE_VIEW_POLICY;
+    $types[] = PhabricatorTransactions::TYPE_EDIT_POLICY;
 
     return $types;
   }
 
   protected function getCustomTransactionOldValue(
     PhabricatorLiskDAO $object,
     PhabricatorApplicationTransaction $xaction) {
 
     switch ($xaction->getTransactionType()) {
       case ManiphestTransaction::TYPE_PRIORITY:
         return (int)$object->getPriority();
       case ManiphestTransaction::TYPE_STATUS:
         return (int)$object->getStatus();
       case ManiphestTransaction::TYPE_TITLE:
         return $object->getTitle();
       case ManiphestTransaction::TYPE_DESCRIPTION:
         return $object->getDescription();
       case ManiphestTransaction::TYPE_OWNER:
         return nonempty($object->getOwnerPHID(), null);
       case ManiphestTransaction::TYPE_CCS:
         return array_values(array_unique($object->getCCPHIDs()));
       case ManiphestTransaction::TYPE_PROJECTS:
         return array_values(array_unique($object->getProjectPHIDs()));
       case ManiphestTransaction::TYPE_ATTACH:
         return $object->getAttached();
       case ManiphestTransaction::TYPE_EDGE:
         // These are pre-populated.
         return $xaction->getOldValue();
     }
 
   }
 
   protected function getCustomTransactionNewValue(
     PhabricatorLiskDAO $object,
     PhabricatorApplicationTransaction $xaction) {
 
     switch ($xaction->getTransactionType()) {
       case ManiphestTransaction::TYPE_PRIORITY:
       case ManiphestTransaction::TYPE_STATUS:
         return (int)$xaction->getNewValue();
       case ManiphestTransaction::TYPE_CCS:
       case ManiphestTransaction::TYPE_PROJECTS:
         return array_values(array_unique($xaction->getNewValue()));
       case ManiphestTransaction::TYPE_OWNER:
         return nonempty($xaction->getNewValue(), null);
       case ManiphestTransaction::TYPE_TITLE:
       case ManiphestTransaction::TYPE_DESCRIPTION:
       case ManiphestTransaction::TYPE_ATTACH:
       case ManiphestTransaction::TYPE_EDGE:
         return $xaction->getNewValue();
     }
 
   }
 
   protected function transactionHasEffect(
     PhabricatorLiskDAO $object,
     PhabricatorApplicationTransaction $xaction) {
 
     $old = $xaction->getOldValue();
     $new = $xaction->getNewValue();
 
     switch ($xaction->getTransactionType()) {
       case ManiphestTransaction::TYPE_PROJECTS:
       case ManiphestTransaction::TYPE_CCS:
         sort($old);
         sort($new);
         return ($old !== $new);
     }
 
     return parent::transactionHasEffect($object, $xaction);
   }
 
 
   protected function applyCustomInternalTransaction(
     PhabricatorLiskDAO $object,
     PhabricatorApplicationTransaction $xaction) {
 
     switch ($xaction->getTransactionType()) {
       case ManiphestTransaction::TYPE_PRIORITY:
         return $object->setPriority($xaction->getNewValue());
       case ManiphestTransaction::TYPE_STATUS:
         return $object->setStatus($xaction->getNewValue());
       case ManiphestTransaction::TYPE_TITLE:
         return $object->setTitle($xaction->getNewValue());
       case ManiphestTransaction::TYPE_DESCRIPTION:
         return $object->setDescription($xaction->getNewValue());
       case ManiphestTransaction::TYPE_OWNER:
         return $object->setOwnerPHID($xaction->getNewValue());
       case ManiphestTransaction::TYPE_CCS:
         return $object->setCCPHIDs($xaction->getNewValue());
       case ManiphestTransaction::TYPE_PROJECTS:
         return $object->setProjectPHIDs($xaction->getNewValue());
       case ManiphestTransaction::TYPE_ATTACH:
         return $object->setAttached($xaction->getNewValue());
       case ManiphestTransaction::TYPE_EDGE:
         // These are a weird, funky mess and are already being applied by the
         // time we reach this.
         return;
     }
 
   }
 
   protected function applyCustomExternalTransaction(
     PhabricatorLiskDAO $object,
     PhabricatorApplicationTransaction $xaction) {
   }
 
   protected function shouldSendMail(
     PhabricatorLiskDAO $object,
     array $xactions) {
     return true;
   }
 
   protected function getMailSubjectPrefix() {
     return PhabricatorEnv::getEnvConfig('metamta.maniphest.subject-prefix');
   }
 
   protected function getMailThreadID(PhabricatorLiskDAO $object) {
     return 'maniphest-task-'.$object->getPHID();
   }
 
   protected function getMailTo(PhabricatorLiskDAO $object) {
     return array(
       $object->getOwnerPHID(),
       $this->requireActor()->getPHID(),
     );
   }
 
   protected function getMailCC(PhabricatorLiskDAO $object) {
     return $object->getCCPHIDs();
   }
 
   protected function buildReplyHandler(PhabricatorLiskDAO $object) {
     return id(new ManiphestReplyHandler())
       ->setMailReceiver($object);
   }
 
   protected function buildMailTemplate(PhabricatorLiskDAO $object) {
     $id = $object->getID();
     $title = $object->getTitle();
 
     return id(new PhabricatorMetaMTAMail())
       ->setSubject("T{$id}: {$title}")
       ->addHeader('Thread-Topic', "T{$id}: ".$object->getOriginalTitle());
   }
 
   protected function buildMailBody(
     PhabricatorLiskDAO $object,
     array $xactions) {
 
     $body = parent::buildMailBody($object, $xactions);
 
     if ($this->getIsNewObject()) {
       $body->addTextSection(
         pht('TASK DESCRIPTION'),
         $object->getDescription());
     }
 
     $body->addTextSection(
       pht('TASK DETAIL'),
       PhabricatorEnv::getProductionURI('/T'.$object->getID()));
 
     return $body;
   }
 
   protected function supportsFeed() {
     return true;
   }
 
   protected function supportsSearch() {
     return true;
   }
 
   protected function supportsHerald() {
     return true;
   }
 
   protected function buildHeraldAdapter(
     PhabricatorLiskDAO $object,
     array $xactions) {
 
     return id(new HeraldManiphestTaskAdapter())
       ->setTask($object);
   }
 
   protected function didApplyHeraldRules(
     PhabricatorLiskDAO $object,
     HeraldAdapter $adapter,
     HeraldTranscript $transcript) {
 
     $cc_phids = $adapter->getCcPHIDs();
     if ($cc_phids) {
       $existing_cc = $object->getCCPHIDs();
       $new_cc = array_unique(array_merge($cc_phids, $existing_cc));
       $object->setCCPHIDs($new_cc);
       $object->save();
     }
   }
 
 }
diff --git a/src/applications/maniphest/storage/ManiphestTask.php b/src/applications/maniphest/storage/ManiphestTask.php
index fbcbea82f9..7b656cb081 100644
--- a/src/applications/maniphest/storage/ManiphestTask.php
+++ b/src/applications/maniphest/storage/ManiphestTask.php
@@ -1,243 +1,258 @@
 <?php
 
 /**
  * @group maniphest
  */
 final class ManiphestTask extends ManiphestDAO
   implements
     PhabricatorMarkupInterface,
     PhabricatorPolicyInterface,
     PhabricatorTokenReceiverInterface,
     PhrequentTrackableInterface,
     PhabricatorCustomFieldInterface {
 
   const MARKUP_FIELD_DESCRIPTION = 'markup:desc';
 
   protected $phid;
   protected $authorPHID;
   protected $ownerPHID;
   protected $ccPHIDs = array();
 
   protected $status = ManiphestTaskStatus::STATUS_OPEN;
   protected $priority;
   protected $subpriority = 0;
 
   protected $title = '';
   protected $originalTitle;
   protected $description = '';
   protected $originalEmailSource;
   protected $mailKey;
   protected $viewPolicy = PhabricatorPolicies::POLICY_USER;
   protected $editPolicy = PhabricatorPolicies::POLICY_USER;
 
   protected $attached = array();
   protected $projectPHIDs = array();
   private $projectsNeedUpdate;
   private $subscribersNeedUpdate;
 
   protected $ownerOrdering;
 
   private $groupByProjectPHID = self::ATTACHABLE;
   private $customFields = self::ATTACHABLE;
 
   public function getConfiguration() {
     return array(
       self::CONFIG_AUX_PHID => true,
       self::CONFIG_SERIALIZATION => array(
         'ccPHIDs' => self::SERIALIZATION_JSON,
         'attached' => self::SERIALIZATION_JSON,
         'projectPHIDs' => self::SERIALIZATION_JSON,
       ),
     ) + parent::getConfiguration();
   }
 
   public function loadDependsOnTaskPHIDs() {
     return PhabricatorEdgeQuery::loadDestinationPHIDs(
       $this->getPHID(),
       PhabricatorEdgeConfig::TYPE_TASK_DEPENDS_ON_TASK);
   }
 
   public function loadDependedOnByTaskPHIDs() {
     return PhabricatorEdgeQuery::loadDestinationPHIDs(
       $this->getPHID(),
       PhabricatorEdgeConfig::TYPE_TASK_DEPENDED_ON_BY_TASK);
   }
 
   public function getAttachedPHIDs($type) {
     return array_keys(idx($this->attached, $type, array()));
   }
 
   public function generatePHID() {
     return PhabricatorPHID::generateNewPHID(ManiphestPHIDTypeTask::TYPECONST);
   }
 
   public function getCCPHIDs() {
     return array_values(nonempty($this->ccPHIDs, array()));
   }
 
   public function setProjectPHIDs(array $phids) {
     $this->projectPHIDs = array_values($phids);
     $this->projectsNeedUpdate = true;
     return $this;
   }
 
   public function getProjectPHIDs() {
     return array_values(nonempty($this->projectPHIDs, array()));
   }
 
   public function setCCPHIDs(array $phids) {
     $this->ccPHIDs = array_values($phids);
     $this->subscribersNeedUpdate = true;
     return $this;
   }
 
   public function setOwnerPHID($phid) {
     $this->ownerPHID = nonempty($phid, null);
     $this->subscribersNeedUpdate = true;
     return $this;
   }
 
   public function setTitle($title) {
     $this->title = $title;
     if (!$this->getID()) {
       $this->originalTitle = $title;
     }
     return $this;
   }
 
   public function attachGroupByProjectPHID($phid) {
     $this->groupByProjectPHID = $phid;
     return $this;
   }
 
   public function getGroupByProjectPHID() {
     return $this->assertAttached($this->groupByProjectPHID);
   }
 
   public function save() {
     if (!$this->mailKey) {
       $this->mailKey = Filesystem::readRandomCharacters(20);
     }
 
     $result = parent::save();
 
     if ($this->projectsNeedUpdate) {
       // If we've changed the project PHIDs for this task, update the link
       // table.
       ManiphestTaskProject::updateTaskProjects($this);
       $this->projectsNeedUpdate = false;
     }
 
     if ($this->subscribersNeedUpdate) {
       // If we've changed the subscriber PHIDs for this task, update the link
       // table.
       ManiphestTaskSubscriber::updateTaskSubscribers($this);
       $this->subscribersNeedUpdate = false;
     }
 
     return $result;
   }
 
 
 
 /* -(  Markup Interface  )--------------------------------------------------- */
 
 
   /**
    * @task markup
    */
   public function getMarkupFieldKey($field) {
     $hash = PhabricatorHash::digest($this->getMarkupText($field));
     $id = $this->getID();
     return "maniphest:T{$id}:{$field}:{$hash}";
   }
 
 
   /**
    * @task markup
    */
   public function getMarkupText($field) {
     return $this->getDescription();
   }
 
 
   /**
    * @task markup
    */
   public function newMarkupEngine($field) {
     return PhabricatorMarkupEngine::newManiphestMarkupEngine();
   }
 
 
   /**
    * @task markup
    */
   public function didMarkupText(
     $field,
     $output,
     PhutilMarkupEngine $engine) {
     return $output;
   }
 
 
   /**
    * @task markup
    */
   public function shouldUseMarkupCache($field) {
     return (bool)$this->getID();
   }
 
 
 /* -(  Policy Interface  )--------------------------------------------------- */
 
 
   public function getCapabilities() {
     return array(
       PhabricatorPolicyCapability::CAN_VIEW,
       PhabricatorPolicyCapability::CAN_EDIT,
     );
   }
 
   public function getPolicy($capability) {
-    return PhabricatorPolicies::POLICY_USER;
+    switch ($capability) {
+      case PhabricatorPolicyCapability::CAN_VIEW:
+        return $this->getViewPolicy();
+      case PhabricatorPolicyCapability::CAN_EDIT:
+        return $this->getEditPolicy();
+    }
   }
 
   public function hasAutomaticCapability($capability, PhabricatorUser $user) {
+
+    // The owner of a task can always view and edit it.
+    $owner_phid = $this->getOwnerPHID();
+    if ($owner_phid) {
+      $user_phid = $user->getPHID();
+      if ($user_phid == $owner_phid) {
+        return true;
+      }
+    }
+
     return false;
   }
 
 
 /* -(  PhabricatorTokenReceiverInterface  )---------------------------------- */
 
   public function getUsersToNotifyOfTokenGiven() {
     // Sort of ambiguous who this was intended for; just let them both know.
     return array_filter(
       array_unique(
         array(
           $this->getAuthorPHID(),
           $this->getOwnerPHID(),
         )));
   }
 
 
 /* -(  PhabricatorCustomFieldInterface  )------------------------------------ */
 
 
   public function getCustomFieldSpecificationForRole($role) {
     return PhabricatorEnv::getEnvConfig('maniphest.fields');
   }
 
   public function getCustomFieldBaseClass() {
     return 'ManiphestCustomField';
   }
 
   public function getCustomFields() {
     return $this->assertAttached($this->customFields);
   }
 
   public function attachCustomFields(PhabricatorCustomFieldAttachment $fields) {
     $this->customFields = $fields;
     return $this;
   }
 
 }