diff --git a/resources/sql/autopatches/20160706.phame.blog.parentdomain.2.sql b/resources/sql/autopatches/20160706.phame.blog.parentdomain.2.sql
new file mode 100644
index 0000000000..0fa4f17197
--- /dev/null
+++ b/resources/sql/autopatches/20160706.phame.blog.parentdomain.2.sql
@@ -0,0 +1,2 @@
+ALTER TABLE {$NAMESPACE}_phame.phame_blog
+  MODIFY parentDomain VARCHAR(128) NULL COLLATE {$COLLATE_TEXT};
diff --git a/resources/sql/autopatches/20160706.phame.blog.parentsite.1.sql b/resources/sql/autopatches/20160706.phame.blog.parentsite.1.sql
new file mode 100644
index 0000000000..6c2f2e2483
--- /dev/null
+++ b/resources/sql/autopatches/20160706.phame.blog.parentsite.1.sql
@@ -0,0 +1,2 @@
+ALTER TABLE {$NAMESPACE}_phame.phame_blog
+  MODIFY parentSite VARCHAR(128) NULL COLLATE {$COLLATE_TEXT};
diff --git a/src/applications/phame/editor/PhameBlogEditor.php b/src/applications/phame/editor/PhameBlogEditor.php
index d075a750ea..ea1c132f64 100644
--- a/src/applications/phame/editor/PhameBlogEditor.php
+++ b/src/applications/phame/editor/PhameBlogEditor.php
@@ -1,312 +1,313 @@
 <?php
 
 final class PhameBlogEditor
   extends PhabricatorApplicationTransactionEditor {
 
   public function getEditorApplicationClass() {
     return 'PhabricatorPhameApplication';
   }
 
   public function getEditorObjectsDescription() {
     return pht('Phame Blogs');
   }
 
   public function getTransactionTypes() {
     $types = parent::getTransactionTypes();
 
     $types[] = PhameBlogTransaction::TYPE_NAME;
     $types[] = PhameBlogTransaction::TYPE_SUBTITLE;
     $types[] = PhameBlogTransaction::TYPE_DESCRIPTION;
     $types[] = PhameBlogTransaction::TYPE_FULLDOMAIN;
     $types[] = PhameBlogTransaction::TYPE_PARENTSITE;
     $types[] = PhameBlogTransaction::TYPE_PARENTDOMAIN;
     $types[] = PhameBlogTransaction::TYPE_STATUS;
     $types[] = PhameBlogTransaction::TYPE_HEADERIMAGE;
     $types[] = PhameBlogTransaction::TYPE_PROFILEIMAGE;
 
     $types[] = PhabricatorTransactions::TYPE_VIEW_POLICY;
     $types[] = PhabricatorTransactions::TYPE_EDIT_POLICY;
 
     return $types;
   }
 
   protected function getCustomTransactionOldValue(
     PhabricatorLiskDAO $object,
     PhabricatorApplicationTransaction $xaction) {
 
     switch ($xaction->getTransactionType()) {
       case PhameBlogTransaction::TYPE_NAME:
         return $object->getName();
       case PhameBlogTransaction::TYPE_SUBTITLE:
         return $object->getSubtitle();
       case PhameBlogTransaction::TYPE_DESCRIPTION:
         return $object->getDescription();
       case PhameBlogTransaction::TYPE_FULLDOMAIN:
         return $object->getDomainFullURI();
       case PhameBlogTransaction::TYPE_PARENTSITE:
         return $object->getParentSite();
       case PhameBlogTransaction::TYPE_PARENTDOMAIN:
         return $object->getParentDomain();
       case PhameBlogTransaction::TYPE_PROFILEIMAGE:
         return $object->getProfileImagePHID();
       case PhameBlogTransaction::TYPE_HEADERIMAGE:
         return $object->getHeaderImagePHID();
       case PhameBlogTransaction::TYPE_STATUS:
         return $object->getStatus();
     }
   }
 
   protected function getCustomTransactionNewValue(
     PhabricatorLiskDAO $object,
     PhabricatorApplicationTransaction $xaction) {
 
     switch ($xaction->getTransactionType()) {
       case PhameBlogTransaction::TYPE_NAME:
       case PhameBlogTransaction::TYPE_SUBTITLE:
       case PhameBlogTransaction::TYPE_DESCRIPTION:
       case PhameBlogTransaction::TYPE_STATUS:
       case PhameBlogTransaction::TYPE_PARENTSITE:
+      case PhameBlogTransaction::TYPE_PARENTDOMAIN:
       case PhameBlogTransaction::TYPE_PROFILEIMAGE:
       case PhameBlogTransaction::TYPE_HEADERIMAGE:
         return $xaction->getNewValue();
       case PhameBlogTransaction::TYPE_FULLDOMAIN:
         $domain = $xaction->getNewValue();
         if (!strlen($xaction->getNewValue())) {
           return null;
         }
         return $domain;
     }
   }
 
   protected function applyCustomInternalTransaction(
     PhabricatorLiskDAO $object,
     PhabricatorApplicationTransaction $xaction) {
 
     switch ($xaction->getTransactionType()) {
       case PhameBlogTransaction::TYPE_NAME:
         return $object->setName($xaction->getNewValue());
       case PhameBlogTransaction::TYPE_SUBTITLE:
         return $object->setSubtitle($xaction->getNewValue());
       case PhameBlogTransaction::TYPE_DESCRIPTION:
         return $object->setDescription($xaction->getNewValue());
       case PhameBlogTransaction::TYPE_FULLDOMAIN:
         $new_value = $xaction->getNewValue();
         if (strlen($new_value)) {
           $uri = new PhutilURI($new_value);
           $domain = $uri->getDomain();
           $object->setDomain($domain);
         } else {
           $object->setDomain(null);
         }
         $object->setDomainFullURI($new_value);
         return;
       case PhameBlogTransaction::TYPE_PROFILEIMAGE:
         return $object->setProfileImagePHID($xaction->getNewValue());
       case PhameBlogTransaction::TYPE_HEADERIMAGE:
         return $object->setHeaderImagePHID($xaction->getNewValue());
       case PhameBlogTransaction::TYPE_STATUS:
         return $object->setStatus($xaction->getNewValue());
       case PhameBlogTransaction::TYPE_PARENTSITE:
         return $object->setParentSite($xaction->getNewValue());
       case PhameBlogTransaction::TYPE_PARENTDOMAIN:
         return $object->setParentDomain($xaction->getNewValue());
     }
 
     return parent::applyCustomInternalTransaction($object, $xaction);
   }
 
   protected function applyCustomExternalTransaction(
     PhabricatorLiskDAO $object,
     PhabricatorApplicationTransaction $xaction) {
 
     switch ($xaction->getTransactionType()) {
       case PhameBlogTransaction::TYPE_NAME:
       case PhameBlogTransaction::TYPE_SUBTITLE:
       case PhameBlogTransaction::TYPE_DESCRIPTION:
       case PhameBlogTransaction::TYPE_FULLDOMAIN:
       case PhameBlogTransaction::TYPE_PARENTSITE:
       case PhameBlogTransaction::TYPE_PARENTDOMAIN:
       case PhameBlogTransaction::TYPE_HEADERIMAGE:
       case PhameBlogTransaction::TYPE_PROFILEIMAGE:
       case PhameBlogTransaction::TYPE_STATUS:
         return;
     }
 
     return parent::applyCustomExternalTransaction($object, $xaction);
   }
 
   protected function validateTransaction(
     PhabricatorLiskDAO $object,
     $type,
     array $xactions) {
 
     $errors = parent::validateTransaction($object, $type, $xactions);
 
 
     switch ($type) {
       case PhameBlogTransaction::TYPE_NAME:
         $missing = $this->validateIsEmptyTextField(
           $object->getName(),
           $xactions);
 
         if ($missing) {
           $error = new PhabricatorApplicationTransactionValidationError(
             $type,
             pht('Required'),
             pht('Name is required.'),
             nonempty(last($xactions), null));
 
           $error->setIsMissingFieldError(true);
           $errors[] = $error;
         }
         break;
       case PhameBlogTransaction::TYPE_PARENTDOMAIN:
         if (!$xactions) {
           continue;
         }
         $parent_domain = last($xactions)->getNewValue();
         if (empty($parent_domain)) {
           continue;
         }
         try {
           PhabricatorEnv::requireValidRemoteURIForLink($parent_domain);
         } catch (Exception $ex) {
           $error = new PhabricatorApplicationTransactionValidationError(
             $type,
             pht('Invalid URI'),
             pht('Parent Domain must be set to a valid Remote URI.'),
             nonempty(last($xactions), null));
           $errors[] = $error;
         }
         break;
       case PhameBlogTransaction::TYPE_FULLDOMAIN:
         if (!$xactions) {
           continue;
         }
         $custom_domain = last($xactions)->getNewValue();
         if (empty($custom_domain)) {
           continue;
         }
         list($error_label, $error_text) =
           $object->validateCustomDomain($custom_domain);
         if ($error_label) {
           $error = new PhabricatorApplicationTransactionValidationError(
             $type,
             $error_label,
             $error_text,
             nonempty(last($xactions), null));
           $errors[] = $error;
         }
         if ($object->getViewPolicy() != PhabricatorPolicies::POLICY_PUBLIC) {
           $error_text = pht(
             'For custom domains to work, the blog must have a view policy of '.
             'public.');
           $error = new PhabricatorApplicationTransactionValidationError(
             PhabricatorTransactions::TYPE_VIEW_POLICY,
             pht('Invalid Policy'),
             $error_text,
             nonempty(last($xactions), null));
           $errors[] = $error;
         }
         $domain = new PhutilURI($custom_domain);
         $domain = $domain->getDomain();
         $duplicate_blog = id(new PhameBlogQuery())
           ->setViewer(PhabricatorUser::getOmnipotentUser())
           ->withDomain($domain)
           ->executeOne();
         if ($duplicate_blog && $duplicate_blog->getID() != $object->getID()) {
           $error = new PhabricatorApplicationTransactionValidationError(
             $type,
             pht('Not Unique'),
             pht('Domain must be unique; another blog already has this domain.'),
             nonempty(last($xactions), null));
           $errors[] = $error;
         }
 
         break;
     }
     return $errors;
   }
 
   protected function shouldSendMail(
     PhabricatorLiskDAO $object,
     array $xactions) {
     return true;
   }
 
   protected function shouldPublishFeedStory(
     PhabricatorLiskDAO $object,
     array $xactions) {
     return true;
   }
 
    protected function getMailTo(PhabricatorLiskDAO $object) {
     $phids = array();
     $phids[] = $this->requireActor()->getPHID();
     $phids[] = $object->getCreatorPHID();
 
     return $phids;
   }
 
   protected function buildMailTemplate(PhabricatorLiskDAO $object) {
     $phid = $object->getPHID();
     $name = $object->getName();
 
     return id(new PhabricatorMetaMTAMail())
       ->setSubject($name)
       ->addHeader('Thread-Topic', $phid);
   }
 
   protected function buildReplyHandler(PhabricatorLiskDAO $object) {
     return id(new PhameBlogReplyHandler())
       ->setMailReceiver($object);
   }
 
   protected function buildMailBody(
     PhabricatorLiskDAO $object,
     array $xactions) {
 
     $body = parent::buildMailBody($object, $xactions);
 
     $body->addLinkSection(
       pht('BLOG DETAIL'),
       PhabricatorEnv::getProductionURI($object->getViewURI()));
 
     return $body;
   }
 
   public function getMailTagsMap() {
     return array(
       PhameBlogTransaction::MAILTAG_DETAILS =>
         pht("A blog's details change."),
       PhameBlogTransaction::MAILTAG_SUBSCRIBERS =>
         pht("A blog's subscribers change."),
       PhameBlogTransaction::MAILTAG_OTHER =>
         pht('Other blog activity not listed above occurs.'),
     );
   }
 
   protected function getMailSubjectPrefix() {
     return '[Phame]';
   }
 
 
   protected function supportsSearch() {
     return true;
   }
 
   protected function shouldApplyHeraldRules(
     PhabricatorLiskDAO $object,
     array $xactions) {
     return true;
   }
 
   protected function buildHeraldAdapter(
     PhabricatorLiskDAO $object,
     array $xactions) {
 
     return id(new HeraldPhameBlogAdapter())
       ->setBlog($object);
   }
 
 }
diff --git a/src/applications/phame/storage/PhameBlog.php b/src/applications/phame/storage/PhameBlog.php
index 23ab671552..dc91672465 100644
--- a/src/applications/phame/storage/PhameBlog.php
+++ b/src/applications/phame/storage/PhameBlog.php
@@ -1,407 +1,407 @@
 <?php
 
 final class PhameBlog extends PhameDAO
   implements
     PhabricatorPolicyInterface,
     PhabricatorMarkupInterface,
     PhabricatorSubscribableInterface,
     PhabricatorFlaggableInterface,
     PhabricatorProjectInterface,
     PhabricatorDestructibleInterface,
     PhabricatorApplicationTransactionInterface,
     PhabricatorConduitResultInterface,
     PhabricatorFulltextInterface {
 
   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',
+        'parentSite' => 'text128?',
+        'parentDomain' => 'text128?',
         'status' => 'text32',
         'mailKey' => 'bytes20',
         'profileImagePHID' => 'phid?',
         'headerImagePHID' => 'phid?',
 
         // T6203/NULLABILITY
         // These policies should always be non-null.
         '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 array(
         $label,
         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 array(
         $label,
         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 array(
         $label,
         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 array(
         pht('Fix Configuration'),
         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) {
     $hash = PhabricatorHash::digest($this->getMarkupText($field));
     return $this->getPHID().':'.$field.':'.$hash;
   }
 
 
   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 getApplicationTransactionObject() {
     return $this;
   }
 
   public function getApplicationTransactionTemplate() {
     return new PhameBlogTransaction();
   }
 
   public function willRenderTimeline(
     PhabricatorApplicationTransactionView $timeline,
     AphrontRequest $request) {
     return $timeline;
   }
 
 
 /* -(  PhabricatorSubscribableInterface Implementation  )-------------------- */
 
 
   public function isAutomaticallySubscribed($phid) {
     return ($this->creatorPHID == $phid);
   }
 
 
 /* -(  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();
   }
 
 }