diff --git a/src/applications/maniphest/storage/ManiphestTask.php b/src/applications/maniphest/storage/ManiphestTask.php
index 4f90de3507..46dd8a1547 100644
--- a/src/applications/maniphest/storage/ManiphestTask.php
+++ b/src/applications/maniphest/storage/ManiphestTask.php
@@ -1,607 +1,605 @@
 <?php
 
 final class ManiphestTask extends ManiphestDAO
   implements
     PhabricatorSubscribableInterface,
     PhabricatorMarkupInterface,
     PhabricatorPolicyInterface,
     PhabricatorTokenReceiverInterface,
     PhabricatorFlaggableInterface,
     PhabricatorMentionableInterface,
     PhrequentTrackableInterface,
     PhabricatorCustomFieldInterface,
     PhabricatorDestructibleInterface,
     PhabricatorApplicationTransactionInterface,
     PhabricatorProjectInterface,
     PhabricatorSpacesInterface,
     PhabricatorConduitResultInterface,
     PhabricatorFulltextInterface,
     PhabricatorFerretInterface,
     DoorkeeperBridgedObjectInterface,
     PhabricatorEditEngineSubtypeInterface,
     PhabricatorEditEngineLockableInterface,
     PhabricatorEditEngineMFAInterface,
     PhabricatorPolicyCodexInterface,
     PhabricatorUnlockableInterface {
 
-  const MARKUP_FIELD_DESCRIPTION = 'markup:desc';
-
   protected $authorPHID;
   protected $ownerPHID;
 
   protected $status;
   protected $priority;
   protected $subpriority = 0;
 
   protected $title = '';
   protected $description = '';
   protected $originalEmailSource;
   protected $mailKey;
   protected $viewPolicy = PhabricatorPolicies::POLICY_USER;
   protected $editPolicy = PhabricatorPolicies::POLICY_USER;
 
   protected $ownerOrdering;
   protected $spacePHID;
   protected $bridgedObjectPHID;
   protected $properties = array();
   protected $points;
   protected $subtype;
 
   protected $closedEpoch;
   protected $closerPHID;
 
   private $subscriberPHIDs = self::ATTACHABLE;
   private $groupByProjectPHID = self::ATTACHABLE;
   private $customFields = self::ATTACHABLE;
   private $edgeProjectPHIDs = self::ATTACHABLE;
   private $bridgedObject = self::ATTACHABLE;
 
   public static function initializeNewTask(PhabricatorUser $actor) {
     $app = id(new PhabricatorApplicationQuery())
       ->setViewer($actor)
       ->withClasses(array('PhabricatorManiphestApplication'))
       ->executeOne();
 
     $view_policy = $app->getPolicy(ManiphestDefaultViewCapability::CAPABILITY);
     $edit_policy = $app->getPolicy(ManiphestDefaultEditCapability::CAPABILITY);
 
     return id(new ManiphestTask())
       ->setStatus(ManiphestTaskStatus::getDefaultStatus())
       ->setPriority(ManiphestTaskPriority::getDefaultPriority())
       ->setAuthorPHID($actor->getPHID())
       ->setViewPolicy($view_policy)
       ->setEditPolicy($edit_policy)
       ->setSpacePHID($actor->getDefaultSpacePHID())
       ->setSubtype(PhabricatorEditEngineSubtype::SUBTYPE_DEFAULT)
       ->attachProjectPHIDs(array())
       ->attachSubscriberPHIDs(array());
   }
 
   protected function getConfiguration() {
     return array(
       self::CONFIG_AUX_PHID => true,
       self::CONFIG_SERIALIZATION => array(
         'properties' => self::SERIALIZATION_JSON,
       ),
       self::CONFIG_COLUMN_SCHEMA => array(
         'ownerPHID' => 'phid?',
         'status' => 'text64',
         'priority' => 'uint32',
         'title' => 'sort',
         'description' => 'text',
         'mailKey' => 'bytes20',
         'ownerOrdering' => 'text64?',
         'originalEmailSource' => 'text255?',
         'subpriority' => 'double',
         'points' => 'double?',
         'bridgedObjectPHID' => 'phid?',
         'subtype' => 'text64',
         'closedEpoch' => 'epoch?',
         'closerPHID' => 'phid?',
       ),
       self::CONFIG_KEY_SCHEMA => array(
         'key_phid' => null,
         'phid' => array(
           'columns' => array('phid'),
           'unique' => true,
         ),
         'priority' => array(
           'columns' => array('priority', 'status'),
         ),
         'status' => array(
           'columns' => array('status'),
         ),
         'ownerPHID' => array(
           'columns' => array('ownerPHID', 'status'),
         ),
         'authorPHID' => array(
           'columns' => array('authorPHID', 'status'),
         ),
         'ownerOrdering' => array(
           'columns' => array('ownerOrdering'),
         ),
         'priority_2' => array(
           'columns' => array('priority', 'subpriority'),
         ),
         'key_dateCreated' => array(
           'columns' => array('dateCreated'),
         ),
         'key_dateModified' => array(
           'columns' => array('dateModified'),
         ),
         'key_title' => array(
           'columns' => array('title(64)'),
         ),
         'key_bridgedobject' => array(
           'columns' => array('bridgedObjectPHID'),
           'unique' => true,
         ),
         'key_subtype' => array(
           'columns' => array('subtype'),
         ),
         'key_closed' => array(
           'columns' => array('closedEpoch'),
         ),
         'key_closer' => array(
           'columns' => array('closerPHID', 'closedEpoch'),
         ),
       ),
     ) + parent::getConfiguration();
   }
 
   public function loadDependsOnTaskPHIDs() {
     return PhabricatorEdgeQuery::loadDestinationPHIDs(
       $this->getPHID(),
       ManiphestTaskDependsOnTaskEdgeType::EDGECONST);
   }
 
   public function loadDependedOnByTaskPHIDs() {
     return PhabricatorEdgeQuery::loadDestinationPHIDs(
       $this->getPHID(),
       ManiphestTaskDependedOnByTaskEdgeType::EDGECONST);
   }
 
   public function generatePHID() {
     return PhabricatorPHID::generateNewPHID(ManiphestTaskPHIDType::TYPECONST);
   }
 
   public function getSubscriberPHIDs() {
     return $this->assertAttached($this->subscriberPHIDs);
   }
 
   public function getProjectPHIDs() {
     return $this->assertAttached($this->edgeProjectPHIDs);
   }
 
   public function attachProjectPHIDs(array $phids) {
     $this->edgeProjectPHIDs = $phids;
     return $this;
   }
 
   public function attachSubscriberPHIDs(array $phids) {
     $this->subscriberPHIDs = $phids;
     return $this;
   }
 
   public function setOwnerPHID($phid) {
     $this->ownerPHID = nonempty($phid, null);
     return $this;
   }
 
   public function getMonogram() {
     return 'T'.$this->getID();
   }
 
   public function getURI() {
     return '/'.$this->getMonogram();
   }
 
   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();
 
     return $result;
   }
 
   public function isClosed() {
     return ManiphestTaskStatus::isClosedStatus($this->getStatus());
   }
 
   public function areCommentsLocked() {
     if ($this->areEditsLocked()) {
       return true;
     }
 
     return ManiphestTaskStatus::areCommentsLockedInStatus($this->getStatus());
   }
 
   public function areEditsLocked() {
     return ManiphestTaskStatus::areEditsLockedInStatus($this->getStatus());
   }
 
   public function setProperty($key, $value) {
     $this->properties[$key] = $value;
     return $this;
   }
 
   public function getProperty($key, $default = null) {
     return idx($this->properties, $key, $default);
   }
 
   public function getCoverImageFilePHID() {
     return idx($this->properties, 'cover.filePHID');
   }
 
   public function getCoverImageThumbnailPHID() {
     return idx($this->properties, 'cover.thumbnailPHID');
   }
 
   public function getPriorityKeyword() {
     $priority = $this->getPriority();
 
     $keyword = ManiphestTaskPriority::getKeywordForTaskPriority($priority);
     if ($keyword !== null) {
       return $keyword;
     }
 
     return ManiphestTaskPriority::UNKNOWN_PRIORITY_KEYWORD;
   }
 
 
 /* -(  PhabricatorSubscribableInterface  )----------------------------------- */
 
 
   public function isAutomaticallySubscribed($phid) {
     return ($phid == $this->getOwnerPHID());
   }
 
 
 /* -(  Markup Interface  )--------------------------------------------------- */
 
 
   /**
    * @task markup
    */
   public function getMarkupFieldKey($field) {
     $content = $this->getMarkupText($field);
     return PhabricatorMarkupEngine::digestRemarkupContent($this, $content);
   }
 
 
   /**
    * @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_INTERACT,
       PhabricatorPolicyCapability::CAN_EDIT,
     );
   }
 
   public function getPolicy($capability) {
     switch ($capability) {
       case PhabricatorPolicyCapability::CAN_VIEW:
         return $this->getViewPolicy();
       case PhabricatorPolicyCapability::CAN_INTERACT:
         if ($this->areCommentsLocked()) {
           return PhabricatorPolicies::POLICY_NOONE;
         } else {
           return $this->getViewPolicy();
         }
       case PhabricatorPolicyCapability::CAN_EDIT:
         if ($this->areEditsLocked()) {
           return PhabricatorPolicies::POLICY_NOONE;
         } else {
           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;
   }
 
 
 /* -(  PhabricatorDestructibleInterface  )----------------------------------- */
 
 
   public function destroyObjectPermanently(
     PhabricatorDestructionEngine $engine) {
 
     $this->openTransaction();
     $this->delete();
     $this->saveTransaction();
   }
 
 
 /* -(  PhabricatorApplicationTransactionInterface  )------------------------- */
 
 
   public function getApplicationTransactionEditor() {
     return new ManiphestTransactionEditor();
   }
 
   public function getApplicationTransactionTemplate() {
     return new ManiphestTransaction();
   }
 
 
 /* -(  PhabricatorSpacesInterface  )----------------------------------------- */
 
 
   public function getSpacePHID() {
     return $this->spacePHID;
   }
 
 
 /* -(  PhabricatorConduitResultInterface  )---------------------------------- */
 
 
   public function getFieldSpecificationsForConduit() {
     return array(
       id(new PhabricatorConduitSearchFieldSpecification())
         ->setKey('title')
         ->setType('string')
         ->setDescription(pht('The title of the task.')),
       id(new PhabricatorConduitSearchFieldSpecification())
         ->setKey('description')
         ->setType('remarkup')
         ->setDescription(pht('The task description.')),
       id(new PhabricatorConduitSearchFieldSpecification())
         ->setKey('authorPHID')
         ->setType('phid')
         ->setDescription(pht('Original task author.')),
       id(new PhabricatorConduitSearchFieldSpecification())
         ->setKey('ownerPHID')
         ->setType('phid?')
         ->setDescription(pht('Current task owner, if task is assigned.')),
       id(new PhabricatorConduitSearchFieldSpecification())
         ->setKey('status')
         ->setType('map<string, wild>')
         ->setDescription(pht('Information about task status.')),
       id(new PhabricatorConduitSearchFieldSpecification())
         ->setKey('priority')
         ->setType('map<string, wild>')
         ->setDescription(pht('Information about task priority.')),
       id(new PhabricatorConduitSearchFieldSpecification())
         ->setKey('points')
         ->setType('points')
         ->setDescription(pht('Point value of the task.')),
       id(new PhabricatorConduitSearchFieldSpecification())
         ->setKey('subtype')
         ->setType('string')
         ->setDescription(pht('Subtype of the task.')),
       id(new PhabricatorConduitSearchFieldSpecification())
         ->setKey('closerPHID')
         ->setType('phid?')
         ->setDescription(
           pht('User who closed the task, if the task is closed.')),
       id(new PhabricatorConduitSearchFieldSpecification())
         ->setKey('dateClosed')
         ->setType('int?')
         ->setDescription(
           pht('Epoch timestamp when the task was closed.')),
     );
   }
 
   public function getFieldValuesForConduit() {
     $status_value = $this->getStatus();
     $status_info = array(
       'value' => $status_value,
       'name' => ManiphestTaskStatus::getTaskStatusName($status_value),
       'color' => ManiphestTaskStatus::getStatusColor($status_value),
     );
 
     $priority_value = (int)$this->getPriority();
     $priority_info = array(
       'value' => $priority_value,
       'name' => ManiphestTaskPriority::getTaskPriorityName($priority_value),
       'color' => ManiphestTaskPriority::getTaskPriorityColor($priority_value),
     );
 
     $closed_epoch = $this->getClosedEpoch();
     if ($closed_epoch !== null) {
       $closed_epoch = (int)$closed_epoch;
     }
 
     return array(
       'name' => $this->getTitle(),
       'description' => array(
         'raw' => $this->getDescription(),
       ),
       'authorPHID' => $this->getAuthorPHID(),
       'ownerPHID' => $this->getOwnerPHID(),
       'status' => $status_info,
       'priority' => $priority_info,
       'points' => $this->getPoints(),
       'subtype' => $this->getSubtype(),
       'closerPHID' => $this->getCloserPHID(),
       'dateClosed' => $closed_epoch,
     );
   }
 
   public function getConduitSearchAttachments() {
     return array(
       id(new PhabricatorBoardColumnsSearchEngineAttachment())
         ->setAttachmentKey('columns'),
     );
   }
 
   public function newSubtypeObject() {
     $subtype_key = $this->getEditEngineSubtype();
     $subtype_map = $this->newEditEngineSubtypeMap();
     return $subtype_map->getSubtype($subtype_key);
   }
 
 /* -(  PhabricatorFulltextInterface  )--------------------------------------- */
 
 
   public function newFulltextEngine() {
     return new ManiphestTaskFulltextEngine();
   }
 
 
 /* -(  DoorkeeperBridgedObjectInterface  )----------------------------------- */
 
 
   public function getBridgedObject() {
     return $this->assertAttached($this->bridgedObject);
   }
 
   public function attachBridgedObject(
     DoorkeeperExternalObject $object = null) {
     $this->bridgedObject = $object;
     return $this;
   }
 
 
 /* -(  PhabricatorEditEngineSubtypeInterface  )------------------------------ */
 
 
   public function getEditEngineSubtype() {
     return $this->getSubtype();
   }
 
   public function setEditEngineSubtype($value) {
     return $this->setSubtype($value);
   }
 
   public function newEditEngineSubtypeMap() {
     $config = PhabricatorEnv::getEnvConfig('maniphest.subtypes');
     return PhabricatorEditEngineSubtype::newSubtypeMap($config)
       ->setDatasource(new ManiphestTaskSubtypeDatasource());
   }
 
 
 /* -(  PhabricatorEditEngineLockableInterface  )----------------------------- */
 
 
   public function newEditEngineLock() {
     return new ManiphestTaskEditEngineLock();
   }
 
 
 /* -(  PhabricatorFerretInterface  )----------------------------------------- */
 
 
   public function newFerretEngine() {
     return new ManiphestTaskFerretEngine();
   }
 
 
 /* -(  PhabricatorEditEngineMFAInterface  )---------------------------------- */
 
 
   public function newEditEngineMFAEngine() {
     return new ManiphestTaskMFAEngine();
   }
 
 
 /* -(  PhabricatorPolicyCodexInterface  )------------------------------------ */
 
 
   public function newPolicyCodex() {
     return new ManiphestTaskPolicyCodex();
   }
 
 
 /* -(  PhabricatorUnlockableInterface  )------------------------------------- */
 
 
   public function newUnlockEngine() {
     return new ManiphestTaskUnlockEngine();
   }
 
 }
diff --git a/src/applications/phame/controller/blog/PhameBlogManageController.php b/src/applications/phame/controller/blog/PhameBlogManageController.php
index 65378d91cb..a30d036c3f 100644
--- a/src/applications/phame/controller/blog/PhameBlogManageController.php
+++ b/src/applications/phame/controller/blog/PhameBlogManageController.php
@@ -1,244 +1,239 @@
 <?php
 
 final class PhameBlogManageController extends PhameBlogController {
 
   public function shouldAllowPublic() {
     return true;
   }
 
   public function handleRequest(AphrontRequest $request) {
     $viewer = $request->getViewer();
     $id = $request->getURIData('id');
 
     $blog = id(new PhameBlogQuery())
       ->setViewer($viewer)
       ->withIDs(array($id))
       ->needProfileImage(true)
       ->needHeaderImage(true)
       ->executeOne();
     if (!$blog) {
       return new Aphront404Response();
     }
 
     if ($blog->isArchived()) {
       $header_icon = 'fa-ban';
       $header_name = pht('Archived');
       $header_color = 'dark';
     } else {
       $header_icon = 'fa-check';
       $header_name = pht('Active');
       $header_color = 'bluegrey';
     }
 
     $picture = $blog->getProfileImageURI();
 
     $view = id(new PHUIButtonView())
       ->setTag('a')
       ->setText(pht('View Live'))
       ->setIcon('fa-external-link')
       ->setHref($blog->getLiveURI())
       ->setDisabled($blog->isArchived());
 
     $header = id(new PHUIHeaderView())
       ->setHeader($blog->getName())
       ->setUser($viewer)
       ->setPolicyObject($blog)
       ->setImage($picture)
       ->setStatus($header_icon, $header_color, $header_name)
       ->addActionLink($view);
 
     $can_edit = PhabricatorPolicyFilter::hasCapability(
       $viewer,
       $blog,
       PhabricatorPolicyCapability::CAN_EDIT);
 
     if ($can_edit) {
       $header->setImageEditURL(
         $this->getApplicationURI('blog/picture/'.$blog->getID().'/'));
     }
 
     $curtain = $this->buildCurtain($blog);
     $properties = $this->buildPropertyView($blog);
     $file = $this->buildFileView($blog);
 
     $crumbs = $this->buildApplicationCrumbs();
     $crumbs->addTextCrumb(
       pht('Blogs'),
       $this->getApplicationURI('blog/'));
     $crumbs->addTextCrumb(
       $blog->getName(),
       $this->getApplicationURI('blog/view/'.$id));
     $crumbs->addTextCrumb(pht('Manage Blog'));
     $crumbs->setBorder(true);
 
     $object_box = id(new PHUIObjectBoxView())
       ->setHeader($header)
       ->addPropertyList($properties);
 
     $timeline = $this->buildTransactionTimeline(
       $blog,
       new PhameBlogTransactionQuery());
     $timeline->setShouldTerminate(true);
 
     $view = id(new PHUITwoColumnView())
       ->setHeader($header)
       ->setCurtain($curtain)
       ->addPropertySection(pht('Details'), $properties)
       ->addPropertySection(pht('Header'), $file)
       ->setMainColumn(
         array(
           $timeline,
         ));
 
     return $this->newPage()
       ->setTitle($blog->getName())
       ->setCrumbs($crumbs)
       ->appendChild(
         array(
           $view,
       ));
   }
 
   private function buildPropertyView(PhameBlog $blog) {
     $viewer = $this->getViewer();
 
     require_celerity_resource('aphront-tooltip-css');
     Javelin::initBehavior('phabricator-tooltips');
 
     $properties = id(new PHUIPropertyListView())
       ->setUser($viewer);
 
     $full_domain = $blog->getDomainFullURI();
     if (!$full_domain) {
       $full_domain = phutil_tag('em', array(), pht('No external domain'));
     }
     $properties->addProperty(pht('Full Domain'), $full_domain);
 
     $parent_site = $blog->getParentSite();
     if (!$parent_site) {
       $parent_site = phutil_tag('em', array(), pht('No parent site'));
     }
 
     $properties->addProperty(pht('Parent Site'), $parent_site);
 
     $parent_domain = $blog->getParentDomain();
     if (!$parent_domain) {
       $parent_domain = phutil_tag('em', array(), pht('No parent domain'));
     }
 
     $properties->addProperty(pht('Parent Domain'), $parent_domain);
 
     $feed_uri = PhabricatorEnv::getProductionURI(
       $this->getApplicationURI('blog/feed/'.$blog->getID().'/'));
     $properties->addProperty(
       pht('Atom URI'),
       javelin_tag('a',
         array(
           'href' => $feed_uri,
           'sigil' => 'has-tooltip',
           'meta' => array(
             'tip' => pht('Atom URI does not support custom domains.'),
             'size' => 320,
           ),
         ),
         $feed_uri));
 
-    $engine = id(new PhabricatorMarkupEngine())
-      ->setViewer($viewer)
-      ->addObject($blog, PhameBlog::MARKUP_FIELD_DESCRIPTION)
-      ->process();
-
     $description = $blog->getDescription();
     if (strlen($description)) {
       $description = new PHUIRemarkupView($viewer, $description);
       $properties->addSectionHeader(
         pht('Description'),
         PHUIPropertyListView::ICON_SUMMARY);
       $properties->addTextContent($description);
     }
 
     return $properties;
   }
 
   private function buildCurtain(PhameBlog $blog) {
     $viewer = $this->getViewer();
 
     $curtain = $this->newCurtainView($blog);
 
     $actions = id(new PhabricatorActionListView())
       ->setObject($blog)
       ->setUser($viewer);
 
     $can_edit = PhabricatorPolicyFilter::hasCapability(
       $viewer,
       $blog,
       PhabricatorPolicyCapability::CAN_EDIT);
 
     $curtain->addAction(
       id(new PhabricatorActionView())
         ->setIcon('fa-pencil')
         ->setHref($this->getApplicationURI('blog/edit/'.$blog->getID().'/'))
         ->setName(pht('Edit Blog'))
         ->setDisabled(!$can_edit)
         ->setWorkflow(!$can_edit));
 
     $curtain->addAction(
       id(new PhabricatorActionView())
         ->setIcon('fa-camera')
         ->setHref($this->getApplicationURI('blog/header/'.$blog->getID().'/'))
         ->setName(pht('Edit Blog Header'))
         ->setDisabled(!$can_edit)
         ->setWorkflow(!$can_edit));
 
     $curtain->addAction(
       id(new PhabricatorActionView())
         ->setIcon('fa-picture-o')
         ->setHref($this->getApplicationURI('blog/picture/'.$blog->getID().'/'))
         ->setName(pht('Edit Blog Picture'))
         ->setDisabled(!$can_edit)
         ->setWorkflow(!$can_edit));
 
     if ($blog->isArchived()) {
       $curtain->addAction(
         id(new PhabricatorActionView())
           ->setName(pht('Activate Blog'))
           ->setIcon('fa-check')
           ->setHref(
             $this->getApplicationURI('blog/archive/'.$blog->getID().'/'))
           ->setDisabled(!$can_edit)
           ->setWorkflow(true));
     } else {
       $curtain->addAction(
         id(new PhabricatorActionView())
           ->setName(pht('Archive Blog'))
           ->setIcon('fa-ban')
           ->setHref(
             $this->getApplicationURI('blog/archive/'.$blog->getID().'/'))
           ->setDisabled(!$can_edit)
           ->setWorkflow(true));
     }
 
     return $curtain;
   }
 
   private function buildFileView(
     PhameBlog $blog) {
     $viewer = $this->getViewer();
 
     $view = id(new PHUIPropertyListView())
       ->setUser($viewer);
 
     if ($blog->getHeaderImagePHID()) {
       $view->addImageContent(
         phutil_tag(
           'img',
           array(
             'src'     => $blog->getHeaderImageURI(),
             'class'   => 'phabricator-image-macro-hero',
           )));
       return $view;
     }
     return null;
   }
 
 }
diff --git a/src/applications/phame/storage/PhameBlog.php b/src/applications/phame/storage/PhameBlog.php
index 232f1fe4db..a68ddac0b0 100644
--- a/src/applications/phame/storage/PhameBlog.php
+++ b/src/applications/phame/storage/PhameBlog.php
@@ -1,392 +1,390 @@
 <?php
 
 final class PhameBlog extends PhameDAO
   implements
     PhabricatorPolicyInterface,
     PhabricatorMarkupInterface,
     PhabricatorSubscribableInterface,
     PhabricatorFlaggableInterface,
     PhabricatorProjectInterface,
     PhabricatorDestructibleInterface,
     PhabricatorApplicationTransactionInterface,
     PhabricatorConduitResultInterface,
     PhabricatorFulltextInterface,
     PhabricatorFerretInterface {
 
-  const MARKUP_FIELD_DESCRIPTION = 'markup:description';
-
   protected $name;
   protected $subtitle;
   protected $description;
   protected $domain;
   protected $domainFullURI;
   protected $parentSite;
   protected $parentDomain;
   protected $configData;
   protected $creatorPHID;
   protected $viewPolicy;
   protected $editPolicy;
   protected $status;
   protected $mailKey;
   protected $profileImagePHID;
   protected $headerImagePHID;
 
   private $profileImageFile = self::ATTACHABLE;
   private $headerImageFile = self::ATTACHABLE;
 
   const STATUS_ACTIVE = 'active';
   const STATUS_ARCHIVED = 'archived';
 
   protected function getConfiguration() {
     return array(
       self::CONFIG_AUX_PHID   => true,
       self::CONFIG_SERIALIZATION => array(
         'configData' => self::SERIALIZATION_JSON,
       ),
       self::CONFIG_COLUMN_SCHEMA => array(
         'name' => 'text64',
         'subtitle' => 'text64',
         'description' => 'text',
         'domain' => 'text128?',
         'domainFullURI' => 'text128?',
         'parentSite' => 'text128?',
         'parentDomain' => 'text128?',
         'status' => 'text32',
         'mailKey' => 'bytes20',
         'profileImagePHID' => 'phid?',
         'headerImagePHID' => 'phid?',
 
         'editPolicy' => 'policy',
         'viewPolicy' => 'policy',
       ),
       self::CONFIG_KEY_SCHEMA => array(
         'key_phid' => null,
         'phid' => array(
           'columns' => array('phid'),
           'unique' => true,
         ),
         'domain' => array(
           'columns' => array('domain'),
           'unique' => true,
         ),
       ),
     ) + parent::getConfiguration();
   }
 
   public function save() {
     if (!$this->getMailKey()) {
       $this->setMailKey(Filesystem::readRandomCharacters(20));
     }
     return parent::save();
   }
 
   public function generatePHID() {
     return PhabricatorPHID::generateNewPHID(
       PhabricatorPhameBlogPHIDType::TYPECONST);
   }
 
   public static function initializeNewBlog(PhabricatorUser $actor) {
     $blog = id(new PhameBlog())
       ->setCreatorPHID($actor->getPHID())
       ->setStatus(self::STATUS_ACTIVE)
       ->setViewPolicy(PhabricatorPolicies::getMostOpenPolicy())
       ->setEditPolicy(PhabricatorPolicies::POLICY_USER);
     return $blog;
   }
 
   public function isArchived() {
     return ($this->getStatus() == self::STATUS_ARCHIVED);
   }
 
   public static function getStatusNameMap() {
     return array(
       self::STATUS_ACTIVE => pht('Active'),
       self::STATUS_ARCHIVED => pht('Archived'),
     );
   }
 
   /**
    * Makes sure a given custom blog uri is properly configured in DNS
    * to point at this Phabricator instance. If there is an error in
    * the configuration, return a string describing the error and how
    * to fix it. If there is no error, return an empty string.
    *
    * @return string
    */
   public function validateCustomDomain($domain_full_uri) {
     $example_domain = 'http://blog.example.com/';
     $label = pht('Invalid');
 
     // note this "uri" should be pretty busted given the desired input
     // so just use it to test if there's a protocol specified
     $uri = new PhutilURI($domain_full_uri);
     $domain = $uri->getDomain();
     $protocol = $uri->getProtocol();
     $path = $uri->getPath();
     $supported_protocols = array('http', 'https');
 
     if (!in_array($protocol, $supported_protocols)) {
       return pht(
           'The custom domain should include a valid protocol in the URI '.
           '(for example, "%s"). Valid protocols are "http" or "https".',
           $example_domain);
     }
 
     if (strlen($path) && $path != '/') {
       return pht(
           'The custom domain should not specify a path (hosting a Phame '.
           'blog at a path is currently not supported). Instead, just provide '.
           'the bare domain name (for example, "%s").',
           $example_domain);
     }
 
     if (strpos($domain, '.') === false) {
       return pht(
           'The custom domain should contain at least one dot (.) because '.
           'some browsers fail to set cookies on domains without a dot. '.
           'Instead, use a normal looking domain name like "%s".',
           $example_domain);
     }
 
     if (!PhabricatorEnv::getEnvConfig('policy.allow-public')) {
       $href = PhabricatorEnv::getProductionURI(
         '/config/edit/policy.allow-public/');
       return pht(
         'For custom domains to work, this Phabricator instance must be '.
         'configured to allow the public access policy. Configure this '.
         'setting %s, or ask an administrator to configure this setting. '.
         'The domain can be specified later once this setting has been '.
         'changed.',
         phutil_tag(
           'a',
           array('href' => $href),
           pht('here')));
     }
 
     return null;
   }
 
   public function getLiveURI() {
     if (strlen($this->getDomain())) {
       return $this->getExternalLiveURI();
     } else {
       return $this->getInternalLiveURI();
     }
   }
 
   public function getExternalLiveURI() {
     $uri = new PhutilURI($this->getDomainFullURI());
     PhabricatorEnv::requireValidRemoteURIForLink($uri);
     return (string)$uri;
   }
 
   public function getExternalParentURI() {
     $uri = $this->getParentDomain();
     PhabricatorEnv::requireValidRemoteURIForLink($uri);
     return (string)$uri;
   }
 
   public function getInternalLiveURI() {
     return '/phame/live/'.$this->getID().'/';
   }
 
   public function getViewURI() {
     return '/phame/blog/view/'.$this->getID().'/';
   }
 
   public function getManageURI() {
     return '/phame/blog/manage/'.$this->getID().'/';
   }
 
   public function getProfileImageURI() {
     return $this->getProfileImageFile()->getBestURI();
   }
 
   public function attachProfileImageFile(PhabricatorFile $file) {
     $this->profileImageFile = $file;
     return $this;
   }
 
   public function getProfileImageFile() {
     return $this->assertAttached($this->profileImageFile);
   }
 
   public function getHeaderImageURI() {
     return $this->getHeaderImageFile()->getBestURI();
   }
 
   public function attachHeaderImageFile(PhabricatorFile $file) {
     $this->headerImageFile = $file;
     return $this;
   }
 
   public function getHeaderImageFile() {
     return $this->assertAttached($this->headerImageFile);
   }
 
 
 /* -(  PhabricatorPolicyInterface Implementation  )-------------------------- */
 
 
   public function getCapabilities() {
     return array(
       PhabricatorPolicyCapability::CAN_VIEW,
       PhabricatorPolicyCapability::CAN_EDIT,
     );
   }
 
 
   public function getPolicy($capability) {
     switch ($capability) {
       case PhabricatorPolicyCapability::CAN_VIEW:
         return $this->getViewPolicy();
       case PhabricatorPolicyCapability::CAN_EDIT:
         return $this->getEditPolicy();
     }
   }
 
   public function hasAutomaticCapability($capability, PhabricatorUser $user) {
     $can_edit = PhabricatorPolicyCapability::CAN_EDIT;
 
     switch ($capability) {
       case PhabricatorPolicyCapability::CAN_VIEW:
         // Users who can edit or post to a blog can always view it.
         if (PhabricatorPolicyFilter::hasCapability($user, $this, $can_edit)) {
           return true;
         }
         break;
     }
 
     return false;
   }
 
 
   public function describeAutomaticCapability($capability) {
     switch ($capability) {
       case PhabricatorPolicyCapability::CAN_VIEW:
         return pht(
           'Users who can edit a blog can always view it.');
     }
 
     return null;
   }
 
 
 /* -(  PhabricatorMarkupInterface Implementation  )-------------------------- */
 
 
   public function getMarkupFieldKey($field) {
     $content = $this->getMarkupText($field);
     return PhabricatorMarkupEngine::digestRemarkupContent($this, $content);
   }
 
 
   public function newMarkupEngine($field) {
     return PhabricatorMarkupEngine::newPhameMarkupEngine();
   }
 
 
   public function getMarkupText($field) {
     return $this->getDescription();
   }
 
 
   public function didMarkupText(
     $field,
     $output,
     PhutilMarkupEngine $engine) {
     return $output;
   }
 
   public function shouldUseMarkupCache($field) {
     return (bool)$this->getPHID();
   }
 
 /* -(  PhabricatorDestructibleInterface  )----------------------------------- */
 
   public function destroyObjectPermanently(
     PhabricatorDestructionEngine $engine) {
 
     $this->openTransaction();
 
       $posts = id(new PhamePostQuery())
         ->setViewer($engine->getViewer())
         ->withBlogPHIDs(array($this->getPHID()))
         ->execute();
       foreach ($posts as $post) {
         $engine->destroyObject($post);
       }
       $this->delete();
 
     $this->saveTransaction();
   }
 
 
 /* -(  PhabricatorApplicationTransactionInterface  )------------------------- */
 
 
   public function getApplicationTransactionEditor() {
     return new PhameBlogEditor();
   }
 
   public function getApplicationTransactionTemplate() {
     return new PhameBlogTransaction();
   }
 
 
 /* -(  PhabricatorSubscribableInterface Implementation  )-------------------- */
 
 
   public function isAutomaticallySubscribed($phid) {
     return false;
   }
 
 
 /* -(  PhabricatorConduitResultInterface  )---------------------------------- */
 
 
   public function getFieldSpecificationsForConduit() {
     return array(
       id(new PhabricatorConduitSearchFieldSpecification())
         ->setKey('name')
         ->setType('string')
         ->setDescription(pht('The name of the blog.')),
       id(new PhabricatorConduitSearchFieldSpecification())
         ->setKey('description')
         ->setType('string')
         ->setDescription(pht('Blog description.')),
       id(new PhabricatorConduitSearchFieldSpecification())
         ->setKey('status')
         ->setType('string')
         ->setDescription(pht('Archived or active status.')),
     );
   }
 
   public function getFieldValuesForConduit() {
     return array(
       'name' => $this->getName(),
       'description' => $this->getDescription(),
       'status' => $this->getStatus(),
     );
   }
 
   public function getConduitSearchAttachments() {
     return array();
   }
 
 
 /* -(  PhabricatorFulltextInterface  )--------------------------------------- */
 
   public function newFulltextEngine() {
     return new PhameBlogFulltextEngine();
   }
 
 
 /* -(  PhabricatorFerretInterface  )----------------------------------------- */
 
 
   public function newFerretEngine() {
     return new PhameBlogFerretEngine();
   }
 
 }