diff --git a/src/applications/maniphest/config/PhabricatorManiphestConfigOptions.php b/src/applications/maniphest/config/PhabricatorManiphestConfigOptions.php
index 8f2830908b..05f98a2f62 100644
--- a/src/applications/maniphest/config/PhabricatorManiphestConfigOptions.php
+++ b/src/applications/maniphest/config/PhabricatorManiphestConfigOptions.php
@@ -1,474 +1,497 @@
 <?php
 
 final class PhabricatorManiphestConfigOptions
   extends PhabricatorApplicationConfigOptions {
 
   public function getName() {
     return pht('Maniphest');
   }
 
   public function getDescription() {
     return pht('Configure Maniphest.');
   }
 
   public function getIcon() {
     return 'fa-anchor';
   }
 
   public function getGroup() {
     return 'apps';
   }
 
   public function getOptions() {
     $priority_type = 'maniphest.priorities';
     $priority_defaults = array(
       100 => array(
         'name'  => pht('Unbreak Now!'),
         'keywords' => array('unbreak'),
         'short' => pht('Unbreak!'),
         'color' => 'pink',
       ),
       90 => array(
         'name' => pht('Needs Triage'),
         'keywords' => array('triage'),
         'short' => pht('Triage'),
         'color' => 'violet',
       ),
       80 => array(
         'name' => pht('High'),
         'keywords' => array('high'),
         'short' => pht('High'),
         'color' => 'red',
       ),
       50 => array(
         'name' => pht('Normal'),
         'keywords' => array('normal'),
         'short' => pht('Normal'),
         'color' => 'orange',
       ),
       25 => array(
         'name' => pht('Low'),
         'keywords' => array('low'),
         'short' => pht('Low'),
         'color' => 'yellow',
       ),
       0 => array(
         'name' => pht('Wishlist'),
         'keywords' => array('wish', 'wishlist'),
         'short' => pht('Wish'),
         'color' => 'sky',
       ),
     );
 
     $status_type = 'maniphest.statuses';
     $status_defaults = array(
       'open' => array(
         'name' => pht('Open'),
         'special' => ManiphestTaskStatus::SPECIAL_DEFAULT,
         'prefixes' => array(
           'open',
           'opens',
           'reopen',
           'reopens',
         ),
       ),
       'resolved' => array(
         'name' => pht('Resolved'),
         'name.full' => pht('Closed, Resolved'),
         'closed' => true,
         'special' => ManiphestTaskStatus::SPECIAL_CLOSED,
         'transaction.icon' => 'fa-check-circle',
         'prefixes' => array(
           'closed',
           'closes',
           'close',
           'fix',
           'fixes',
           'fixed',
           'resolve',
           'resolves',
           'resolved',
         ),
         'suffixes' => array(
           'as resolved',
           'as fixed',
         ),
         'keywords' => array('closed', 'fixed', 'resolved'),
       ),
       'wontfix' => array(
         'name' => pht('Wontfix'),
         'name.full' => pht('Closed, Wontfix'),
         'transaction.icon' => 'fa-ban',
         'closed' => true,
         'prefixes' => array(
           'wontfix',
           'wontfixes',
           'wontfixed',
         ),
         'suffixes' => array(
           'as wontfix',
         ),
       ),
       'invalid' => array(
         'name' => pht('Invalid'),
         'name.full' => pht('Closed, Invalid'),
         'transaction.icon' => 'fa-minus-circle',
         'closed' => true,
         'claim' => false,
         'prefixes' => array(
           'invalidate',
           'invalidates',
           'invalidated',
         ),
         'suffixes' => array(
           'as invalid',
         ),
       ),
       'duplicate' => array(
         'name' => pht('Duplicate'),
         'name.full' => pht('Closed, Duplicate'),
         'transaction.icon' => 'fa-files-o',
         'special' => ManiphestTaskStatus::SPECIAL_DUPLICATE,
         'closed' => true,
         'claim' => false,
       ),
       'spite' => array(
         'name' => pht('Spite'),
         'name.full' => pht('Closed, Spite'),
         'name.action' => pht('Spited'),
         'transaction.icon' => 'fa-thumbs-o-down',
         'silly' => true,
         'closed' => true,
         'prefixes' => array(
           'spite',
           'spites',
           'spited',
         ),
         'suffixes' => array(
           'out of spite',
           'as spite',
         ),
       ),
     );
 
     $status_description = $this->deformat(pht(<<<EOTEXT
 Allows you to edit, add, or remove the task statuses available in Maniphest,
 like "Open", "Resolved" and "Invalid". The configuration should contain a map
 of status constants to status specifications (see defaults below for examples).
 
 The constant for each status should be 1-12 characters long and  contain only
 lowercase letters and digits. Valid examples are "open", "closed", and
 "invalid". Users will not normally see these values.
 
 The keys you can provide in a specification are:
 
   - `name` //Required string.// Name of the status, like "Invalid".
   - `name.full` //Optional string.// Longer name, like "Closed, Invalid". This
     appears on the task detail view in the header.
   - `name.action` //Optional string.// Action name for email subjects, like
     "Marked Invalid".
   - `closed` //Optional bool.// Statuses are either "open" or "closed".
     Specifying `true` here will mark the status as closed (like "Resolved" or
     "Invalid"). By default, statuses are open.
   - `special` //Optional string.// Mark this status as special. The special
     statuses are:
     - `default` This is the default status for newly created tasks. You must
       designate one status as default, and it must be an open status.
     - `closed` This is the default status for closed tasks (for example, tasks
       closed via the "!close" action in email or via the quick close button in
       Maniphest). You must designate one status as the default closed status,
       and it must be a closed status.
     - `duplicate` This is the status used when tasks are merged into one
       another as duplicates. You must designate one status for duplicates,
       and it must be a closed status.
   - `transaction.icon` //Optional string.// Allows you to choose a different
     icon to use for this status when showing status changes in the transaction
     log. Please see UIExamples, Icons and Images for a list.
   - `transaction.color` //Optional string.// Allows you to choose a different
     color to use for this status when showing status changes in the transaction
     log.
   - `silly` //Optional bool.// Marks this status as silly, and thus wholly
     inappropriate for use by serious businesses.
   - `prefixes` //Optional list<string>.// Allows you to specify a list of
     text prefixes which will trigger a task transition into this status
     when mentioned in a commit message. For example, providing "closes" here
     will allow users to move tasks to this status by writing `Closes T123` in
     commit messages.
   - `suffixes` //Optional list<string>.// Allows you to specify a list of
     text suffixes which will trigger a task transition into this status
     when mentioned in a commit message, after a valid prefix. For example,
     providing "as invalid" here will allow users to move tasks
     to this status by writing `Closes T123 as invalid`, even if another status
     is selected by the "Closes" prefix.
   - `keywords` //Optional list<string>.// Allows you to specify a list
     of keywords which can be used with `!status` commands in email to select
     this status.
   - `disabled` //Optional bool.// Marks this status as no longer in use so
     tasks can not be created or edited to have this status. Existing tasks with
     this status will not be affected, but you can batch edit them or let them
     die out on their own.
   - `claim` //Optional bool.// By default, closing an unassigned task claims
     it. You can set this to `false` to disable this behavior for a particular
     status.
   - `locked` //Optional bool.// Lock tasks in this status, preventing users
     from commenting.
   - `mfa` //Optional bool.// Require all edits to this task to be signed with
     multi-factor authentication.
 
 Statuses will appear in the UI in the order specified. Note the status marked
 `special` as `duplicate` is not settable directly and will not appear in UI
 elements, and that any status marked `silly` does not appear if Phabricator
 is configured with `phabricator.serious-business` set to true.
 
 Examining the default configuration and examples below will probably be helpful
 in understanding these options.
 
 EOTEXT
 ));
 
     $status_example = array(
       'open' => array(
         'name' => pht('Open'),
         'special' => 'default',
       ),
       'closed' => array(
         'name' => pht('Closed'),
         'special' => 'closed',
         'closed' => true,
       ),
       'duplicate' => array(
         'name' => pht('Duplicate'),
         'special' => 'duplicate',
         'closed' => true,
       ),
     );
 
     $json = new PhutilJSON();
     $status_example = $json->encodeFormatted($status_example);
 
     // This is intentionally blank for now, until we can move more Maniphest
     // logic to custom fields.
     $default_fields = array();
 
     foreach ($default_fields as $key => $enabled) {
       $default_fields[$key] = array(
         'disabled' => !$enabled,
       );
     }
 
     $custom_field_type = 'custom:PhabricatorCustomFieldConfigOptionType';
 
     $fields_example = array(
       'mycompany.estimated-hours' => array(
         'name' => pht('Estimated Hours'),
         'type' => 'int',
         'caption' => pht('Estimated number of hours this will take.'),
       ),
     );
     $fields_json = id(new PhutilJSON())->encodeFormatted($fields_example);
 
     $points_type = 'maniphest.points';
 
     $points_example_1 = array(
       'enabled' => true,
       'label' => pht('Story Points'),
       'action' => pht('Change Story Points'),
     );
     $points_json_1 = id(new PhutilJSON())->encodeFormatted($points_example_1);
 
     $points_example_2 = array(
       'enabled' => true,
       'label' => pht('Estimated Hours'),
       'action' => pht('Change Estimate'),
     );
     $points_json_2 = id(new PhutilJSON())->encodeFormatted($points_example_2);
 
     $points_description = $this->deformat(pht(<<<EOTEXT
 Activates a points field on tasks. You can use points for estimation or
 planning. If configured, points will appear on workboards.
 
 To activate points, set this value to a map with these keys:
 
   - `enabled` //Optional bool.// Use `true` to enable points, or
     `false` to disable them.
   - `label` //Optional string.// Label for points, like "Story Points" or
     "Estimated Hours". If omitted, points will be called "Points".
   - `action` //Optional string.// Label for the action which changes points
     in Maniphest, like "Change Estimate". If omitted, the action will
     be called "Change Points".
 
 See the example below for a starting point.
 EOTEXT
 ));
 
     $subtype_type = 'maniphest.subtypes';
     $subtype_default_key = PhabricatorEditEngineSubtype::SUBTYPE_DEFAULT;
     $subtype_example = array(
       array(
         'key' => $subtype_default_key,
         'name' => pht('Task'),
       ),
       array(
         'key' => 'bug',
         'name' => pht('Bug'),
       ),
       array(
         'key' => 'feature',
         'name' => pht('Feature Request'),
       ),
     );
     $subtype_example = id(new PhutilJSON())->encodeAsList($subtype_example);
 
     $subtype_default = array(
       array(
         'key' => $subtype_default_key,
         'name' => pht('Task'),
       ),
     );
 
     $subtype_description = $this->deformat(pht(<<<EOTEXT
 Allows you to define task subtypes. Subtypes let you hide fields you don't
 need to simplify the workflows for editing tasks.
 
 To define subtypes, provide a list of subtypes. Each subtype should be a
 dictionary with these keys:
 
   - `key` //Required string.// Internal identifier for the subtype, like
     "task", "feature", or "bug".
   - `name` //Required string.// Human-readable name for this subtype, like
     "Task", "Feature Request" or "Bug Report".
   - `tag` //Optional string.// Tag text for this subtype.
   - `color` //Optional string.// Display color for this subtype.
   - `icon` //Optional string.// Icon for the subtype.
   - `children` //Optional map.// Configure options shown to the user when
      they "Create Subtask". See below.
+  - `fields` //Optional map.// Configure field behaviors. See below.
 
 Each subtype must have a unique key, and you must define a subtype with
 the key "%s", which is used as a default subtype.
 
 The tag text (`tag`) is used to set the text shown in the subtype tag on list
 views and workboards. If you do not configure it, the default subtype will have
 no subtype tag and other subtypes will use their name as tag text.
 
 The `children` key allows you to configure which options are presented to the
 user when they "Create Subtask" from a task of this subtype. You can specify
 these keys:
 
   - `subtypes`: //Optional list<string>.// Show users creation forms for these
     task subtypes.
   - `forms`: //Optional list<string|int>.// Show users these specific forms,
     in order.
 
 If you don't specify either constraint, users will be shown creation forms
 for the same subtype.
 
 For example, if you have a "quest" subtype and do not configure `children`,
 users who click "Create Subtask" will be presented with all create forms for
 "quest" tasks.
 
 If you want to present them with forms for a different task subtype or set of
 subtypes instead, use `subtypes`:
 
 ```
   {
     ...
     "children": {
       "subtypes": ["objective", "boss", "reward"]
     }
     ...
   }
 ```
 
 If you want to present them with specific forms, use `forms` and specify form
 IDs:
 
 ```
   {
     ...
     "children": {
       "forms": [12, 16]
     }
     ...
   }
 ```
 
 When specifying forms by ID explicitly, the order you specify the forms in will
 be used when presenting options to the user.
 
 If only one option would be presented, the user will be taken directly to the
 appropriate form instead of being prompted to choose a form.
+
+The `fields` key can configure the behavior of custom fields on specific
+task subtypes. For example:
+
+```
+{
+  ...
+  "fields": {
+    "custom.some-field": {
+      "disabled": true
+    }
+  }
+  ...
+}
+```
+
+Each field supports these options:
+
+  - `disabled` //Optional bool.// Allows you to disable fields on certain
+    subtypes.
+  - `name` //Optional string.// Custom name of this field for the subtype.
+
 EOTEXT
       ,
       $subtype_default_key));
 
     $priorities_description = $this->deformat(pht(<<<EOTEXT
 Allows you to edit or override the default priorities available in Maniphest,
 like "High", "Normal" and "Low". The configuration should contain a map of
 numeric priority values (where larger numbers correspond to higher priorities)
 to priority specifications (see defaults below for examples).
 
 The keys you can define for a priority are:
 
   - `name` //Required string.// Name of the priority.
   - `keywords` //Required list<string>.// List of unique keywords which identify
     this priority, like "high" or "low". Each priority must have at least one
     keyword and two priorities may not share the same keyword.
   - `short` //Optional string.// Alternate shorter name, used in UIs where
     there is less space available.
   - `color` //Optional string.// Color for this priority, like "red" or
     "blue".
   - `disabled` //Optional bool.// Set to true to prevent users from choosing
     this priority when creating or editing tasks. Existing tasks will not be
     affected, and can be batch edited to a different priority or left to
     eventually die out.
 
 You can choose the default priority for newly created tasks with
 "maniphest.default-priority".
 EOTEXT
       ));
 
 
     return array(
       $this->newOption('maniphest.custom-field-definitions', 'wild', array())
         ->setSummary(pht('Custom Maniphest fields.'))
         ->setDescription(
           pht(
             'Array of custom fields for Maniphest tasks. For details on '.
             'adding custom fields to Maniphest, see "Configuring Custom '.
             'Fields" in the documentation.'))
         ->addExample($fields_json, pht('Valid setting')),
       $this->newOption('maniphest.fields', $custom_field_type, $default_fields)
         ->setCustomData(id(new ManiphestTask())->getCustomFieldBaseClass())
         ->setDescription(pht('Select and reorder task fields.')),
       $this->newOption(
         'maniphest.priorities',
         $priority_type,
         $priority_defaults)
         ->setSummary(pht('Configure Maniphest priority names.'))
         ->setDescription($priorities_description),
       $this->newOption('maniphest.statuses', $status_type, $status_defaults)
         ->setSummary(pht('Configure Maniphest task statuses.'))
         ->setDescription($status_description)
         ->addExample($status_example, pht('Minimal Valid Config')),
       $this->newOption('maniphest.default-priority', 'int', 90)
         ->setSummary(pht('Default task priority for create flows.'))
         ->setDescription(
           pht(
             'Choose a default priority for newly created tasks. You can '.
             'review and adjust available priorities by using the '.
             '%s configuration option. The default value (`90`) '.
             'corresponds to the default "Needs Triage" priority.',
             'maniphest.priorities')),
       $this->newOption('maniphest.points', $points_type, array())
         ->setSummary(pht('Configure point values for tasks.'))
         ->setDescription($points_description)
         ->addExample($points_json_1, pht('Points Config'))
         ->addExample($points_json_2, pht('Hours Config')),
       $this->newOption('maniphest.subtypes', $subtype_type, $subtype_default)
         ->setSummary(pht('Define task subtypes.'))
         ->setDescription($subtype_description)
         ->addExample($subtype_example, pht('Simple Subtypes')),
     );
   }
 
 }
diff --git a/src/applications/transactions/editengine/PhabricatorEditEngine.php b/src/applications/transactions/editengine/PhabricatorEditEngine.php
index 353d7ee385..82af45dca8 100644
--- a/src/applications/transactions/editengine/PhabricatorEditEngine.php
+++ b/src/applications/transactions/editengine/PhabricatorEditEngine.php
@@ -1,2666 +1,2681 @@
 <?php
 
 
 /**
  * @task fields Managing Fields
  * @task text Display Text
  * @task config Edit Engine Configuration
  * @task uri Managing URIs
  * @task load Creating and Loading Objects
  * @task web Responding to Web Requests
  * @task edit Responding to Edit Requests
  * @task http Responding to HTTP Parameter Requests
  * @task conduit Responding to Conduit Requests
  */
 abstract class PhabricatorEditEngine
   extends Phobject
   implements PhabricatorPolicyInterface {
 
   const EDITENGINECONFIG_DEFAULT = 'default';
 
   const SUBTYPE_DEFAULT = 'default';
 
   private $viewer;
   private $controller;
   private $isCreate;
   private $editEngineConfiguration;
   private $contextParameters = array();
   private $targetObject;
   private $page;
   private $pages;
   private $navigation;
 
   final public function setViewer(PhabricatorUser $viewer) {
     $this->viewer = $viewer;
     return $this;
   }
 
   final public function getViewer() {
     return $this->viewer;
   }
 
   final public function setController(PhabricatorController $controller) {
     $this->controller = $controller;
     $this->setViewer($controller->getViewer());
     return $this;
   }
 
   final public function getController() {
     return $this->controller;
   }
 
   final public function getEngineKey() {
     $key = $this->getPhobjectClassConstant('ENGINECONST', 64);
     if (strpos($key, '/') !== false) {
       throw new Exception(
         pht(
           'EditEngine ("%s") contains an invalid key character "/".',
           get_class($this)));
     }
     return $key;
   }
 
   final public function getApplication() {
     $app_class = $this->getEngineApplicationClass();
     return PhabricatorApplication::getByClass($app_class);
   }
 
   final public function addContextParameter($key) {
     $this->contextParameters[] = $key;
     return $this;
   }
 
   public function isEngineConfigurable() {
     return true;
   }
 
   public function isEngineExtensible() {
     return true;
   }
 
   public function isDefaultQuickCreateEngine() {
     return false;
   }
 
   public function getDefaultQuickCreateFormKeys() {
     $keys = array();
 
     if ($this->isDefaultQuickCreateEngine()) {
       $keys[] = self::EDITENGINECONFIG_DEFAULT;
     }
 
     foreach ($keys as $idx => $key) {
       $keys[$idx] = $this->getEngineKey().'/'.$key;
     }
 
     return $keys;
   }
 
   public static function splitFullKey($full_key) {
     return explode('/', $full_key, 2);
   }
 
   public function getQuickCreateOrderVector() {
     return id(new PhutilSortVector())
       ->addString($this->getObjectCreateShortText());
   }
 
   /**
    * Force the engine to edit a particular object.
    */
   public function setTargetObject($target_object) {
     $this->targetObject = $target_object;
     return $this;
   }
 
   public function getTargetObject() {
     return $this->targetObject;
   }
 
   public function setNavigation(AphrontSideNavFilterView $navigation) {
     $this->navigation = $navigation;
     return $this;
   }
 
   public function getNavigation() {
     return $this->navigation;
   }
 
 
 /* -(  Managing Fields  )---------------------------------------------------- */
 
 
   abstract public function getEngineApplicationClass();
   abstract protected function buildCustomEditFields($object);
 
   public function getFieldsForConfig(
     PhabricatorEditEngineConfiguration $config) {
 
     $object = $this->newEditableObject();
 
     $this->editEngineConfiguration = $config;
 
     // This is mostly making sure that we fill in default values.
     $this->setIsCreate(true);
 
     return $this->buildEditFields($object);
   }
 
   final protected function buildEditFields($object) {
     $viewer = $this->getViewer();
 
     $fields = $this->buildCustomEditFields($object);
 
     foreach ($fields as $field) {
       $field
         ->setViewer($viewer)
         ->setObject($object);
     }
 
     $fields = mpull($fields, null, 'getKey');
 
     if ($this->isEngineExtensible()) {
       $extensions = PhabricatorEditEngineExtension::getAllEnabledExtensions();
     } else {
       $extensions = array();
     }
 
+    // See T13248. Create a template object to provide to extensions. We
+    // adjust the template to have the intended subtype, so that extensions
+    // may change behavior based on the form subtype.
+
+    $template_object = clone $object;
+    if ($this->getIsCreate()) {
+      if ($this->supportsSubtypes()) {
+        $config = $this->getEditEngineConfiguration();
+        $subtype = $config->getSubtype();
+        $template_object->setSubtype($subtype);
+      }
+    }
+
     foreach ($extensions as $extension) {
       $extension->setViewer($viewer);
 
-      if (!$extension->supportsObject($this, $object)) {
+      if (!$extension->supportsObject($this, $template_object)) {
         continue;
       }
 
-      $extension_fields = $extension->buildCustomEditFields($this, $object);
+      $extension_fields = $extension->buildCustomEditFields(
+        $this,
+        $template_object);
 
       // TODO: Validate this in more detail with a more tailored error.
       assert_instances_of($extension_fields, 'PhabricatorEditField');
 
       foreach ($extension_fields as $field) {
         $field
           ->setViewer($viewer)
           ->setObject($object);
 
         $group_key = $field->getBulkEditGroupKey();
         if ($group_key === null) {
           $field->setBulkEditGroupKey('extension');
         }
       }
 
       $extension_fields = mpull($extension_fields, null, 'getKey');
 
       foreach ($extension_fields as $key => $field) {
         $fields[$key] = $field;
       }
     }
 
     $config = $this->getEditEngineConfiguration();
     $fields = $this->willConfigureFields($object, $fields);
     $fields = $config->applyConfigurationToFields($this, $object, $fields);
 
     $fields = $this->applyPageToFields($object, $fields);
 
     return $fields;
   }
 
   protected function willConfigureFields($object, array $fields) {
     return $fields;
   }
 
   final public function supportsSubtypes() {
     try {
       $object = $this->newEditableObject();
     } catch (Exception $ex) {
       return false;
     }
 
     return ($object instanceof PhabricatorEditEngineSubtypeInterface);
   }
 
   final public function newSubtypeMap() {
     return $this->newEditableObject()->newEditEngineSubtypeMap();
   }
 
 
 /* -(  Display Text  )------------------------------------------------------- */
 
 
   /**
    * @task text
    */
   abstract public function getEngineName();
 
 
   /**
    * @task text
    */
   abstract protected function getObjectCreateTitleText($object);
 
   /**
    * @task text
    */
   protected function getFormHeaderText($object) {
     $config = $this->getEditEngineConfiguration();
     return $config->getName();
   }
 
   /**
    * @task text
    */
   abstract protected function getObjectEditTitleText($object);
 
 
   /**
    * @task text
    */
   abstract protected function getObjectCreateShortText();
 
 
   /**
    * @task text
    */
   abstract protected function getObjectName();
 
 
   /**
    * @task text
    */
   abstract protected function getObjectEditShortText($object);
 
 
   /**
    * @task text
    */
   protected function getObjectCreateButtonText($object) {
     return $this->getObjectCreateTitleText($object);
   }
 
 
   /**
    * @task text
    */
   protected function getObjectEditButtonText($object) {
     return pht('Save Changes');
   }
 
 
   /**
    * @task text
    */
   protected function getCommentViewSeriousHeaderText($object) {
     return pht('Take Action');
   }
 
 
   /**
    * @task text
    */
   protected function getCommentViewSeriousButtonText($object) {
     return pht('Submit');
   }
 
 
   /**
    * @task text
    */
   protected function getCommentViewHeaderText($object) {
     return $this->getCommentViewSeriousHeaderText($object);
   }
 
 
   /**
    * @task text
    */
   protected function getCommentViewButtonText($object) {
     return $this->getCommentViewSeriousButtonText($object);
   }
 
 
   /**
    * @task text
    */
   protected function getPageHeader($object) {
     return null;
   }
 
 
 
   /**
    * Return a human-readable header describing what this engine is used to do,
    * like "Configure Maniphest Task Forms".
    *
    * @return string Human-readable description of the engine.
    * @task text
    */
   abstract public function getSummaryHeader();
 
 
   /**
    * Return a human-readable summary of what this engine is used to do.
    *
    * @return string Human-readable description of the engine.
    * @task text
    */
   abstract public function getSummaryText();
 
 
 
 
 /* -(  Edit Engine Configuration  )------------------------------------------ */
 
 
   protected function supportsEditEngineConfiguration() {
     return true;
   }
 
   final protected function getEditEngineConfiguration() {
     return $this->editEngineConfiguration;
   }
 
   public function newConfigurationQuery() {
     return id(new PhabricatorEditEngineConfigurationQuery())
       ->setViewer($this->getViewer())
       ->withEngineKeys(array($this->getEngineKey()));
   }
 
   private function loadEditEngineConfigurationWithQuery(
     PhabricatorEditEngineConfigurationQuery $query,
     $sort_method) {
 
     if ($sort_method) {
       $results = $query->execute();
       $results = msort($results, $sort_method);
       $result = head($results);
     } else {
       $result = $query->executeOne();
     }
 
     if (!$result) {
       return null;
     }
 
     $this->editEngineConfiguration = $result;
     return $result;
   }
 
   private function loadEditEngineConfigurationWithIdentifier($identifier) {
     $query = $this->newConfigurationQuery()
       ->withIdentifiers(array($identifier));
 
     return $this->loadEditEngineConfigurationWithQuery($query, null);
   }
 
   private function loadDefaultConfiguration() {
     $query = $this->newConfigurationQuery()
       ->withIdentifiers(
         array(
           self::EDITENGINECONFIG_DEFAULT,
         ))
       ->withIgnoreDatabaseConfigurations(true);
 
     return $this->loadEditEngineConfigurationWithQuery($query, null);
   }
 
   private function loadDefaultCreateConfiguration() {
     $query = $this->newConfigurationQuery()
       ->withIsDefault(true)
       ->withIsDisabled(false);
 
     return $this->loadEditEngineConfigurationWithQuery(
       $query,
       'getCreateSortKey');
   }
 
   public function loadDefaultEditConfiguration($object) {
     $query = $this->newConfigurationQuery()
       ->withIsEdit(true)
       ->withIsDisabled(false);
 
     // If this object supports subtyping, we edit it with a form of the same
     // subtype: so "bug" tasks get edited with "bug" forms.
     if ($object instanceof PhabricatorEditEngineSubtypeInterface) {
       $query->withSubtypes(
         array(
           $object->getEditEngineSubtype(),
         ));
     }
 
     return $this->loadEditEngineConfigurationWithQuery(
       $query,
       'getEditSortKey');
   }
 
   final public function getBuiltinEngineConfigurations() {
     $configurations = $this->newBuiltinEngineConfigurations();
 
     if (!$configurations) {
       throw new Exception(
         pht(
           'EditEngine ("%s") returned no builtin engine configurations, but '.
           'an edit engine must have at least one configuration.',
           get_class($this)));
     }
 
     assert_instances_of($configurations, 'PhabricatorEditEngineConfiguration');
 
     $has_default = false;
     foreach ($configurations as $config) {
       if ($config->getBuiltinKey() == self::EDITENGINECONFIG_DEFAULT) {
         $has_default = true;
       }
     }
 
     if (!$has_default) {
       $first = head($configurations);
       if (!$first->getBuiltinKey()) {
         $first
           ->setBuiltinKey(self::EDITENGINECONFIG_DEFAULT)
           ->setIsDefault(true)
           ->setIsEdit(true);
 
         if (!strlen($first->getName())) {
           $first->setName($this->getObjectCreateShortText());
         }
     } else {
         throw new Exception(
           pht(
             'EditEngine ("%s") returned builtin engine configurations, '.
             'but none are marked as default and the first configuration has '.
             'a different builtin key already. Mark a builtin as default or '.
             'omit the key from the first configuration',
             get_class($this)));
       }
     }
 
     $builtins = array();
     foreach ($configurations as $key => $config) {
       $builtin_key = $config->getBuiltinKey();
 
       if ($builtin_key === null) {
         throw new Exception(
           pht(
             'EditEngine ("%s") returned builtin engine configurations, '.
             'but one (with key "%s") is missing a builtin key. Provide a '.
             'builtin key for each configuration (you can omit it from the '.
             'first configuration in the list to automatically assign the '.
             'default key).',
             get_class($this),
             $key));
       }
 
       if (isset($builtins[$builtin_key])) {
         throw new Exception(
           pht(
             'EditEngine ("%s") returned builtin engine configurations, '.
             'but at least two specify the same builtin key ("%s"). Engines '.
             'must have unique builtin keys.',
             get_class($this),
             $builtin_key));
       }
 
       $builtins[$builtin_key] = $config;
     }
 
 
     return $builtins;
   }
 
   protected function newBuiltinEngineConfigurations() {
     return array(
       $this->newConfiguration(),
     );
   }
 
   final protected function newConfiguration() {
     return PhabricatorEditEngineConfiguration::initializeNewConfiguration(
       $this->getViewer(),
       $this);
   }
 
 
 /* -(  Managing URIs  )------------------------------------------------------ */
 
 
   /**
    * @task uri
    */
   abstract protected function getObjectViewURI($object);
 
 
   /**
    * @task uri
    */
   protected function getObjectCreateCancelURI($object) {
     return $this->getApplication()->getApplicationURI();
   }
 
 
   /**
    * @task uri
    */
   protected function getEditorURI() {
     return $this->getApplication()->getApplicationURI('edit/');
   }
 
 
   /**
    * @task uri
    */
   protected function getObjectEditCancelURI($object) {
     return $this->getObjectViewURI($object);
   }
 
 
   /**
    * @task uri
    */
   public function getEditURI($object = null, $path = null) {
     $parts = array();
 
     $parts[] = $this->getEditorURI();
 
     if ($object && $object->getID()) {
       $parts[] = $object->getID().'/';
     }
 
     if ($path !== null) {
       $parts[] = $path;
     }
 
     return implode('', $parts);
   }
 
   public function getEffectiveObjectViewURI($object) {
     if ($this->getIsCreate()) {
       return $this->getObjectViewURI($object);
     }
 
     $page = $this->getSelectedPage();
     if ($page) {
       $view_uri = $page->getViewURI();
       if ($view_uri !== null) {
         return $view_uri;
       }
     }
 
     return $this->getObjectViewURI($object);
   }
 
   public function getEffectiveObjectEditDoneURI($object) {
     return $this->getEffectiveObjectViewURI($object);
   }
 
   public function getEffectiveObjectEditCancelURI($object) {
     $page = $this->getSelectedPage();
     if ($page) {
       $view_uri = $page->getViewURI();
       if ($view_uri !== null) {
         return $view_uri;
       }
     }
 
     return $this->getObjectEditCancelURI($object);
   }
 
 
 /* -(  Creating and Loading Objects  )--------------------------------------- */
 
 
   /**
    * Initialize a new object for creation.
    *
    * @return object Newly initialized object.
    * @task load
    */
   abstract protected function newEditableObject();
 
 
   /**
    * Build an empty query for objects.
    *
    * @return PhabricatorPolicyAwareQuery Query.
    * @task load
    */
   abstract protected function newObjectQuery();
 
 
   /**
    * Test if this workflow is creating a new object or editing an existing one.
    *
    * @return bool True if a new object is being created.
    * @task load
    */
   final public function getIsCreate() {
     return $this->isCreate;
   }
 
   /**
    * Initialize a new object for object creation via Conduit.
    *
    * @return object Newly initialized object.
    * @param list<wild> Raw transactions.
    * @task load
    */
   protected function newEditableObjectFromConduit(array $raw_xactions) {
     return $this->newEditableObject();
   }
 
   /**
    * Initialize a new object for documentation creation.
    *
    * @return object Newly initialized object.
    * @task load
    */
   protected function newEditableObjectForDocumentation() {
     return $this->newEditableObject();
   }
 
   /**
    * Flag this workflow as a create or edit.
    *
    * @param bool True if this is a create workflow.
    * @return this
    * @task load
    */
   private function setIsCreate($is_create) {
     $this->isCreate = $is_create;
     return $this;
   }
 
 
   /**
    * Try to load an object by ID, PHID, or monogram. This is done primarily
    * to make Conduit a little easier to use.
    *
    * @param wild ID, PHID, or monogram.
    * @param list<const> List of required capability constants, or omit for
    *   defaults.
    * @return object Corresponding editable object.
    * @task load
    */
   private function newObjectFromIdentifier(
     $identifier,
     array $capabilities = array()) {
     if (is_int($identifier) || ctype_digit($identifier)) {
       $object = $this->newObjectFromID($identifier, $capabilities);
 
       if (!$object) {
         throw new Exception(
           pht(
             'No object exists with ID "%s".',
             $identifier));
       }
 
       return $object;
     }
 
     $type_unknown = PhabricatorPHIDConstants::PHID_TYPE_UNKNOWN;
     if (phid_get_type($identifier) != $type_unknown) {
       $object = $this->newObjectFromPHID($identifier, $capabilities);
 
       if (!$object) {
         throw new Exception(
           pht(
             'No object exists with PHID "%s".',
             $identifier));
       }
 
       return $object;
     }
 
     $target = id(new PhabricatorObjectQuery())
       ->setViewer($this->getViewer())
       ->withNames(array($identifier))
       ->executeOne();
     if (!$target) {
       throw new Exception(
         pht(
           'Monogram "%s" does not identify a valid object.',
           $identifier));
     }
 
     $expect = $this->newEditableObject();
     $expect_class = get_class($expect);
     $target_class = get_class($target);
     if ($expect_class !== $target_class) {
       throw new Exception(
         pht(
           'Monogram "%s" identifies an object of the wrong type. Loaded '.
           'object has class "%s", but this editor operates on objects of '.
           'type "%s".',
           $identifier,
           $target_class,
           $expect_class));
     }
 
     // Load the object by PHID using this engine's standard query. This makes
     // sure it's really valid, goes through standard policy check logic, and
     // picks up any `need...()` clauses we want it to load with.
 
     $object = $this->newObjectFromPHID($target->getPHID(), $capabilities);
     if (!$object) {
       throw new Exception(
         pht(
           'Failed to reload object identified by monogram "%s" when '.
           'querying by PHID.',
           $identifier));
     }
 
     return $object;
   }
 
   /**
    * Load an object by ID.
    *
    * @param int Object ID.
    * @param list<const> List of required capability constants, or omit for
    *   defaults.
    * @return object|null Object, or null if no such object exists.
    * @task load
    */
   private function newObjectFromID($id, array $capabilities = array()) {
     $query = $this->newObjectQuery()
       ->withIDs(array($id));
 
     return $this->newObjectFromQuery($query, $capabilities);
   }
 
 
   /**
    * Load an object by PHID.
    *
    * @param phid Object PHID.
    * @param list<const> List of required capability constants, or omit for
    *   defaults.
    * @return object|null Object, or null if no such object exists.
    * @task load
    */
   private function newObjectFromPHID($phid, array $capabilities = array()) {
     $query = $this->newObjectQuery()
       ->withPHIDs(array($phid));
 
     return $this->newObjectFromQuery($query, $capabilities);
   }
 
 
   /**
    * Load an object given a configured query.
    *
    * @param PhabricatorPolicyAwareQuery Configured query.
    * @param list<const> List of required capability constants, or omit for
    *  defaults.
    * @return object|null Object, or null if no such object exists.
    * @task load
    */
   private function newObjectFromQuery(
     PhabricatorPolicyAwareQuery $query,
     array $capabilities = array()) {
 
     $viewer = $this->getViewer();
 
     if (!$capabilities) {
       $capabilities = array(
         PhabricatorPolicyCapability::CAN_VIEW,
         PhabricatorPolicyCapability::CAN_EDIT,
       );
     }
 
     $object = $query
       ->setViewer($viewer)
       ->requireCapabilities($capabilities)
       ->executeOne();
     if (!$object) {
       return null;
     }
 
     return $object;
   }
 
 
   /**
    * Verify that an object is appropriate for editing.
    *
    * @param wild Loaded value.
    * @return void
    * @task load
    */
   private function validateObject($object) {
     if (!$object || !is_object($object)) {
       throw new Exception(
         pht(
           'EditEngine "%s" created or loaded an invalid object: object must '.
           'actually be an object, but is of some other type ("%s").',
           get_class($this),
           gettype($object)));
     }
 
     if (!($object instanceof PhabricatorApplicationTransactionInterface)) {
       throw new Exception(
         pht(
           'EditEngine "%s" created or loaded an invalid object: object (of '.
           'class "%s") must implement "%s", but does not.',
           get_class($this),
           get_class($object),
           'PhabricatorApplicationTransactionInterface'));
     }
   }
 
 
 /* -(  Responding to Web Requests  )----------------------------------------- */
 
 
   final public function buildResponse() {
     $viewer = $this->getViewer();
     $controller = $this->getController();
     $request = $controller->getRequest();
 
     $action = $this->getEditAction();
 
     $capabilities = array();
     $use_default = false;
     $require_create = true;
     switch ($action) {
       case 'comment':
         $capabilities = array(
           PhabricatorPolicyCapability::CAN_VIEW,
         );
         $use_default = true;
         break;
       case 'parameters':
         $use_default = true;
         break;
       case 'nodefault':
       case 'nocreate':
       case 'nomanage':
         $require_create = false;
         break;
       default:
         break;
     }
 
     $object = $this->getTargetObject();
     if (!$object) {
       $id = $request->getURIData('id');
 
       if ($id) {
         $this->setIsCreate(false);
         $object = $this->newObjectFromID($id, $capabilities);
         if (!$object) {
           return new Aphront404Response();
         }
       } else {
         // Make sure the viewer has permission to create new objects of
         // this type if we're going to create a new object.
         if ($require_create) {
           $this->requireCreateCapability();
         }
 
         $this->setIsCreate(true);
         $object = $this->newEditableObject();
       }
     } else {
       $id = $object->getID();
     }
 
     $this->validateObject($object);
 
     if ($use_default) {
       $config = $this->loadDefaultConfiguration();
       if (!$config) {
         return new Aphront404Response();
       }
     } else {
       $form_key = $request->getURIData('formKey');
       if (strlen($form_key)) {
         $config = $this->loadEditEngineConfigurationWithIdentifier($form_key);
 
         if (!$config) {
           return new Aphront404Response();
         }
 
         if ($id && !$config->getIsEdit()) {
           return $this->buildNotEditFormRespose($object, $config);
         }
       } else {
         if ($id) {
           $config = $this->loadDefaultEditConfiguration($object);
           if (!$config) {
             return $this->buildNoEditResponse($object);
           }
         } else {
           $config = $this->loadDefaultCreateConfiguration();
           if (!$config) {
             return $this->buildNoCreateResponse($object);
           }
         }
       }
     }
 
     if ($config->getIsDisabled()) {
       return $this->buildDisabledFormResponse($object, $config);
     }
 
     $page_key = $request->getURIData('pageKey');
     if (!strlen($page_key)) {
       $pages = $this->getPages($object);
       if ($pages) {
         $page_key = head_key($pages);
       }
     }
 
     if (strlen($page_key)) {
       $page = $this->selectPage($object, $page_key);
       if (!$page) {
         return new Aphront404Response();
       }
     }
 
     switch ($action) {
       case 'parameters':
         return $this->buildParametersResponse($object);
       case 'nodefault':
         return $this->buildNoDefaultResponse($object);
       case 'nocreate':
         return $this->buildNoCreateResponse($object);
       case 'nomanage':
         return $this->buildNoManageResponse($object);
       case 'comment':
         return $this->buildCommentResponse($object);
       default:
         return $this->buildEditResponse($object);
     }
   }
 
   private function buildCrumbs($object, $final = false) {
     $controller = $this->getController();
 
     $crumbs = $controller->buildApplicationCrumbsForEditEngine();
     if ($this->getIsCreate()) {
       $create_text = $this->getObjectCreateShortText();
       if ($final) {
         $crumbs->addTextCrumb($create_text);
       } else {
         $edit_uri = $this->getEditURI($object);
         $crumbs->addTextCrumb($create_text, $edit_uri);
       }
     } else {
       $crumbs->addTextCrumb(
         $this->getObjectEditShortText($object),
         $this->getEffectiveObjectViewURI($object));
 
       $edit_text = pht('Edit');
       if ($final) {
         $crumbs->addTextCrumb($edit_text);
       } else {
         $edit_uri = $this->getEditURI($object);
         $crumbs->addTextCrumb($edit_text, $edit_uri);
       }
     }
 
     return $crumbs;
   }
 
   private function buildEditResponse($object) {
     $viewer = $this->getViewer();
     $controller = $this->getController();
     $request = $controller->getRequest();
 
     $fields = $this->buildEditFields($object);
     $template = $object->getApplicationTransactionTemplate();
 
     if ($this->getIsCreate()) {
       $cancel_uri = $this->getObjectCreateCancelURI($object);
       $submit_button = $this->getObjectCreateButtonText($object);
     } else {
       $cancel_uri = $this->getEffectiveObjectEditCancelURI($object);
       $submit_button = $this->getObjectEditButtonText($object);
     }
 
     $config = $this->getEditEngineConfiguration()
       ->attachEngine($this);
 
     // NOTE: Don't prompt users to override locks when creating objects,
     // even if the default settings would create a locked object.
 
     $can_interact = PhabricatorPolicyFilter::canInteract($viewer, $object);
     if (!$can_interact &&
         !$this->getIsCreate() &&
         !$request->getBool('editEngine') &&
         !$request->getBool('overrideLock')) {
 
       $lock = PhabricatorEditEngineLock::newForObject($viewer, $object);
 
       $dialog = $this->getController()
         ->newDialog()
         ->addHiddenInput('overrideLock', true)
         ->setDisableWorkflowOnSubmit(true)
         ->addCancelButton($cancel_uri);
 
       return $lock->willPromptUserForLockOverrideWithDialog($dialog);
     }
 
     $validation_exception = null;
     if ($request->isFormOrHisecPost() && $request->getBool('editEngine')) {
       $submit_fields = $fields;
 
       foreach ($submit_fields as $key => $field) {
         if (!$field->shouldGenerateTransactionsFromSubmit()) {
           unset($submit_fields[$key]);
           continue;
         }
       }
 
       // Before we read the submitted values, store a copy of what we would
       // use if the form was empty so we can figure out which transactions are
       // just setting things to their default values for the current form.
       $defaults = array();
       foreach ($submit_fields as $key => $field) {
         $defaults[$key] = $field->getValueForTransaction();
       }
 
       foreach ($submit_fields as $key => $field) {
         $field->setIsSubmittedForm(true);
 
         if (!$field->shouldReadValueFromSubmit()) {
           continue;
         }
 
         $field->readValueFromSubmit($request);
       }
 
       $xactions = array();
 
       if ($this->getIsCreate()) {
         $xactions[] = id(clone $template)
           ->setTransactionType(PhabricatorTransactions::TYPE_CREATE);
 
         if ($this->supportsSubtypes()) {
           $xactions[] = id(clone $template)
             ->setTransactionType(PhabricatorTransactions::TYPE_SUBTYPE)
             ->setNewValue($config->getSubtype());
         }
       }
 
       foreach ($submit_fields as $key => $field) {
         $field_value = $field->getValueForTransaction();
 
         $type_xactions = $field->generateTransactions(
           clone $template,
           array(
             'value' => $field_value,
           ));
 
         foreach ($type_xactions as $type_xaction) {
           $default = $defaults[$key];
 
           if ($default === $field->getValueForTransaction()) {
             $type_xaction->setIsDefaultTransaction(true);
           }
 
           $xactions[] = $type_xaction;
         }
       }
 
       $editor = $object->getApplicationTransactionEditor()
         ->setActor($viewer)
         ->setContentSourceFromRequest($request)
         ->setCancelURI($cancel_uri)
         ->setContinueOnNoEffect(true);
 
       try {
         $xactions = $this->willApplyTransactions($object, $xactions);
 
         $editor->applyTransactions($object, $xactions);
 
         $this->didApplyTransactions($object, $xactions);
 
         return $this->newEditResponse($request, $object, $xactions);
       } catch (PhabricatorApplicationTransactionValidationException $ex) {
         $validation_exception = $ex;
 
         foreach ($fields as $field) {
           $message = $this->getValidationExceptionShortMessage($ex, $field);
           if ($message === null) {
             continue;
           }
 
           $field->setControlError($message);
         }
       }
     } else {
       if ($this->getIsCreate()) {
         $template = $request->getStr('template');
 
         if (strlen($template)) {
           $template_object = $this->newObjectFromIdentifier(
             $template,
             array(
               PhabricatorPolicyCapability::CAN_VIEW,
             ));
           if (!$template_object) {
             return new Aphront404Response();
           }
         } else {
           $template_object = null;
         }
 
         if ($template_object) {
           $copy_fields = $this->buildEditFields($template_object);
           $copy_fields = mpull($copy_fields, null, 'getKey');
           foreach ($copy_fields as $copy_key => $copy_field) {
             if (!$copy_field->getIsCopyable()) {
               unset($copy_fields[$copy_key]);
             }
           }
         } else {
           $copy_fields = array();
         }
 
         foreach ($fields as $field) {
           if (!$field->shouldReadValueFromRequest()) {
             continue;
           }
 
           $field_key = $field->getKey();
           if (isset($copy_fields[$field_key])) {
             $field->readValueFromField($copy_fields[$field_key]);
           }
 
           $field->readValueFromRequest($request);
         }
       }
     }
 
     $action_button = $this->buildEditFormActionButton($object);
 
     if ($this->getIsCreate()) {
       $header_text = $this->getFormHeaderText($object);
     } else {
       $header_text = $this->getObjectEditTitleText($object);
     }
 
     $show_preview = !$request->isAjax();
 
     if ($show_preview) {
       $previews = array();
       foreach ($fields as $field) {
         $preview = $field->getPreviewPanel();
         if (!$preview) {
           continue;
         }
 
         $control_id = $field->getControlID();
 
         $preview
           ->setControlID($control_id)
           ->setPreviewURI('/transactions/remarkuppreview/');
 
         $previews[] = $preview;
       }
     } else {
       $previews = array();
     }
 
     $form = $this->buildEditForm($object, $fields);
 
     $crumbs = $this->buildCrumbs($object, $final = true);
     $crumbs->setBorder(true);
 
     if ($request->isAjax()) {
       return $this->getController()
         ->newDialog()
         ->setWidth(AphrontDialogView::WIDTH_FULL)
         ->setTitle($header_text)
         ->setValidationException($validation_exception)
         ->appendForm($form)
         ->addCancelButton($cancel_uri)
         ->addSubmitButton($submit_button);
     }
 
     $box_header = id(new PHUIHeaderView())
       ->setHeader($header_text);
 
     if ($action_button) {
       $box_header->addActionLink($action_button);
     }
 
     $box = id(new PHUIObjectBoxView())
       ->setUser($viewer)
       ->setHeader($box_header)
       ->setValidationException($validation_exception)
       ->setBackground(PHUIObjectBoxView::WHITE_CONFIG)
       ->appendChild($form);
 
     // This is fairly questionable, but in use by Settings.
     if ($request->getURIData('formSaved')) {
       $box->setFormSaved(true);
     }
 
     $content = array(
       $box,
       $previews,
     );
 
     $view = new PHUITwoColumnView();
 
     $page_header = $this->getPageHeader($object);
     if ($page_header) {
       $view->setHeader($page_header);
     }
 
     $view->setFooter($content);
 
     $page = $controller->newPage()
       ->setTitle($header_text)
       ->setCrumbs($crumbs)
       ->appendChild($view);
 
     $navigation = $this->getNavigation();
     if ($navigation) {
       $page->setNavigation($navigation);
     }
 
     return $page;
   }
 
   protected function newEditResponse(
     AphrontRequest $request,
     $object,
     array $xactions) {
     return id(new AphrontRedirectResponse())
       ->setURI($this->getEffectiveObjectEditDoneURI($object));
   }
 
   private function buildEditForm($object, array $fields) {
     $viewer = $this->getViewer();
     $controller = $this->getController();
     $request = $controller->getRequest();
 
     $fields = $this->willBuildEditForm($object, $fields);
 
     $request_path = $request->getPath();
 
     $form = id(new AphrontFormView())
       ->setUser($viewer)
       ->setAction($request_path)
       ->addHiddenInput('editEngine', 'true');
 
     foreach ($this->contextParameters as $param) {
       $form->addHiddenInput($param, $request->getStr($param));
     }
 
     $requires_mfa = false;
     if ($object instanceof PhabricatorEditEngineMFAInterface) {
       $mfa_engine = PhabricatorEditEngineMFAEngine::newEngineForObject($object)
         ->setViewer($viewer);
       $requires_mfa = $mfa_engine->shouldRequireMFA();
     }
 
     if ($requires_mfa) {
       $message = pht(
         'You will be required to provide multi-factor credentials to make '.
         'changes.');
       $form->appendChild(
         id(new PHUIInfoView())
           ->setSeverity(PHUIInfoView::SEVERITY_MFA)
           ->setErrors(array($message)));
 
       // TODO: This should also set workflow on the form, so the user doesn't
       // lose any form data if they "Cancel". However, Maniphest currently
       // overrides "newEditResponse()" if the request is Ajax and returns a
       // bag of view data. This can reasonably be cleaned up when workboards
       // get their next iteration.
     }
 
     foreach ($fields as $field) {
       if (!$field->getIsFormField()) {
         continue;
       }
 
       $field->appendToForm($form);
     }
 
     if ($this->getIsCreate()) {
       $cancel_uri = $this->getObjectCreateCancelURI($object);
       $submit_button = $this->getObjectCreateButtonText($object);
     } else {
       $cancel_uri = $this->getEffectiveObjectEditCancelURI($object);
       $submit_button = $this->getObjectEditButtonText($object);
     }
 
     if (!$request->isAjax()) {
       $buttons = id(new AphrontFormSubmitControl())
         ->setValue($submit_button);
 
       if ($cancel_uri) {
         $buttons->addCancelButton($cancel_uri);
       }
 
       $form->appendControl($buttons);
     }
 
     return $form;
   }
 
   protected function willBuildEditForm($object, array $fields) {
     return $fields;
   }
 
   private function buildEditFormActionButton($object) {
     if (!$this->isEngineConfigurable()) {
       return null;
     }
 
     $viewer = $this->getViewer();
 
     $action_view = id(new PhabricatorActionListView())
       ->setUser($viewer);
 
     foreach ($this->buildEditFormActions($object) as $action) {
       $action_view->addAction($action);
     }
 
     $action_button = id(new PHUIButtonView())
       ->setTag('a')
       ->setText(pht('Configure Form'))
       ->setHref('#')
       ->setIcon('fa-gear')
       ->setDropdownMenu($action_view);
 
     return $action_button;
   }
 
   private function buildEditFormActions($object) {
     $actions = array();
 
     if ($this->supportsEditEngineConfiguration()) {
       $engine_key = $this->getEngineKey();
       $config = $this->getEditEngineConfiguration();
 
       $can_manage = PhabricatorPolicyFilter::hasCapability(
         $this->getViewer(),
         $config,
         PhabricatorPolicyCapability::CAN_EDIT);
 
       if ($can_manage) {
         $manage_uri = $config->getURI();
       } else {
         $manage_uri = $this->getEditURI(null, 'nomanage/');
       }
 
       $view_uri = "/transactions/editengine/{$engine_key}/";
 
       $actions[] = id(new PhabricatorActionView())
         ->setLabel(true)
         ->setName(pht('Configuration'));
 
       $actions[] = id(new PhabricatorActionView())
         ->setName(pht('View Form Configurations'))
         ->setIcon('fa-list-ul')
         ->setHref($view_uri);
 
       $actions[] = id(new PhabricatorActionView())
         ->setName(pht('Edit Form Configuration'))
         ->setIcon('fa-pencil')
         ->setHref($manage_uri)
         ->setDisabled(!$can_manage)
         ->setWorkflow(!$can_manage);
     }
 
     $actions[] = id(new PhabricatorActionView())
       ->setLabel(true)
       ->setName(pht('Documentation'));
 
     $actions[] = id(new PhabricatorActionView())
       ->setName(pht('Using HTTP Parameters'))
       ->setIcon('fa-book')
       ->setHref($this->getEditURI($object, 'parameters/'));
 
     $doc_href = PhabricatorEnv::getDoclink('User Guide: Customizing Forms');
     $actions[] = id(new PhabricatorActionView())
       ->setName(pht('User Guide: Customizing Forms'))
       ->setIcon('fa-book')
       ->setHref($doc_href);
 
     return $actions;
   }
 
 
   public function newNUXButton($text) {
     $specs = $this->newCreateActionSpecifications(array());
     $head = head($specs);
 
     return id(new PHUIButtonView())
       ->setTag('a')
       ->setText($text)
       ->setHref($head['uri'])
       ->setDisabled($head['disabled'])
       ->setWorkflow($head['workflow'])
       ->setColor(PHUIButtonView::GREEN);
   }
 
 
   final public function addActionToCrumbs(
     PHUICrumbsView $crumbs,
     array $parameters = array()) {
     $viewer = $this->getViewer();
 
     $specs = $this->newCreateActionSpecifications($parameters);
 
     $head = head($specs);
     $menu_uri = $head['uri'];
 
     $dropdown = null;
     if (count($specs) > 1) {
       $menu_icon = 'fa-caret-square-o-down';
       $menu_name = $this->getObjectCreateShortText();
       $workflow = false;
       $disabled = false;
 
       $dropdown = id(new PhabricatorActionListView())
         ->setUser($viewer);
 
       foreach ($specs as $spec) {
         $dropdown->addAction(
           id(new PhabricatorActionView())
             ->setName($spec['name'])
             ->setIcon($spec['icon'])
             ->setHref($spec['uri'])
             ->setDisabled($head['disabled'])
             ->setWorkflow($head['workflow']));
       }
 
     } else {
       $menu_icon = $head['icon'];
       $menu_name = $head['name'];
 
       $workflow = $head['workflow'];
       $disabled = $head['disabled'];
     }
 
     $action = id(new PHUIListItemView())
       ->setName($menu_name)
       ->setHref($menu_uri)
       ->setIcon($menu_icon)
       ->setWorkflow($workflow)
       ->setDisabled($disabled);
 
     if ($dropdown) {
       $action->setDropdownMenu($dropdown);
     }
 
     $crumbs->addAction($action);
   }
 
 
   /**
    * Build a raw description of available "Create New Object" UI options so
    * other methods can build menus or buttons.
    */
   public function newCreateActionSpecifications(array $parameters) {
     $viewer = $this->getViewer();
 
     $can_create = $this->hasCreateCapability();
     if ($can_create) {
       $configs = $this->loadUsableConfigurationsForCreate();
     } else {
       $configs = array();
     }
 
     $disabled = false;
     $workflow = false;
 
     $menu_icon = 'fa-plus-square';
     $specs = array();
     if (!$configs) {
       if ($viewer->isLoggedIn()) {
         $disabled = true;
       } else {
         // If the viewer isn't logged in, assume they'll get hit with a login
         // dialog and are likely able to create objects after they log in.
         $disabled = false;
       }
       $workflow = true;
 
       if ($can_create) {
         $create_uri = $this->getEditURI(null, 'nodefault/');
       } else {
         $create_uri = $this->getEditURI(null, 'nocreate/');
       }
 
       $specs[] = array(
         'name' => $this->getObjectCreateShortText(),
         'uri' => $create_uri,
         'icon' => $menu_icon,
         'disabled' => $disabled,
         'workflow' => $workflow,
       );
     } else {
       foreach ($configs as $config) {
         $config_uri = $config->getCreateURI();
 
         if ($parameters) {
           $config_uri = (string)new PhutilURI($config_uri, $parameters);
         }
 
         $specs[] = array(
           'name' => $config->getDisplayName(),
           'uri' => $config_uri,
           'icon' => 'fa-plus',
           'disabled' => false,
           'workflow' => false,
         );
       }
     }
 
     return $specs;
   }
 
   final public function buildEditEngineCommentView($object) {
     $config = $this->loadDefaultEditConfiguration($object);
 
     if (!$config) {
       // TODO: This just nukes the entire comment form if you don't have access
       // to any edit forms. We might want to tailor this UX a bit.
       return id(new PhabricatorApplicationTransactionCommentView())
         ->setNoPermission(true);
     }
 
     $viewer = $this->getViewer();
 
     $can_interact = PhabricatorPolicyFilter::canInteract($viewer, $object);
     if (!$can_interact) {
       $lock = PhabricatorEditEngineLock::newForObject($viewer, $object);
 
       return id(new PhabricatorApplicationTransactionCommentView())
         ->setEditEngineLock($lock);
     }
 
     $object_phid = $object->getPHID();
     $is_serious = PhabricatorEnv::getEnvConfig('phabricator.serious-business');
 
     if ($is_serious) {
       $header_text = $this->getCommentViewSeriousHeaderText($object);
       $button_text = $this->getCommentViewSeriousButtonText($object);
     } else {
       $header_text = $this->getCommentViewHeaderText($object);
       $button_text = $this->getCommentViewButtonText($object);
     }
 
     $comment_uri = $this->getEditURI($object, 'comment/');
 
     $requires_mfa = false;
     if ($object instanceof PhabricatorEditEngineMFAInterface) {
       $mfa_engine = PhabricatorEditEngineMFAEngine::newEngineForObject($object)
         ->setViewer($viewer);
       $requires_mfa = $mfa_engine->shouldRequireMFA();
     }
 
     $view = id(new PhabricatorApplicationTransactionCommentView())
       ->setUser($viewer)
       ->setObjectPHID($object_phid)
       ->setHeaderText($header_text)
       ->setAction($comment_uri)
       ->setRequiresMFA($requires_mfa)
       ->setSubmitButtonName($button_text);
 
     $draft = PhabricatorVersionedDraft::loadDraft(
       $object_phid,
       $viewer->getPHID());
     if ($draft) {
       $view->setVersionedDraft($draft);
     }
 
     $view->setCurrentVersion($this->loadDraftVersion($object));
 
     $fields = $this->buildEditFields($object);
 
     $can_edit = PhabricatorPolicyFilter::hasCapability(
       $viewer,
       $object,
       PhabricatorPolicyCapability::CAN_EDIT);
 
     $comment_actions = array();
     foreach ($fields as $field) {
       if (!$field->shouldGenerateTransactionsFromComment()) {
         continue;
       }
 
       if (!$can_edit) {
         if (!$field->getCanApplyWithoutEditCapability()) {
           continue;
         }
       }
 
       $comment_action = $field->getCommentAction();
       if (!$comment_action) {
         continue;
       }
 
       $key = $comment_action->getKey();
 
       // TODO: Validate these better.
 
       $comment_actions[$key] = $comment_action;
     }
 
     $comment_actions = msortv($comment_actions, 'getSortVector');
 
     $view->setCommentActions($comment_actions);
 
     $comment_groups = $this->newCommentActionGroups();
     $view->setCommentActionGroups($comment_groups);
 
     return $view;
   }
 
   protected function loadDraftVersion($object) {
     $viewer = $this->getViewer();
 
     if (!$viewer->isLoggedIn()) {
       return null;
     }
 
     $template = $object->getApplicationTransactionTemplate();
     $conn_r = $template->establishConnection('r');
 
     // Find the most recent transaction the user has written. We'll use this
     // as a version number to make sure that out-of-date drafts get discarded.
     $result = queryfx_one(
       $conn_r,
       'SELECT id AS version FROM %T
         WHERE objectPHID = %s AND authorPHID = %s
         ORDER BY id DESC LIMIT 1',
       $template->getTableName(),
       $object->getPHID(),
       $viewer->getPHID());
 
     if ($result) {
       return (int)$result['version'];
     } else {
       return null;
     }
   }
 
 
 /* -(  Responding to HTTP Parameter Requests  )------------------------------ */
 
 
   /**
    * Respond to a request for documentation on HTTP parameters.
    *
    * @param object Editable object.
    * @return AphrontResponse Response object.
    * @task http
    */
   private function buildParametersResponse($object) {
     $controller = $this->getController();
     $viewer = $this->getViewer();
     $request = $controller->getRequest();
     $fields = $this->buildEditFields($object);
 
     $crumbs = $this->buildCrumbs($object);
     $crumbs->addTextCrumb(pht('HTTP Parameters'));
     $crumbs->setBorder(true);
 
     $header_text = pht(
       'HTTP Parameters: %s',
       $this->getObjectCreateShortText());
 
     $header = id(new PHUIHeaderView())
       ->setHeader($header_text);
 
     $help_view = id(new PhabricatorApplicationEditHTTPParameterHelpView())
       ->setUser($viewer)
       ->setFields($fields);
 
     $document = id(new PHUIDocumentView())
       ->setUser($viewer)
       ->setHeader($header)
       ->appendChild($help_view);
 
     return $controller->newPage()
       ->setTitle(pht('HTTP Parameters'))
       ->setCrumbs($crumbs)
       ->appendChild($document);
   }
 
 
   private function buildError($object, $title, $body) {
     $cancel_uri = $this->getObjectCreateCancelURI($object);
 
     $dialog = $this->getController()
       ->newDialog()
       ->addCancelButton($cancel_uri);
 
     if ($title !== null) {
       $dialog->setTitle($title);
     }
 
     if ($body !== null) {
       $dialog->appendParagraph($body);
     }
 
     return $dialog;
   }
 
 
   private function buildNoDefaultResponse($object) {
     return $this->buildError(
       $object,
       pht('No Default Create Forms'),
       pht(
         'This application is not configured with any forms for creating '.
         'objects that are visible to you and enabled.'));
   }
 
   private function buildNoCreateResponse($object) {
     return $this->buildError(
       $object,
       pht('No Create Permission'),
       pht('You do not have permission to create these objects.'));
   }
 
   private function buildNoManageResponse($object) {
     return $this->buildError(
       $object,
       pht('No Manage Permission'),
       pht(
         'You do not have permission to configure forms for this '.
         'application.'));
   }
 
   private function buildNoEditResponse($object) {
     return $this->buildError(
       $object,
       pht('No Edit Forms'),
       pht(
         'You do not have access to any forms which are enabled and marked '.
         'as edit forms.'));
   }
 
   private function buildNotEditFormRespose($object, $config) {
     return $this->buildError(
       $object,
       pht('Not an Edit Form'),
       pht(
         'This form ("%s") is not marked as an edit form, so '.
         'it can not be used to edit objects.',
         $config->getName()));
   }
 
   private function buildDisabledFormResponse($object, $config) {
     return $this->buildError(
       $object,
       pht('Form Disabled'),
       pht(
         'This form ("%s") has been disabled, so it can not be used.',
         $config->getName()));
   }
 
   private function buildLockedObjectResponse($object) {
     $dialog = $this->buildError($object, null, null);
     $viewer = $this->getViewer();
 
     $lock = PhabricatorEditEngineLock::newForObject($viewer, $object);
     return $lock->willBlockUserInteractionWithDialog($dialog);
   }
 
   private function buildCommentResponse($object) {
     $viewer = $this->getViewer();
 
     if ($this->getIsCreate()) {
       return new Aphront404Response();
     }
 
     $controller = $this->getController();
     $request = $controller->getRequest();
 
     // NOTE: We handle hisec inside the transaction editor with "Sign With MFA"
     // comment actions.
     if (!$request->isFormOrHisecPost()) {
       return new Aphront400Response();
     }
 
     $can_interact = PhabricatorPolicyFilter::canInteract($viewer, $object);
     if (!$can_interact) {
       return $this->buildLockedObjectResponse($object);
     }
 
     $config = $this->loadDefaultEditConfiguration($object);
     if (!$config) {
       return new Aphront404Response();
     }
 
     $fields = $this->buildEditFields($object);
 
     $is_preview = $request->isPreviewRequest();
     $view_uri = $this->getEffectiveObjectViewURI($object);
 
     $template = $object->getApplicationTransactionTemplate();
     $comment_template = $template->getApplicationTransactionCommentObject();
 
     $comment_text = $request->getStr('comment');
 
     $actions = $request->getStr('editengine.actions');
     if ($actions) {
       $actions = phutil_json_decode($actions);
     }
 
     if ($is_preview) {
       $version_key = PhabricatorVersionedDraft::KEY_VERSION;
       $request_version = $request->getInt($version_key);
       $current_version = $this->loadDraftVersion($object);
       if ($request_version >= $current_version) {
         $draft = PhabricatorVersionedDraft::loadOrCreateDraft(
           $object->getPHID(),
           $viewer->getPHID(),
           $current_version);
 
         $is_empty = (!strlen($comment_text) && !$actions);
 
         $draft
           ->setProperty('comment', $comment_text)
           ->setProperty('actions', $actions)
           ->save();
 
         $draft_engine = $this->newDraftEngine($object);
         if ($draft_engine) {
           $draft_engine
             ->setVersionedDraft($draft)
             ->synchronize();
         }
       }
     }
 
     $xactions = array();
 
     $can_edit = PhabricatorPolicyFilter::hasCapability(
       $viewer,
       $object,
       PhabricatorPolicyCapability::CAN_EDIT);
 
     if ($actions) {
       $action_map = array();
       foreach ($actions as $action) {
         $type = idx($action, 'type');
         if (!$type) {
           continue;
         }
 
         if (empty($fields[$type])) {
           continue;
         }
 
         $action_map[$type] = $action;
       }
 
       foreach ($action_map as $type => $action) {
         $field = $fields[$type];
 
         if (!$field->shouldGenerateTransactionsFromComment()) {
           continue;
         }
 
         // If you don't have edit permission on the object, you're limited in
         // which actions you can take via the comment form. Most actions
         // need edit permission, but some actions (like "Accept Revision")
         // can be applied by anyone with view permission.
         if (!$can_edit) {
           if (!$field->getCanApplyWithoutEditCapability()) {
             // We know the user doesn't have the capability, so this will
             // raise a policy exception.
             PhabricatorPolicyFilter::requireCapability(
               $viewer,
               $object,
               PhabricatorPolicyCapability::CAN_EDIT);
           }
         }
 
         if (array_key_exists('initialValue', $action)) {
           $field->setInitialValue($action['initialValue']);
         }
 
         $field->readValueFromComment(idx($action, 'value'));
 
         $type_xactions = $field->generateTransactions(
           clone $template,
           array(
             'value' => $field->getValueForTransaction(),
           ));
         foreach ($type_xactions as $type_xaction) {
           $xactions[] = $type_xaction;
         }
       }
     }
 
     $auto_xactions = $this->newAutomaticCommentTransactions($object);
     foreach ($auto_xactions as $xaction) {
       $xactions[] = $xaction;
     }
 
     if (strlen($comment_text) || !$xactions) {
       $xactions[] = id(clone $template)
         ->setTransactionType(PhabricatorTransactions::TYPE_COMMENT)
         ->attachComment(
           id(clone $comment_template)
             ->setContent($comment_text));
     }
 
     $editor = $object->getApplicationTransactionEditor()
       ->setActor($viewer)
       ->setContinueOnNoEffect($request->isContinueRequest())
       ->setContinueOnMissingFields(true)
       ->setContentSourceFromRequest($request)
       ->setCancelURI($view_uri)
       ->setRaiseWarnings(!$request->getBool('editEngine.warnings'))
       ->setIsPreview($is_preview);
 
     try {
       $xactions = $editor->applyTransactions($object, $xactions);
     } catch (PhabricatorApplicationTransactionValidationException $ex) {
       return id(new PhabricatorApplicationTransactionValidationResponse())
         ->setCancelURI($view_uri)
         ->setException($ex);
     } catch (PhabricatorApplicationTransactionNoEffectException $ex) {
       return id(new PhabricatorApplicationTransactionNoEffectResponse())
         ->setCancelURI($view_uri)
         ->setException($ex);
     } catch (PhabricatorApplicationTransactionWarningException $ex) {
       return id(new PhabricatorApplicationTransactionWarningResponse())
         ->setCancelURI($view_uri)
         ->setException($ex);
     }
 
     if (!$is_preview) {
       PhabricatorVersionedDraft::purgeDrafts(
         $object->getPHID(),
         $viewer->getPHID());
 
       $draft_engine = $this->newDraftEngine($object);
       if ($draft_engine) {
         $draft_engine
           ->setVersionedDraft(null)
           ->synchronize();
       }
     }
 
     if ($request->isAjax() && $is_preview) {
       $preview_content = $this->newCommentPreviewContent($object, $xactions);
 
       $raw_view_data = $request->getStr('viewData');
       try {
         $view_data = phutil_json_decode($raw_view_data);
       } catch (Exception $ex) {
         $view_data = array();
       }
 
       return id(new PhabricatorApplicationTransactionResponse())
         ->setObject($object)
         ->setViewer($viewer)
         ->setTransactions($xactions)
         ->setIsPreview($is_preview)
         ->setViewData($view_data)
         ->setPreviewContent($preview_content);
     } else {
       return id(new AphrontRedirectResponse())
         ->setURI($view_uri);
     }
   }
 
   protected function newDraftEngine($object) {
     $viewer = $this->getViewer();
 
     if ($object instanceof PhabricatorDraftInterface) {
       $engine = $object->newDraftEngine();
     } else {
       $engine = new PhabricatorBuiltinDraftEngine();
     }
 
     return $engine
       ->setObject($object)
       ->setViewer($viewer);
   }
 
 
 /* -(  Conduit  )------------------------------------------------------------ */
 
 
   /**
    * Respond to a Conduit edit request.
    *
    * This method accepts a list of transactions to apply to an object, and
    * either edits an existing object or creates a new one.
    *
    * @task conduit
    */
   final public function buildConduitResponse(ConduitAPIRequest $request) {
     $viewer = $this->getViewer();
 
     $config = $this->loadDefaultConfiguration();
     if (!$config) {
       throw new Exception(
         pht(
           'Unable to load configuration for this EditEngine ("%s").',
           get_class($this)));
     }
 
     $raw_xactions = $this->getRawConduitTransactions($request);
 
     $identifier = $request->getValue('objectIdentifier');
     if ($identifier) {
       $this->setIsCreate(false);
 
       // After T13186, each transaction can individually weaken or replace the
       // capabilities required to apply it, so we no longer need CAN_EDIT to
       // attempt to apply transactions to objects. In practice, almost all
       // transactions require CAN_EDIT so we won't get very far if we don't
       // have it.
       $capabilities = array(
         PhabricatorPolicyCapability::CAN_VIEW,
       );
 
       $object = $this->newObjectFromIdentifier(
         $identifier,
         $capabilities);
     } else {
       $this->requireCreateCapability();
 
       $this->setIsCreate(true);
       $object = $this->newEditableObjectFromConduit($raw_xactions);
     }
 
     $this->validateObject($object);
 
     $fields = $this->buildEditFields($object);
 
     $types = $this->getConduitEditTypesFromFields($fields);
     $template = $object->getApplicationTransactionTemplate();
 
     $xactions = $this->getConduitTransactions(
       $request,
       $raw_xactions,
       $types,
       $template);
 
     $editor = $object->getApplicationTransactionEditor()
       ->setActor($viewer)
       ->setContentSource($request->newContentSource())
       ->setContinueOnNoEffect(true);
 
     if (!$this->getIsCreate()) {
       $editor->setContinueOnMissingFields(true);
     }
 
     $xactions = $editor->applyTransactions($object, $xactions);
 
     $xactions_struct = array();
     foreach ($xactions as $xaction) {
       $xactions_struct[] = array(
         'phid' => $xaction->getPHID(),
       );
     }
 
     return array(
       'object' => array(
         'id' => (int)$object->getID(),
         'phid' => $object->getPHID(),
       ),
       'transactions' => $xactions_struct,
     );
   }
 
   private function getRawConduitTransactions(ConduitAPIRequest $request) {
     $transactions_key = 'transactions';
 
     $xactions = $request->getValue($transactions_key);
     if (!is_array($xactions)) {
       throw new Exception(
         pht(
           'Parameter "%s" is not a list of transactions.',
           $transactions_key));
     }
 
     foreach ($xactions as $key => $xaction) {
       if (!is_array($xaction)) {
         throw new Exception(
           pht(
             'Parameter "%s" must contain a list of transaction descriptions, '.
             'but item with key "%s" is not a dictionary.',
             $transactions_key,
             $key));
       }
 
       if (!array_key_exists('type', $xaction)) {
         throw new Exception(
           pht(
             'Parameter "%s" must contain a list of transaction descriptions, '.
             'but item with key "%s" is missing a "type" field. Each '.
             'transaction must have a type field.',
             $transactions_key,
             $key));
       }
     }
 
     return $xactions;
   }
 
 
   /**
    * Generate transactions which can be applied from edit actions in a Conduit
    * request.
    *
    * @param ConduitAPIRequest The request.
    * @param list<wild> Raw conduit transactions.
    * @param list<PhabricatorEditType> Supported edit types.
    * @param PhabricatorApplicationTransaction Template transaction.
    * @return list<PhabricatorApplicationTransaction> Generated transactions.
    * @task conduit
    */
   private function getConduitTransactions(
     ConduitAPIRequest $request,
     array $xactions,
     array $types,
     PhabricatorApplicationTransaction $template) {
 
     $viewer = $request->getUser();
     $results = array();
 
     foreach ($xactions as $key => $xaction) {
       $type = $xaction['type'];
       if (empty($types[$type])) {
         throw new Exception(
           pht(
             'Transaction with key "%s" has invalid type "%s". This type is '.
             'not recognized. Valid types are: %s.',
             $key,
             $type,
             implode(', ', array_keys($types))));
       }
     }
 
     if ($this->getIsCreate()) {
       $results[] = id(clone $template)
         ->setTransactionType(PhabricatorTransactions::TYPE_CREATE);
     }
 
     $is_strict = $request->getIsStrictlyTyped();
 
     foreach ($xactions as $xaction) {
       $type = $types[$xaction['type']];
 
       // Let the parameter type interpret the value. This allows you to
       // use usernames in list<user> fields, for example.
       $parameter_type = $type->getConduitParameterType();
 
       $parameter_type->setViewer($viewer);
 
       try {
         $value = $xaction['value'];
         $value = $parameter_type->getValue($xaction, 'value', $is_strict);
         $value = $type->getTransactionValueFromConduit($value);
         $xaction['value'] = $value;
       } catch (Exception $ex) {
         throw new PhutilProxyException(
           pht(
             'Exception when processing transaction of type "%s": %s',
             $xaction['type'],
             $ex->getMessage()),
           $ex);
       }
 
       $type_xactions = $type->generateTransactions(
         clone $template,
         $xaction);
 
       foreach ($type_xactions as $type_xaction) {
         $results[] = $type_xaction;
       }
     }
 
     return $results;
   }
 
 
   /**
    * @return map<string, PhabricatorEditType>
    * @task conduit
    */
   private function getConduitEditTypesFromFields(array $fields) {
     $types = array();
     foreach ($fields as $field) {
       $field_types = $field->getConduitEditTypes();
 
       if ($field_types === null) {
         continue;
       }
 
       foreach ($field_types as $field_type) {
         $types[$field_type->getEditType()] = $field_type;
       }
     }
     return $types;
   }
 
   public function getConduitEditTypes() {
     $config = $this->loadDefaultConfiguration();
     if (!$config) {
       return array();
     }
 
     $object = $this->newEditableObjectForDocumentation();
     $fields = $this->buildEditFields($object);
     return $this->getConduitEditTypesFromFields($fields);
   }
 
   final public static function getAllEditEngines() {
     return id(new PhutilClassMapQuery())
       ->setAncestorClass(__CLASS__)
       ->setUniqueMethod('getEngineKey')
       ->execute();
   }
 
   final public static function getByKey(PhabricatorUser $viewer, $key) {
     return id(new PhabricatorEditEngineQuery())
       ->setViewer($viewer)
       ->withEngineKeys(array($key))
       ->executeOne();
   }
 
   public function getIcon() {
     $application = $this->getApplication();
     return $application->getIcon();
   }
 
   private function loadUsableConfigurationsForCreate() {
     $viewer = $this->getViewer();
 
     $configs = id(new PhabricatorEditEngineConfigurationQuery())
       ->setViewer($viewer)
       ->withEngineKeys(array($this->getEngineKey()))
       ->withIsDefault(true)
       ->withIsDisabled(false)
       ->execute();
 
     $configs = msort($configs, 'getCreateSortKey');
 
     // Attach this specific engine to configurations we load so they can access
     // any runtime configuration. For example, this allows us to generate the
     // correct "Create Form" buttons when editing forms, see T12301.
     foreach ($configs as $config) {
       $config->attachEngine($this);
     }
 
     return $configs;
   }
 
   protected function getValidationExceptionShortMessage(
     PhabricatorApplicationTransactionValidationException $ex,
     PhabricatorEditField $field) {
 
     $xaction_type = $field->getTransactionType();
     if ($xaction_type === null) {
       return null;
     }
 
     return $ex->getShortMessage($xaction_type);
   }
 
   protected function getCreateNewObjectPolicy() {
     return PhabricatorPolicies::POLICY_USER;
   }
 
   private function requireCreateCapability() {
     PhabricatorPolicyFilter::requireCapability(
       $this->getViewer(),
       $this,
       PhabricatorPolicyCapability::CAN_EDIT);
   }
 
   private function hasCreateCapability() {
     return PhabricatorPolicyFilter::hasCapability(
       $this->getViewer(),
       $this,
       PhabricatorPolicyCapability::CAN_EDIT);
   }
 
   public function isCommentAction() {
     return ($this->getEditAction() == 'comment');
   }
 
   public function getEditAction() {
     $controller = $this->getController();
     $request = $controller->getRequest();
     return $request->getURIData('editAction');
   }
 
   protected function newCommentActionGroups() {
     return array();
   }
 
   protected function newAutomaticCommentTransactions($object) {
     return array();
   }
 
   protected function newCommentPreviewContent($object, array $xactions) {
     return null;
   }
 
 
 /* -(  Form Pages  )--------------------------------------------------------- */
 
 
   public function getSelectedPage() {
     return $this->page;
   }
 
 
   private function selectPage($object, $page_key) {
     $pages = $this->getPages($object);
 
     if (empty($pages[$page_key])) {
       return null;
     }
 
     $this->page = $pages[$page_key];
     return $this->page;
   }
 
 
   protected function newPages($object) {
     return array();
   }
 
 
   protected function getPages($object) {
     if ($this->pages === null) {
       $pages = $this->newPages($object);
 
       assert_instances_of($pages, 'PhabricatorEditPage');
       $pages = mpull($pages, null, 'getKey');
 
       $this->pages = $pages;
     }
 
     return $this->pages;
   }
 
   private function applyPageToFields($object, array $fields) {
     $pages = $this->getPages($object);
     if (!$pages) {
       return $fields;
     }
 
     if (!$this->getSelectedPage()) {
       return $fields;
     }
 
     $page_picks = array();
     $default_key = head($pages)->getKey();
     foreach ($pages as $page_key => $page) {
       foreach ($page->getFieldKeys() as $field_key) {
         $page_picks[$field_key] = $page_key;
       }
       if ($page->getIsDefault()) {
         $default_key = $page_key;
       }
     }
 
     $page_map = array_fill_keys(array_keys($pages), array());
     foreach ($fields as $field_key => $field) {
       if (isset($page_picks[$field_key])) {
         $page_map[$page_picks[$field_key]][$field_key] = $field;
         continue;
       }
 
       // TODO: Maybe let the field pick a page to associate itself with so
       // extensions can force themselves onto a particular page?
 
       $page_map[$default_key][$field_key] = $field;
     }
 
     $page = $this->getSelectedPage();
     if (!$page) {
       $page = head($pages);
     }
 
     $selected_key = $page->getKey();
     return $page_map[$selected_key];
   }
 
   protected function willApplyTransactions($object, array $xactions) {
     return $xactions;
   }
 
   protected function didApplyTransactions($object, array $xactions) {
     return;
   }
 
 
 /* -(  Bulk Edits  )--------------------------------------------------------- */
 
   final public function newBulkEditGroupMap() {
     $groups = $this->newBulkEditGroups();
 
     $map = array();
     foreach ($groups as $group) {
       $key = $group->getKey();
 
       if (isset($map[$key])) {
         throw new Exception(
           pht(
             'Two bulk edit groups have the same key ("%s"). Each bulk edit '.
             'group must have a unique key.',
             $key));
       }
 
       $map[$key] = $group;
     }
 
     if ($this->isEngineExtensible()) {
       $extensions = PhabricatorEditEngineExtension::getAllEnabledExtensions();
     } else {
       $extensions = array();
     }
 
     foreach ($extensions as $extension) {
       $extension_groups = $extension->newBulkEditGroups($this);
       foreach ($extension_groups as $group) {
         $key = $group->getKey();
 
         if (isset($map[$key])) {
           throw new Exception(
             pht(
               'Extension "%s" defines a bulk edit group with the same key '.
               '("%s") as the main editor or another extension. Each bulk '.
               'edit group must have a unique key.'));
         }
 
         $map[$key] = $group;
       }
     }
 
     return $map;
   }
 
   protected function newBulkEditGroups() {
     return array(
       id(new PhabricatorBulkEditGroup())
         ->setKey('default')
         ->setLabel(pht('Primary Fields')),
       id(new PhabricatorBulkEditGroup())
         ->setKey('extension')
         ->setLabel(pht('Support Applications')),
     );
   }
 
   final public function newBulkEditMap() {
     $config = $this->loadDefaultConfiguration();
     if (!$config) {
       throw new Exception(
         pht('No default edit engine configuration for bulk edit.'));
     }
 
     $object = $this->newEditableObject();
     $fields = $this->buildEditFields($object);
     $groups = $this->newBulkEditGroupMap();
 
     $edit_types = $this->getBulkEditTypesFromFields($fields);
 
     $map = array();
     foreach ($edit_types as $key => $type) {
       $bulk_type = $type->getBulkParameterType();
       if ($bulk_type === null) {
         continue;
       }
 
       $bulk_label = $type->getBulkEditLabel();
       if ($bulk_label === null) {
         continue;
       }
 
       $group_key = $type->getBulkEditGroupKey();
       if (!$group_key) {
         $group_key = 'default';
       }
 
       if (!isset($groups[$group_key])) {
         throw new Exception(
           pht(
             'Field "%s" has a bulk edit group key ("%s") with no '.
             'corresponding bulk edit group.',
             $key,
             $group_key));
       }
 
       $map[] = array(
         'label' => $bulk_label,
         'xaction' => $key,
         'group' => $group_key,
         'control' => array(
           'type' => $bulk_type->getPHUIXControlType(),
           'spec' => (object)$bulk_type->getPHUIXControlSpecification(),
         ),
       );
     }
 
     return $map;
   }
 
 
   final public function newRawBulkTransactions(array $xactions) {
     $config = $this->loadDefaultConfiguration();
     if (!$config) {
       throw new Exception(
         pht('No default edit engine configuration for bulk edit.'));
     }
 
     $object = $this->newEditableObject();
     $fields = $this->buildEditFields($object);
 
     $edit_types = $this->getBulkEditTypesFromFields($fields);
     $template = $object->getApplicationTransactionTemplate();
 
     $raw_xactions = array();
     foreach ($xactions as $key => $xaction) {
       PhutilTypeSpec::checkMap(
         $xaction,
         array(
           'type' => 'string',
           'value' => 'optional wild',
         ));
 
       $type = $xaction['type'];
       if (!isset($edit_types[$type])) {
         throw new Exception(
           pht(
             'Unsupported bulk edit type "%s".',
             $type));
       }
 
       $edit_type = $edit_types[$type];
 
       // Replace the edit type with the underlying transaction type. Usually
       // these are 1:1 and the transaction type just has more internal noise,
       // but it's possible that this isn't the case.
       $xaction['type'] = $edit_type->getTransactionType();
 
       $value = $xaction['value'];
       $value = $edit_type->getTransactionValueFromBulkEdit($value);
       $xaction['value'] = $value;
 
       $xaction_objects = $edit_type->generateTransactions(
         clone $template,
         $xaction);
 
       foreach ($xaction_objects as $xaction_object) {
         $raw_xaction = array(
           'type' => $xaction_object->getTransactionType(),
           'metadata' => $xaction_object->getMetadata(),
           'new' => $xaction_object->getNewValue(),
         );
 
         if ($xaction_object->hasOldValue()) {
           $raw_xaction['old'] = $xaction_object->getOldValue();
         }
 
         if ($xaction_object->hasComment()) {
           $comment = $xaction_object->getComment();
           $raw_xaction['comment'] = $comment->getContent();
         }
 
         $raw_xactions[] = $raw_xaction;
       }
     }
 
     return $raw_xactions;
   }
 
   private function getBulkEditTypesFromFields(array $fields) {
     $types = array();
 
     foreach ($fields as $field) {
       $field_types = $field->getBulkEditTypes();
 
       if ($field_types === null) {
         continue;
       }
 
       foreach ($field_types as $field_type) {
         $types[$field_type->getEditType()] = $field_type;
       }
     }
 
     return $types;
   }
 
 
 /* -(  PhabricatorPolicyInterface  )----------------------------------------- */
 
 
   public function getPHID() {
     return get_class($this);
   }
 
   public function getCapabilities() {
     return array(
       PhabricatorPolicyCapability::CAN_VIEW,
       PhabricatorPolicyCapability::CAN_EDIT,
     );
   }
 
   public function getPolicy($capability) {
     switch ($capability) {
       case PhabricatorPolicyCapability::CAN_VIEW:
         return PhabricatorPolicies::getMostOpenPolicy();
       case PhabricatorPolicyCapability::CAN_EDIT:
         return $this->getCreateNewObjectPolicy();
     }
   }
 
   public function hasAutomaticCapability($capability, PhabricatorUser $viewer) {
     return false;
   }
 
 }
diff --git a/src/applications/transactions/editengine/PhabricatorEditEngineSubtype.php b/src/applications/transactions/editengine/PhabricatorEditEngineSubtype.php
index 9e754a3ca8..6e1d1de115 100644
--- a/src/applications/transactions/editengine/PhabricatorEditEngineSubtype.php
+++ b/src/applications/transactions/editengine/PhabricatorEditEngineSubtype.php
@@ -1,247 +1,281 @@
 <?php
 
 
 final class PhabricatorEditEngineSubtype
   extends Phobject {
 
   const SUBTYPE_DEFAULT = 'default';
 
   private $key;
   private $name;
   private $icon;
   private $tagText;
   private $color;
   private $childSubtypes = array();
   private $childIdentifiers = array();
+  private $fieldConfiguration = array();
 
   public function setKey($key) {
     $this->key = $key;
     return $this;
   }
 
   public function getKey() {
     return $this->key;
   }
 
   public function setName($name) {
     $this->name = $name;
     return $this;
   }
 
   public function getName() {
     return $this->name;
   }
 
   public function setIcon($icon) {
     $this->icon = $icon;
     return $this;
   }
 
   public function getIcon() {
     return $this->icon;
   }
 
   public function setTagText($text) {
     $this->tagText = $text;
     return $this;
   }
 
   public function getTagText() {
     return $this->tagText;
   }
 
   public function setColor($color) {
     $this->color = $color;
     return $this;
   }
 
   public function getColor() {
     return $this->color;
   }
 
   public function setChildSubtypes(array $child_subtypes) {
     $this->childSubtypes = $child_subtypes;
     return $this;
   }
 
   public function getChildSubtypes() {
     return $this->childSubtypes;
   }
 
   public function setChildFormIdentifiers(array $child_identifiers) {
     $this->childIdentifiers = $child_identifiers;
     return $this;
   }
 
   public function getChildFormIdentifiers() {
     return $this->childIdentifiers;
   }
 
   public function hasTagView() {
     return (bool)strlen($this->getTagText());
   }
 
   public function newTagView() {
     $view = id(new PHUITagView())
       ->setType(PHUITagView::TYPE_OUTLINE)
       ->setName($this->getTagText());
 
     $color = $this->getColor();
     if ($color) {
       $view->setColor($color);
     }
 
     return $view;
   }
 
+  public function setSubtypeFieldConfiguration(
+    $subtype_key,
+    array $configuration) {
+    $this->fieldConfiguration[$subtype_key] = $configuration;
+    return $this;
+  }
+
+  public function getSubtypeFieldConfiguration($subtype_key) {
+    return idx($this->fieldConfiguration, $subtype_key);
+  }
+
   public static function validateSubtypeKey($subtype) {
     if (strlen($subtype) > 64) {
       throw new Exception(
         pht(
           'Subtype "%s" is not valid: subtype keys must be no longer than '.
           '64 bytes.',
           $subtype));
     }
 
     if (strlen($subtype) < 3) {
       throw new Exception(
         pht(
           'Subtype "%s" is not valid: subtype keys must have a minimum '.
           'length of 3 bytes.',
           $subtype));
     }
 
     if (!preg_match('/^[a-z]+\z/', $subtype)) {
       throw new Exception(
         pht(
           'Subtype "%s" is not valid: subtype keys may only contain '.
           'lowercase latin letters ("a" through "z").',
           $subtype));
     }
   }
 
   public static function validateConfiguration($config) {
     if (!is_array($config)) {
       throw new Exception(
         pht(
           'Subtype configuration is invalid: it must be a list of subtype '.
           'specifications.'));
     }
 
     $map = array();
     foreach ($config as $value) {
       PhutilTypeSpec::checkMap(
         $value,
         array(
           'key' => 'string',
           'name' => 'string',
           'tag' => 'optional string',
           'color' => 'optional string',
           'icon' => 'optional string',
           'children' => 'optional map<string, wild>',
+          'fields' => 'optional map<string, wild>',
         ));
 
       $key = $value['key'];
       self::validateSubtypeKey($key);
 
       if (isset($map[$key])) {
         throw new Exception(
           pht(
             'Subtype configuration is invalid: two subtypes use the same '.
             'key ("%s"). Each subtype must have a unique key.',
             $key));
       }
 
       $map[$key] = true;
 
       $name = $value['name'];
       if (!strlen($name)) {
         throw new Exception(
           pht(
             'Subtype configuration is invalid: subtype with key "%s" has '.
             'no name. Subtypes must have a name.',
             $key));
       }
 
       $children = idx($value, 'children');
       if ($children) {
         PhutilTypeSpec::checkMap(
           $children,
           array(
             'subtypes' => 'optional list<string>',
             'forms' => 'optional list<string|int>',
           ));
 
         $child_subtypes = idx($children, 'subtypes');
         $child_forms = idx($children, 'forms');
 
         if ($child_subtypes && $child_forms) {
           throw new Exception(
             pht(
               'Subtype configuration is invalid: subtype with key "%s" '.
               'specifies both child subtypes and child forms. Specify one '.
               'or the other, but not both.'));
         }
       }
+
+      $fields = idx($value, 'fields');
+      if ($fields) {
+        foreach ($fields as $field_key => $configuration) {
+          PhutilTypeSpec::checkMap(
+            $configuration,
+            array(
+              'disabled' => 'optional bool',
+              'name' => 'optional string',
+            ));
+        }
+      }
     }
 
     if (!isset($map[self::SUBTYPE_DEFAULT])) {
       throw new Exception(
         pht(
           'Subtype configuration is invalid: there is no subtype defined '.
           'with key "%s". This subtype is required and must be defined.',
           self::SUBTYPE_DEFAULT));
     }
   }
 
   public static function newSubtypeMap(array $config) {
     $map = array();
 
     foreach ($config as $entry) {
       $key = $entry['key'];
       $name = $entry['name'];
 
       $tag_text = idx($entry, 'tag');
       if ($tag_text === null) {
         if ($key != self::SUBTYPE_DEFAULT) {
           $tag_text = phutil_utf8_strtoupper($name);
         }
       }
 
       $color = idx($entry, 'color', 'blue');
       $icon = idx($entry, 'icon', 'fa-drivers-license-o');
 
       $subtype = id(new self())
         ->setKey($key)
         ->setName($name)
         ->setTagText($tag_text)
         ->setIcon($icon);
 
       if ($color) {
         $subtype->setColor($color);
       }
 
       $children = idx($entry, 'children', array());
       $child_subtypes = idx($children, 'subtypes');
       $child_forms = idx($children, 'forms');
 
       if ($child_subtypes) {
         $subtype->setChildSubtypes($child_subtypes);
       }
 
       if ($child_forms) {
         $subtype->setChildFormIdentifiers($child_forms);
       }
 
+      $field_configurations = idx($entry, 'fields');
+      if ($field_configurations) {
+        foreach ($field_configurations as $field_key => $field_configuration) {
+          $subtype->setSubtypeFieldConfiguration(
+            $field_key,
+            $field_configuration);
+        }
+      }
+
       $map[$key] = $subtype;
     }
 
     return new PhabricatorEditEngineSubtypeMap($map);
   }
 
   public function newIconView() {
     return id(new PHUIIconView())
       ->setIcon($this->getIcon(), $this->getColor());
   }
 
 }
diff --git a/src/infrastructure/customfield/field/PhabricatorCustomField.php b/src/infrastructure/customfield/field/PhabricatorCustomField.php
index d7df3c5b78..c6c70a9614 100644
--- a/src/infrastructure/customfield/field/PhabricatorCustomField.php
+++ b/src/infrastructure/customfield/field/PhabricatorCustomField.php
@@ -1,1625 +1,1712 @@
 <?php
 
 /**
  * @task apps         Building Applications with Custom Fields
  * @task core         Core Properties and Field Identity
  * @task proxy        Field Proxies
  * @task context      Contextual Data
  * @task render       Rendering Utilities
  * @task storage      Field Storage
  * @task edit         Integration with Edit Views
  * @task view         Integration with Property Views
  * @task list         Integration with List views
  * @task appsearch    Integration with ApplicationSearch
  * @task appxaction   Integration with ApplicationTransactions
  * @task xactionmail  Integration with Transaction Mail
  * @task globalsearch Integration with Global Search
  * @task herald       Integration with Herald
  */
 abstract class PhabricatorCustomField extends Phobject {
 
   private $viewer;
   private $object;
   private $proxy;
 
   const ROLE_APPLICATIONTRANSACTIONS  = 'ApplicationTransactions';
   const ROLE_TRANSACTIONMAIL          = 'ApplicationTransactions.mail';
   const ROLE_APPLICATIONSEARCH        = 'ApplicationSearch';
   const ROLE_STORAGE                  = 'storage';
   const ROLE_DEFAULT                  = 'default';
   const ROLE_EDIT                     = 'edit';
   const ROLE_VIEW                     = 'view';
   const ROLE_LIST                     = 'list';
   const ROLE_GLOBALSEARCH             = 'GlobalSearch';
   const ROLE_CONDUIT                  = 'conduit';
   const ROLE_HERALD                   = 'herald';
   const ROLE_EDITENGINE = 'EditEngine';
   const ROLE_HERALDACTION = 'herald.action';
   const ROLE_EXPORT = 'export';
 
 
 /* -(  Building Applications with Custom Fields  )--------------------------- */
 
 
   /**
    * @task apps
    */
   public static function getObjectFields(
     PhabricatorCustomFieldInterface $object,
     $role) {
 
     try {
       $attachment = $object->getCustomFields();
     } catch (PhabricatorDataNotAttachedException $ex) {
       $attachment = new PhabricatorCustomFieldAttachment();
       $object->attachCustomFields($attachment);
     }
 
     try {
       $field_list = $attachment->getCustomFieldList($role);
     } catch (PhabricatorCustomFieldNotAttachedException $ex) {
       $base_class = $object->getCustomFieldBaseClass();
 
       $spec = $object->getCustomFieldSpecificationForRole($role);
       if (!is_array($spec)) {
         throw new Exception(
           pht(
             "Expected an array from %s for object of class '%s'.",
             'getCustomFieldSpecificationForRole()',
             get_class($object)));
       }
 
       $fields = self::buildFieldList(
         $base_class,
         $spec,
         $object);
 
+      $fields = self::adjustCustomFieldsForObjectSubtype(
+        $object,
+        $role,
+        $fields);
+
       foreach ($fields as $key => $field) {
+        // NOTE: We perform this filtering in "buildFieldList()", but may need
+        // to filter again after subtype adjustment.
+        if (!$field->isFieldEnabled()) {
+          unset($fields[$key]);
+          continue;
+        }
+
         if (!$field->shouldEnableForRole($role)) {
           unset($fields[$key]);
+          continue;
         }
       }
 
       foreach ($fields as $field) {
         $field->setObject($object);
       }
 
       $field_list = new PhabricatorCustomFieldList($fields);
       $attachment->addCustomFieldList($role, $field_list);
     }
 
     return $field_list;
   }
 
 
   /**
    * @task apps
    */
   public static function getObjectField(
     PhabricatorCustomFieldInterface $object,
     $role,
     $field_key) {
 
     $fields = self::getObjectFields($object, $role)->getFields();
 
     return idx($fields, $field_key);
   }
 
 
   /**
    * @task apps
    */
   public static function buildFieldList(
     $base_class,
     array $spec,
     $object,
     array $options = array()) {
 
     $field_objects = id(new PhutilClassMapQuery())
       ->setAncestorClass($base_class)
       ->execute();
 
     $fields = array();
     foreach ($field_objects as $field_object) {
       $field_object = clone $field_object;
       foreach ($field_object->createFields($object) as $field) {
         $key = $field->getFieldKey();
         if (isset($fields[$key])) {
           throw new Exception(
             pht(
               "Both '%s' and '%s' define a custom field with ".
               "field key '%s'. Field keys must be unique.",
               get_class($fields[$key]),
               get_class($field),
               $key));
         }
         $fields[$key] = $field;
       }
     }
 
     foreach ($fields as $key => $field) {
       if (!$field->isFieldEnabled()) {
         unset($fields[$key]);
       }
     }
 
     $fields = array_select_keys($fields, array_keys($spec)) + $fields;
 
     if (empty($options['withDisabled'])) {
       foreach ($fields as $key => $field) {
         if (isset($spec[$key]['disabled'])) {
           $is_disabled = $spec[$key]['disabled'];
         } else {
           $is_disabled = $field->shouldDisableByDefault();
         }
 
         if ($is_disabled) {
           if ($field->canDisableField()) {
             unset($fields[$key]);
           }
         }
       }
     }
 
     return $fields;
   }
 
 
 /* -(  Core Properties and Field Identity  )--------------------------------- */
 
 
   /**
    * Return a key which uniquely identifies this field, like
    * "mycompany:dinosaur:count". Normally you should provide some level of
    * namespacing to prevent collisions.
    *
    * @return string String which uniquely identifies this field.
    * @task core
    */
   public function getFieldKey() {
     if ($this->proxy) {
       return $this->proxy->getFieldKey();
     }
     throw new PhabricatorCustomFieldImplementationIncompleteException(
       $this,
       $field_key_is_incomplete = true);
   }
 
   public function getModernFieldKey() {
     if ($this->proxy) {
       return $this->proxy->getModernFieldKey();
     }
     return $this->getFieldKey();
   }
 
 
   /**
    * Return a human-readable field name.
    *
    * @return string Human readable field name.
    * @task core
    */
   public function getFieldName() {
     if ($this->proxy) {
       return $this->proxy->getFieldName();
     }
     return $this->getModernFieldKey();
   }
 
 
   /**
    * Return a short, human-readable description of the field's behavior. This
    * provides more context to administrators when they are customizing fields.
    *
    * @return string|null Optional human-readable description.
    * @task core
    */
   public function getFieldDescription() {
     if ($this->proxy) {
       return $this->proxy->getFieldDescription();
     }
     return null;
   }
 
 
   /**
    * Most field implementations are unique, in that one class corresponds to
    * one field. However, some field implementations are general and a single
    * implementation may drive several fields.
    *
    * For general implementations, the general field implementation can return
    * multiple field instances here.
    *
    * @param object The object to create fields for.
    * @return list<PhabricatorCustomField> List of fields.
    * @task core
    */
   public function createFields($object) {
     return array($this);
   }
 
 
   /**
    * You can return `false` here if the field should not be enabled for any
    * role. For example, it might depend on something (like an application or
    * library) which isn't installed, or might have some global configuration
    * which allows it to be disabled.
    *
    * @return bool False to completely disable this field for all roles.
    * @task core
    */
   public function isFieldEnabled() {
     if ($this->proxy) {
       return $this->proxy->isFieldEnabled();
     }
     return true;
   }
 
 
   /**
    * Low level selector for field availability. Fields can appear in different
    * roles (like an edit view, a list view, etc.), but not every field needs
    * to appear everywhere. Fields that are disabled in a role won't appear in
    * that context within applications.
    *
    * Normally, you do not need to override this method. Instead, override the
    * methods specific to roles you want to enable. For example, implement
    * @{method:shouldUseStorage()} to activate the `'storage'` role.
    *
    * @return bool True to enable the field for the given role.
    * @task core
    */
   public function shouldEnableForRole($role) {
 
     // NOTE: All of these calls proxy individually, so we don't need to
     // proxy this call as a whole.
 
     switch ($role) {
       case self::ROLE_APPLICATIONTRANSACTIONS:
         return $this->shouldAppearInApplicationTransactions();
       case self::ROLE_APPLICATIONSEARCH:
         return $this->shouldAppearInApplicationSearch();
       case self::ROLE_STORAGE:
         return $this->shouldUseStorage();
       case self::ROLE_EDIT:
         return $this->shouldAppearInEditView();
       case self::ROLE_VIEW:
         return $this->shouldAppearInPropertyView();
       case self::ROLE_LIST:
         return $this->shouldAppearInListView();
       case self::ROLE_GLOBALSEARCH:
         return $this->shouldAppearInGlobalSearch();
       case self::ROLE_CONDUIT:
         return $this->shouldAppearInConduitDictionary();
       case self::ROLE_TRANSACTIONMAIL:
         return $this->shouldAppearInTransactionMail();
       case self::ROLE_HERALD:
         return $this->shouldAppearInHerald();
       case self::ROLE_HERALDACTION:
         return $this->shouldAppearInHeraldActions();
       case self::ROLE_EDITENGINE:
         return $this->shouldAppearInEditView() ||
                $this->shouldAppearInEditEngine();
       case self::ROLE_EXPORT:
         return $this->shouldAppearInDataExport();
       case self::ROLE_DEFAULT:
         return true;
       default:
         throw new Exception(pht("Unknown field role '%s'!", $role));
     }
   }
 
 
   /**
    * Allow administrators to disable this field. Most fields should allow this,
    * but some are fundamental to the behavior of the application and can be
    * locked down to avoid chaos, disorder, and the decline of civilization.
    *
    * @return bool False to prevent this field from being disabled through
    *              configuration.
    * @task core
    */
   public function canDisableField() {
     return true;
   }
 
   public function shouldDisableByDefault() {
     return false;
   }
 
 
   /**
    * Return an index string which uniquely identifies this field.
    *
    * @return string Index string which uniquely identifies this field.
    * @task core
    */
   final public function getFieldIndex() {
     return PhabricatorHash::digestForIndex($this->getFieldKey());
   }
 
 
 /* -(  Field Proxies  )------------------------------------------------------ */
 
 
   /**
    * Proxies allow a field to use some other field's implementation for most
    * of their behavior while still subclassing an application field. When a
    * proxy is set for a field with @{method:setProxy}, all of its methods will
    * call through to the proxy by default.
    *
    * This is most commonly used to implement configuration-driven custom fields
    * using @{class:PhabricatorStandardCustomField}.
    *
    * This method must be overridden to return `true` before a field can accept
    * proxies.
    *
    * @return bool True if you can @{method:setProxy} this field.
    * @task proxy
    */
   public function canSetProxy() {
     if ($this instanceof PhabricatorStandardCustomFieldInterface) {
       return true;
     }
     return false;
   }
 
 
   /**
    * Set the proxy implementation for this field. See @{method:canSetProxy} for
    * discussion of field proxies.
    *
    * @param PhabricatorCustomField Field implementation.
    * @return this
    */
   final public function setProxy(PhabricatorCustomField $proxy) {
     if (!$this->canSetProxy()) {
       throw new PhabricatorCustomFieldNotProxyException($this);
     }
 
     $this->proxy = $proxy;
     return $this;
   }
 
 
   /**
    * Get the field's proxy implementation, if any. For discussion, see
    * @{method:canSetProxy}.
    *
    * @return PhabricatorCustomField|null  Proxy field, if one is set.
    */
   final public function getProxy() {
     return $this->proxy;
   }
 
 
 /* -(  Contextual Data  )---------------------------------------------------- */
 
 
   /**
    * Sets the object this field belongs to.
    *
    * @param PhabricatorCustomFieldInterface The object this field belongs to.
    * @return this
    * @task context
    */
   final public function setObject(PhabricatorCustomFieldInterface $object) {
     if ($this->proxy) {
       $this->proxy->setObject($object);
       return $this;
     }
 
     $this->object = $object;
     $this->didSetObject($object);
     return $this;
   }
 
 
   /**
    * Read object data into local field storage, if applicable.
    *
    * @param PhabricatorCustomFieldInterface The object this field belongs to.
    * @return this
    * @task context
    */
   public function readValueFromObject(PhabricatorCustomFieldInterface $object) {
     if ($this->proxy) {
       $this->proxy->readValueFromObject($object);
     }
     return $this;
   }
 
 
   /**
    * Get the object this field belongs to.
    *
    * @return PhabricatorCustomFieldInterface The object this field belongs to.
    * @task context
    */
   final public function getObject() {
     if ($this->proxy) {
       return $this->proxy->getObject();
     }
 
     return $this->object;
   }
 
 
   /**
    * This is a hook, primarily for subclasses to load object data.
    *
    * @return PhabricatorCustomFieldInterface The object this field belongs to.
    * @return void
    */
   protected function didSetObject(PhabricatorCustomFieldInterface $object) {
     return;
   }
 
 
   /**
    * @task context
    */
   final public function setViewer(PhabricatorUser $viewer) {
     if ($this->proxy) {
       $this->proxy->setViewer($viewer);
       return $this;
     }
 
     $this->viewer = $viewer;
     return $this;
   }
 
 
   /**
    * @task context
    */
   final public function getViewer() {
     if ($this->proxy) {
       return $this->proxy->getViewer();
     }
 
     return $this->viewer;
   }
 
 
   /**
    * @task context
    */
   final protected function requireViewer() {
     if ($this->proxy) {
       return $this->proxy->requireViewer();
     }
 
     if (!$this->viewer) {
       throw new PhabricatorCustomFieldDataNotAvailableException($this);
     }
     return $this->viewer;
   }
 
 
 /* -(  Rendering Utilities  )------------------------------------------------ */
 
 
   /**
    * @task render
    */
   protected function renderHandleList(array $handles) {
     if (!$handles) {
       return null;
     }
 
     $out = array();
     foreach ($handles as $handle) {
       $out[] = $handle->renderHovercardLink();
     }
 
     return phutil_implode_html(phutil_tag('br'), $out);
   }
 
 
 /* -(  Storage  )------------------------------------------------------------ */
 
 
   /**
    * Return true to use field storage.
    *
    * Fields which can be edited by the user will most commonly use storage,
    * while some other types of fields (for instance, those which just display
    * information in some stylized way) may not. Many builtin fields do not use
    * storage because their data is available on the object itself.
    *
    * If you implement this, you must also implement @{method:getValueForStorage}
    * and @{method:setValueFromStorage}.
    *
    * @return bool True to use storage.
    * @task storage
    */
   public function shouldUseStorage() {
     if ($this->proxy) {
       return $this->proxy->shouldUseStorage();
     }
     return false;
   }
 
 
   /**
    * Return a new, empty storage object. This should be a subclass of
    * @{class:PhabricatorCustomFieldStorage} which is bound to the application's
    * database.
    *
    * @return PhabricatorCustomFieldStorage New empty storage object.
    * @task storage
    */
   public function newStorageObject() {
     // NOTE: This intentionally isn't proxied, to avoid call cycles.
     throw new PhabricatorCustomFieldImplementationIncompleteException($this);
   }
 
 
   /**
    * Return a serialized representation of the field value, appropriate for
    * storing in auxiliary field storage. You must implement this method if
    * you implement @{method:shouldUseStorage}.
    *
    * If the field value is a scalar, it can be returned unmodiifed. If not,
    * it should be serialized (for example, using JSON).
    *
    * @return string Serialized field value.
    * @task storage
    */
   public function getValueForStorage() {
     if ($this->proxy) {
       return $this->proxy->getValueForStorage();
     }
     throw new PhabricatorCustomFieldImplementationIncompleteException($this);
   }
 
 
   /**
    * Set the field's value given a serialized storage value. This is called
    * when the field is loaded; if no data is available, the value will be
    * null. You must implement this method if you implement
    * @{method:shouldUseStorage}.
    *
    * Usually, the value can be loaded directly. If it isn't a scalar, you'll
    * need to undo whatever serialization you applied in
    * @{method:getValueForStorage}.
    *
    * @param string|null Serialized field representation (from
    *                    @{method:getValueForStorage}) or null if no value has
    *                    ever been stored.
    * @return this
    * @task storage
    */
   public function setValueFromStorage($value) {
     if ($this->proxy) {
       return $this->proxy->setValueFromStorage($value);
     }
     throw new PhabricatorCustomFieldImplementationIncompleteException($this);
   }
 
   public function didSetValueFromStorage() {
     if ($this->proxy) {
       return $this->proxy->didSetValueFromStorage();
     }
     return $this;
   }
 
 
 /* -(  ApplicationSearch  )-------------------------------------------------- */
 
 
   /**
    * Appearing in ApplicationSearch allows a field to be indexed and searched
    * for.
    *
    * @return bool True to appear in ApplicationSearch.
    * @task appsearch
    */
   public function shouldAppearInApplicationSearch() {
     if ($this->proxy) {
       return $this->proxy->shouldAppearInApplicationSearch();
     }
     return false;
   }
 
 
   /**
    * Return one or more indexes which this field can meaningfully query against
    * to implement ApplicationSearch.
    *
    * Normally, you should build these using @{method:newStringIndex} and
    * @{method:newNumericIndex}. For example, if a field holds a numeric value
    * it might return a single numeric index:
    *
    *   return array($this->newNumericIndex($this->getValue()));
    *
    * If a field holds a more complex value (like a list of users), it might
    * return several string indexes:
    *
    *   $indexes = array();
    *   foreach ($this->getValue() as $phid) {
    *     $indexes[] = $this->newStringIndex($phid);
    *   }
    *   return $indexes;
    *
    * @return list<PhabricatorCustomFieldIndexStorage> List of indexes.
    * @task appsearch
    */
   public function buildFieldIndexes() {
     if ($this->proxy) {
       return $this->proxy->buildFieldIndexes();
     }
     return array();
   }
 
 
   /**
    * Return an index against which this field can be meaningfully ordered
    * against to implement ApplicationSearch.
    *
    * This should be a single index, normally built using
    * @{method:newStringIndex} and @{method:newNumericIndex}.
    *
    * The value of the index is not used.
    *
    * Return null from this method if the field can not be ordered.
    *
    * @return PhabricatorCustomFieldIndexStorage A single index to order by.
    * @task appsearch
    */
   public function buildOrderIndex() {
     if ($this->proxy) {
       return $this->proxy->buildOrderIndex();
     }
     return null;
   }
 
 
   /**
    * Build a new empty storage object for storing string indexes. Normally,
    * this should be a concrete subclass of
    * @{class:PhabricatorCustomFieldStringIndexStorage}.
    *
    * @return PhabricatorCustomFieldStringIndexStorage Storage object.
    * @task appsearch
    */
   protected function newStringIndexStorage() {
     // NOTE: This intentionally isn't proxied, to avoid call cycles.
     throw new PhabricatorCustomFieldImplementationIncompleteException($this);
   }
 
 
   /**
    * Build a new empty storage object for storing string indexes. Normally,
    * this should be a concrete subclass of
    * @{class:PhabricatorCustomFieldStringIndexStorage}.
    *
    * @return PhabricatorCustomFieldStringIndexStorage Storage object.
    * @task appsearch
    */
   protected function newNumericIndexStorage() {
     // NOTE: This intentionally isn't proxied, to avoid call cycles.
     throw new PhabricatorCustomFieldImplementationIncompleteException($this);
   }
 
 
   /**
    * Build and populate storage for a string index.
    *
    * @param string String to index.
    * @return PhabricatorCustomFieldStringIndexStorage Populated storage.
    * @task appsearch
    */
   protected function newStringIndex($value) {
     if ($this->proxy) {
       return $this->proxy->newStringIndex();
     }
 
     $key = $this->getFieldIndex();
     return $this->newStringIndexStorage()
       ->setIndexKey($key)
       ->setIndexValue($value);
   }
 
 
   /**
    * Build and populate storage for a numeric index.
    *
    * @param string Numeric value to index.
    * @return PhabricatorCustomFieldNumericIndexStorage Populated storage.
    * @task appsearch
    */
   protected function newNumericIndex($value) {
     if ($this->proxy) {
       return $this->proxy->newNumericIndex();
     }
     $key = $this->getFieldIndex();
     return $this->newNumericIndexStorage()
       ->setIndexKey($key)
       ->setIndexValue($value);
   }
 
 
   /**
    * Read a query value from a request, for storage in a saved query. Normally,
    * this method should, e.g., read a string out of the request.
    *
    * @param PhabricatorApplicationSearchEngine Engine building the query.
    * @param AphrontRequest Request to read from.
    * @return wild
    * @task appsearch
    */
   public function readApplicationSearchValueFromRequest(
     PhabricatorApplicationSearchEngine $engine,
     AphrontRequest $request) {
     if ($this->proxy) {
       return $this->proxy->readApplicationSearchValueFromRequest(
         $engine,
         $request);
     }
     throw new PhabricatorCustomFieldImplementationIncompleteException($this);
   }
 
 
   /**
    * Constrain a query, given a field value. Generally, this method should
    * use `with...()` methods to apply filters or other constraints to the
    * query.
    *
    * @param PhabricatorApplicationSearchEngine Engine executing the query.
    * @param PhabricatorCursorPagedPolicyAwareQuery Query to constrain.
    * @param wild Constraint provided by the user.
    * @return void
    * @task appsearch
    */
   public function applyApplicationSearchConstraintToQuery(
     PhabricatorApplicationSearchEngine $engine,
     PhabricatorCursorPagedPolicyAwareQuery $query,
     $value) {
     if ($this->proxy) {
       return $this->proxy->applyApplicationSearchConstraintToQuery(
         $engine,
         $query,
         $value);
     }
     throw new PhabricatorCustomFieldImplementationIncompleteException($this);
   }
 
 
   /**
    * Append search controls to the interface.
    *
    * @param PhabricatorApplicationSearchEngine Engine constructing the form.
    * @param AphrontFormView The form to update.
    * @param wild Value from the saved query.
    * @return void
    * @task appsearch
    */
   public function appendToApplicationSearchForm(
     PhabricatorApplicationSearchEngine $engine,
     AphrontFormView $form,
     $value) {
     if ($this->proxy) {
       return $this->proxy->appendToApplicationSearchForm(
         $engine,
         $form,
         $value);
     }
     throw new PhabricatorCustomFieldImplementationIncompleteException($this);
   }
 
 
 /* -(  ApplicationTransactions  )-------------------------------------------- */
 
 
   /**
    * Appearing in ApplicationTrasactions allows a field to be edited using
    * standard workflows.
    *
    * @return bool True to appear in ApplicationTransactions.
    * @task appxaction
    */
   public function shouldAppearInApplicationTransactions() {
     if ($this->proxy) {
       return $this->proxy->shouldAppearInApplicationTransactions();
     }
     return false;
   }
 
 
   /**
    * @task appxaction
    */
   public function getApplicationTransactionType() {
     if ($this->proxy) {
       return $this->proxy->getApplicationTransactionType();
     }
     return PhabricatorTransactions::TYPE_CUSTOMFIELD;
   }
 
 
   /**
    * @task appxaction
    */
   public function getApplicationTransactionMetadata() {
     if ($this->proxy) {
       return $this->proxy->getApplicationTransactionMetadata();
     }
     return array();
   }
 
 
   /**
    * @task appxaction
    */
   public function getOldValueForApplicationTransactions() {
     if ($this->proxy) {
       return $this->proxy->getOldValueForApplicationTransactions();
     }
     return $this->getValueForStorage();
   }
 
 
   /**
    * @task appxaction
    */
   public function getNewValueForApplicationTransactions() {
     if ($this->proxy) {
       return $this->proxy->getNewValueForApplicationTransactions();
     }
     return $this->getValueForStorage();
   }
 
 
   /**
    * @task appxaction
    */
   public function setValueFromApplicationTransactions($value) {
     if ($this->proxy) {
       return $this->proxy->setValueFromApplicationTransactions($value);
     }
     return $this->setValueFromStorage($value);
   }
 
 
   /**
    * @task appxaction
    */
   public function getNewValueFromApplicationTransactions(
     PhabricatorApplicationTransaction $xaction) {
     if ($this->proxy) {
       return $this->proxy->getNewValueFromApplicationTransactions($xaction);
     }
     return $xaction->getNewValue();
   }
 
 
   /**
    * @task appxaction
    */
   public function getApplicationTransactionHasEffect(
     PhabricatorApplicationTransaction $xaction) {
     if ($this->proxy) {
       return $this->proxy->getApplicationTransactionHasEffect($xaction);
     }
     return ($xaction->getOldValue() !== $xaction->getNewValue());
   }
 
 
   /**
    * @task appxaction
    */
   public function applyApplicationTransactionInternalEffects(
     PhabricatorApplicationTransaction $xaction) {
     if ($this->proxy) {
       return $this->proxy->applyApplicationTransactionInternalEffects($xaction);
     }
     return;
   }
 
 
   /**
    * @task appxaction
    */
   public function getApplicationTransactionRemarkupBlocks(
     PhabricatorApplicationTransaction $xaction) {
     if ($this->proxy) {
       return $this->proxy->getApplicationTransactionRemarkupBlocks($xaction);
     }
     return array();
   }
 
 
   /**
    * @task appxaction
    */
   public function applyApplicationTransactionExternalEffects(
     PhabricatorApplicationTransaction $xaction) {
     if ($this->proxy) {
       return $this->proxy->applyApplicationTransactionExternalEffects($xaction);
     }
 
     if (!$this->shouldEnableForRole(self::ROLE_STORAGE)) {
       return;
     }
 
     $this->setValueFromApplicationTransactions($xaction->getNewValue());
     $value = $this->getValueForStorage();
 
     $table = $this->newStorageObject();
     $conn_w = $table->establishConnection('w');
 
     if ($value === null) {
       queryfx(
         $conn_w,
         'DELETE FROM %T WHERE objectPHID = %s AND fieldIndex = %s',
         $table->getTableName(),
         $this->getObject()->getPHID(),
         $this->getFieldIndex());
     } else {
       queryfx(
         $conn_w,
         'INSERT INTO %T (objectPHID, fieldIndex, fieldValue)
           VALUES (%s, %s, %s)
           ON DUPLICATE KEY UPDATE fieldValue = VALUES(fieldValue)',
         $table->getTableName(),
         $this->getObject()->getPHID(),
         $this->getFieldIndex(),
         $value);
     }
 
     return;
   }
 
 
   /**
    * Validate transactions for an object. This allows you to raise an error
    * when a transaction would set a field to an invalid value, or when a field
    * is required but no transactions provide value.
    *
    * @param PhabricatorLiskDAO Editor applying the transactions.
    * @param string Transaction type. This type is always
    *   `PhabricatorTransactions::TYPE_CUSTOMFIELD`, it is provided for
    *   convenience when constructing exceptions.
    * @param list<PhabricatorApplicationTransaction> Transactions being applied,
    *   which may be empty if this field is not being edited.
    * @return list<PhabricatorApplicationTransactionValidationError> Validation
    *   errors.
    *
    * @task appxaction
    */
   public function validateApplicationTransactions(
     PhabricatorApplicationTransactionEditor $editor,
     $type,
     array $xactions) {
     if ($this->proxy) {
       return $this->proxy->validateApplicationTransactions(
         $editor,
         $type,
         $xactions);
     }
     return array();
   }
 
   public function getApplicationTransactionTitle(
     PhabricatorApplicationTransaction $xaction) {
     if ($this->proxy) {
       return $this->proxy->getApplicationTransactionTitle(
         $xaction);
     }
 
     $author_phid = $xaction->getAuthorPHID();
     return pht(
       '%s updated this object.',
       $xaction->renderHandleLink($author_phid));
   }
 
   public function getApplicationTransactionTitleForFeed(
     PhabricatorApplicationTransaction $xaction) {
     if ($this->proxy) {
       return $this->proxy->getApplicationTransactionTitleForFeed(
         $xaction);
     }
 
     $author_phid = $xaction->getAuthorPHID();
     $object_phid = $xaction->getObjectPHID();
     return pht(
       '%s updated %s.',
       $xaction->renderHandleLink($author_phid),
       $xaction->renderHandleLink($object_phid));
   }
 
 
   public function getApplicationTransactionHasChangeDetails(
     PhabricatorApplicationTransaction $xaction) {
     if ($this->proxy) {
       return $this->proxy->getApplicationTransactionHasChangeDetails(
         $xaction);
     }
     return false;
   }
 
   public function getApplicationTransactionChangeDetails(
     PhabricatorApplicationTransaction $xaction,
     PhabricatorUser $viewer) {
     if ($this->proxy) {
       return $this->proxy->getApplicationTransactionChangeDetails(
         $xaction,
         $viewer);
     }
     return null;
   }
 
   public function getApplicationTransactionRequiredHandlePHIDs(
     PhabricatorApplicationTransaction $xaction) {
     if ($this->proxy) {
       return $this->proxy->getApplicationTransactionRequiredHandlePHIDs(
         $xaction);
     }
     return array();
   }
 
   public function shouldHideInApplicationTransactions(
     PhabricatorApplicationTransaction $xaction) {
     if ($this->proxy) {
       return $this->proxy->shouldHideInApplicationTransactions($xaction);
     }
     return false;
   }
 
 
 /* -(  Transaction Mail  )--------------------------------------------------- */
 
 
   /**
    * @task xactionmail
    */
   public function shouldAppearInTransactionMail() {
     if ($this->proxy) {
       return $this->proxy->shouldAppearInTransactionMail();
     }
     return false;
   }
 
 
   /**
    * @task xactionmail
    */
   public function updateTransactionMailBody(
     PhabricatorMetaMTAMailBody $body,
     PhabricatorApplicationTransactionEditor $editor,
     array $xactions) {
     if ($this->proxy) {
       return $this->proxy->updateTransactionMailBody($body, $editor, $xactions);
     }
     return;
   }
 
 
 /* -(  Edit View  )---------------------------------------------------------- */
 
 
   public function getEditEngineFields(PhabricatorEditEngine $engine) {
     $field = $this->newStandardEditField();
 
     return array(
       $field,
     );
   }
 
   protected function newEditField() {
     $field = id(new PhabricatorCustomFieldEditField())
       ->setCustomField($this);
 
     $http_type = $this->getHTTPParameterType();
     if ($http_type) {
       $field->setCustomFieldHTTPParameterType($http_type);
     }
 
     $conduit_type = $this->getConduitEditParameterType();
     if ($conduit_type) {
       $field->setCustomFieldConduitParameterType($conduit_type);
     }
 
     $bulk_type = $this->getBulkParameterType();
     if ($bulk_type) {
       $field->setCustomFieldBulkParameterType($bulk_type);
     }
 
     $comment_action = $this->getCommentAction();
     if ($comment_action) {
       $field
         ->setCustomFieldCommentAction($comment_action)
         ->setCommentActionLabel(
           pht(
             'Change %s',
             $this->getFieldName()));
     }
 
     return $field;
   }
 
   protected function newStandardEditField() {
     if ($this->proxy) {
       return $this->proxy->newStandardEditField();
     }
 
     if ($this->shouldAppearInEditView()) {
       $form_field = true;
     } else {
       $form_field = false;
     }
 
     $bulk_label = $this->getBulkEditLabel();
 
     return $this->newEditField()
       ->setKey($this->getFieldKey())
       ->setEditTypeKey($this->getModernFieldKey())
       ->setLabel($this->getFieldName())
       ->setBulkEditLabel($bulk_label)
       ->setDescription($this->getFieldDescription())
       ->setTransactionType($this->getApplicationTransactionType())
       ->setIsFormField($form_field)
       ->setValue($this->getNewValueForApplicationTransactions());
   }
 
   protected function getBulkEditLabel() {
     if ($this->proxy) {
       return $this->proxy->getBulkEditLabel();
     }
 
     return pht('Set "%s" to', $this->getFieldName());
   }
 
   public function getBulkParameterType() {
     return $this->newBulkParameterType();
   }
 
   protected function newBulkParameterType() {
     if ($this->proxy) {
       return $this->proxy->newBulkParameterType();
     }
     return null;
   }
 
   protected function getHTTPParameterType() {
     if ($this->proxy) {
       return $this->proxy->getHTTPParameterType();
     }
     return null;
   }
 
   /**
    * @task edit
    */
   public function shouldAppearInEditView() {
     if ($this->proxy) {
       return $this->proxy->shouldAppearInEditView();
     }
     return false;
   }
 
   /**
    * @task edit
    */
   public function shouldAppearInEditEngine() {
     if ($this->proxy) {
       return $this->proxy->shouldAppearInEditEngine();
     }
     return false;
   }
 
 
   /**
    * @task edit
    */
   public function readValueFromRequest(AphrontRequest $request) {
     if ($this->proxy) {
       return $this->proxy->readValueFromRequest($request);
     }
     throw new PhabricatorCustomFieldImplementationIncompleteException($this);
   }
 
 
   /**
    * @task edit
    */
   public function getRequiredHandlePHIDsForEdit() {
     if ($this->proxy) {
       return $this->proxy->getRequiredHandlePHIDsForEdit();
     }
     return array();
   }
 
 
   /**
    * @task edit
    */
   public function getInstructionsForEdit() {
     if ($this->proxy) {
       return $this->proxy->getInstructionsForEdit();
     }
     return null;
   }
 
 
   /**
    * @task edit
    */
   public function renderEditControl(array $handles) {
     if ($this->proxy) {
       return $this->proxy->renderEditControl($handles);
     }
     throw new PhabricatorCustomFieldImplementationIncompleteException($this);
   }
 
 
 /* -(  Property View  )------------------------------------------------------ */
 
 
   /**
    * @task view
    */
   public function shouldAppearInPropertyView() {
     if ($this->proxy) {
       return $this->proxy->shouldAppearInPropertyView();
     }
     return false;
   }
 
 
   /**
    * @task view
    */
   public function renderPropertyViewLabel() {
     if ($this->proxy) {
       return $this->proxy->renderPropertyViewLabel();
     }
     return $this->getFieldName();
   }
 
 
   /**
    * @task view
    */
   public function renderPropertyViewValue(array $handles) {
     if ($this->proxy) {
       return $this->proxy->renderPropertyViewValue($handles);
     }
     throw new PhabricatorCustomFieldImplementationIncompleteException($this);
   }
 
 
   /**
    * @task view
    */
   public function getStyleForPropertyView() {
     if ($this->proxy) {
       return $this->proxy->getStyleForPropertyView();
     }
     return 'property';
   }
 
 
   /**
    * @task view
    */
   public function getIconForPropertyView() {
     if ($this->proxy) {
       return $this->proxy->getIconForPropertyView();
     }
     return null;
   }
 
 
   /**
    * @task view
    */
   public function getRequiredHandlePHIDsForPropertyView() {
     if ($this->proxy) {
       return $this->proxy->getRequiredHandlePHIDsForPropertyView();
     }
     return array();
   }
 
 
 /* -(  List View  )---------------------------------------------------------- */
 
 
   /**
    * @task list
    */
   public function shouldAppearInListView() {
     if ($this->proxy) {
       return $this->proxy->shouldAppearInListView();
     }
     return false;
   }
 
 
   /**
    * @task list
    */
   public function renderOnListItem(PHUIObjectItemView $view) {
     if ($this->proxy) {
       return $this->proxy->renderOnListItem($view);
     }
     throw new PhabricatorCustomFieldImplementationIncompleteException($this);
   }
 
 
 /* -(  Global Search  )------------------------------------------------------ */
 
 
   /**
    * @task globalsearch
    */
   public function shouldAppearInGlobalSearch() {
     if ($this->proxy) {
       return $this->proxy->shouldAppearInGlobalSearch();
     }
     return false;
   }
 
 
   /**
    * @task globalsearch
    */
   public function updateAbstractDocument(
     PhabricatorSearchAbstractDocument $document) {
     if ($this->proxy) {
       return $this->proxy->updateAbstractDocument($document);
     }
     return $document;
   }
 
 
 /* -(  Data Export  )-------------------------------------------------------- */
 
 
   public function shouldAppearInDataExport() {
     if ($this->proxy) {
       return $this->proxy->shouldAppearInDataExport();
     }
 
     try {
       $this->newExportFieldType();
       return true;
     } catch (PhabricatorCustomFieldImplementationIncompleteException $ex) {
       return false;
     }
   }
 
   public function newExportField() {
     if ($this->proxy) {
       return $this->proxy->newExportField();
     }
 
     return $this->newExportFieldType()
       ->setLabel($this->getFieldName());
   }
 
   public function newExportData() {
     if ($this->proxy) {
       return $this->proxy->newExportData();
     }
     throw new PhabricatorCustomFieldImplementationIncompleteException($this);
   }
 
   protected function newExportFieldType() {
     if ($this->proxy) {
       return $this->proxy->newExportFieldType();
     }
     throw new PhabricatorCustomFieldImplementationIncompleteException($this);
   }
 
 
 /* -(  Conduit  )------------------------------------------------------------ */
 
 
   /**
    * @task conduit
    */
   public function shouldAppearInConduitDictionary() {
     if ($this->proxy) {
       return $this->proxy->shouldAppearInConduitDictionary();
     }
     return false;
   }
 
 
   /**
    * @task conduit
    */
   public function getConduitDictionaryValue() {
     if ($this->proxy) {
       return $this->proxy->getConduitDictionaryValue();
     }
     throw new PhabricatorCustomFieldImplementationIncompleteException($this);
   }
 
 
   public function shouldAppearInConduitTransactions() {
     if ($this->proxy) {
       return $this->proxy->shouldAppearInConduitDictionary();
     }
     return false;
   }
 
   public function getConduitSearchParameterType() {
     return $this->newConduitSearchParameterType();
   }
 
   protected function newConduitSearchParameterType() {
     if ($this->proxy) {
       return $this->proxy->newConduitSearchParameterType();
     }
     return null;
   }
 
   public function getConduitEditParameterType() {
     return $this->newConduitEditParameterType();
   }
 
   protected function newConduitEditParameterType() {
     if ($this->proxy) {
       return $this->proxy->newConduitEditParameterType();
     }
     return null;
   }
 
   public function getCommentAction() {
     return $this->newCommentAction();
   }
 
   protected function newCommentAction() {
     if ($this->proxy) {
       return $this->proxy->newCommentAction();
     }
     return null;
   }
 
 
 /* -(  Herald  )------------------------------------------------------------- */
 
 
   /**
    * Return `true` to make this field available in Herald.
    *
    * @return bool True to expose the field in Herald.
    * @task herald
    */
   public function shouldAppearInHerald() {
     if ($this->proxy) {
       return $this->proxy->shouldAppearInHerald();
     }
     return false;
   }
 
 
   /**
    * Get the name of the field in Herald. By default, this uses the
    * normal field name.
    *
    * @return string Herald field name.
    * @task herald
    */
   public function getHeraldFieldName() {
     if ($this->proxy) {
       return $this->proxy->getHeraldFieldName();
     }
     return $this->getFieldName();
   }
 
 
   /**
    * Get the field value for evaluation by Herald.
    *
    * @return wild Field value.
    * @task herald
    */
   public function getHeraldFieldValue() {
     if ($this->proxy) {
       return $this->proxy->getHeraldFieldValue();
     }
     throw new PhabricatorCustomFieldImplementationIncompleteException($this);
   }
 
 
   /**
    * Get the available conditions for this field in Herald.
    *
    * @return list<const> List of Herald condition constants.
    * @task herald
    */
   public function getHeraldFieldConditions() {
     if ($this->proxy) {
       return $this->proxy->getHeraldFieldConditions();
     }
     throw new PhabricatorCustomFieldImplementationIncompleteException($this);
   }
 
 
   /**
    * Get the Herald value type for the given condition.
    *
    * @param   const       Herald condition constant.
    * @return  const|null  Herald value type, or null to use the default.
    * @task herald
    */
   public function getHeraldFieldValueType($condition) {
     if ($this->proxy) {
       return $this->proxy->getHeraldFieldValueType($condition);
     }
     return null;
   }
 
   public function getHeraldFieldStandardType() {
     if ($this->proxy) {
       return $this->proxy->getHeraldFieldStandardType();
     }
     return null;
   }
 
   public function getHeraldDatasource() {
     if ($this->proxy) {
       return $this->proxy->getHeraldDatasource();
     }
     return null;
   }
 
 
   public function shouldAppearInHeraldActions() {
     if ($this->proxy) {
       return $this->proxy->shouldAppearInHeraldActions();
     }
     return false;
   }
 
 
   public function getHeraldActionName() {
     if ($this->proxy) {
       return $this->proxy->getHeraldActionName();
     }
 
     return null;
   }
 
 
   public function getHeraldActionStandardType() {
     if ($this->proxy) {
       return $this->proxy->getHeraldActionStandardType();
     }
 
     return null;
   }
 
 
   public function getHeraldActionDescription($value) {
     if ($this->proxy) {
       return $this->proxy->getHeraldActionDescription($value);
     }
 
     return null;
   }
 
 
   public function getHeraldActionEffectDescription($value) {
     if ($this->proxy) {
       return $this->proxy->getHeraldActionEffectDescription($value);
     }
 
     return null;
   }
 
 
   public function getHeraldActionDatasource() {
     if ($this->proxy) {
       return $this->proxy->getHeraldActionDatasource();
     }
 
     return null;
   }
 
+  private static function adjustCustomFieldsForObjectSubtype(
+    PhabricatorCustomFieldInterface $object,
+    $role,
+    array $fields) {
+    assert_instances_of($fields, __CLASS__);
+
+    // We only apply subtype adjustment for some roles. For example, when
+    // writing Herald rules or building a Search interface, we always want to
+    // show all the fields in their default state, so we do not apply any
+    // adjustments.
+    $subtype_roles = array(
+      self::ROLE_EDITENGINE,
+      self::ROLE_VIEW,
+    );
+
+    $subtype_roles = array_fuse($subtype_roles);
+    if (!isset($subtype_roles[$role])) {
+      return $fields;
+    }
+
+    // If the object doesn't support subtypes, we can't possibly make
+    // any adjustments based on subtype.
+    if (!($object instanceof PhabricatorEditEngineSubtypeInterface)) {
+      return $fields;
+    }
+
+    $subtype_map = $object->newEditEngineSubtypeMap();
+    $subtype_key = $object->getEditEngineSubtype();
+    $subtype_object = $subtype_map->getSubtype($subtype_key);
+
+    $map = array();
+    foreach ($fields as $field) {
+      $modern_key = $field->getModernFieldKey();
+      if (!strlen($modern_key)) {
+        continue;
+      }
+
+      $map[$modern_key] = $field;
+    }
+
+    foreach ($map as $field_key => $field) {
+      // For now, only support overriding standard custom fields. In the
+      // future there's no technical or product reason we couldn't let you
+      // override (some properites of) other fields like "Title", but they
+      // don't usually support appropriate "setX()" methods today.
+      if (!($field instanceof PhabricatorStandardCustomField)) {
+        // For fields that are proxies on top of StandardCustomField, which
+        // is how most application custom fields work today, we can reconfigure
+        // the proxied field instead.
+        $field = $field->getProxy();
+        if (!$field || !($field instanceof PhabricatorStandardCustomField)) {
+          continue;
+        }
+      }
+
+      $subtype_config = $subtype_object->getSubtypeFieldConfiguration(
+        $field_key);
+
+      if (!$subtype_config) {
+        continue;
+      }
+
+      if (isset($subtype_config['disabled'])) {
+        $field->setIsEnabled(!$subtype_config['disabled']);
+      }
+
+      if (isset($subtype_config['name'])) {
+        $field->setFieldName($subtype_config['name']);
+      }
+    }
+
+    return $fields;
+  }
+
 }
diff --git a/src/infrastructure/customfield/standard/PhabricatorStandardCustomField.php b/src/infrastructure/customfield/standard/PhabricatorStandardCustomField.php
index 5bd6256b73..4c0bce861b 100644
--- a/src/infrastructure/customfield/standard/PhabricatorStandardCustomField.php
+++ b/src/infrastructure/customfield/standard/PhabricatorStandardCustomField.php
@@ -1,503 +1,517 @@
 <?php
 
 abstract class PhabricatorStandardCustomField
   extends PhabricatorCustomField {
 
   private $rawKey;
   private $fieldKey;
   private $fieldName;
   private $fieldValue;
   private $fieldDescription;
   private $fieldConfig;
   private $applicationField;
   private $strings = array();
   private $caption;
   private $fieldError;
   private $required;
   private $default;
   private $isCopyable;
   private $hasStorageValue;
   private $isBuiltin;
+  private $isEnabled = true;
 
   abstract public function getFieldType();
 
   public static function buildStandardFields(
     PhabricatorCustomField $template,
     array $config,
     $builtin = false) {
 
     $types = id(new PhutilClassMapQuery())
       ->setAncestorClass(__CLASS__)
       ->setUniqueMethod('getFieldType')
       ->execute();
 
     $fields = array();
     foreach ($config as $key => $value) {
       $type = idx($value, 'type', 'text');
       if (empty($types[$type])) {
         // TODO: We should have better typechecking somewhere, and then make
         // this more serious.
         continue;
       }
 
       $namespace = $template->getStandardCustomFieldNamespace();
       $full_key = "std:{$namespace}:{$key}";
 
       $template = clone $template;
       $standard = id(clone $types[$type])
         ->setRawStandardFieldKey($key)
         ->setFieldKey($full_key)
         ->setFieldConfig($value)
         ->setApplicationField($template);
 
       if ($builtin) {
         $standard->setIsBuiltin(true);
       }
 
       $field = $template->setProxy($standard);
       $fields[] = $field;
     }
 
     return $fields;
   }
 
   public function setApplicationField(
     PhabricatorStandardCustomFieldInterface $application_field) {
     $this->applicationField = $application_field;
     return $this;
   }
 
   public function getApplicationField() {
     return $this->applicationField;
   }
 
   public function setFieldName($name) {
     $this->fieldName = $name;
     return $this;
   }
 
   public function getFieldValue() {
     return $this->fieldValue;
   }
 
   public function setFieldValue($value) {
     $this->fieldValue = $value;
     return $this;
   }
 
   public function setCaption($caption) {
     $this->caption = $caption;
     return $this;
   }
 
   public function getCaption() {
     return $this->caption;
   }
 
   public function setFieldDescription($description) {
     $this->fieldDescription = $description;
     return $this;
   }
 
   public function setIsBuiltin($is_builtin) {
     $this->isBuiltin = $is_builtin;
     return $this;
   }
 
   public function getIsBuiltin() {
     return $this->isBuiltin;
   }
 
   public function setFieldConfig(array $config) {
     foreach ($config as $key => $value) {
       switch ($key) {
         case 'name':
           $this->setFieldName($value);
           break;
         case 'description':
           $this->setFieldDescription($value);
           break;
         case 'strings':
           $this->setStrings($value);
           break;
         case 'caption':
           $this->setCaption($value);
           break;
         case 'required':
           if ($value) {
             $this->setRequired($value);
             $this->setFieldError(true);
           }
           break;
         case 'default':
           $this->setFieldValue($value);
           break;
         case 'copy':
           $this->setIsCopyable($value);
           break;
         case 'type':
           // We set this earlier on.
           break;
       }
     }
     $this->fieldConfig = $config;
     return $this;
   }
 
   public function getFieldConfigValue($key, $default = null) {
     return idx($this->fieldConfig, $key, $default);
   }
 
   public function setFieldError($field_error) {
     $this->fieldError = $field_error;
     return $this;
   }
 
   public function getFieldError() {
     return $this->fieldError;
   }
 
   public function setRequired($required) {
     $this->required = $required;
     return $this;
   }
 
   public function getRequired() {
     return $this->required;
   }
 
   public function setRawStandardFieldKey($raw_key) {
     $this->rawKey = $raw_key;
     return $this;
   }
 
   public function getRawStandardFieldKey() {
     return $this->rawKey;
   }
 
+  public function setIsEnabled($is_enabled) {
+    $this->isEnabled = $is_enabled;
+    return $this;
+  }
+
+  public function getIsEnabled() {
+    return $this->isEnabled;
+  }
+
+  public function isFieldEnabled() {
+    return $this->getIsEnabled();
+  }
+
 
 /* -(  PhabricatorCustomField  )--------------------------------------------- */
 
 
   public function setFieldKey($field_key) {
     $this->fieldKey = $field_key;
     return $this;
   }
 
   public function getFieldKey() {
     return $this->fieldKey;
   }
 
   public function getFieldName() {
     return coalesce($this->fieldName, parent::getFieldName());
   }
 
   public function getFieldDescription() {
     return coalesce($this->fieldDescription, parent::getFieldDescription());
   }
 
   public function setStrings(array $strings) {
     $this->strings = $strings;
     return;
   }
 
   public function getString($key, $default = null) {
     return idx($this->strings, $key, $default);
   }
 
   public function setIsCopyable($is_copyable) {
     $this->isCopyable = $is_copyable;
     return $this;
   }
 
   public function getIsCopyable() {
     return $this->isCopyable;
   }
 
   public function shouldUseStorage() {
     try {
       $object = $this->newStorageObject();
       return true;
     } catch (PhabricatorCustomFieldImplementationIncompleteException $ex) {
       return false;
     }
   }
 
   public function getValueForStorage() {
     return $this->getFieldValue();
   }
 
   public function setValueFromStorage($value) {
     return $this->setFieldValue($value);
   }
 
   public function didSetValueFromStorage() {
     $this->hasStorageValue = true;
     return $this;
   }
 
   public function getOldValueForApplicationTransactions() {
     if ($this->hasStorageValue) {
       return $this->getValueForStorage();
     } else {
       return null;
     }
   }
 
   public function shouldAppearInApplicationTransactions() {
     return true;
   }
 
   public function shouldAppearInEditView() {
     return $this->getFieldConfigValue('edit', true);
   }
 
   public function readValueFromRequest(AphrontRequest $request) {
     $value = $request->getStr($this->getFieldKey());
     if (!strlen($value)) {
       $value = null;
     }
     $this->setFieldValue($value);
   }
 
   public function getInstructionsForEdit() {
     return $this->getFieldConfigValue('instructions');
   }
 
   public function getPlaceholder() {
     return $this->getFieldConfigValue('placeholder', null);
   }
 
   public function renderEditControl(array $handles) {
     return id(new AphrontFormTextControl())
       ->setName($this->getFieldKey())
       ->setCaption($this->getCaption())
       ->setValue($this->getFieldValue())
       ->setError($this->getFieldError())
       ->setLabel($this->getFieldName())
       ->setPlaceholder($this->getPlaceholder());
   }
 
   public function newStorageObject() {
     return $this->getApplicationField()->newStorageObject();
   }
 
   public function shouldAppearInPropertyView() {
     return $this->getFieldConfigValue('view', true);
   }
 
   public function renderPropertyViewValue(array $handles) {
     if (!strlen($this->getFieldValue())) {
       return null;
     }
     return $this->getFieldValue();
   }
 
   public function shouldAppearInApplicationSearch() {
     return $this->getFieldConfigValue('search', false);
   }
 
   protected function newStringIndexStorage() {
     return $this->getApplicationField()->newStringIndexStorage();
   }
 
   protected function newNumericIndexStorage() {
     return $this->getApplicationField()->newNumericIndexStorage();
   }
 
   public function buildFieldIndexes() {
     return array();
   }
 
   public function buildOrderIndex() {
     return null;
   }
 
   public function readApplicationSearchValueFromRequest(
     PhabricatorApplicationSearchEngine $engine,
     AphrontRequest $request) {
     return;
   }
 
   public function applyApplicationSearchConstraintToQuery(
     PhabricatorApplicationSearchEngine $engine,
     PhabricatorCursorPagedPolicyAwareQuery $query,
     $value) {
     return;
   }
 
   public function appendToApplicationSearchForm(
     PhabricatorApplicationSearchEngine $engine,
     AphrontFormView $form,
     $value) {
     return;
   }
 
   public function validateApplicationTransactions(
     PhabricatorApplicationTransactionEditor $editor,
     $type,
     array $xactions) {
 
     $this->setFieldError(null);
 
     $errors = parent::validateApplicationTransactions(
       $editor,
       $type,
       $xactions);
 
     if ($this->getRequired()) {
       $value = $this->getOldValueForApplicationTransactions();
 
       $transaction = null;
       foreach ($xactions as $xaction) {
         $value = $xaction->getNewValue();
         if (!$this->isValueEmpty($value)) {
           $transaction = $xaction;
           break;
         }
       }
       if ($this->isValueEmpty($value)) {
         $error = new PhabricatorApplicationTransactionValidationError(
           $type,
           pht('Required'),
           pht('%s is required.', $this->getFieldName()),
           $transaction);
         $error->setIsMissingFieldError(true);
         $errors[] = $error;
         $this->setFieldError(pht('Required'));
       }
     }
 
     return $errors;
   }
 
   protected function isValueEmpty($value) {
     if (is_array($value)) {
       return empty($value);
     }
     return !strlen($value);
   }
 
   public function getApplicationTransactionTitle(
     PhabricatorApplicationTransaction $xaction) {
     $author_phid = $xaction->getAuthorPHID();
     $old = $xaction->getOldValue();
     $new = $xaction->getNewValue();
 
     if (!$old) {
       return pht(
         '%s set %s to %s.',
         $xaction->renderHandleLink($author_phid),
         $this->getFieldName(),
         $new);
     } else if (!$new) {
       return pht(
         '%s removed %s.',
         $xaction->renderHandleLink($author_phid),
         $this->getFieldName());
     } else {
       return pht(
         '%s changed %s from %s to %s.',
         $xaction->renderHandleLink($author_phid),
         $this->getFieldName(),
         $old,
         $new);
     }
   }
 
   public function getApplicationTransactionTitleForFeed(
     PhabricatorApplicationTransaction $xaction) {
 
     $author_phid = $xaction->getAuthorPHID();
     $object_phid = $xaction->getObjectPHID();
 
     $old = $xaction->getOldValue();
     $new = $xaction->getNewValue();
 
     if (!$old) {
       return pht(
         '%s set %s to %s on %s.',
         $xaction->renderHandleLink($author_phid),
         $this->getFieldName(),
         $new,
         $xaction->renderHandleLink($object_phid));
     } else if (!$new) {
       return pht(
         '%s removed %s on %s.',
         $xaction->renderHandleLink($author_phid),
         $this->getFieldName(),
         $xaction->renderHandleLink($object_phid));
     } else {
       return pht(
         '%s changed %s from %s to %s on %s.',
         $xaction->renderHandleLink($author_phid),
         $this->getFieldName(),
         $old,
         $new,
         $xaction->renderHandleLink($object_phid));
     }
   }
 
   public function getHeraldFieldValue() {
     return $this->getFieldValue();
   }
 
   public function getFieldControlID($key = null) {
     $key = coalesce($key, $this->getRawStandardFieldKey());
     return 'std:control:'.$key;
   }
 
   public function shouldAppearInGlobalSearch() {
     return $this->getFieldConfigValue('fulltext', false);
   }
 
   public function updateAbstractDocument(
     PhabricatorSearchAbstractDocument $document) {
 
     $field_key = $this->getFieldConfigValue('fulltext');
 
     // If the caller or configuration didn't specify a valid field key,
     // generate one automatically from the field index.
     if (!is_string($field_key) || (strlen($field_key) != 4)) {
       $field_key = '!'.substr($this->getFieldIndex(), 0, 3);
     }
 
     $field_value = $this->getFieldValue();
     if (strlen($field_value)) {
       $document->addField($field_key, $field_value);
     }
   }
 
   protected function newStandardEditField() {
     $short = $this->getModernFieldKey();
 
     return parent::newStandardEditField()
       ->setEditTypeKey($short)
       ->setIsCopyable($this->getIsCopyable());
   }
 
   public function shouldAppearInConduitTransactions() {
     return true;
   }
 
   public function shouldAppearInConduitDictionary() {
     return true;
   }
 
   public function getModernFieldKey() {
     if ($this->getIsBuiltin()) {
       return $this->getRawStandardFieldKey();
     } else {
       return 'custom.'.$this->getRawStandardFieldKey();
     }
   }
 
   public function getConduitDictionaryValue() {
     return $this->getFieldValue();
   }
 
   public function newExportData() {
     return $this->getFieldValue();
   }
 
 }