diff --git a/src/applications/auth/storage/PhabricatorAuthProviderConfig.php b/src/applications/auth/storage/PhabricatorAuthProviderConfig.php
index c60aace712..99805554cc 100644
--- a/src/applications/auth/storage/PhabricatorAuthProviderConfig.php
+++ b/src/applications/auth/storage/PhabricatorAuthProviderConfig.php
@@ -1,109 +1,109 @@
 <?php
 
 final class PhabricatorAuthProviderConfig extends PhabricatorAuthDAO
   implements PhabricatorPolicyInterface {
 
   protected $providerClass;
   protected $providerType;
   protected $providerDomain;
 
   protected $isEnabled;
   protected $shouldAllowLogin         = 0;
   protected $shouldAllowRegistration  = 0;
   protected $shouldAllowLink          = 0;
   protected $shouldAllowUnlink        = 0;
   protected $shouldTrustEmails        = 0;
 
   protected $properties = array();
 
   private $provider;
 
   public function generatePHID() {
     return PhabricatorPHID::generateNewPHID(
       PhabricatorPHIDConstants::PHID_TYPE_AUTH);
   }
 
   public function getConfiguration() {
     return array(
       self::CONFIG_AUX_PHID => true,
       self::CONFIG_SERIALIZATION => array(
         'properties' => self::SERIALIZATION_JSON,
       ),
       self::CONFIG_COLUMN_SCHEMA => array(
         'isEnabled' => 'bool',
         'providerClass' => 'text128',
-        'providerType' => 'text64',
+        'providerType' => 'text32',
         'providerDomain' => 'text128',
         'shouldAllowLogin' => 'bool',
         'shouldAllowRegistration' => 'bool',
         'shouldAllowLink' => 'bool',
         'shouldAllowUnlink' => 'bool',
         'shouldTrustEmails' => 'bool',
       ),
       self::CONFIG_KEY_SCHEMA => array(
         'key_provider' => array(
           'columns' => array('providerType', 'providerDomain'),
           'unique' => true,
         ),
         'key_class' => array(
           'columns' => array('providerClass'),
         ),
       ),
     ) + parent::getConfiguration();
   }
 
   public function getProperty($key, $default = null) {
     return idx($this->properties, $key, $default);
   }
 
   public function setProperty($key, $value) {
     $this->properties[$key] = $value;
     return $this;
   }
 
   public function getProvider() {
     if (!$this->provider) {
       $base = PhabricatorAuthProvider::getAllBaseProviders();
       $found = null;
       foreach ($base as $provider) {
         if (get_class($provider) == $this->providerClass) {
           $found = $provider;
           break;
         }
       }
       if ($found) {
         $this->provider = id(clone $found)->attachProviderConfig($this);
       }
     }
     return $this->provider;
   }
 
 
 /* -(  PhabricatorPolicyInterface  )----------------------------------------- */
 
 
   public function getCapabilities() {
     return array(
       PhabricatorPolicyCapability::CAN_VIEW,
       PhabricatorPolicyCapability::CAN_EDIT,
     );
   }
 
   public function getPolicy($capability) {
     switch ($capability) {
       case PhabricatorPolicyCapability::CAN_VIEW:
         return PhabricatorPolicies::POLICY_USER;
       case PhabricatorPolicyCapability::CAN_EDIT:
         return PhabricatorPolicies::POLICY_ADMIN;
     }
   }
 
   public function hasAutomaticCapability($capability, PhabricatorUser $viewer) {
     return false;
   }
 
   public function describeAutomaticCapability($capability) {
     return null;
   }
 
 }
diff --git a/src/applications/conduit/storage/PhabricatorConduitMethodCallLog.php b/src/applications/conduit/storage/PhabricatorConduitMethodCallLog.php
index 6d6f3dfc4f..d9a4a57ffe 100644
--- a/src/applications/conduit/storage/PhabricatorConduitMethodCallLog.php
+++ b/src/applications/conduit/storage/PhabricatorConduitMethodCallLog.php
@@ -1,59 +1,59 @@
 <?php
 
 final class PhabricatorConduitMethodCallLog
   extends PhabricatorConduitDAO
   implements PhabricatorPolicyInterface {
 
   protected $callerPHID;
   protected $connectionID;
   protected $method;
   protected $error;
   protected $duration;
 
   public function getConfiguration() {
     return array(
       self::CONFIG_COLUMN_SCHEMA => array(
         'id' => 'id64',
         'connectionID' => 'id64?',
-        'method' => 'text255',
+        'method' => 'text64',
         'error' => 'text255',
         'duration' => 'uint64',
         'callerPHID' => 'phid?',
       ),
       self::CONFIG_KEY_SCHEMA => array(
         'key_date' => array(
           'columns' => array('dateCreated'),
         ),
         'key_method' => array(
           'columns' => array('method'),
         ),
         'key_callermethod' => array(
           'columns' => array('callerPHID', 'method'),
         ),
       ),
     ) + parent::getConfiguration();
   }
 
 
 /* -(  PhabricatorPolicyInterface  )----------------------------------------- */
 
 
   public function getCapabilities() {
     return array(
       PhabricatorPolicyCapability::CAN_VIEW,
     );
   }
 
   public function getPolicy($capability) {
     return PhabricatorPolicies::POLICY_USER;
   }
 
   public function hasAutomaticCapability($capability, PhabricatorUser $viewer) {
     return false;
   }
 
   public function describeAutomaticCapability($capability) {
     return null;
   }
 
 }
diff --git a/src/applications/config/controller/PhabricatorConfigDatabaseController.php b/src/applications/config/controller/PhabricatorConfigDatabaseController.php
index 37a8700834..a4e11623be 100644
--- a/src/applications/config/controller/PhabricatorConfigDatabaseController.php
+++ b/src/applications/config/controller/PhabricatorConfigDatabaseController.php
@@ -1,67 +1,65 @@
 <?php
 
 abstract class PhabricatorConfigDatabaseController
   extends PhabricatorConfigController {
 
-  const MAX_INNODB_KEY_LENGTH = 767;
-
   protected function buildSchemaQuery() {
     $conf = PhabricatorEnv::newObjectFromConfig(
       'mysql.configuration-provider',
       array($dao = null, 'w'));
 
     $api = id(new PhabricatorStorageManagementAPI())
       ->setUser($conf->getUser())
       ->setHost($conf->getHost())
       ->setPort($conf->getPort())
       ->setNamespace(PhabricatorLiskDAO::getDefaultStorageNamespace())
       ->setPassword($conf->getPassword());
 
     $query = id(new PhabricatorConfigSchemaQuery())
       ->setAPI($api);
 
     return $query;
   }
 
   protected function renderIcon($status) {
     switch ($status) {
       case PhabricatorConfigStorageSchema::STATUS_OKAY:
         $icon = 'fa-check-circle green';
         break;
       case PhabricatorConfigStorageSchema::STATUS_WARN:
         $icon = 'fa-exclamation-circle yellow';
         break;
       case PhabricatorConfigStorageSchema::STATUS_FAIL:
       default:
         $icon = 'fa-times-circle red';
         break;
     }
 
     return id(new PHUIIconView())
       ->setIconFont($icon);
   }
 
   protected function renderAttr($attr, $issue) {
     if ($issue) {
       return phutil_tag(
         'span',
         array(
           'style' => 'color: #aa0000;',
         ),
         $attr);
     } else {
       return $attr;
     }
   }
 
   protected function renderBoolean($value) {
     if ($value === null) {
       return '';
     } else if ($value === true) {
       return pht('Yes');
     } else {
       return pht('No');
     }
   }
 
 }
diff --git a/src/applications/config/controller/PhabricatorConfigDatabaseStatusController.php b/src/applications/config/controller/PhabricatorConfigDatabaseStatusController.php
index 6175f57d2f..4bdb53554c 100644
--- a/src/applications/config/controller/PhabricatorConfigDatabaseStatusController.php
+++ b/src/applications/config/controller/PhabricatorConfigDatabaseStatusController.php
@@ -1,737 +1,738 @@
 <?php
 
 final class PhabricatorConfigDatabaseStatusController
   extends PhabricatorConfigDatabaseController {
 
   private $database;
   private $table;
   private $column;
   private $key;
 
   public function willProcessRequest(array $data) {
     $this->database = idx($data, 'database');
     $this->table = idx($data, 'table');
     $this->column = idx($data, 'column');
     $this->key = idx($data, 'key');
   }
 
   public function processRequest() {
     $request = $this->getRequest();
     $viewer = $request->getUser();
 
     $query = $this->buildSchemaQuery();
 
     $actual = $query->loadActualSchema();
     $expect = $query->loadExpectedSchema();
     $comp = $query->buildComparisonSchema($expect, $actual);
 
     if ($this->column) {
       return $this->renderColumn(
         $comp,
         $expect,
         $actual,
         $this->database,
         $this->table,
         $this->column);
     } else if ($this->key) {
       return $this->renderKey(
         $comp,
         $expect,
         $actual,
         $this->database,
         $this->table,
         $this->key);
     } else if ($this->table) {
       return $this->renderTable(
         $comp,
         $expect,
         $actual,
         $this->database,
         $this->table);
     } else if ($this->database) {
       return $this->renderDatabase(
         $comp,
         $expect,
         $actual,
         $this->database);
     } else {
       return $this->renderServer(
         $comp,
         $expect,
         $actual);
     }
   }
 
   private function buildResponse($title, $body) {
     $nav = $this->buildSideNavView();
     $nav->selectFilter('database/');
 
     $crumbs = $this->buildApplicationCrumbs();
     if ($this->database) {
       $crumbs->addTextCrumb(
         pht('Database Status'),
         $this->getApplicationURI('database/'));
       if ($this->table) {
         $crumbs->addTextCrumb(
           $this->database,
           $this->getApplicationURI('database/'.$this->database.'/'));
         if ($this->column || $this->key) {
           $crumbs->addTextCrumb(
             $this->table,
             $this->getApplicationURI(
               'database/'.$this->database.'/'.$this->table.'/'));
           if ($this->column) {
             $crumbs->addTextCrumb($this->column);
           } else {
             $crumbs->addTextCrumb($this->key);
           }
         } else {
           $crumbs->addTextCrumb($this->table);
         }
       } else {
         $crumbs->addTextCrumb($this->database);
       }
     } else {
       $crumbs->addTextCrumb(pht('Database Status'));
     }
 
     $nav->setCrumbs($crumbs);
     $nav->appendChild($body);
 
     return $this->buildApplicationPage(
       $nav,
       array(
         'title' => $title,
       ));
   }
 
 
   private function renderServer(
     PhabricatorConfigServerSchema $comp,
     PhabricatorConfigServerSchema $expect,
     PhabricatorConfigServerSchema $actual) {
 
     $charset_issue = PhabricatorConfigStorageSchema::ISSUE_CHARSET;
     $collation_issue = PhabricatorConfigStorageSchema::ISSUE_COLLATION;
 
     $rows = array();
     foreach ($comp->getDatabases() as $database_name => $database) {
       $actual_database = $actual->getDatabase($database_name);
       if ($actual_database) {
         $charset = $actual_database->getCharacterSet();
         $collation = $actual_database->getCollation();
       } else {
         $charset = null;
         $collation = null;
       }
 
       $status = $database->getStatus();
       $issues = $database->getIssues();
 
       $rows[] = array(
         $this->renderIcon($status),
         phutil_tag(
           'a',
           array(
             'href' => $this->getApplicationURI(
               '/database/'.$database_name.'/'),
           ),
           $database_name),
         $this->renderAttr($charset, $database->hasIssue($charset_issue)),
         $this->renderAttr($collation, $database->hasIssue($collation_issue)),
       );
     }
 
     $table = id(new AphrontTableView($rows))
       ->setHeaders(
         array(
           null,
           pht('Database'),
           pht('Charset'),
           pht('Collation'),
         ))
       ->setColumnClasses(
         array(
           null,
           'wide pri',
           null,
           null,
         ));
 
     $title = pht('Database Status');
 
     $properties = $this->buildProperties(
       array(
       ),
       $comp->getIssues());
 
     $box = id(new PHUIObjectBoxView())
       ->setHeaderText($title)
       ->addPropertyList($properties)
       ->appendChild($table);
 
     return $this->buildResponse($title, $box);
   }
 
   private function renderDatabase(
     PhabricatorConfigServerSchema $comp,
     PhabricatorConfigServerSchema $expect,
     PhabricatorConfigServerSchema $actual,
     $database_name) {
 
     $collation_issue = PhabricatorConfigStorageSchema::ISSUE_COLLATION;
 
     $database = $comp->getDatabase($database_name);
     if (!$database) {
       return new Aphront404Response();
     }
 
     $rows = array();
     foreach ($database->getTables() as $table_name => $table) {
       $status = $table->getStatus();
 
       $rows[] = array(
         $this->renderIcon($status),
         phutil_tag(
           'a',
           array(
             'href' => $this->getApplicationURI(
               '/database/'.$database_name.'/'.$table_name.'/'),
           ),
           $table_name),
         $this->renderAttr(
           $table->getCollation(),
           $table->hasIssue($collation_issue)),
       );
     }
 
     $table = id(new AphrontTableView($rows))
       ->setHeaders(
         array(
           null,
           pht('Table'),
           pht('Collation'),
         ))
       ->setColumnClasses(
         array(
           null,
           'wide pri',
           null,
         ));
 
     $title = pht('Database Status: %s', $database_name);
 
     $actual_database = $actual->getDatabase($database_name);
     if ($actual_database) {
       $actual_charset = $actual_database->getCharacterSet();
       $actual_collation = $actual_database->getCollation();
     } else {
       $actual_charset = null;
       $actual_collation = null;
     }
 
     $expect_database = $expect->getDatabase($database_name);
     if ($expect_database) {
       $expect_charset = $expect_database->getCharacterSet();
       $expect_collation = $expect_database->getCollation();
     } else {
       $expect_charset = null;
       $expect_collation = null;
     }
 
     $properties = $this->buildProperties(
       array(
         array(
           pht('Character Set'),
           $actual_charset,
         ),
         array(
           pht('Expected Character Set'),
           $expect_charset,
         ),
         array(
           pht('Collation'),
           $actual_collation,
         ),
         array(
           pht('Expected Collation'),
           $expect_collation,
         ),
       ),
       $database->getIssues());
 
     $box = id(new PHUIObjectBoxView())
       ->setHeaderText($title)
       ->addPropertyList($properties)
       ->appendChild($table);
 
     return $this->buildResponse($title, $box);
   }
 
   private function renderTable(
     PhabricatorConfigServerSchema $comp,
     PhabricatorConfigServerSchema $expect,
     PhabricatorConfigServerSchema $actual,
     $database_name,
     $table_name) {
 
     $type_issue = PhabricatorConfigStorageSchema::ISSUE_COLUMNTYPE;
     $charset_issue = PhabricatorConfigStorageSchema::ISSUE_CHARSET;
     $collation_issue = PhabricatorConfigStorageSchema::ISSUE_COLLATION;
     $nullable_issue = PhabricatorConfigStorageSchema::ISSUE_NULLABLE;
     $unique_issue = PhabricatorConfigStorageSchema::ISSUE_UNIQUE;
     $columns_issue = PhabricatorConfigStorageSchema::ISSUE_KEYCOLUMNS;
+    $longkey_issue = PhabricatorConfigStorageSchema::ISSUE_LONGKEY;
 
     $database = $comp->getDatabase($database_name);
     if (!$database) {
       return new Aphront404Response();
     }
 
     $table = $database->getTable($table_name);
     if (!$table) {
       return new Aphront404Response();
     }
 
     $actual_database = $actual->getDatabase($database_name);
     $actual_table = null;
     if ($actual_database) {
       $actual_table = $actual_database->getTable($table_name);
     }
 
     $expect_database = $expect->getDatabase($database_name);
     $expect_table = null;
     if ($expect_database) {
       $expect_table = $expect_database->getTable($table_name);
     }
 
     $rows = array();
     foreach ($table->getColumns() as $column_name => $column) {
       $expect_column = null;
       if ($expect_table) {
         $expect_column = $expect_table->getColumn($column_name);
       }
 
       $status = $column->getStatus();
 
       $data_type = null;
       if ($expect_column) {
         $data_type = $expect_column->getDataType();
       }
 
       $rows[] = array(
         $this->renderIcon($status),
         phutil_tag(
           'a',
           array(
             'href' => $this->getApplicationURI(
               'database/'.
               $database_name.'/'.
               $table_name.'/'.
               'col/'.
               $column_name.'/'),
           ),
           $column_name),
         $data_type,
         $this->renderAttr(
           $column->getColumnType(),
           $column->hasIssue($type_issue)),
         $this->renderAttr(
           $this->renderBoolean($column->getNullable()),
           $column->hasIssue($nullable_issue)),
         $this->renderAttr(
           $column->getCharacterSet(),
           $column->hasIssue($charset_issue)),
         $this->renderAttr(
           $column->getCollation(),
           $column->hasIssue($collation_issue)),
       );
     }
 
     $table_view = id(new AphrontTableView($rows))
       ->setHeaders(
         array(
           null,
           pht('Column'),
           pht('Data Type'),
           pht('Column Type'),
           pht('Nullable'),
           pht('Character Set'),
           pht('Collation'),
         ))
       ->setColumnClasses(
         array(
           null,
           'wide pri',
           null,
           null,
           null,
           null
         ));
 
     $key_rows = array();
     foreach ($table->getKeys() as $key_name => $key) {
       $expect_key = null;
       if ($expect_table) {
         $expect_key = $expect_table->getKey($key_name);
       }
 
       $status = $key->getStatus();
 
       $size = 0;
       foreach ($key->getColumnNames() as $column_spec) {
         list($column_name, $prefix) = $key->getKeyColumnAndPrefix($column_spec);
         $column = $table->getColumn($column_name);
         if (!$column) {
           $size = 0;
           break;
         }
         $size += $column->getKeyByteLength($prefix);
       }
 
       $size_formatted = null;
       if ($size) {
         $size_formatted = $this->renderAttr(
           $size,
-          ($size > self::MAX_INNODB_KEY_LENGTH));
+          $key->hasIssue($longkey_issue));
       }
 
       $key_rows[] = array(
         $this->renderIcon($status),
         phutil_tag(
           'a',
           array(
             'href' => $this->getApplicationURI(
               'database/'.
               $database_name.'/'.
               $table_name.'/'.
               'key/'.
               $key_name.'/'),
           ),
           $key_name),
         $this->renderAttr(
           implode(', ', $key->getColumnNames()),
           $key->hasIssue($columns_issue)),
         $this->renderAttr(
           $this->renderBoolean($key->getUnique()),
           $key->hasIssue($unique_issue)),
         $size_formatted,
       );
     }
 
     $keys_view = id(new AphrontTableView($key_rows))
       ->setHeaders(
         array(
           null,
           pht('Key'),
           pht('Columns'),
           pht('Unique'),
           pht('Size'),
         ))
       ->setColumnClasses(
         array(
           null,
           'wide pri',
           null,
           null,
           null,
         ));
 
     $title = pht('Database Status: %s.%s', $database_name, $table_name);
 
     if ($actual_table) {
       $actual_collation = $actual_table->getCollation();
     } else {
       $actual_collation = null;
     }
 
     if ($expect_table) {
       $expect_collation = $expect_table->getCollation();
     } else {
       $expect_collation = null;
     }
 
     $properties = $this->buildProperties(
       array(
         array(
           pht('Collation'),
           $actual_collation,
         ),
         array(
           pht('Expected Collation'),
           $expect_collation,
         ),
       ),
       $table->getIssues());
 
     $box = id(new PHUIObjectBoxView())
       ->setHeaderText($title)
       ->addPropertyList($properties)
       ->appendChild($table_view)
       ->appendChild($keys_view);
 
     return $this->buildResponse($title, $box);
   }
 
   private function renderColumn(
     PhabricatorConfigServerSchema $comp,
     PhabricatorConfigServerSchema $expect,
     PhabricatorConfigServerSchema $actual,
     $database_name,
     $table_name,
     $column_name) {
 
     $database = $comp->getDatabase($database_name);
     if (!$database) {
       return new Aphront404Response();
     }
 
     $table = $database->getTable($table_name);
     if (!$table) {
       return new Aphront404Response();
     }
 
     $column = $table->getColumn($column_name);
     if (!$column) {
       return new Aphront404Response();
     }
 
     $actual_database = $actual->getDatabase($database_name);
     $actual_table = null;
     $actual_column = null;
     if ($actual_database) {
       $actual_table = $actual_database->getTable($table_name);
       if ($actual_table) {
         $actual_column = $actual_table->getColumn($column_name);
       }
     }
 
     $expect_database = $expect->getDatabase($database_name);
     $expect_table = null;
     $expect_column = null;
     if ($expect_database) {
       $expect_table = $expect_database->getTable($table_name);
       if ($expect_table) {
         $expect_column = $expect_table->getColumn($column_name);
       }
     }
 
     if ($actual_column) {
       $actual_coltype = $actual_column->getColumnType();
       $actual_charset = $actual_column->getCharacterSet();
       $actual_collation = $actual_column->getCollation();
       $actual_nullable = $actual_column->getNullable();
     } else {
       $actual_coltype = null;
       $actual_charset = null;
       $actual_collation = null;
       $actual_nullable = null;
     }
 
     if ($expect_column) {
       $data_type = $expect_column->getDataType();
       $expect_coltype = $expect_column->getColumnType();
       $expect_charset = $expect_column->getCharacterSet();
       $expect_collation = $expect_column->getCollation();
       $expect_nullable = $expect_column->getNullable();
     } else {
       $data_type = null;
       $expect_coltype = null;
       $expect_charset = null;
       $expect_collation = null;
       $expect_nullable = null;
     }
 
 
     $title = pht(
       'Database Status: %s.%s.%s',
       $database_name,
       $table_name,
       $column_name);
 
     $properties = $this->buildProperties(
       array(
         array(
           pht('Data Type'),
           $data_type,
         ),
         array(
           pht('Column Type'),
           $actual_coltype,
         ),
         array(
           pht('Expected Column Type'),
           $expect_coltype,
         ),
         array(
           pht('Character Set'),
           $actual_charset,
         ),
         array(
           pht('Expected Character Set'),
           $expect_charset,
         ),
         array(
           pht('Collation'),
           $actual_collation,
         ),
         array(
           pht('Expected Collation'),
           $expect_collation,
         ),
         array(
           pht('Nullable'),
           $this->renderBoolean($actual_nullable),
         ),
         array(
           pht('Expected Nullable'),
           $this->renderBoolean($expect_nullable),
         ),
       ),
       $column->getIssues());
 
     $box = id(new PHUIObjectBoxView())
       ->setHeaderText($title)
       ->addPropertyList($properties);
 
     return $this->buildResponse($title, $box);
   }
 
   private function renderKey(
     PhabricatorConfigServerSchema $comp,
     PhabricatorConfigServerSchema $expect,
     PhabricatorConfigServerSchema $actual,
     $database_name,
     $table_name,
     $key_name) {
 
     $database = $comp->getDatabase($database_name);
     if (!$database) {
       return new Aphront404Response();
     }
 
     $table = $database->getTable($table_name);
     if (!$table) {
       return new Aphront404Response();
     }
 
     $key = $table->getKey($key_name);
     if (!$key) {
       return new Aphront404Response();
     }
 
     $actual_database = $actual->getDatabase($database_name);
     $actual_table = null;
     $actual_key = null;
     if ($actual_database) {
       $actual_table = $actual_database->getTable($table_name);
       if ($actual_table) {
         $actual_key = $actual_table->getKey($key_name);
       }
     }
 
     $expect_database = $expect->getDatabase($database_name);
     $expect_table = null;
     $expect_key = null;
     if ($expect_database) {
       $expect_table = $expect_database->getTable($table_name);
       if ($expect_table) {
         $expect_key = $expect_table->getKey($key_name);
       }
     }
 
     if ($actual_key) {
       $actual_columns = $actual_key->getColumnNames();
       $actual_unique = $actual_key->getUnique();
     } else {
       $actual_columns = array();
       $actual_unique = null;
     }
 
     if ($expect_key) {
       $expect_columns = $expect_key->getColumnNames();
       $expect_unique = $expect_key->getUnique();
     } else {
       $expect_columns = array();
       $expect_unique = null;
     }
 
     $title = pht(
       'Database Status: %s.%s (%s)',
       $database_name,
       $table_name,
       $key_name);
 
     $properties = $this->buildProperties(
       array(
         array(
           pht('Unique'),
           $this->renderBoolean($actual_unique),
         ),
         array(
           pht('Expected Unique'),
           $this->renderBoolean($expect_unique),
         ),
         array(
           pht('Columns'),
           implode(', ', $actual_columns),
         ),
         array(
           pht('Expected Columns'),
           implode(', ', $expect_columns),
         ),
       ),
       $key->getIssues());
 
     $box = id(new PHUIObjectBoxView())
       ->setHeaderText($title)
       ->addPropertyList($properties);
 
     return $this->buildResponse($title, $box);
   }
 
   private function buildProperties(array $properties, array $issues) {
     $view = id(new PHUIPropertyListView())
       ->setUser($this->getRequest()->getUser());
 
     foreach ($properties as $property) {
       list($key, $value) = $property;
       $view->addProperty($key, $value);
     }
 
     $status_view = new PHUIStatusListView();
     if (!$issues) {
       $status_view->addItem(
         id(new PHUIStatusItemView())
           ->setIcon(PHUIStatusItemView::ICON_ACCEPT, 'green')
           ->setTarget(pht('No Schema Issues')));
     } else {
       foreach ($issues as $issue) {
         $note = PhabricatorConfigStorageSchema::getIssueDescription($issue);
 
         $status = PhabricatorConfigStorageSchema::getIssueStatus($issue);
         switch ($status) {
           case PhabricatorConfigStorageSchema::STATUS_WARN:
             $icon = PHUIStatusItemView::ICON_WARNING;
             $color = 'yellow';
             break;
           case PhabricatorConfigStorageSchema::STATUS_FAIL:
           default:
             $icon = PHUIStatusItemView::ICON_REJECT;
             $color = 'red';
             break;
         }
 
         $item = id(new PHUIStatusItemView())
           ->setTarget(PhabricatorConfigStorageSchema::getIssueName($issue))
           ->setIcon($icon, $color)
           ->setNote($note);
 
         $status_view->addItem($item);
       }
     }
     $view->addProperty(pht('Schema Status'), $status_view);
 
     return $view;
   }
 
 }
diff --git a/src/applications/config/schema/PhabricatorConfigColumnSchema.php b/src/applications/config/schema/PhabricatorConfigColumnSchema.php
index 900ba1945f..ebb6f41707 100644
--- a/src/applications/config/schema/PhabricatorConfigColumnSchema.php
+++ b/src/applications/config/schema/PhabricatorConfigColumnSchema.php
@@ -1,142 +1,142 @@
 <?php
 
 final class PhabricatorConfigColumnSchema
   extends PhabricatorConfigStorageSchema {
 
   private $characterSet;
   private $collation;
   private $columnType;
   private $dataType;
   private $nullable;
 
   public function setNullable($nullable) {
     $this->nullable = $nullable;
     return $this;
   }
 
   public function getNullable() {
     return $this->nullable;
   }
 
   public function setColumnType($column_type) {
     $this->columnType = $column_type;
     return $this;
   }
 
   public function getColumnType() {
     return $this->columnType;
   }
 
   protected function getSubschemata() {
     return array();
   }
 
   public function setDataType($data_type) {
     $this->dataType = $data_type;
     return $this;
   }
 
   public function getDataType() {
     return $this->dataType;
   }
 
   public function setCollation($collation) {
     $this->collation = $collation;
     return $this;
   }
 
   public function getCollation() {
     return $this->collation;
   }
 
   public function setCharacterSet($character_set) {
     $this->characterSet = $character_set;
     return $this;
   }
 
   public function getCharacterSet() {
     return $this->characterSet;
   }
 
   public function getKeyByteLength($prefix = null) {
     $type = $this->getColumnType();
 
     $matches = null;
-    if (preg_match('/^varchar\((\d+)\)$/', $type, $matches)) {
+    if (preg_match('/^(?:var)?char\((\d+)\)$/', $type, $matches)) {
       // For utf8mb4, each character requires 4 bytes.
       $size = (int)$matches[1];
       if ($prefix && $prefix < $size) {
         $size = $prefix;
       }
       return $size * 4;
     }
 
     $matches = null;
-    if (preg_match('/^char\((\d+)\)$/', $type, $matches)) {
-      // We use char() only for fixed-length binary data, so its size
+    if (preg_match('/^(?:var)?binary\((\d+)\)$/', $type, $matches)) {
+      // binary()/varbinary() store fixed-length binary data, so their size
       // is always the column size.
       $size = (int)$matches[1];
       if ($prefix && $prefix < $size) {
         $size = $prefix;
       }
       return $size;
     }
 
     // The "long..." types are arbitrarily long, so just use a big number to
     // get the point across. In practice, these should always index only a
     // prefix.
     if ($type == 'longtext') {
       $size = (1 << 16);
       if ($prefix && $prefix < $size) {
         $size = $prefix;
       }
       return $size * 4;
     }
 
     if ($type == 'longblob') {
       $size = (1 << 16);
       if ($prefix && $prefix < $size) {
         $size = $prefix;
       }
       return $size * 1;
     }
 
     switch ($type) {
       case 'int(10) unsigned':
         return 4;
     }
 
     // TODO: Build this out to catch overlong indexes.
 
     return 0;
   }
 
   public function compareToSimilarSchema(
     PhabricatorConfigStorageSchema $expect) {
 
     $issues = array();
     if ($this->getCharacterSet() != $expect->getCharacterSet()) {
       $issues[] = self::ISSUE_CHARSET;
     }
 
     if ($this->getCollation() != $expect->getCollation()) {
       $issues[] = self::ISSUE_COLLATION;
     }
 
     if ($this->getColumnType() != $expect->getColumnType()) {
       $issues[] = self::ISSUE_COLUMNTYPE;
     }
 
     if ($this->getNullable() !== $expect->getNullable()) {
       $issues[] = self::ISSUE_NULLABLE;
     }
 
     return $issues;
   }
 
   public function newEmptyClone() {
     $clone = clone $this;
     return $clone;
   }
 
 }
diff --git a/src/applications/config/schema/PhabricatorConfigKeySchema.php b/src/applications/config/schema/PhabricatorConfigKeySchema.php
index 1e2cb4c654..5fe11842de 100644
--- a/src/applications/config/schema/PhabricatorConfigKeySchema.php
+++ b/src/applications/config/schema/PhabricatorConfigKeySchema.php
@@ -1,60 +1,114 @@
 <?php
 
 final class PhabricatorConfigKeySchema
   extends PhabricatorConfigStorageSchema {
 
+  const MAX_INNODB_KEY_LENGTH = 767;
+
   private $columnNames;
   private $unique;
+  private $table;
+  private $indexType;
+
+  public function setIndexType($index_type) {
+    $this->indexType = $index_type;
+    return $this;
+  }
+
+  public function getIndexType() {
+    return $this->indexType;
+  }
+
+  public function setProperty($property) {
+    $this->property = $property;
+    return $this;
+  }
+
+  public function getProperty() {
+    return $this->property;
+  }
 
   public function setUnique($unique) {
     $this->unique = $unique;
     return $this;
   }
 
   public function getUnique() {
     return $this->unique;
   }
 
+  public function setTable(PhabricatorConfigTableSchema $table) {
+    $this->table = $table;
+    return $this;
+  }
+
+  public function getTable() {
+    return $this->table;
+  }
+
   public function setColumnNames(array $column_names) {
     $this->columnNames = array_values($column_names);
     return $this;
   }
 
   public function getColumnNames() {
     return $this->columnNames;
   }
 
   protected function getSubschemata() {
     return array();
   }
 
   public function getKeyColumnAndPrefix($column_name) {
     $matches = null;
     if (preg_match('/^(.*)\((\d+)\)\z/', $column_name, $matches)) {
       return array($matches[1], (int)$matches[2]);
     } else {
       return array($column_name, null);
     }
   }
 
+  public function getKeyByteLength() {
+    $size = 0;
+    foreach ($this->getColumnNames() as $column_spec) {
+      list($column_name, $prefix) = $this->getKeyColumnAndPrefix($column_spec);
+      $column = $this->getTable()->getColumn($column_name);
+      if (!$column) {
+        $size = 0;
+        break;
+      }
+      $size += $column->getKeyByteLength($prefix);
+    }
+
+    return $size;
+  }
+
   public function compareToSimilarSchema(
     PhabricatorConfigStorageSchema $expect) {
 
     $issues = array();
     if ($this->getColumnNames() !== $expect->getColumnNames()) {
       $issues[] = self::ISSUE_KEYCOLUMNS;
     }
 
     if ($this->getUnique() !== $expect->getUnique()) {
       $issues[] = self::ISSUE_UNIQUE;
     }
 
+    // A fulltext index can be of any length.
+    if ($this->getIndexType() != 'FULLTEXT') {
+      if ($this->getKeyByteLength() > self::MAX_INNODB_KEY_LENGTH) {
+        $issues[] = self::ISSUE_LONGKEY;
+      }
+    }
+
     return $issues;
   }
 
   public function newEmptyClone() {
     $clone = clone $this;
+    $this->table = null;
     return $clone;
   }
 
 }
diff --git a/src/applications/config/schema/PhabricatorConfigSchemaQuery.php b/src/applications/config/schema/PhabricatorConfigSchemaQuery.php
index 1a84cf4778..9fba6e03be 100644
--- a/src/applications/config/schema/PhabricatorConfigSchemaQuery.php
+++ b/src/applications/config/schema/PhabricatorConfigSchemaQuery.php
@@ -1,297 +1,298 @@
 <?php
 
 final class PhabricatorConfigSchemaQuery extends Phobject {
 
   private $api;
 
   public function setAPI(PhabricatorStorageManagementAPI $api) {
     $this->api = $api;
     return $this;
   }
 
   protected function getAPI() {
     if (!$this->api) {
       throw new Exception(pht('Call setAPI() before issuing a query!'));
     }
     return $this->api;
   }
 
   protected function getConn() {
     return $this->getAPI()->getConn(null);
   }
 
   private function getDatabaseNames() {
     $api = $this->getAPI();
     $patches = PhabricatorSQLPatchList::buildAllPatches();
     return $api->getDatabaseList(
       $patches,
       $only_living = true);
   }
 
   public function loadActualSchema() {
     $databases = $this->getDatabaseNames();
 
     $conn = $this->getConn();
     $tables = queryfx_all(
       $conn,
       'SELECT TABLE_SCHEMA, TABLE_NAME, TABLE_COLLATION
         FROM INFORMATION_SCHEMA.TABLES
         WHERE TABLE_SCHEMA IN (%Ls)',
       $databases);
 
     $database_info = queryfx_all(
       $conn,
       'SELECT SCHEMA_NAME, DEFAULT_CHARACTER_SET_NAME, DEFAULT_COLLATION_NAME
         FROM INFORMATION_SCHEMA.SCHEMATA
         WHERE SCHEMA_NAME IN (%Ls)',
       $databases);
     $database_info = ipull($database_info, null, 'SCHEMA_NAME');
 
     $sql = array();
     foreach ($tables as $table) {
       $sql[] = qsprintf(
         $conn,
         '(TABLE_SCHEMA = %s AND TABLE_NAME = %s)',
         $table['TABLE_SCHEMA'],
         $table['TABLE_NAME']);
     }
 
     if ($sql) {
       $column_info = queryfx_all(
         $conn,
         'SELECT TABLE_SCHEMA, TABLE_NAME, COLUMN_NAME, CHARACTER_SET_NAME,
             COLLATION_NAME, COLUMN_TYPE, IS_NULLABLE
           FROM INFORMATION_SCHEMA.COLUMNS
           WHERE (%Q)',
         '('.implode(') OR (', $sql).')');
       $column_info = igroup($column_info, 'TABLE_SCHEMA');
     } else {
       $column_info = array();
     }
 
     // NOTE: Tables like KEY_COLUMN_USAGE and TABLE_CONSTRAINTS only contain
     // primary, unique, and foreign keys, so we can't use them here. We pull
     // indexes later on using SHOW INDEXES.
 
     $server_schema = new PhabricatorConfigServerSchema();
 
     $tables = igroup($tables, 'TABLE_SCHEMA');
     foreach ($tables as $database_name => $database_tables) {
       $info = $database_info[$database_name];
 
       $database_schema = id(new PhabricatorConfigDatabaseSchema())
         ->setName($database_name)
         ->setCharacterSet($info['DEFAULT_CHARACTER_SET_NAME'])
         ->setCollation($info['DEFAULT_COLLATION_NAME']);
 
       $database_column_info = idx($column_info, $database_name, array());
       $database_column_info = igroup($database_column_info, 'TABLE_NAME');
 
       foreach ($database_tables as $table) {
         $table_name = $table['TABLE_NAME'];
 
         $table_schema = id(new PhabricatorConfigTableSchema())
           ->setName($table_name)
           ->setCollation($table['TABLE_COLLATION']);
 
         $columns = idx($database_column_info, $table_name, array());
         foreach ($columns as $column) {
           $column_schema = id(new PhabricatorConfigColumnSchema())
             ->setName($column['COLUMN_NAME'])
             ->setCharacterSet($column['CHARACTER_SET_NAME'])
             ->setCollation($column['COLLATION_NAME'])
             ->setColumnType($column['COLUMN_TYPE'])
             ->setNullable($column['IS_NULLABLE'] == 'YES');
 
           $table_schema->addColumn($column_schema);
         }
 
         $key_parts = queryfx_all(
           $conn,
           'SHOW INDEXES FROM %T.%T',
           $database_name,
           $table_name);
         $keys = igroup($key_parts, 'Key_name');
         foreach ($keys as $key_name => $key_pieces) {
           $key_pieces = isort($key_pieces, 'Seq_in_index');
           $head = head($key_pieces);
 
           // This handles string indexes which index only a prefix of a field.
           $column_names = array();
           foreach ($key_pieces as $piece) {
             $name = $piece['Column_name'];
             if ($piece['Sub_part']) {
               $name = $name.'('.$piece['Sub_part'].')';
             }
             $column_names[] = $name;
           }
 
           $key_schema = id(new PhabricatorConfigKeySchema())
             ->setName($key_name)
             ->setColumnNames($column_names)
-            ->setUnique(!$head['Non_unique']);
+            ->setUnique(!$head['Non_unique'])
+            ->setIndexType($head['Index_type']);
 
           $table_schema->addKey($key_schema);
         }
 
         $database_schema->addTable($table_schema);
       }
 
       $server_schema->addDatabase($database_schema);
     }
 
     return $server_schema;
   }
 
   public function loadExpectedSchema() {
     $databases = $this->getDatabaseNames();
 
     $api = $this->getAPI();
 
     if ($api->isCharacterSetAvailable('utf8mb4')) {
       // If utf8mb4 is available, we use it with the utf8mb4_unicode_ci
       // collation. This is most correct, and will sort properly.
 
       $utf8_charset = 'utf8mb4';
       $utf8_collation = 'utf8mb4_unicode_ci';
     } else {
       // If utf8mb4 is not available, we use binary. This allows us to store
       // 4-byte unicode characters. This has some tradeoffs:
       //
       // Unicode characters won't sort correctly. There's nothing we can do
       // about this while still supporting 4-byte characters.
       //
       // It's possible that strings will be truncated in the middle of a
       // character on insert. We encourage users to set STRICT_ALL_TABLES
       // to prevent this.
 
       $utf8_charset = 'binary';
       $utf8_collation = 'binary';
     }
 
     $specs = id(new PhutilSymbolLoader())
       ->setAncestorClass('PhabricatorConfigSchemaSpec')
       ->loadObjects();
 
     $server_schema = new PhabricatorConfigServerSchema();
     foreach ($specs as $spec) {
       $spec
         ->setUTF8Collation($utf8_collation)
         ->setUTF8Charset($utf8_charset)
         ->setServer($server_schema)
         ->buildSchemata($server_schema);
     }
 
     return $server_schema;
   }
 
   public function buildComparisonSchema(
     PhabricatorConfigServerSchema $expect,
     PhabricatorConfigServerSchema $actual) {
 
     $comp_server = $actual->newEmptyClone();
 
     $all_databases = $actual->getDatabases() + $expect->getDatabases();
     foreach ($all_databases as $database_name => $database_template) {
       $actual_database = $actual->getDatabase($database_name);
       $expect_database = $expect->getDatabase($database_name);
 
       $issues = $this->compareSchemata($expect_database, $actual_database);
 
       $comp_database = $database_template->newEmptyClone()
         ->setIssues($issues);
 
       if (!$actual_database) {
         $actual_database = $expect_database->newEmptyClone();
       }
       if (!$expect_database) {
         $expect_database = $actual_database->newEmptyClone();
       }
 
       $all_tables =
         $actual_database->getTables() +
         $expect_database->getTables();
       foreach ($all_tables as $table_name => $table_template) {
         $actual_table = $actual_database->getTable($table_name);
         $expect_table = $expect_database->getTable($table_name);
 
         $issues = $this->compareSchemata($expect_table, $actual_table);
 
         $comp_table = $table_template->newEmptyClone()
           ->setIssues($issues);
 
         if (!$actual_table) {
           $actual_table = $expect_table->newEmptyClone();
         }
         if (!$expect_table) {
           $expect_table = $actual_table->newEmptyClone();
         }
 
         $all_columns =
           $actual_table->getColumns() +
           $expect_table->getColumns();
         foreach ($all_columns as $column_name => $column_template) {
           $actual_column = $actual_table->getColumn($column_name);
           $expect_column = $expect_table->getColumn($column_name);
 
           $issues = $this->compareSchemata($expect_column, $actual_column);
 
           $comp_column = $column_template->newEmptyClone()
             ->setIssues($issues);
 
           $comp_table->addColumn($comp_column);
         }
 
         $all_keys =
           $actual_table->getKeys() +
           $expect_table->getKeys();
         foreach ($all_keys as $key_name => $key_template) {
           $actual_key = $actual_table->getKey($key_name);
           $expect_key = $expect_table->getKey($key_name);
 
           $issues = $this->compareSchemata($expect_key, $actual_key);
 
           $comp_key = $key_template->newEmptyClone()
             ->setIssues($issues);
 
           $comp_table->addKey($comp_key);
         }
 
         $comp_database->addTable($comp_table);
       }
       $comp_server->addDatabase($comp_database);
     }
 
     return $comp_server;
   }
 
   private function compareSchemata(
     PhabricatorConfigStorageSchema $expect = null,
     PhabricatorConfigStorageSchema $actual = null) {
 
     $expect_is_key = ($expect instanceof PhabricatorConfigKeySchema);
     $actual_is_key = ($actual instanceof PhabricatorConfigKeySchema);
 
     if ($expect_is_key || $actual_is_key) {
       $missing_issue = PhabricatorConfigStorageSchema::ISSUE_MISSINGKEY;
       $surplus_issue = PhabricatorConfigStorageSchema::ISSUE_SURPLUSKEY;
     } else {
       $missing_issue = PhabricatorConfigStorageSchema::ISSUE_MISSING;
       $surplus_issue = PhabricatorConfigStorageSchema::ISSUE_SURPLUS;
     }
 
     if (!$expect && !$actual) {
       throw new Exception(pht('Can not compare two missing schemata!'));
     } else if ($expect && !$actual) {
       $issues = array($missing_issue);
     } else if ($actual && !$expect) {
       $issues = array($surplus_issue);
     } else {
       $issues = $actual->compareTo($expect);
     }
 
     return $issues;
   }
 
 
 }
diff --git a/src/applications/config/schema/PhabricatorConfigSchemaSpec.php b/src/applications/config/schema/PhabricatorConfigSchemaSpec.php
index 7c65240b89..9915db0f61 100644
--- a/src/applications/config/schema/PhabricatorConfigSchemaSpec.php
+++ b/src/applications/config/schema/PhabricatorConfigSchemaSpec.php
@@ -1,362 +1,363 @@
 <?php
 
 abstract class PhabricatorConfigSchemaSpec extends Phobject {
 
   private $server;
   private $utf8Charset;
   private $utf8Collation;
 
   public function setUTF8Collation($utf8_collation) {
     $this->utf8Collation = $utf8_collation;
     return $this;
   }
 
   public function getUTF8Collation() {
     return $this->utf8Collation;
   }
 
   public function setUTF8Charset($utf8_charset) {
     $this->utf8Charset = $utf8_charset;
     return $this;
   }
 
   public function getUTF8Charset() {
     return $this->utf8Charset;
   }
 
   public function setServer(PhabricatorConfigServerSchema $server) {
     $this->server = $server;
     return $this;
   }
 
   public function getServer() {
     return $this->server;
   }
 
   abstract public function buildSchemata();
 
   protected function buildLiskSchemata($base) {
 
     $objects = id(new PhutilSymbolLoader())
       ->setAncestorClass($base)
       ->loadObjects();
 
     foreach ($objects as $object) {
       if ($object->getConfigOption(LiskDAO::CONFIG_NO_TABLE)) {
         continue;
       }
       $this->buildLiskObjectSchema($object);
     }
   }
 
   protected function buildTransactionSchema(
     PhabricatorApplicationTransaction $xaction,
     PhabricatorApplicationTransactionComment $comment = null) {
 
     $this->buildLiskObjectSchema($xaction);
     if ($comment) {
       $this->buildLiskObjectSchema($comment);
     }
   }
 
   protected function buildCustomFieldSchemata(
     PhabricatorLiskDAO $storage,
     array $indexes) {
 
     $this->buildLiskObjectSchema($storage);
     foreach ($indexes as $index) {
       $this->buildLiskObjectSchema($index);
     }
   }
 
   private function buildLiskObjectSchema(PhabricatorLiskDAO $object) {
     $this->buildRawSchema(
       $object->getApplicationName(),
       $object->getTableName(),
       $object->getSchemaColumns(),
       $object->getSchemaKeys());
   }
 
   protected function buildRawSchema(
     $database_name,
     $table_name,
     array $columns,
     array $keys) {
     $database = $this->getDatabase($database_name);
 
     $table = $this->newTable($table_name);
 
     foreach ($columns as $name => $type) {
       if ($type === null) {
         continue;
       }
 
       $details = $this->getDetailsForDataType($type);
       list($column_type, $charset, $collation, $nullable) = $details;
 
       $column = $this->newColumn($name)
         ->setDataType($type)
         ->setColumnType($column_type)
         ->setCharacterSet($charset)
         ->setCollation($collation)
         ->setNullable($nullable);
 
       $table->addColumn($column);
     }
 
     foreach ($keys as $key_name => $key_spec) {
       if ($key_spec === null) {
         // This is a subclass removing a key which Lisk expects.
         continue;
       }
 
       $key = $this->newKey($key_name)
         ->setColumnNames(idx($key_spec, 'columns', array()));
 
       $key->setUnique((bool)idx($key_spec, 'unique'));
+      $key->setIndexType(idx($key_spec, 'type', 'BTREE'));
 
       $table->addKey($key);
     }
 
     $database->addTable($table);
   }
 
   protected function buildEdgeSchemata(PhabricatorLiskDAO $object) {
     $this->buildRawSchema(
       $object->getApplicationName(),
       PhabricatorEdgeConfig::TABLE_NAME_EDGE,
       array(
         'src' => 'phid',
         'type' => 'uint32',
         'dst' => 'phid',
         'dateCreated' => 'epoch',
         'seq' => 'uint32',
         'dataID' => 'id?',
       ),
       array(
         'PRIMARY' => array(
           'columns' => array('src', 'type', 'dst'),
           'unique' => true,
         ),
         'src' => array(
           'columns' => array('src', 'type', 'dateCreated', 'seq'),
         ),
         'key_dst' => array(
           'columns' => array('dst', 'type', 'src'),
           'unique' => true,
         ),
       ));
 
     $this->buildRawSchema(
       $object->getApplicationName(),
       PhabricatorEdgeConfig::TABLE_NAME_EDGEDATA,
       array(
         'id' => 'id',
         'data' => 'text',
       ),
       array(
         'PRIMARY' => array(
           'columns' => array('id'),
           'unique' => true,
         ),
       ));
   }
 
   public function buildCounterSchema(PhabricatorLiskDAO $object) {
     $this->buildRawSchema(
       $object->getApplicationName(),
       PhabricatorLiskDAO::COUNTER_TABLE_NAME,
       array(
         'counterName' => 'text32',
         'counterValue' => 'id64',
       ),
       array(
         'PRIMARY' => array(
           'columns' => array('counterName'),
           'unique' => true,
         ),
       ));
   }
 
   protected function getDatabase($name) {
     $server = $this->getServer();
 
     $database = $server->getDatabase($this->getNamespacedDatabase($name));
     if (!$database) {
       $database = $this->newDatabase($name);
       $server->addDatabase($database);
     }
 
     return $database;
   }
 
   protected function newDatabase($name) {
     return id(new PhabricatorConfigDatabaseSchema())
       ->setName($this->getNamespacedDatabase($name))
       ->setCharacterSet($this->getUTF8Charset())
       ->setCollation($this->getUTF8Collation());
   }
 
   protected function getNamespacedDatabase($name) {
     $namespace = PhabricatorLiskDAO::getStorageNamespace();
     return $namespace.'_'.$name;
   }
 
   protected function newTable($name) {
     return id(new PhabricatorConfigTableSchema())
       ->setName($name)
       ->setCollation($this->getUTF8Collation());
   }
 
   protected function newColumn($name) {
     return id(new PhabricatorConfigColumnSchema())
       ->setName($name);
   }
 
   protected function newKey($name) {
     return id(new PhabricatorConfigKeySchema())
       ->setName($name);
   }
 
   private function getDetailsForDataType($data_type) {
     $column_type = null;
     $charset = null;
     $collation = null;
 
     // If the type ends with "?", make the column nullable.
     $nullable = false;
     if (preg_match('/\?$/', $data_type)) {
       $nullable = true;
       $data_type = substr($data_type, 0, -1);
     }
 
     // NOTE: MySQL allows fragments like "VARCHAR(32) CHARACTER SET binary",
     // but just interprets that to mean "VARBINARY(32)". The fragment is
     // totally disallowed in a MODIFY statement vs a CREATE TABLE statement.
 
     switch ($data_type) {
       case 'id':
       case 'epoch':
       case 'uint32':
         $column_type = 'int(10) unsigned';
         break;
       case 'sint32':
         $column_type = 'int(10)';
         break;
       case 'id64':
       case 'uint64':
         $column_type = 'bigint(20) unsigned';
         break;
       case 'sint64':
         $column_type = 'bigint(20)';
         break;
       case 'phid':
       case 'policy';
         $column_type = 'varbinary(64)';
         break;
       case 'bytes64':
         $column_type = 'binary(64)';
         break;
       case 'bytes40':
         $column_type = 'binary(40)';
         break;
       case 'bytes32':
         $column_type = 'binary(32)';
         break;
       case 'bytes20':
         $column_type = 'binary(20)';
         break;
       case 'bytes12':
         $column_type = 'binary(12)';
         break;
       case 'bytes4':
         $column_type = 'binary(4)';
         break;
       case 'bytes':
         $column_type = 'longblob';
         break;
       case 'text255':
         $column_type = 'varchar(255)';
         $charset = $this->getUTF8Charset();
         $collation = $this->getUTF8Collation();
         break;
       case 'text160':
         $column_type = 'varchar(160)';
         $charset = $this->getUTF8Charset();
         $collation = $this->getUTF8Collation();
         break;
       case 'text128':
         $column_type = 'varchar(128)';
         $charset = $this->getUTF8Charset();
         $collation = $this->getUTF8Collation();
         break;
       case 'text80':
         $column_type = 'varchar(80)';
         $charset = $this->getUTF8Charset();
         $collation = $this->getUTF8Collation();
         break;
       case 'text64':
         $column_type = 'varchar(64)';
         $charset = $this->getUTF8Charset();
         $collation = $this->getUTF8Collation();
         break;
       case 'text40':
         $column_type = 'varchar(40)';
         $charset = $this->getUTF8Charset();
         $collation = $this->getUTF8Collation();
         break;
       case 'text32':
         $column_type = 'varchar(32)';
         $charset = $this->getUTF8Charset();
         $collation = $this->getUTF8Collation();
         break;
       case 'text20':
         $column_type = 'varchar(20)';
         $charset = $this->getUTF8Charset();
         $collation = $this->getUTF8Collation();
         break;
       case 'text16':
         $column_type = 'varchar(16)';
         $charset = $this->getUTF8Charset();
         $collation = $this->getUTF8Collation();
         break;
       case 'text12':
         $column_type = 'varchar(12)';
         $charset = $this->getUTF8Charset();
         $collation = $this->getUTF8Collation();
         break;
       case 'text8':
         $column_type = 'varchar(8)';
         $charset = $this->getUTF8Charset();
         $collation = $this->getUTF8Collation();
         break;
       case 'text4':
         $column_type = 'varchar(4)';
         $charset = $this->getUTF8Charset();
         $collation = $this->getUTF8Collation();
         break;
       case 'text':
         $column_type = 'longtext';
         $charset = $this->getUTF8Charset();
         $collation = $this->getUTF8Collation();
         break;
       case 'bool':
         $column_type = 'tinyint(1)';
         break;
       case 'double':
         $column_type = 'double';
         break;
       case 'date':
         $column_type = 'date';
         break;
       default:
         $column_type = pht('<unknown>');
         $charset = pht('<unknown>');
         $collation = pht('<unknown>');
         break;
     }
 
     return array($column_type, $charset, $collation, $nullable);
   }
 
 }
diff --git a/src/applications/config/schema/PhabricatorConfigStorageSchema.php b/src/applications/config/schema/PhabricatorConfigStorageSchema.php
index 367b67f962..849a4157e8 100644
--- a/src/applications/config/schema/PhabricatorConfigStorageSchema.php
+++ b/src/applications/config/schema/PhabricatorConfigStorageSchema.php
@@ -1,206 +1,212 @@
 <?php
 
 abstract class PhabricatorConfigStorageSchema extends Phobject {
 
   const ISSUE_MISSING = 'missing';
   const ISSUE_MISSINGKEY = 'missingkey';
   const ISSUE_SURPLUS = 'surplus';
   const ISSUE_SURPLUSKEY = 'surpluskey';
   const ISSUE_CHARSET = 'charset';
   const ISSUE_COLLATION = 'collation';
   const ISSUE_COLUMNTYPE = 'columntype';
   const ISSUE_NULLABLE = 'nullable';
   const ISSUE_KEYCOLUMNS = 'keycolumns';
   const ISSUE_UNIQUE = 'unique';
+  const ISSUE_LONGKEY = 'longkey';
   const ISSUE_SUBWARN = 'subwarn';
   const ISSUE_SUBFAIL = 'subfail';
 
   const STATUS_OKAY = 'okay';
   const STATUS_WARN = 'warn';
   const STATUS_FAIL = 'fail';
 
   private $issues = array();
   private $name;
 
   abstract public function newEmptyClone();
   abstract protected function compareToSimilarSchema(
     PhabricatorConfigStorageSchema $expect);
   abstract protected function getSubschemata();
 
   public function compareTo(PhabricatorConfigStorageSchema $expect) {
     if (get_class($expect) != get_class($this)) {
       throw new Exception(pht('Classes must match to compare schemata!'));
     }
 
     if ($this->getName() != $expect->getName()) {
       throw new Exception(pht('Names must match to compare schemata!'));
     }
 
     return $this->compareToSimilarSchema($expect);
   }
 
   public function setName($name) {
     $this->name = $name;
     return $this;
   }
 
   public function getName() {
     return $this->name;
   }
 
   public function setIssues(array $issues) {
     $this->issues = array_fuse($issues);
     return $this;
   }
 
   public function getIssues() {
     $issues = $this->issues;
 
     foreach ($this->getSubschemata() as $sub) {
       switch ($sub->getStatus()) {
         case self::STATUS_WARN:
           $issues[self::ISSUE_SUBWARN] = self::ISSUE_SUBWARN;
           break;
         case self::STATUS_FAIL:
           $issues[self::ISSUE_SUBFAIL] = self::ISSUE_SUBFAIL;
           break;
       }
     }
 
     return $issues;
   }
 
   public function getLocalIssues() {
     return $this->issues;
   }
 
   public function hasIssue($issue) {
     return (bool)idx($this->getIssues(), $issue);
   }
 
   public function getAllIssues() {
     $issues = $this->getIssues();
     foreach ($this->getSubschemata() as $sub) {
       $issues += $sub->getAllIssues();
     }
     return $issues;
   }
 
   public function getStatus() {
     $status = self::STATUS_OKAY;
     foreach ($this->getAllIssues() as $issue) {
       $issue_status = self::getIssueStatus($issue);
       $status = self::getStrongestStatus($status, $issue_status);
     }
     return $status;
   }
 
   public static function getIssueName($issue) {
     switch ($issue) {
       case self::ISSUE_MISSING:
         return pht('Missing');
       case self::ISSUE_MISSINGKEY:
         return pht('Missing Key');
       case self::ISSUE_SURPLUS:
         return pht('Surplus');
       case self::ISSUE_SURPLUSKEY:
         return pht('Surplus Key');
       case self::ISSUE_CHARSET:
         return pht('Better Character Set Available');
       case self::ISSUE_COLLATION:
         return pht('Better Collation Available');
       case self::ISSUE_COLUMNTYPE:
         return pht('Wrong Column Type');
       case self::ISSUE_NULLABLE:
         return pht('Wrong Nullable Setting');
       case self::ISSUE_KEYCOLUMNS:
         return pht('Key on Wrong Columns');
       case self::ISSUE_UNIQUE:
         return pht('Key has Wrong Uniqueness');
+      case self::ISSUE_LONGKEY:
+        return pht('Key is Too Long');
       case self::ISSUE_SUBWARN:
         return pht('Subschemata Have Warnings');
       case self::ISSUE_SUBFAIL:
         return pht('Subschemata Have Failures');
       default:
         throw new Exception(pht('Unknown schema issue "%s"!', $issue));
     }
   }
 
   public static function getIssueDescription($issue) {
     switch ($issue) {
       case self::ISSUE_MISSING:
         return pht('This schema is expected to exist, but does not.');
       case self::ISSUE_MISSINGKEY:
         return pht('This key is expected to exist, but does not.');
       case self::ISSUE_SURPLUS:
         return pht('This schema is not expected to exist.');
       case self::ISSUE_SURPLUSKEY:
         return pht('This key is not expected to exist.');
       case self::ISSUE_CHARSET:
         return pht('This schema can use a better character set.');
       case self::ISSUE_COLLATION:
         return pht('This schema can use a better collation.');
       case self::ISSUE_COLUMNTYPE:
         return pht('This schema can use a better column type.');
       case self::ISSUE_NULLABLE:
         return pht('This schema has the wrong nullable setting.');
       case self::ISSUE_KEYCOLUMNS:
-        return pht('This schema is on the wrong columns.');
+        return pht('This key is on the wrong columns.');
       case self::ISSUE_UNIQUE:
         return pht('This key has the wrong uniqueness setting.');
+      case self::ISSUE_LONGKEY:
+        return pht('This key is too long for utf8mb4.');
       case self::ISSUE_SUBWARN:
         return pht('Subschemata have setup warnings.');
       case self::ISSUE_SUBFAIL:
         return pht('Subschemata have setup failures.');
       default:
         throw new Exception(pht('Unknown schema issue "%s"!', $issue));
     }
   }
 
   public static function getIssueStatus($issue) {
     switch ($issue) {
       case self::ISSUE_MISSING:
       case self::ISSUE_SURPLUS:
       case self::ISSUE_NULLABLE:
       case self::ISSUE_SUBFAIL:
         return self::STATUS_FAIL;
       case self::ISSUE_SUBWARN:
       case self::ISSUE_COLUMNTYPE:
       case self::ISSUE_CHARSET:
       case self::ISSUE_COLLATION:
       case self::ISSUE_MISSINGKEY:
       case self::ISSUE_SURPLUSKEY:
       case self::ISSUE_UNIQUE:
       case self::ISSUE_KEYCOLUMNS:
+      case self::ISSUE_LONGKEY:
         return self::STATUS_WARN;
       default:
         throw new Exception(pht('Unknown schema issue "%s"!', $issue));
     }
   }
 
   public static function getStatusSeverity($status) {
     switch ($status) {
       case self::STATUS_FAIL:
         return 2;
       case self::STATUS_WARN:
         return 1;
       case self::STATUS_OKAY:
         return 0;
       default:
         throw new Exception(pht('Unknown schema status "%s"!', $status));
     }
   }
 
   public static function getStrongestStatus($u, $v) {
     $u_sev = self::getStatusSeverity($u);
     $v_sev = self::getStatusSeverity($v);
 
     if ($u_sev >= $v_sev) {
       return $u;
     } else {
       return $v;
     }
   }
 
 
 }
diff --git a/src/applications/config/schema/PhabricatorConfigTableSchema.php b/src/applications/config/schema/PhabricatorConfigTableSchema.php
index 81c23d68c3..c7b0888705 100644
--- a/src/applications/config/schema/PhabricatorConfigTableSchema.php
+++ b/src/applications/config/schema/PhabricatorConfigTableSchema.php
@@ -1,77 +1,83 @@
 <?php
 
 final class PhabricatorConfigTableSchema
   extends PhabricatorConfigStorageSchema {
 
   private $collation;
   private $columns = array();
   private $keys = array();
 
   public function addColumn(PhabricatorConfigColumnSchema $column) {
     $key = $column->getName();
     if (isset($this->columns[$key])) {
       throw new Exception(
         pht('Trying to add duplicate column "%s"!', $key));
     }
     $this->columns[$key] = $column;
     return $this;
   }
 
   public function addKey(PhabricatorConfigKeySchema $key) {
     $name = $key->getName();
     if (isset($this->keys[$name])) {
       throw new Exception(
         pht('Trying to add duplicate key "%s"!', $name));
     }
+    $key->setTable($this);
     $this->keys[$name] = $key;
     return $this;
   }
 
   public function getColumns() {
     return $this->columns;
   }
 
   public function getColumn($key) {
     return idx($this->getColumns(), $key);
   }
 
   public function getKeys() {
     return $this->keys;
   }
 
   public function getKey($key) {
     return idx($this->getKeys(), $key);
   }
 
   protected function getSubschemata() {
-    return array_merge($this->getColumns(), $this->getKeys());
+    // NOTE: Keys and columns may have the same name, so make sure we return
+    // everything.
+
+    return array_merge(
+      array_values($this->columns),
+      array_values($this->keys));
   }
 
   public function setCollation($collation) {
     $this->collation = $collation;
     return $this;
   }
 
   public function getCollation() {
     return $this->collation;
   }
 
   public function compareToSimilarSchema(
     PhabricatorConfigStorageSchema $expect) {
 
     $issues = array();
     if ($this->getCollation() != $expect->getCollation()) {
       $issues[] = self::ISSUE_COLLATION;
     }
 
     return $issues;
   }
 
   public function newEmptyClone() {
     $clone = clone $this;
     $clone->columns = array();
     $clone->keys = array();
     return $clone;
   }
 
 }
diff --git a/src/applications/differential/storage/DifferentialDiffProperty.php b/src/applications/differential/storage/DifferentialDiffProperty.php
index a7286bfec1..bdd8153a1f 100644
--- a/src/applications/differential/storage/DifferentialDiffProperty.php
+++ b/src/applications/differential/storage/DifferentialDiffProperty.php
@@ -1,26 +1,26 @@
 <?php
 
 final class DifferentialDiffProperty extends DifferentialDAO {
 
   protected $diffID;
   protected $name;
   protected $data;
 
   protected function getConfiguration() {
     return array(
       self::CONFIG_SERIALIZATION => array(
         'data' => self::SERIALIZATION_JSON,
       ),
       self::CONFIG_COLUMN_SCHEMA => array(
-        'name' => 'text255',
+        'name' => 'text128',
       ),
       self::CONFIG_KEY_SCHEMA => array(
         'diffID' => array(
           'columns' => array('diffID', 'name'),
           'unique' => true,
         ),
       ),
     ) + parent::getConfiguration();
   }
 
 }
diff --git a/src/applications/diviner/storage/DivinerLiveSymbol.php b/src/applications/diviner/storage/DivinerLiveSymbol.php
index 3ab7216dbf..3281b50140 100644
--- a/src/applications/diviner/storage/DivinerLiveSymbol.php
+++ b/src/applications/diviner/storage/DivinerLiveSymbol.php
@@ -1,245 +1,245 @@
 <?php
 
 final class DivinerLiveSymbol extends DivinerDAO
   implements PhabricatorPolicyInterface, PhabricatorMarkupInterface {
 
   protected $bookPHID;
   protected $context;
   protected $type;
   protected $name;
   protected $atomIndex;
   protected $graphHash;
   protected $identityHash;
   protected $nodeHash;
 
   protected $title;
   protected $titleSlugHash;
   protected $groupName;
   protected $summary;
   protected $isDocumentable = 0;
 
   private $book = self::ATTACHABLE;
   private $atom = self::ATTACHABLE;
   private $extends = self::ATTACHABLE;
   private $children = self::ATTACHABLE;
 
   public function getConfiguration() {
     return array(
       self::CONFIG_AUX_PHID => true,
       self::CONFIG_TIMESTAMPS => false,
       self::CONFIG_COLUMN_SCHEMA => array(
         'context' => 'text255?',
         'type' => 'text32',
         'name' => 'text255',
         'atomIndex' => 'uint32',
         'identityHash' => 'bytes12',
         'graphHash' => 'bytes64?',
         'title' => 'text?',
         'titleSlugHash' => 'bytes12?',
         'groupName' => 'text255?',
         'summary' => 'text?',
         'isDocumentable' => 'bool',
         'nodeHash' => 'bytes64?',
       ),
       self::CONFIG_KEY_SCHEMA => array(
         'key_phid' => null,
         'identityHash' => array(
           'columns' => array('identityHash'),
           'unique' => true,
         ),
         'phid' => array(
           'columns' => array('phid'),
           'unique' => true,
         ),
         'graphHash' => array(
           'columns' => array('graphHash'),
           'unique' => true,
         ),
         'nodeHash' => array(
           'columns' => array('nodeHash'),
           'unique' => true,
         ),
         'bookPHID' => array(
           'columns' => array(
             'bookPHID',
             'type',
             'name(64)',
             'context(64)',
             'atomIndex',
           ),
         ),
         'name' => array(
-          'columns' => array('name'),
+          'columns' => array('name(64)'),
         ),
         'key_slug' => array(
           'columns' => array('titleSlugHash'),
         ),
       ),
     ) + parent::getConfiguration();
   }
 
   public function generatePHID() {
     return PhabricatorPHID::generateNewPHID(DivinerAtomPHIDType::TYPECONST);
   }
 
   public function getBook() {
     return $this->assertAttached($this->book);
   }
 
   public function attachBook(DivinerLiveBook $book) {
     $this->book = $book;
     return $this;
   }
 
   public function getAtom() {
     return $this->assertAttached($this->atom);
   }
 
   public function attachAtom(DivinerLiveAtom $atom) {
     $this->atom = DivinerAtom::newFromDictionary($atom->getAtomData());
     return $this;
   }
 
   public function getURI() {
     $parts = array(
       'book',
       $this->getBook()->getName(),
       $this->getType(),
     );
 
     if ($this->getContext()) {
       $parts[] = $this->getContext();
     }
 
     $parts[] = $this->getName();
 
     if ($this->getAtomIndex()) {
       $parts[] = $this->getAtomIndex();
     }
 
     return '/'.implode('/', $parts).'/';
   }
 
   public function getSortKey() {
     // Sort articles before other types of content. Then, sort atoms in a
     // case-insensitive way.
     return sprintf(
       '%c:%s',
       ($this->getType() == DivinerAtom::TYPE_ARTICLE ? '0' : '1'),
       phutil_utf8_strtolower($this->getTitle()));
   }
 
   public function save() {
 
     // NOTE: The identity hash is just a sanity check because the unique tuple
     // on this table is way way too long to fit into a normal UNIQUE KEY. We
     // don't use it directly, but its existence prevents duplicate records.
 
     if (!$this->identityHash) {
       $this->identityHash = PhabricatorHash::digestForIndex(
         serialize(
           array(
             'bookPHID' => $this->getBookPHID(),
             'context'  => $this->getContext(),
             'type'     => $this->getType(),
             'name'     => $this->getName(),
             'index'    => $this->getAtomIndex(),
           )));
     }
 
     return parent::save();
   }
 
   public function getTitle() {
     $title = parent::getTitle();
     if (!strlen($title)) {
       $title = $this->getName();
     }
     return $title;
   }
 
   public function setTitle($value) {
     $this->writeField('title', $value);
     if (strlen($value)) {
       $slug = DivinerAtomRef::normalizeTitleString($value);
       $hash = PhabricatorHash::digestForIndex($slug);
       $this->titleSlugHash = $hash;
     } else {
       $this->titleSlugHash = null;
     }
     return $this;
   }
 
   public function attachExtends(array $extends) {
     assert_instances_of($extends, 'DivinerLiveSymbol');
     $this->extends = $extends;
     return $this;
   }
 
   public function getExtends() {
     return $this->assertAttached($this->extends);
   }
 
   public function attachChildren(array $children) {
     assert_instances_of($children, 'DivinerLiveSymbol');
     $this->children = $children;
     return $this;
   }
 
   public function getChildren() {
     return $this->assertAttached($this->children);
   }
 
 
 /* -(  PhabricatorPolicyInterface  )----------------------------------------- */
 
   public function getCapabilities() {
     return $this->getBook()->getCapabilities();
   }
 
 
   public function getPolicy($capability) {
     return $this->getBook()->getPolicy($capability);
   }
 
 
   public function hasAutomaticCapability($capability, PhabricatorUser $viewer) {
     return $this->getBook()->hasAutomaticCapability($capability, $viewer);
   }
 
   public function describeAutomaticCapability($capability) {
     return pht('Atoms inherit the policies of the books they are part of.');
   }
 
 
 /* -(  Markup Interface  )--------------------------------------------------- */
 
 
   public function getMarkupFieldKey($field) {
     return $this->getPHID().':'.$field.':'.$this->getGraphHash();
   }
 
 
   public function newMarkupEngine($field) {
     return PhabricatorMarkupEngine::getEngine('diviner');
   }
 
 
   public function getMarkupText($field) {
     return $this->getAtom()->getDocblockText();
   }
 
 
   public function didMarkupText(
     $field,
     $output,
     PhutilMarkupEngine $engine) {
     return $output;
   }
 
 
   public function shouldUseMarkupCache($field) {
     return true;
   }
 
 }
diff --git a/src/applications/files/storage/PhabricatorTransformedFile.php b/src/applications/files/storage/PhabricatorTransformedFile.php
index 5b0f0e2f1d..e4e2c86dc5 100644
--- a/src/applications/files/storage/PhabricatorTransformedFile.php
+++ b/src/applications/files/storage/PhabricatorTransformedFile.php
@@ -1,26 +1,26 @@
 <?php
 
 final class PhabricatorTransformedFile extends PhabricatorFileDAO {
 
   protected $originalPHID;
   protected $transform;
   protected $transformedPHID;
 
   public function getConfiguration() {
     return array(
       self::CONFIG_COLUMN_SCHEMA => array(
-        'transform' => 'text255',
+        'transform' => 'text128',
       ),
       self::CONFIG_KEY_SCHEMA => array(
         'originalPHID' => array(
           'columns' => array('originalPHID', 'transform'),
           'unique' => true,
         ),
         'transformedPHID' => array(
           'columns' => array('transformedPHID'),
         ),
       ),
     ) + parent::getConfiguration();
   }
 
 }
diff --git a/src/applications/herald/controller/HeraldRuleController.php b/src/applications/herald/controller/HeraldRuleController.php
index b3be8ae643..e103daeffe 100644
--- a/src/applications/herald/controller/HeraldRuleController.php
+++ b/src/applications/herald/controller/HeraldRuleController.php
@@ -1,668 +1,661 @@
 <?php
 
 final class HeraldRuleController extends HeraldController {
 
   private $id;
   private $filter;
 
   public function willProcessRequest(array $data) {
     $this->id = (int)idx($data, 'id');
   }
 
   public function processRequest() {
     $request = $this->getRequest();
     $user = $request->getUser();
 
     $content_type_map = HeraldAdapter::getEnabledAdapterMap($user);
     $rule_type_map = HeraldRuleTypeConfig::getRuleTypeMap();
 
     if ($this->id) {
       $id = $this->id;
       $rule = id(new HeraldRuleQuery())
         ->setViewer($user)
         ->withIDs(array($id))
         ->requireCapabilities(
           array(
             PhabricatorPolicyCapability::CAN_VIEW,
             PhabricatorPolicyCapability::CAN_EDIT,
           ))
         ->executeOne();
       if (!$rule) {
         return new Aphront404Response();
       }
       $cancel_uri = $this->getApplicationURI("rule/{$id}/");
     } else {
       $rule = new HeraldRule();
       $rule->setAuthorPHID($user->getPHID());
       $rule->setMustMatchAll(1);
 
       $content_type = $request->getStr('content_type');
       $rule->setContentType($content_type);
 
       $rule_type = $request->getStr('rule_type');
       if (!isset($rule_type_map[$rule_type])) {
         $rule_type = HeraldRuleTypeConfig::RULE_TYPE_PERSONAL;
       }
       $rule->setRuleType($rule_type);
 
       $adapter = HeraldAdapter::getAdapterForContentType(
         $rule->getContentType());
 
       if (!$adapter->supportsRuleType($rule->getRuleType())) {
         throw new Exception(
           pht(
             "This rule's content type does not support the selected rule ".
             "type."));
       }
 
       if ($rule->isObjectRule()) {
         $rule->setTriggerObjectPHID($request->getStr('targetPHID'));
         $object = id(new PhabricatorObjectQuery())
           ->setViewer($user)
           ->withPHIDs(array($rule->getTriggerObjectPHID()))
           ->requireCapabilities(
             array(
               PhabricatorPolicyCapability::CAN_VIEW,
               PhabricatorPolicyCapability::CAN_EDIT,
             ))
           ->executeOne();
         if (!$object) {
           throw new Exception(
             pht('No valid object provided for object rule!'));
         }
 
         if (!$adapter->canTriggerOnObject($object)) {
           throw new Exception(
             pht('Object is of wrong type for adapter!'));
         }
       }
 
       $cancel_uri = $this->getApplicationURI();
     }
 
     if ($rule->isGlobalRule()) {
       $this->requireApplicationCapability(
         HeraldManageGlobalRulesCapability::CAPABILITY);
     }
 
     $adapter = HeraldAdapter::getAdapterForContentType($rule->getContentType());
 
     $local_version = id(new HeraldRule())->getConfigVersion();
     if ($rule->getConfigVersion() > $local_version) {
       throw new Exception(
         pht(
           'This rule was created with a newer version of Herald. You can not '.
           'view or edit it in this older version. Upgrade your Phabricator '.
           'deployment.'));
     }
 
     // Upgrade rule version to our version, since we might add newly-defined
     // conditions, etc.
     $rule->setConfigVersion($local_version);
 
     $rule_conditions = $rule->loadConditions();
     $rule_actions = $rule->loadActions();
 
     $rule->attachConditions($rule_conditions);
     $rule->attachActions($rule_actions);
 
     $e_name = true;
     $errors = array();
     if ($request->isFormPost() && $request->getStr('save')) {
       list($e_name, $errors) = $this->saveRule($adapter, $rule, $request);
       if (!$errors) {
         $id = $rule->getID();
         $uri = $this->getApplicationURI("rule/{$id}/");
         return id(new AphrontRedirectResponse())->setURI($uri);
       }
     }
 
     $must_match_selector = $this->renderMustMatchSelector($rule);
     $repetition_selector = $this->renderRepetitionSelector($rule, $adapter);
 
     $handles = $this->loadHandlesForRule($rule);
 
     require_celerity_resource('herald-css');
 
     $content_type_name = $content_type_map[$rule->getContentType()];
     $rule_type_name = $rule_type_map[$rule->getRuleType()];
 
     $form = id(new AphrontFormView())
       ->setUser($user)
       ->setID('herald-rule-edit-form')
       ->addHiddenInput('content_type', $rule->getContentType())
       ->addHiddenInput('rule_type', $rule->getRuleType())
       ->addHiddenInput('save', 1)
       ->appendChild(
         // Build this explicitly (instead of using addHiddenInput())
         // so we can add a sigil to it.
         javelin_tag(
           'input',
           array(
             'type'  => 'hidden',
             'name'  => 'rule',
             'sigil' => 'rule',
           )))
       ->appendChild(
         id(new AphrontFormTextControl())
           ->setLabel(pht('Rule Name'))
           ->setName('name')
           ->setError($e_name)
           ->setValue($rule->getName()));
 
     $trigger_object_control = false;
     if ($rule->isObjectRule()) {
       $trigger_object_control = id(new AphrontFormStaticControl())
         ->setValue(
           pht(
             'This rule triggers for %s.',
             $handles[$rule->getTriggerObjectPHID()]->renderLink()));
     }
 
 
     $form
       ->appendChild(
         id(new AphrontFormMarkupControl())
           ->setValue(pht(
             'This %s rule triggers for %s.',
             phutil_tag('strong', array(), $rule_type_name),
             phutil_tag('strong', array(), $content_type_name))))
       ->appendChild($trigger_object_control)
       ->appendChild(
         id(new AphrontFormInsetView())
           ->setTitle(pht('Conditions'))
           ->setRightButton(javelin_tag(
             'a',
             array(
               'href' => '#',
               'class' => 'button green',
               'sigil' => 'create-condition',
               'mustcapture' => true
             ),
             pht('New Condition')))
           ->setDescription(
             pht('When %s these conditions are met:', $must_match_selector))
           ->setContent(javelin_tag(
             'table',
             array(
               'sigil' => 'rule-conditions',
               'class' => 'herald-condition-table'
             ),
             '')))
       ->appendChild(
         id(new AphrontFormInsetView())
           ->setTitle(pht('Action'))
           ->setRightButton(javelin_tag(
             'a',
             array(
               'href' => '#',
               'class' => 'button green',
               'sigil' => 'create-action',
               'mustcapture' => true,
             ),
             pht('New Action')))
           ->setDescription(pht(
             'Take these actions %s this rule matches:',
             $repetition_selector))
           ->setContent(javelin_tag(
               'table',
               array(
                 'sigil' => 'rule-actions',
                 'class' => 'herald-action-table',
               ),
               '')))
       ->appendChild(
         id(new AphrontFormSubmitControl())
           ->setValue(pht('Save Rule'))
           ->addCancelButton($cancel_uri));
 
     $this->setupEditorBehavior($rule, $handles, $adapter);
 
     $title = $rule->getID()
         ? pht('Edit Herald Rule')
         : pht('Create Herald Rule');
 
     $form_box = id(new PHUIObjectBoxView())
       ->setHeaderText($title)
       ->setFormErrors($errors)
       ->setForm($form);
 
     $crumbs = $this
       ->buildApplicationCrumbs()
       ->addTextCrumb($title);
 
     return $this->buildApplicationPage(
       array(
         $crumbs,
         $form_box,
       ),
       array(
         'title' => pht('Edit Rule'),
       ));
   }
 
   private function saveRule(HeraldAdapter $adapter, $rule, $request) {
     $rule->setName($request->getStr('name'));
     $match_all = ($request->getStr('must_match') == 'all');
     $rule->setMustMatchAll((int)$match_all);
 
     $repetition_policy_param = $request->getStr('repetition_policy');
     $rule->setRepetitionPolicy(
       HeraldRepetitionPolicyConfig::toInt($repetition_policy_param));
 
     $e_name = true;
     $errors = array();
 
     if (!strlen($rule->getName())) {
       $e_name = pht('Required');
       $errors[] = pht('Rule must have a name.');
     }
 
     $data = json_decode($request->getStr('rule'), true);
     if (!is_array($data) ||
         !$data['conditions'] ||
         !$data['actions']) {
       throw new Exception('Failed to decode rule data.');
     }
 
     $conditions = array();
     foreach ($data['conditions'] as $condition) {
       if ($condition === null) {
         // We manage this as a sparse array on the client, so may receive
         // NULL if conditions have been removed.
         continue;
       }
 
       $obj = new HeraldCondition();
       $obj->setFieldName($condition[0]);
       $obj->setFieldCondition($condition[1]);
 
       if (is_array($condition[2])) {
         $obj->setValue(array_keys($condition[2]));
       } else {
         $obj->setValue($condition[2]);
       }
 
       try {
         $adapter->willSaveCondition($obj);
       } catch (HeraldInvalidConditionException $ex) {
         $errors[] = $ex->getMessage();
       }
 
       $conditions[] = $obj;
     }
 
     $actions = array();
     foreach ($data['actions'] as $action) {
       if ($action === null) {
         // Sparse on the client; removals can give us NULLs.
         continue;
       }
 
       if (!isset($action[1])) {
         // Legitimate for any action which doesn't need a target, like
         // "Do nothing".
         $action[1] = null;
       }
 
       $obj = new HeraldAction();
       $obj->setAction($action[0]);
       $obj->setTarget($action[1]);
 
       try {
         $adapter->willSaveAction($rule, $obj);
       } catch (HeraldInvalidActionException $ex) {
         $errors[] = $ex;
       }
 
       $actions[] = $obj;
     }
 
     $rule->attachConditions($conditions);
     $rule->attachActions($actions);
 
     if (!$errors) {
-      try {
-
-        $edit_action = $rule->getID() ? 'edit' : 'create';
-
-        $rule->openTransaction();
-          $rule->save();
-          $rule->saveConditions($conditions);
-          $rule->saveActions($actions);
-          $rule->logEdit($request->getUser()->getPHID(), $edit_action);
-        $rule->saveTransaction();
-
-      } catch (AphrontDuplicateKeyQueryException $ex) {
-        $e_name = pht('Not Unique');
-        $errors[] = pht('Rule name is not unique. Choose a unique name.');
-      }
+      $edit_action = $rule->getID() ? 'edit' : 'create';
+
+      $rule->openTransaction();
+        $rule->save();
+        $rule->saveConditions($conditions);
+        $rule->saveActions($actions);
+        $rule->logEdit($request->getUser()->getPHID(), $edit_action);
+      $rule->saveTransaction();
     }
 
     return array($e_name, $errors);
   }
 
   private function setupEditorBehavior(
     HeraldRule $rule,
     array $handles,
     HeraldAdapter $adapter) {
 
     $serial_conditions = array(
       array('default', 'default', ''),
     );
 
     if ($rule->getConditions()) {
       $serial_conditions = array();
       foreach ($rule->getConditions() as $condition) {
 
         $value = $condition->getValue();
         switch ($condition->getFieldName()) {
           case HeraldAdapter::FIELD_TASK_PRIORITY:
             $value_map = array();
             $priority_map = ManiphestTaskPriority::getTaskPriorityMap();
             foreach ($value as $priority) {
               $value_map[$priority] = idx($priority_map, $priority);
             }
             $value = $value_map;
             break;
           default:
             if (is_array($value)) {
               $value_map = array();
               foreach ($value as $k => $fbid) {
                 $value_map[$fbid] = $handles[$fbid]->getName();
               }
               $value = $value_map;
             }
             break;
         }
         $serial_conditions[] = array(
           $condition->getFieldName(),
           $condition->getFieldCondition(),
           $value,
         );
       }
     }
 
     $serial_actions = array(
       array('default', ''),
     );
     if ($rule->getActions()) {
       $serial_actions = array();
       foreach ($rule->getActions() as $action) {
 
         switch ($action->getAction()) {
           case HeraldAdapter::ACTION_FLAG:
           case HeraldAdapter::ACTION_BLOCK:
             $current_value = $action->getTarget();
             break;
           default:
             if (is_array($action->getTarget())) {
               $target_map = array();
               foreach ((array)$action->getTarget() as $fbid) {
                 $target_map[$fbid] = $handles[$fbid]->getName();
               }
               $current_value = $target_map;
             } else {
               $current_value = $action->getTarget();
             }
             break;
         }
 
         $serial_actions[] = array(
           $action->getAction(),
           $current_value,
         );
       }
     }
 
     $all_rules = $this->loadRulesThisRuleMayDependUpon($rule);
     $all_rules = mpull($all_rules, 'getName', 'getPHID');
     asort($all_rules);
 
     $all_fields = $adapter->getFieldNameMap();
     $all_conditions = $adapter->getConditionNameMap();
     $all_actions = $adapter->getActionNameMap($rule->getRuleType());
 
     $fields = $adapter->getFields();
     $field_map = array_select_keys($all_fields, $fields);
 
     // Populate any fields which exist in the rule but which we don't know the
     // names of, so that saving a rule without touching anything doesn't change
     // it.
     foreach ($rule->getConditions() as $condition) {
       if (empty($field_map[$condition->getFieldName()])) {
         $field_map[$condition->getFieldName()] = pht('<Unknown Field>');
       }
     }
 
     $actions = $adapter->getActions($rule->getRuleType());
     $action_map = array_select_keys($all_actions, $actions);
 
     $config_info = array();
     $config_info['fields'] = $field_map;
     $config_info['conditions'] = $all_conditions;
     $config_info['actions'] = $action_map;
 
     foreach ($config_info['fields'] as $field => $name) {
       $field_conditions = $adapter->getConditionsForField($field);
       $config_info['conditionMap'][$field] = $field_conditions;
     }
 
     foreach ($config_info['fields'] as $field => $fname) {
       foreach ($config_info['conditionMap'][$field] as $condition) {
         $value_type = $adapter->getValueTypeForFieldAndCondition(
           $field,
           $condition);
         $config_info['values'][$field][$condition] = $value_type;
       }
     }
 
     $config_info['rule_type'] = $rule->getRuleType();
 
     foreach ($config_info['actions'] as $action => $name) {
       $config_info['targets'][$action] = $adapter->getValueTypeForAction(
         $action,
        $rule->getRuleType());
     }
 
     $changeflag_options =
       PhabricatorRepositoryPushLog::getHeraldChangeFlagConditionOptions();
     Javelin::initBehavior(
       'herald-rule-editor',
       array(
         'root' => 'herald-rule-edit-form',
         'conditions' => (object)$serial_conditions,
         'actions' => (object)$serial_actions,
         'select' => array(
           HeraldAdapter::VALUE_CONTENT_SOURCE => array(
             'options' => PhabricatorContentSource::getSourceNameMap(),
             'default' => PhabricatorContentSource::SOURCE_WEB,
           ),
           HeraldAdapter::VALUE_FLAG_COLOR => array(
             'options' => PhabricatorFlagColor::getColorNameMap(),
             'default' => PhabricatorFlagColor::COLOR_BLUE,
           ),
           HeraldPreCommitRefAdapter::VALUE_REF_TYPE => array(
             'options' => array(
               PhabricatorRepositoryPushLog::REFTYPE_BRANCH
                 => pht('branch (git/hg)'),
               PhabricatorRepositoryPushLog::REFTYPE_TAG
                 => pht('tag (git)'),
               PhabricatorRepositoryPushLog::REFTYPE_BOOKMARK
                 => pht('bookmark (hg)'),
             ),
             'default' => PhabricatorRepositoryPushLog::REFTYPE_BRANCH,
           ),
           HeraldPreCommitRefAdapter::VALUE_REF_CHANGE => array(
             'options' => $changeflag_options,
             'default' => PhabricatorRepositoryPushLog::CHANGEFLAG_ADD,
           ),
         ),
         'template' => $this->buildTokenizerTemplates($handles) + array(
           'rules' => $all_rules,
         ),
         'author' => array($rule->getAuthorPHID() =>
                           $handles[$rule->getAuthorPHID()]->getName()),
         'info' => $config_info,
       ));
   }
 
   private function loadHandlesForRule($rule) {
     $phids = array();
 
     foreach ($rule->getActions() as $action) {
       if (!is_array($action->getTarget())) {
         continue;
       }
       foreach ($action->getTarget() as $target) {
         $target = (array)$target;
         foreach ($target as $phid) {
           $phids[] = $phid;
         }
       }
     }
 
     foreach ($rule->getConditions() as $condition) {
       $value = $condition->getValue();
       if (is_array($value)) {
         foreach ($value as $phid) {
           $phids[] = $phid;
         }
       }
     }
 
     $phids[] = $rule->getAuthorPHID();
 
     if ($rule->isObjectRule()) {
       $phids[] = $rule->getTriggerObjectPHID();
     }
 
     return $this->loadViewerHandles($phids);
   }
 
 
   /**
    * Render the selector for the "When (all of | any of) these conditions are
    * met:" element.
    */
   private function renderMustMatchSelector($rule) {
     return AphrontFormSelectControl::renderSelectTag(
       $rule->getMustMatchAll() ? 'all' : 'any',
       array(
         'all' => pht('all of'),
         'any' => pht('any of'),
       ),
       array(
         'name' => 'must_match',
       ));
   }
 
 
   /**
    * Render the selector for "Take these actions (every time | only the first
    * time) this rule matches..." element.
    */
   private function renderRepetitionSelector($rule, HeraldAdapter $adapter) {
     $repetition_policy = HeraldRepetitionPolicyConfig::toString(
       $rule->getRepetitionPolicy());
 
     $repetition_options = $adapter->getRepetitionOptions();
     $repetition_names = HeraldRepetitionPolicyConfig::getMap();
     $repetition_map = array_select_keys($repetition_names, $repetition_options);
 
     if (count($repetition_map) < 2) {
       return head($repetition_names);
     } else {
       return AphrontFormSelectControl::renderSelectTag(
         $repetition_policy,
         $repetition_map,
         array(
           'name' => 'repetition_policy',
         ));
     }
   }
 
 
   protected function buildTokenizerTemplates(array $handles) {
     $template = new AphrontTokenizerTemplateView();
     $template = $template->render();
 
     $sources = array(
       'repository' => new DiffusionRepositoryDatasource(),
       'legaldocuments' => new LegalpadDocumentDatasource(),
       'taskpriority' => new ManiphestTaskPriorityDatasource(),
       'buildplan' => new HarbormasterBuildPlanDatasource(),
       'arcanistprojects' => new DiffusionArcanistProjectDatasource(),
       'package' => new PhabricatorOwnersPackageDatasource(),
       'project' => new PhabricatorProjectDatasource(),
       'user' => new PhabricatorPeopleDatasource(),
       'email' => new PhabricatorMetaMTAMailableDatasource(),
       'userorproject' => new PhabricatorProjectOrUserDatasource(),
     );
 
     foreach ($sources as $key => $source) {
       $sources[$key] = array(
         'uri' => $source->getDatasourceURI(),
         'placeholder' => $source->getPlaceholderText(),
       );
     }
 
     return array(
       'source' => $sources,
       'username' => $this->getRequest()->getUser()->getUserName(),
       'icons' => mpull($handles, 'getTypeIcon', 'getPHID'),
       'markup' => $template,
     );
   }
 
 
   /**
    * Load rules for the "Another Herald rule..." condition dropdown, which
    * allows one rule to depend upon the success or failure of another rule.
    */
   private function loadRulesThisRuleMayDependUpon(HeraldRule $rule) {
     $viewer = $this->getRequest()->getUser();
 
     // Any rule can depend on a global rule.
     $all_rules = id(new HeraldRuleQuery())
       ->setViewer($viewer)
       ->withRuleTypes(array(HeraldRuleTypeConfig::RULE_TYPE_GLOBAL))
       ->withContentTypes(array($rule->getContentType()))
       ->execute();
 
     if ($rule->isObjectRule()) {
       // Object rules may depend on other rules for the same object.
       $all_rules += id(new HeraldRuleQuery())
         ->setViewer($viewer)
         ->withRuleTypes(array(HeraldRuleTypeConfig::RULE_TYPE_OBJECT))
         ->withContentTypes(array($rule->getContentType()))
         ->withTriggerObjectPHIDs(array($rule->getTriggerObjectPHID()))
         ->execute();
     }
 
     if ($rule->isPersonalRule()) {
       // Personal rules may depend upon your other personal rules.
       $all_rules += id(new HeraldRuleQuery())
         ->setViewer($viewer)
         ->withRuleTypes(array(HeraldRuleTypeConfig::RULE_TYPE_PERSONAL))
         ->withContentTypes(array($rule->getContentType()))
         ->withAuthorPHIDs(array($rule->getAuthorPHID()))
         ->execute();
     }
 
     // mark disabled rules as disabled since they are not useful as such;
     // don't filter though to keep edit cases sane / expected
     foreach ($all_rules as $current_rule) {
       if ($current_rule->getIsDisabled()) {
         $current_rule->makeEphemeral();
         $current_rule->setName($rule->getName().' '.pht('(Disabled)'));
       }
     }
 
     // A rule can not depend upon itself.
     unset($all_rules[$rule->getID()]);
 
     return $all_rules;
   }
 
 }
diff --git a/src/applications/herald/storage/HeraldRule.php b/src/applications/herald/storage/HeraldRule.php
index 938edfb707..7dda0b0729 100644
--- a/src/applications/herald/storage/HeraldRule.php
+++ b/src/applications/herald/storage/HeraldRule.php
@@ -1,295 +1,289 @@
 <?php
 
 final class HeraldRule extends HeraldDAO
   implements
     PhabricatorFlaggableInterface,
     PhabricatorPolicyInterface,
     PhabricatorDestructibleInterface {
 
   const TABLE_RULE_APPLIED = 'herald_ruleapplied';
 
   protected $name;
   protected $authorPHID;
 
   protected $contentType;
   protected $mustMatchAll;
   protected $repetitionPolicy;
   protected $ruleType;
   protected $isDisabled = 0;
   protected $triggerObjectPHID;
 
   protected $configVersion = 37;
 
   // PHIDs for which this rule has been applied
   private $ruleApplied = self::ATTACHABLE;
   private $validAuthor = self::ATTACHABLE;
   private $author = self::ATTACHABLE;
   private $conditions;
   private $actions;
   private $triggerObject = self::ATTACHABLE;
 
   public function getConfiguration() {
     return array(
       self::CONFIG_AUX_PHID => true,
       self::CONFIG_COLUMN_SCHEMA => array(
         'name' => 'text255',
         'contentType' => 'text255',
         'mustMatchAll' => 'bool',
         'configVersion' => 'uint32',
-        'ruleType' => 'text255',
+        'ruleType' => 'text32',
         'isDisabled' => 'uint32',
         'triggerObjectPHID' => 'phid?',
 
         // T6203/NULLABILITY
         // This should not be nullable.
         'repetitionPolicy' => 'uint32?',
       ),
       self::CONFIG_KEY_SCHEMA => array(
-        'key_phid' => null,
-        'phid' => array(
-          'columns' => array('phid'),
-          'unique' => true,
+        'key_author' => array(
+          'columns' => array('authorPHID'),
         ),
-        'authorPHID' => array(
-          'columns' => array('authorPHID', 'name'),
-          'unique' => true,
-        ),
-        'IDX_RULE_TYPE' => array(
+        'key_ruletype' => array(
           'columns' => array('ruleType'),
         ),
         'key_trigger' => array(
           'columns' => array('triggerObjectPHID'),
         ),
       ),
     ) + parent::getConfiguration();
   }
 
   public function generatePHID() {
     return PhabricatorPHID::generateNewPHID(HeraldRulePHIDType::TYPECONST);
   }
 
   public function getRuleApplied($phid) {
     return $this->assertAttachedKey($this->ruleApplied, $phid);
   }
 
   public function setRuleApplied($phid, $applied) {
     if ($this->ruleApplied === self::ATTACHABLE) {
       $this->ruleApplied = array();
     }
     $this->ruleApplied[$phid] = $applied;
     return $this;
   }
 
   public function loadConditions() {
     if (!$this->getID()) {
       return array();
     }
     return id(new HeraldCondition())->loadAllWhere(
       'ruleID = %d',
       $this->getID());
   }
 
   public function attachConditions(array $conditions) {
     assert_instances_of($conditions, 'HeraldCondition');
     $this->conditions = $conditions;
     return $this;
   }
 
   public function getConditions() {
     // TODO: validate conditions have been attached.
     return $this->conditions;
   }
 
   public function loadActions() {
     if (!$this->getID()) {
       return array();
     }
     return id(new HeraldAction())->loadAllWhere(
       'ruleID = %d',
       $this->getID());
   }
 
   public function attachActions(array $actions) {
     // TODO: validate actions have been attached.
     assert_instances_of($actions, 'HeraldAction');
     $this->actions = $actions;
     return $this;
   }
 
   public function getActions() {
     return $this->actions;
   }
 
   public function loadEdits() {
     if (!$this->getID()) {
       return array();
     }
     $edits = id(new HeraldRuleEdit())->loadAllWhere(
       'ruleID = %d ORDER BY dateCreated DESC',
       $this->getID());
 
     return $edits;
   }
 
   public function logEdit($editor_phid, $action) {
     id(new HeraldRuleEdit())
       ->setRuleID($this->getID())
       ->setRuleName($this->getName())
       ->setEditorPHID($editor_phid)
       ->setAction($action)
       ->save();
   }
 
   public function saveConditions(array $conditions) {
     assert_instances_of($conditions, 'HeraldCondition');
     return $this->saveChildren(
       id(new HeraldCondition())->getTableName(),
       $conditions);
   }
 
   public function saveActions(array $actions) {
     assert_instances_of($actions, 'HeraldAction');
     return $this->saveChildren(
       id(new HeraldAction())->getTableName(),
       $actions);
   }
 
   protected function saveChildren($table_name, array $children) {
     assert_instances_of($children, 'HeraldDAO');
 
     if (!$this->getID()) {
       throw new Exception('Save rule before saving children.');
     }
 
     foreach ($children as $child) {
       $child->setRuleID($this->getID());
     }
 
     $this->openTransaction();
       queryfx(
         $this->establishConnection('w'),
         'DELETE FROM %T WHERE ruleID = %d',
         $table_name,
         $this->getID());
       foreach ($children as $child) {
         $child->save();
       }
     $this->saveTransaction();
   }
 
   public function delete() {
     $this->openTransaction();
       queryfx(
         $this->establishConnection('w'),
         'DELETE FROM %T WHERE ruleID = %d',
         id(new HeraldCondition())->getTableName(),
         $this->getID());
       queryfx(
         $this->establishConnection('w'),
         'DELETE FROM %T WHERE ruleID = %d',
         id(new HeraldAction())->getTableName(),
         $this->getID());
       $result = parent::delete();
     $this->saveTransaction();
 
     return $result;
   }
 
   public function hasValidAuthor() {
     return $this->assertAttached($this->validAuthor);
   }
 
   public function attachValidAuthor($valid) {
     $this->validAuthor = $valid;
     return $this;
   }
 
   public function getAuthor() {
     return $this->assertAttached($this->author);
   }
 
   public function attachAuthor(PhabricatorUser $user) {
     $this->author = $user;
     return $this;
   }
 
   public function isGlobalRule() {
     return ($this->getRuleType() === HeraldRuleTypeConfig::RULE_TYPE_GLOBAL);
   }
 
   public function isPersonalRule() {
     return ($this->getRuleType() === HeraldRuleTypeConfig::RULE_TYPE_PERSONAL);
   }
 
   public function isObjectRule() {
     return ($this->getRuleType() == HeraldRuleTypeConfig::RULE_TYPE_OBJECT);
   }
 
   public function attachTriggerObject($trigger_object) {
     $this->triggerObject = $trigger_object;
     return $this;
   }
 
   public function getTriggerObject() {
     return $this->assertAttached($this->triggerObject);
   }
 
 
 /* -(  PhabricatorPolicyInterface  )----------------------------------------- */
 
 
   public function getCapabilities() {
     return array(
       PhabricatorPolicyCapability::CAN_VIEW,
       PhabricatorPolicyCapability::CAN_EDIT,
     );
   }
 
   public function getPolicy($capability) {
     if ($this->isGlobalRule()) {
       switch ($capability) {
         case PhabricatorPolicyCapability::CAN_VIEW:
           return PhabricatorPolicies::POLICY_USER;
         case PhabricatorPolicyCapability::CAN_EDIT:
           $app = 'PhabricatorHeraldApplication';
           $herald = PhabricatorApplication::getByClass($app);
           $global = HeraldManageGlobalRulesCapability::CAPABILITY;
           return $herald->getPolicy($global);
       }
     } else if ($this->isObjectRule()) {
       return $this->getTriggerObject()->getPolicy($capability);
     } else {
       return PhabricatorPolicies::POLICY_NOONE;
     }
   }
 
   public function hasAutomaticCapability($capability, PhabricatorUser $viewer) {
     if ($this->isPersonalRule()) {
       return ($viewer->getPHID() == $this->getAuthorPHID());
     } else {
       return false;
     }
   }
 
   public function describeAutomaticCapability($capability) {
     if ($this->isPersonalRule()) {
       return pht("A personal rule's owner can always view and edit it.");
     } else if ($this->isObjectRule()) {
       return pht('Object rules inherit the policies of their objects.');
     }
 
     return null;
   }
 
 
 /* -(  PhabricatorDestructibleInterface  )----------------------------------- */
 
   public function destroyObjectPermanently(
     PhabricatorDestructionEngine $engine) {
 
     $this->openTransaction();
     $this->delete();
     $this->saveTransaction();
   }
 
 }
diff --git a/src/applications/herald/storage/transcript/HeraldTranscript.php b/src/applications/herald/storage/transcript/HeraldTranscript.php
index cafae6a424..749bbf633a 100644
--- a/src/applications/herald/storage/transcript/HeraldTranscript.php
+++ b/src/applications/herald/storage/transcript/HeraldTranscript.php
@@ -1,233 +1,234 @@
 <?php
 
 final class HeraldTranscript extends HeraldDAO
   implements
     PhabricatorPolicyInterface,
     PhabricatorDestructibleInterface {
 
   protected $objectTranscript;
   protected $ruleTranscripts = array();
   protected $conditionTranscripts = array();
   protected $applyTranscripts = array();
 
   protected $time;
   protected $host;
   protected $duration;
 
   protected $objectPHID;
   protected $dryRun;
   protected $garbageCollected = 0;
 
   const TABLE_SAVED_HEADER = 'herald_savedheader';
 
   public function getXHeraldRulesHeader() {
     $ids = array();
     foreach ($this->applyTranscripts as $xscript) {
       if ($xscript->getApplied()) {
         if ($xscript->getRuleID()) {
           $ids[] = $xscript->getRuleID();
         }
       }
     }
     if (!$ids) {
       return 'none';
     }
 
     // A rule may have multiple effects, which will cause it to be listed
     // multiple times.
     $ids = array_unique($ids);
 
     foreach ($ids as $k => $id) {
       $ids[$k] = '<'.$id.'>';
     }
 
     return implode(', ', $ids);
   }
 
   public static function saveXHeraldRulesHeader($phid, $header) {
 
     // Combine any existing header with the new header, listing all rules
     // which have ever triggered for this object.
     $header = self::combineXHeraldRulesHeaders(
       self::loadXHeraldRulesHeader($phid),
       $header);
 
     queryfx(
       id(new HeraldTranscript())->establishConnection('w'),
       'INSERT INTO %T (phid, header) VALUES (%s, %s)
         ON DUPLICATE KEY UPDATE header = VALUES(header)',
       self::TABLE_SAVED_HEADER,
       $phid,
       $header);
 
     return $header;
   }
 
   private static function combineXHeraldRulesHeaders($u, $v) {
     $u = preg_split('/[, ]+/', $u);
     $v = preg_split('/[, ]+/', $v);
 
     $combined = array_unique(array_filter(array_merge($u, $v)));
     return implode(', ', $combined);
   }
 
   public static function loadXHeraldRulesHeader($phid) {
     $header = queryfx_one(
       id(new HeraldTranscript())->establishConnection('r'),
       'SELECT * FROM %T WHERE phid = %s',
       self::TABLE_SAVED_HEADER,
       $phid);
     if ($header) {
       return idx($header, 'header');
     }
     return null;
   }
 
 
   protected function getConfiguration() {
     // Ugh. Too much of a mess to deal with.
     return array(
       self::CONFIG_AUX_PHID     => true,
       self::CONFIG_TIMESTAMPS   => false,
       self::CONFIG_SERIALIZATION => array(
         'objectTranscript'      => self::SERIALIZATION_PHP,
         'ruleTranscripts'       => self::SERIALIZATION_PHP,
         'conditionTranscripts'  => self::SERIALIZATION_PHP,
         'applyTranscripts'      => self::SERIALIZATION_PHP,
       ),
       self::CONFIG_BINARY => array(
         'objectTranscript'      => true,
         'ruleTranscripts'       => true,
         'conditionTranscripts'  => true,
         'applyTranscripts'      => true,
       ),
       self::CONFIG_COLUMN_SCHEMA => array(
         'time' => 'epoch',
         'host' => 'text255',
         'duration' => 'double',
         'dryRun' => 'bool',
+        'garbageCollected' => 'bool',
       ),
       self::CONFIG_KEY_SCHEMA => array(
         'key_phid' => null,
         'phid' => array(
           'columns' => array('phid'),
           'unique' => true,
         ),
         'objectPHID' => array(
           'columns' => array('objectPHID'),
         ),
         'garbageCollected' => array(
           'columns' => array('garbageCollected', 'time'),
         ),
       ),
     ) + parent::getConfiguration();
   }
 
   public function __construct() {
     $this->time = time();
     $this->host = php_uname('n');
   }
 
   public function addApplyTranscript(HeraldApplyTranscript $transcript) {
     $this->applyTranscripts[] = $transcript;
     return $this;
   }
 
   public function getApplyTranscripts() {
     return nonempty($this->applyTranscripts, array());
   }
 
   public function setDuration($duration) {
     $this->duration = $duration;
     return $this;
   }
 
   public function setObjectTranscript(HeraldObjectTranscript $transcript) {
     $this->objectTranscript = $transcript;
     return $this;
   }
 
   public function getObjectTranscript() {
     return $this->objectTranscript;
   }
 
   public function addRuleTranscript(HeraldRuleTranscript $transcript) {
     $this->ruleTranscripts[$transcript->getRuleID()] = $transcript;
     return $this;
   }
 
   public function discardDetails() {
     $this->applyTranscripts = null;
     $this->ruleTranscripts = null;
     $this->objectTranscript = null;
     $this->conditionTranscripts = null;
   }
 
   public function getRuleTranscripts() {
     return nonempty($this->ruleTranscripts, array());
   }
 
   public function addConditionTranscript(
     HeraldConditionTranscript $transcript) {
     $rule_id = $transcript->getRuleID();
     $cond_id = $transcript->getConditionID();
 
     $this->conditionTranscripts[$rule_id][$cond_id] = $transcript;
     return $this;
   }
 
   public function getConditionTranscriptsForRule($rule_id) {
     return idx($this->conditionTranscripts, $rule_id, array());
   }
 
   public function getMetadataMap() {
     return array(
       'Run At Epoch' => date('F jS, g:i:s A', $this->time),
       'Run On Host'  => $this->host,
       'Run Duration' => (int)(1000 * $this->duration).' ms',
     );
   }
 
   public function generatePHID() {
     return PhabricatorPHID::generateNewPHID('HLXS');
   }
 
 /* -(  PhabricatorPolicyInterface  )----------------------------------------- */
 
   public function getCapabilities() {
     return array(
       PhabricatorPolicyCapability::CAN_VIEW,
     );
   }
 
   public function getPolicy($capability) {
     switch ($capability) {
       case PhabricatorPolicyCapability::CAN_VIEW:
         return PhabricatorPolicies::POLICY_USER;
     }
   }
 
   public function hasAutomaticCapability($capability, PhabricatorUser $viewer) {
     return false;
   }
 
   public function describeAutomaticCapability($capability) {
     return pht(
       'To view a transcript, you must be able to view the object the '.
       'transcript is about.');
   }
 
 
 /* -(  PhabricatorDestructibleInterface  )----------------------------------- */
 
 
   public function destroyObjectPermanently(
     PhabricatorDestructionEngine $engine) {
 
     $this->openTransaction();
       $this->delete();
     $this->saveTransaction();
   }
 
 
 }
diff --git a/src/applications/macro/storage/PhabricatorFileImageMacro.php b/src/applications/macro/storage/PhabricatorFileImageMacro.php
index 61f0000779..f5122dd687 100644
--- a/src/applications/macro/storage/PhabricatorFileImageMacro.php
+++ b/src/applications/macro/storage/PhabricatorFileImageMacro.php
@@ -1,136 +1,136 @@
 <?php
 
 final class PhabricatorFileImageMacro extends PhabricatorFileDAO
   implements
     PhabricatorSubscribableInterface,
     PhabricatorApplicationTransactionInterface,
     PhabricatorFlaggableInterface,
     PhabricatorPolicyInterface {
 
   protected $authorPHID;
   protected $filePHID;
   protected $name;
   protected $isDisabled = 0;
   protected $audioPHID;
   protected $audioBehavior = self::AUDIO_BEHAVIOR_NONE;
   protected $mailKey;
 
   private $file = self::ATTACHABLE;
   private $audio = self::ATTACHABLE;
 
   const AUDIO_BEHAVIOR_NONE   = 'audio:none';
   const AUDIO_BEHAVIOR_ONCE   = 'audio:once';
   const AUDIO_BEHAVIOR_LOOP   = 'audio:loop';
 
   public function attachFile(PhabricatorFile $file) {
     $this->file = $file;
     return $this;
   }
 
   public function getFile() {
     return $this->assertAttached($this->file);
   }
 
   public function attachAudio(PhabricatorFile $audio = null) {
     $this->audio = $audio;
     return $this;
   }
 
   public function getAudio() {
     return $this->assertAttached($this->audio);
   }
 
   public function getConfiguration() {
     return array(
       self::CONFIG_AUX_PHID  => true,
       self::CONFIG_COLUMN_SCHEMA => array(
-        'name' => 'text255',
+        'name' => 'text128',
         'authorPHID' => 'phid?',
         'isDisabled' => 'bool',
         'audioPHID' => 'phid?',
         'audioBehavior' => 'text64',
         'mailKey' => 'bytes20',
       ),
       self::CONFIG_KEY_SCHEMA => array(
         'name' => array(
           'columns' => array('name'),
           'unique' => true,
         ),
         'key_disabled' => array(
           'columns' => array('isDisabled'),
         ),
         'key_dateCreated' => array(
           'columns' => array('dateCreated'),
         ),
       ),
     ) + parent::getConfiguration();
   }
 
   public function generatePHID() {
     return PhabricatorPHID::generateNewPHID(
       PhabricatorMacroMacroPHIDType::TYPECONST);
   }
 
 
   public function save() {
     if (!$this->getMailKey()) {
       $this->setMailKey(Filesystem::readRandomCharacters(20));
     }
     return parent::save();
   }
 
 
 /* -(  PhabricatorApplicationTransactionInterface  )------------------------- */
 
 
   public function getApplicationTransactionEditor() {
     return new PhabricatorMacroEditor();
   }
 
   public function getApplicationTransactionObject() {
     return $this;
   }
 
   public function getApplicationTransactionTemplate() {
     return new PhabricatorMacroTransaction();
   }
 
 
 /* -(  PhabricatorSubscribableInterface  )----------------------------------- */
 
 
   public function isAutomaticallySubscribed($phid) {
     return false;
   }
 
   public function shouldShowSubscribersProperty() {
     return true;
   }
 
   public function shouldAllowSubscription($phid) {
     return true;
   }
 
 
 /* -(  PhabricatorPolicyInterface  )----------------------------------------- */
 
 
   public function getCapabilities() {
     return array(
       PhabricatorPolicyCapability::CAN_VIEW,
     );
   }
 
   public function getPolicy($capability) {
     return PhabricatorPolicies::getMostOpenPolicy();
   }
 
   public function hasAutomaticCapability($capability, PhabricatorUser $viewer) {
     return false;
   }
 
   public function describeAutomaticCapability($capability) {
     return null;
   }
 
 }
diff --git a/src/applications/mailinglists/storage/PhabricatorMetaMTAMailingList.php b/src/applications/mailinglists/storage/PhabricatorMetaMTAMailingList.php
index b2607e4848..70e758715e 100644
--- a/src/applications/mailinglists/storage/PhabricatorMetaMTAMailingList.php
+++ b/src/applications/mailinglists/storage/PhabricatorMetaMTAMailingList.php
@@ -1,77 +1,77 @@
 <?php
 
 final class PhabricatorMetaMTAMailingList extends PhabricatorMetaMTADAO
   implements
     PhabricatorPolicyInterface,
     PhabricatorDestructibleInterface {
 
   protected $name;
   protected $email;
   protected $uri;
 
   public function generatePHID() {
     return PhabricatorPHID::generateNewPHID(
       PhabricatorMailingListListPHIDType::TYPECONST);
   }
 
   public function getConfiguration() {
     return array(
       self::CONFIG_AUX_PHID => true,
       self::CONFIG_COLUMN_SCHEMA => array(
-        'name' => 'text255',
-        'email' => 'text255',
+        'name' => 'text128',
+        'email' => 'text128',
         'uri' => 'text255?',
       ),
       self::CONFIG_KEY_SCHEMA => array(
         'key_phid' => null,
         'phid' => array(
           'columns' => array('phid'),
           'unique' => true,
         ),
         'email' => array(
           'columns' => array('email'),
           'unique' => true,
         ),
         'name' => array(
           'columns' => array('name'),
           'unique' => true,
         ),
       ),
     ) + parent::getConfiguration();
   }
 
 
 /* -(  PhabricatorPolicyInterface  )----------------------------------------- */
 
 
   public function getCapabilities() {
     return array(
       PhabricatorPolicyCapability::CAN_VIEW,
     );
   }
 
   public function getPolicy($capability) {
     return PhabricatorPolicies::POLICY_USER;
   }
 
   public function hasAutomaticCapability($capability, PhabricatorUser $viewer) {
     return false;
   }
 
   public function describeAutomaticCapability($capability) {
     return null;
   }
 
 
 /* -(  PhabricatorDestructibleInterface  )----------------------------------- */
 
 
   public function destroyObjectPermanently(
     PhabricatorDestructionEngine $engine) {
 
     $this->openTransaction();
     $this->delete();
     $this->saveTransaction();
   }
 
 }
diff --git a/src/applications/metamta/storage/PhabricatorMetaMTAMail.php b/src/applications/metamta/storage/PhabricatorMetaMTAMail.php
index e5cf6f46dd..9f0c039aeb 100644
--- a/src/applications/metamta/storage/PhabricatorMetaMTAMail.php
+++ b/src/applications/metamta/storage/PhabricatorMetaMTAMail.php
@@ -1,958 +1,958 @@
 <?php
 
 /**
  * @task recipients   Managing Recipients
  */
 final class PhabricatorMetaMTAMail extends PhabricatorMetaMTADAO {
 
   const STATUS_QUEUE = 'queued';
   const STATUS_SENT  = 'sent';
   const STATUS_FAIL  = 'fail';
   const STATUS_VOID  = 'void';
 
   const RETRY_DELAY   = 5;
 
   protected $parameters;
   protected $status;
   protected $message;
   protected $relatedPHID;
 
   private $recipientExpansionMap;
 
   public function __construct() {
 
     $this->status     = self::STATUS_QUEUE;
     $this->parameters = array();
 
     parent::__construct();
   }
 
   public function getConfiguration() {
     return array(
       self::CONFIG_SERIALIZATION => array(
         'parameters'  => self::SERIALIZATION_JSON,
       ),
       self::CONFIG_COLUMN_SCHEMA => array(
-        'status' => 'text255',
+        'status' => 'text32',
         'relatedPHID' => 'phid?',
 
         // T6203/NULLABILITY
         // This should just be empty if there's no body.
         'message' => 'text?',
       ),
       self::CONFIG_KEY_SCHEMA => array(
         'status' => array(
           'columns' => array('status'),
         ),
         'relatedPHID' => array(
           'columns' => array('relatedPHID'),
         ),
         'key_created' => array(
           'columns' => array('dateCreated'),
         ),
       ),
     ) + parent::getConfiguration();
   }
 
   protected function setParam($param, $value) {
     $this->parameters[$param] = $value;
     return $this;
   }
 
   protected function getParam($param, $default = null) {
     return idx($this->parameters, $param, $default);
   }
 
   /**
    * Set tags (@{class:MetaMTANotificationType} constants) which identify the
    * content of this mail in a general way. These tags are used to allow users
    * to opt out of receiving certain types of mail, like updates when a task's
    * projects change.
    *
    * @param list<const> List of @{class:MetaMTANotificationType} constants.
    * @return this
    */
   public function setMailTags(array $tags) {
     $this->setParam('mailtags', array_unique($tags));
     return $this;
   }
 
   public function getMailTags() {
     return $this->getParam('mailtags', array());
   }
 
   /**
    * In Gmail, conversations will be broken if you reply to a thread and the
    * server sends back a response without referencing your Message-ID, even if
    * it references a Message-ID earlier in the thread. To avoid this, use the
    * parent email's message ID explicitly if it's available. This overwrites the
    * "In-Reply-To" and "References" headers we would otherwise generate. This
    * needs to be set whenever an action is triggered by an email message. See
    * T251 for more details.
    *
    * @param   string The "Message-ID" of the email which precedes this one.
    * @return  this
    */
   public function setParentMessageID($id) {
     $this->setParam('parent-message-id', $id);
     return $this;
   }
 
   public function getParentMessageID() {
     return $this->getParam('parent-message-id');
   }
 
   public function getSubject() {
     return $this->getParam('subject');
   }
 
   public function addTos(array $phids) {
     $phids = array_unique($phids);
     $this->setParam('to', $phids);
     return $this;
   }
 
   public function addRawTos(array $raw_email) {
 
     // Strip addresses down to bare emails, since the MailAdapter API currently
     // requires we pass it just the address (like `alincoln@logcabin.org`), not
     // a full string like `"Abraham Lincoln" <alincoln@logcabin.org>`.
     foreach ($raw_email as $key => $email) {
       $object = new PhutilEmailAddress($email);
       $raw_email[$key] = $object->getAddress();
     }
 
     $this->setParam('raw-to', $raw_email);
     return $this;
   }
 
   public function addCCs(array $phids) {
     $phids = array_unique($phids);
     $this->setParam('cc', $phids);
     return $this;
   }
 
   public function setExcludeMailRecipientPHIDs(array $exclude) {
     $this->setParam('exclude', $exclude);
     return $this;
   }
 
   private function getExcludeMailRecipientPHIDs() {
     return $this->getParam('exclude', array());
   }
 
   public function getTranslation(array $objects) {
     $default_translation = PhabricatorEnv::getEnvConfig('translation.provider');
     $return = null;
     $recipients = array_merge(
       idx($this->parameters, 'to', array()),
       idx($this->parameters, 'cc', array()));
     foreach (array_select_keys($objects, $recipients) as $object) {
       $translation = null;
       if ($object instanceof PhabricatorUser) {
         $translation = $object->getTranslation();
       }
       if (!$translation) {
         $translation = $default_translation;
       }
       if ($return && $translation != $return) {
         return $default_translation;
       }
       $return = $translation;
     }
 
     if (!$return) {
       $return = $default_translation;
     }
 
     return $return;
   }
 
   public function addPHIDHeaders($name, array $phids) {
     foreach ($phids as $phid) {
       $this->addHeader($name, '<'.$phid.'>');
     }
     return $this;
   }
 
   public function addHeader($name, $value) {
     $this->parameters['headers'][] = array($name, $value);
     return $this;
   }
 
   public function addAttachment(PhabricatorMetaMTAAttachment $attachment) {
     $this->parameters['attachments'][] = $attachment->toDictionary();
     return $this;
   }
 
   public function getAttachments() {
     $dicts = $this->getParam('attachments');
 
     $result = array();
     foreach ($dicts as $dict) {
       $result[] = PhabricatorMetaMTAAttachment::newFromDictionary($dict);
     }
     return $result;
   }
 
   public function setAttachments(array $attachments) {
     assert_instances_of($attachments, 'PhabricatorMetaMTAAttachment');
     $this->setParam('attachments', mpull($attachments, 'toDictionary'));
     return $this;
   }
 
   public function setFrom($from) {
     $this->setParam('from', $from);
     return $this;
   }
 
   public function setReplyTo($reply_to) {
     $this->setParam('reply-to', $reply_to);
     return $this;
   }
 
   public function setSubject($subject) {
     $this->setParam('subject', $subject);
     return $this;
   }
 
   public function setSubjectPrefix($prefix) {
     $this->setParam('subject-prefix', $prefix);
     return $this;
   }
 
   public function setVarySubjectPrefix($prefix) {
     $this->setParam('vary-subject-prefix', $prefix);
     return $this;
   }
 
   public function setBody($body) {
     $this->setParam('body', $body);
     return $this;
   }
 
   public function setHTMLBody($html) {
     $this->setParam('html-body', $html);
     return $this;
   }
 
   public function getBody() {
     return $this->getParam('body');
   }
 
   public function getHTMLBody() {
     return $this->getParam('html-body');
   }
 
   public function setIsErrorEmail($is_error) {
     $this->setParam('is-error', $is_error);
     return $this;
   }
 
   public function getIsErrorEmail() {
     return $this->getParam('is-error', false);
   }
 
   public function getToPHIDs() {
     return $this->getParam('to', array());
   }
 
   public function getRawToAddresses() {
     return $this->getParam('raw-to', array());
   }
 
   public function getCcPHIDs() {
     return $this->getParam('cc', array());
   }
 
   /**
    * Force delivery of a message, even if recipients have preferences which
    * would otherwise drop the message.
    *
    * This is primarily intended to let users who don't want any email still
    * receive things like password resets.
    *
    * @param bool  True to force delivery despite user preferences.
    * @return this
    */
   public function setForceDelivery($force) {
     $this->setParam('force', $force);
     return $this;
   }
 
   public function getForceDelivery() {
     return $this->getParam('force', false);
   }
 
   /**
    * Flag that this is an auto-generated bulk message and should have bulk
    * headers added to it if appropriate. Broadly, this means some flavor of
    * "Precedence: bulk" or similar, but is implementation and configuration
    * dependent.
    *
    * @param bool  True if the mail is automated bulk mail.
    * @return this
    */
   public function setIsBulk($is_bulk) {
     $this->setParam('is-bulk', $is_bulk);
     return $this;
   }
 
   /**
    * Use this method to set an ID used for message threading. MetaMTA will
    * set appropriate headers (Message-ID, In-Reply-To, References and
    * Thread-Index) based on the capabilities of the underlying mailer.
    *
    * @param string  Unique identifier, appropriate for use in a Message-ID,
    *                In-Reply-To or References headers.
    * @param bool    If true, indicates this is the first message in the thread.
    * @return this
    */
   public function setThreadID($thread_id, $is_first_message = false) {
     $this->setParam('thread-id', $thread_id);
     $this->setParam('is-first-message', $is_first_message);
     return $this;
   }
 
   /**
    * Save a newly created mail to the database. The mail will eventually be
    * delivered by the MetaMTA daemon.
    *
    * @return this
    */
   public function saveAndSend() {
     return $this->save();
   }
 
   public function save() {
     if ($this->getID()) {
       return parent::save();
     }
 
     // NOTE: When mail is sent from CLI scripts that run tasks in-process, we
     // may re-enter this method from within scheduleTask(). The implementation
     // is intended to avoid anything awkward if we end up reentering this
     // method.
 
     $this->openTransaction();
       // Save to generate a task ID.
       $result = parent::save();
 
       // Queue a task to send this mail.
       $mailer_task = PhabricatorWorker::scheduleTask(
         'PhabricatorMetaMTAWorker',
         $this->getID(),
         PhabricatorWorker::PRIORITY_ALERTS);
 
     $this->saveTransaction();
 
     return $result;
   }
 
   public function buildDefaultMailer() {
     return PhabricatorEnv::newObjectFromConfig('metamta.mail-adapter');
   }
 
 
   /**
    * Attempt to deliver an email immediately, in this process.
    *
    * @param bool  Try to deliver this email even if it has already been
    *              delivered or is in backoff after a failed delivery attempt.
    * @param PhabricatorMailImplementationAdapter Use a specific mail adapter,
    *              instead of the default.
    *
    * @return void
    */
   public function sendNow(
     $force_send = false,
     PhabricatorMailImplementationAdapter $mailer = null) {
 
     if ($mailer === null) {
       $mailer = $this->buildDefaultMailer();
     }
 
     if (!$force_send) {
       if ($this->getStatus() != self::STATUS_QUEUE) {
         throw new Exception('Trying to send an already-sent mail!');
       }
     }
 
     try {
       $params = $this->parameters;
 
       $actors = $this->loadAllActors();
       $deliverable_actors = $this->filterDeliverableActors($actors);
 
       $default_from = PhabricatorEnv::getEnvConfig('metamta.default-address');
       if (empty($params['from'])) {
         $mailer->setFrom($default_from);
       }
 
       $is_first = idx($params, 'is-first-message');
       unset($params['is-first-message']);
 
       $is_threaded = (bool)idx($params, 'thread-id');
 
       $reply_to_name = idx($params, 'reply-to-name', '');
       unset($params['reply-to-name']);
 
       $add_cc = array();
       $add_to = array();
 
       // Only try to use preferences if everything is multiplexed, so we
       // get consistent behavior.
       $use_prefs = self::shouldMultiplexAllMail();
 
       $prefs = null;
       if ($use_prefs) {
 
         // If multiplexing is enabled, some recipients will be in "Cc"
         // rather than "To". We'll move them to "To" later (or supply a
         // dummy "To") but need to look for the recipient in either the
         // "To" or "Cc" fields here.
         $target_phid = head(idx($params, 'to', array()));
         if (!$target_phid) {
           $target_phid = head(idx($params, 'cc', array()));
         }
 
         if ($target_phid) {
           $user = id(new PhabricatorUser())->loadOneWhere(
             'phid = %s',
             $target_phid);
           if ($user) {
             $prefs = $user->loadPreferences();
           }
         }
       }
 
       foreach ($params as $key => $value) {
         switch ($key) {
           case 'from':
             $from = $value;
             $actor_email = null;
             $actor_name = null;
             $actor = idx($actors, $from);
             if ($actor) {
               $actor_email = $actor->getEmailAddress();
               $actor_name = $actor->getName();
             }
             $can_send_as_user = $actor_email &&
               PhabricatorEnv::getEnvConfig('metamta.can-send-as-user');
 
             if ($can_send_as_user) {
               $mailer->setFrom($actor_email, $actor_name);
             } else {
               $from_email = coalesce($actor_email, $default_from);
               $from_name = coalesce($actor_name, pht('Phabricator'));
 
               if (empty($params['reply-to'])) {
                 $params['reply-to'] = $from_email;
                 $params['reply-to-name'] = $from_name;
               }
 
               $mailer->setFrom($default_from, $from_name);
             }
             break;
           case 'reply-to':
             $mailer->addReplyTo($value, $reply_to_name);
             break;
           case 'to':
             $to_phids = $this->expandRecipients($value);
             $to_actors = array_select_keys($deliverable_actors, $to_phids);
             $add_to = array_merge(
               $add_to,
               mpull($to_actors, 'getEmailAddress'));
             break;
           case 'raw-to':
             $add_to = array_merge($add_to, $value);
             break;
           case 'cc':
             $cc_phids = $this->expandRecipients($value);
             $cc_actors = array_select_keys($deliverable_actors, $cc_phids);
             $add_cc = array_merge(
               $add_cc,
               mpull($cc_actors, 'getEmailAddress'));
             break;
           case 'headers':
             foreach ($value as $pair) {
               list($header_key, $header_value) = $pair;
 
               // NOTE: If we have \n in a header, SES rejects the email.
               $header_value = str_replace("\n", ' ', $header_value);
 
               $mailer->addHeader($header_key, $header_value);
             }
             break;
           case 'attachments':
             $value = $this->getAttachments();
             foreach ($value as $attachment) {
               $mailer->addAttachment(
                 $attachment->getData(),
                 $attachment->getFilename(),
                 $attachment->getMimeType());
             }
             break;
           case 'subject':
             $subject = array();
 
             if ($is_threaded) {
               $add_re = PhabricatorEnv::getEnvConfig('metamta.re-prefix');
 
               if ($prefs) {
                 $add_re = $prefs->getPreference(
                   PhabricatorUserPreferences::PREFERENCE_RE_PREFIX,
                   $add_re);
               }
 
               if ($add_re) {
                 $subject[] = 'Re:';
               }
             }
 
             $subject[] = trim(idx($params, 'subject-prefix'));
 
             $vary_prefix = idx($params, 'vary-subject-prefix');
             if ($vary_prefix != '') {
               $use_subject = PhabricatorEnv::getEnvConfig(
                 'metamta.vary-subjects');
 
               if ($prefs) {
                 $use_subject = $prefs->getPreference(
                   PhabricatorUserPreferences::PREFERENCE_VARY_SUBJECT,
                   $use_subject);
               }
 
               if ($use_subject) {
                 $subject[] = $vary_prefix;
               }
             }
 
             $subject[] = $value;
 
             $mailer->setSubject(implode(' ', array_filter($subject)));
             break;
           case 'is-bulk':
             if ($value) {
               if (PhabricatorEnv::getEnvConfig('metamta.precedence-bulk')) {
                 $mailer->addHeader('Precedence', 'bulk');
               }
             }
             break;
           case 'thread-id':
 
             // NOTE: Gmail freaks out about In-Reply-To and References which
             // aren't in the form "<string@domain.tld>"; this is also required
             // by RFC 2822, although some clients are more liberal in what they
             // accept.
             $domain = PhabricatorEnv::getEnvConfig('metamta.domain');
             $value = '<'.$value.'@'.$domain.'>';
 
             if ($is_first && $mailer->supportsMessageIDHeader()) {
               $mailer->addHeader('Message-ID',  $value);
             } else {
               $in_reply_to = $value;
               $references = array($value);
               $parent_id = $this->getParentMessageID();
               if ($parent_id) {
                 $in_reply_to = $parent_id;
                 // By RFC 2822, the most immediate parent should appear last
                 // in the "References" header, so this order is intentional.
                 $references[] = $parent_id;
               }
               $references = implode(' ', $references);
               $mailer->addHeader('In-Reply-To', $in_reply_to);
               $mailer->addHeader('References',  $references);
             }
             $thread_index = $this->generateThreadIndex($value, $is_first);
             $mailer->addHeader('Thread-Index', $thread_index);
             break;
           case 'mailtags':
             // Handled below.
             break;
           case 'subject-prefix':
           case 'vary-subject-prefix':
             // Handled above.
             break;
           default:
             // Just discard.
         }
       }
 
       $body = idx($params, 'body', '');
       $max = PhabricatorEnv::getEnvConfig('metamta.email-body-limit');
       if (strlen($body) > $max) {
         $body = id(new PhutilUTF8StringTruncator())
           ->setMaximumBytes($max)
           ->truncateString($body);
         $body .= "\n";
         $body .= pht('(This email was truncated at %d bytes.)', $max);
       }
       $mailer->setBody($body);
 
       $html_emails = false;
       if ($use_prefs && $prefs) {
         $html_emails = $prefs->getPreference(
           PhabricatorUserPreferences::PREFERENCE_HTML_EMAILS,
           $html_emails);
       }
 
       if ($html_emails && isset($params['html-body'])) {
         $mailer->setHTMLBody($params['html-body']);
       }
 
       if (!$add_to && !$add_cc) {
         $this->setStatus(self::STATUS_VOID);
         $this->setMessage(
           'Message has no valid recipients: all To/Cc are disabled, invalid, '.
           'or configured not to receive this mail.');
         return $this->save();
       }
 
       if ($this->getIsErrorEmail()) {
         $all_recipients = array_merge($add_to, $add_cc);
         if ($this->shouldRateLimitMail($all_recipients)) {
           $this->setStatus(self::STATUS_VOID);
           $this->setMessage(
             pht(
               'This is an error email, but one or more recipients have '.
               'exceeded the error email rate limit. Declining to deliver '.
               'message.'));
           return $this->save();
         }
       }
 
       $mailer->addHeader('X-Phabricator-Sent-This-Message', 'Yes');
       $mailer->addHeader('X-Mail-Transport-Agent', 'MetaMTA');
 
       // Some clients respect this to suppress OOF and other auto-responses.
       $mailer->addHeader('X-Auto-Response-Suppress', 'All');
 
       // If the message has mailtags, filter out any recipients who don't want
       // to receive this type of mail.
       $mailtags = $this->getParam('mailtags');
       if ($mailtags) {
         $tag_header = array();
         foreach ($mailtags as $mailtag) {
           $tag_header[] = '<'.$mailtag.'>';
         }
         $tag_header = implode(', ', $tag_header);
         $mailer->addHeader('X-Phabricator-Mail-Tags', $tag_header);
       }
 
       // Some mailers require a valid "To:" in order to deliver mail. If we
       // don't have any "To:", try to fill it in with a placeholder "To:".
       // If that also fails, move the "Cc:" line to "To:".
       if (!$add_to) {
         $placeholder_key = 'metamta.placeholder-to-recipient';
         $placeholder = PhabricatorEnv::getEnvConfig($placeholder_key);
         if ($placeholder !== null) {
           $add_to = array($placeholder);
         } else {
           $add_to = $add_cc;
           $add_cc = array();
         }
       }
 
       $add_to = array_unique($add_to);
       $add_cc = array_diff(array_unique($add_cc), $add_to);
 
       $mailer->addTos($add_to);
       if ($add_cc) {
         $mailer->addCCs($add_cc);
       }
     } catch (Exception $ex) {
       $this
         ->setStatus(self::STATUS_FAIL)
         ->setMessage($ex->getMessage())
         ->save();
 
       throw $ex;
     }
 
     try {
       $ok = $mailer->send();
       if (!$ok) {
         // TODO: At some point, we should clean this up and make all mailers
         // throw.
         throw new Exception(
           pht('Mail adapter encountered an unexpected, unspecified failure.'));
       }
 
       $this->setStatus(self::STATUS_SENT);
       $this->save();
 
       return $this;
     } catch (PhabricatorMetaMTAPermanentFailureException $ex) {
       $this
         ->setStatus(self::STATUS_FAIL)
         ->setMessage($ex->getMessage())
         ->save();
 
       throw $ex;
     } catch (Exception $ex) {
       $this
         ->setMessage($ex->getMessage()."\n".$ex->getTraceAsString())
         ->save();
 
       throw $ex;
     }
   }
 
   public static function getReadableStatus($status_code) {
     static $readable = array(
       self::STATUS_QUEUE => 'Queued for Delivery',
       self::STATUS_FAIL  => 'Delivery Failed',
       self::STATUS_SENT  => 'Sent',
       self::STATUS_VOID  => 'Void',
     );
     $status_code = coalesce($status_code, '?');
     return idx($readable, $status_code, $status_code);
   }
 
   private function generateThreadIndex($seed, $is_first_mail) {
     // When threading, Outlook ignores the 'References' and 'In-Reply-To'
     // headers that most clients use. Instead, it uses a custom 'Thread-Index'
     // header. The format of this header is something like this (from
     // camel-exchange-folder.c in Evolution Exchange):
 
     /* A new post to a folder gets a 27-byte-long thread index. (The value
      * is apparently unique but meaningless.) Each reply to a post gets a
      * 32-byte-long thread index whose first 27 bytes are the same as the
      * parent's thread index. Each reply to any of those gets a
      * 37-byte-long thread index, etc. The Thread-Index header contains a
      * base64 representation of this value.
      */
 
     // The specific implementation uses a 27-byte header for the first email
     // a recipient receives, and a random 5-byte suffix (32 bytes total)
     // thereafter. This means that all the replies are (incorrectly) siblings,
     // but it would be very difficult to keep track of the entire tree and this
     // gets us reasonable client behavior.
 
     $base = substr(md5($seed), 0, 27);
     if (!$is_first_mail) {
       // Not totally sure, but it seems like outlook orders replies by
       // thread-index rather than timestamp, so to get these to show up in the
       // right order we use the time as the last 4 bytes.
       $base .= ' '.pack('N', time());
     }
 
     return base64_encode($base);
   }
 
   public static function shouldMultiplexAllMail() {
     return PhabricatorEnv::getEnvConfig('metamta.one-mail-per-recipient');
   }
 
 
 /* -(  Managing Recipients  )------------------------------------------------ */
 
 
   /**
    * Get all of the recipients for this mail, after preference filters are
    * applied. This list has all objects to whom delivery will be attempted.
    *
    * @return  list<phid>  A list of all recipients to whom delivery will be
    *                      attempted.
    * @task recipients
    */
   public function buildRecipientList() {
     $actors = $this->loadActors(
       array_merge(
         $this->getToPHIDs(),
         $this->getCcPHIDs()));
     $actors = $this->filterDeliverableActors($actors);
     return mpull($actors, 'getPHID');
   }
 
   public function loadAllActors() {
     $actor_phids = array_merge(
       array($this->getParam('from')),
       $this->getToPHIDs(),
       $this->getCcPHIDs());
 
     $this->loadRecipientExpansions($actor_phids);
     $actor_phids = $this->expandRecipients($actor_phids);
 
     return $this->loadActors($actor_phids);
   }
 
   private function loadRecipientExpansions(array $phids) {
     $expansions = id(new PhabricatorMetaMTAMemberQuery())
       ->setViewer(PhabricatorUser::getOmnipotentUser())
       ->withPHIDs($phids)
       ->execute();
 
     $this->recipientExpansionMap = $expansions;
 
     return $this;
   }
 
   /**
    * Expand a list of recipient PHIDs (possibly including aggregate recipients
    * like projects) into a deaggregated list of individual recipient PHIDs.
    * For example, this will expand project PHIDs into a list of the project's
    * members.
    *
    * @param list<phid>  List of recipient PHIDs, possibly including aggregate
    *                    recipients.
    * @return list<phid> Deaggregated list of mailable recipients.
    */
   private function expandRecipients(array $phids) {
     if ($this->recipientExpansionMap === null) {
       throw new Exception(
         pht(
           'Call loadRecipientExpansions() before expandRecipients()!'));
     }
 
     $results = array();
     foreach ($phids as $phid) {
       if (!isset($this->recipientExpansionMap[$phid])) {
         $results[$phid] = $phid;
       } else {
         foreach ($this->recipientExpansionMap[$phid] as $recipient_phid) {
           $results[$recipient_phid] = $recipient_phid;
         }
       }
     }
 
     return array_keys($results);
   }
 
   private function filterDeliverableActors(array $actors) {
     assert_instances_of($actors, 'PhabricatorMetaMTAActor');
     $deliverable_actors = array();
     foreach ($actors as $phid => $actor) {
       if ($actor->isDeliverable()) {
         $deliverable_actors[$phid] = $actor;
       }
     }
     return $deliverable_actors;
   }
 
   private function loadActors(array $actor_phids) {
     $actor_phids = array_filter($actor_phids);
     $viewer = PhabricatorUser::getOmnipotentUser();
 
     $actors = id(new PhabricatorMetaMTAActorQuery())
       ->setViewer($viewer)
       ->withPHIDs($actor_phids)
       ->execute();
 
     if (!$actors) {
       return array();
     }
 
     if ($this->getForceDelivery()) {
       // If we're forcing delivery, skip all the opt-out checks.
       return $actors;
     }
 
     // Exclude explicit recipients.
     foreach ($this->getExcludeMailRecipientPHIDs() as $phid) {
       $actor = idx($actors, $phid);
       if (!$actor) {
         continue;
       }
       $actor->setUndeliverable(
         pht(
           'This message is a response to another email message, and this '.
           'recipient received the original email message, so we are not '.
           'sending them this substantially similar message (for example, '.
           'the sender used "Reply All" instead of "Reply" in response to '.
           'mail from Phabricator).'));
     }
 
     // Exclude the actor if their preferences are set.
     $from_phid = $this->getParam('from');
     $from_actor = idx($actors, $from_phid);
     if ($from_actor) {
       $from_user = id(new PhabricatorPeopleQuery())
         ->setViewer($viewer)
         ->withPHIDs(array($from_phid))
         ->execute();
       $from_user = head($from_user);
       if ($from_user) {
         $pref_key = PhabricatorUserPreferences::PREFERENCE_NO_SELF_MAIL;
         $exclude_self = $from_user
           ->loadPreferences()
           ->getPreference($pref_key);
         if ($exclude_self) {
           $from_actor->setUndeliverable(
             pht(
               'This recipient is the user whose actions caused delivery of '.
               'this message, but they have set preferences so they do not '.
               'receive mail about their own actions (Settings > Email '.
               'Preferences > Self Actions).'));
         }
       }
     }
 
     $all_prefs = id(new PhabricatorUserPreferences())->loadAllWhere(
       'userPHID in (%Ls)',
       $actor_phids);
     $all_prefs = mpull($all_prefs, null, 'getUserPHID');
 
     // Exclude recipients who don't want any mail.
     foreach ($all_prefs as $phid => $prefs) {
       $exclude = $prefs->getPreference(
         PhabricatorUserPreferences::PREFERENCE_NO_MAIL,
         false);
       if ($exclude) {
         $actors[$phid]->setUndeliverable(
           pht(
             'This recipient has disabled all email notifications '.
             '(Settings > Email Preferences > Email Notifications).'));
       }
     }
 
     $value_email = PhabricatorUserPreferences::MAILTAG_PREFERENCE_EMAIL;
 
     // Exclude all recipients who have set preferences to not receive this type
     // of email (for example, a user who says they don't want emails about task
     // CC changes).
     $tags = $this->getParam('mailtags');
     if ($tags) {
       foreach ($all_prefs as $phid => $prefs) {
         $user_mailtags = $prefs->getPreference(
           PhabricatorUserPreferences::PREFERENCE_MAILTAGS,
           array());
 
         // The user must have elected to receive mail for at least one
         // of the mailtags.
         $send = false;
         foreach ($tags as $tag) {
           if (((int)idx($user_mailtags, $tag, $value_email)) == $value_email) {
             $send = true;
             break;
           }
         }
 
         if (!$send) {
           $actors[$phid]->setUndeliverable(
             pht(
               'This mail has tags which control which users receive it, and '.
               'this recipient has not elected to receive mail with any of '.
               'the tags on this message (Settings > Email Preferences).'));
         }
       }
     }
 
     return $actors;
   }
 
   private function shouldRateLimitMail(array $all_recipients) {
     try {
       PhabricatorSystemActionEngine::willTakeAction(
         $all_recipients,
         new PhabricatorMetaMTAErrorMailAction(),
         1);
       return false;
     } catch (PhabricatorSystemActionRateLimitException $ex) {
       return true;
     }
   }
 
 
 }
diff --git a/src/applications/owners/storage/PhabricatorOwnersPackage.php b/src/applications/owners/storage/PhabricatorOwnersPackage.php
index f357604459..bc19ecdc45 100644
--- a/src/applications/owners/storage/PhabricatorOwnersPackage.php
+++ b/src/applications/owners/storage/PhabricatorOwnersPackage.php
@@ -1,439 +1,439 @@
 <?php
 
 final class PhabricatorOwnersPackage extends PhabricatorOwnersDAO
   implements PhabricatorPolicyInterface {
 
   protected $name;
   protected $originalName;
   protected $auditingEnabled;
   protected $description;
   protected $primaryOwnerPHID;
 
   private $unsavedOwners;
   private $unsavedPaths;
   private $actorPHID;
   private $oldPrimaryOwnerPHID;
   private $oldAuditingEnabled;
 
   public function getCapabilities() {
     return array(
       PhabricatorPolicyCapability::CAN_VIEW,
     );
   }
 
   public function getPolicy($capability) {
     return PhabricatorPolicies::POLICY_USER;
   }
 
   public function hasAutomaticCapability($capability, PhabricatorUser $viewer) {
     return false;
   }
 
   public function describeAutomaticCapability($capability) {
     return null;
   }
 
   public function getConfiguration() {
     return array(
       // This information is better available from the history table.
       self::CONFIG_TIMESTAMPS => false,
       self::CONFIG_AUX_PHID   => true,
       self::CONFIG_COLUMN_SCHEMA => array(
-        'name' => 'text255',
+        'name' => 'text128',
         'originalName' => 'text255',
         'description' => 'text',
         'primaryOwnerPHID' => 'phid?',
         'auditingEnabled' => 'bool',
       ),
       self::CONFIG_KEY_SCHEMA => array(
         'key_phid' => null,
         'phid' => array(
           'columns' => array('phid'),
           'unique' => true,
         ),
         'name' => array(
           'columns' => array('name'),
           'unique' => true,
         ),
       ),
     ) + parent::getConfiguration();
   }
 
   public function generatePHID() {
     return PhabricatorPHID::generateNewPHID('OPKG');
   }
 
   public function attachUnsavedOwners(array $owners) {
     $this->unsavedOwners = $owners;
     return $this;
   }
 
   public function attachUnsavedPaths(array $paths) {
     $this->unsavedPaths = $paths;
     return $this;
   }
 
   public function attachActorPHID($actor_phid) {
     $this->actorPHID = $actor_phid;
     return $this;
   }
 
   public function getActorPHID() {
     return $this->actorPHID;
   }
 
   public function attachOldPrimaryOwnerPHID($old_primary) {
     $this->oldPrimaryOwnerPHID = $old_primary;
     return $this;
   }
 
   public function getOldPrimaryOwnerPHID() {
     return $this->oldPrimaryOwnerPHID;
   }
 
   public function attachOldAuditingEnabled($auditing_enabled) {
     $this->oldAuditingEnabled = $auditing_enabled;
     return $this;
   }
 
   public function getOldAuditingEnabled() {
     return $this->oldAuditingEnabled;
   }
 
   public function setName($name) {
     $this->name = $name;
     if (!$this->getID()) {
       $this->originalName = $name;
     }
     return $this;
   }
 
   public function loadOwners() {
     if (!$this->getID()) {
       return array();
     }
     return id(new PhabricatorOwnersOwner())->loadAllWhere(
       'packageID = %d',
       $this->getID());
   }
 
   public function loadPaths() {
     if (!$this->getID()) {
       return array();
     }
     return id(new PhabricatorOwnersPath())->loadAllWhere(
       'packageID = %d',
       $this->getID());
   }
 
   public static function loadAffectedPackages(
     PhabricatorRepository $repository,
     array $paths) {
 
     if (!$paths) {
       return array();
     }
 
     return self::loadPackagesForPaths($repository, $paths);
  }
 
  public static function loadOwningPackages($repository, $path) {
     if (empty($path)) {
       return array();
     }
 
     return self::loadPackagesForPaths($repository, array($path), 1);
  }
 
   private static function loadPackagesForPaths(
     PhabricatorRepository $repository,
     array $paths,
     $limit = 0) {
 
     $fragments = array();
     foreach ($paths as $path) {
       foreach (self::splitPath($path) as $fragment) {
         $fragments[$fragment][$path] = true;
       }
     }
 
     $package = new PhabricatorOwnersPackage();
     $path = new PhabricatorOwnersPath();
     $conn = $package->establishConnection('r');
 
     $repository_clause = qsprintf(
       $conn,
       'AND p.repositoryPHID = %s',
       $repository->getPHID());
 
     // NOTE: The list of $paths may be very large if we're coming from
     // the OwnersWorker and processing, e.g., an SVN commit which created a new
     // branch. Break it apart so that it will fit within 'max_allowed_packet',
     // and then merge results in PHP.
 
     $rows = array();
     foreach (array_chunk(array_keys($fragments), 128) as $chunk) {
       $rows[] = queryfx_all(
         $conn,
         'SELECT pkg.id, p.excluded, p.path
           FROM %T pkg JOIN %T p ON p.packageID = pkg.id
           WHERE p.path IN (%Ls) %Q',
         $package->getTableName(),
         $path->getTableName(),
         $chunk,
         $repository_clause);
     }
     $rows = array_mergev($rows);
 
     $ids = self::findLongestPathsPerPackage($rows, $fragments);
 
     if (!$ids) {
       return array();
     }
 
     arsort($ids);
     if ($limit) {
       $ids = array_slice($ids, 0, $limit, $preserve_keys = true);
     }
     $ids = array_keys($ids);
 
     $packages = $package->loadAllWhere('id in (%Ld)', $ids);
     $packages = array_select_keys($packages, $ids);
 
     return $packages;
   }
 
   public static function loadPackagesForRepository($repository) {
     $package = new PhabricatorOwnersPackage();
     $ids = ipull(
       queryfx_all(
         $package->establishConnection('r'),
         'SELECT DISTINCT packageID FROM %T WHERE repositoryPHID = %s',
         id(new PhabricatorOwnersPath())->getTableName(),
         $repository->getPHID()),
       'packageID');
 
     return $package->loadAllWhere('id in (%Ld)', $ids);
   }
 
   public static function findLongestPathsPerPackage(array $rows, array $paths) {
     $ids = array();
 
     foreach (igroup($rows, 'id') as $id => $package_paths) {
       $relevant_paths = array_select_keys(
         $paths,
         ipull($package_paths, 'path'));
 
       // For every package, remove all excluded paths.
       $remove = array();
       foreach ($package_paths as $package_path) {
         if ($package_path['excluded']) {
           $remove += idx($relevant_paths, $package_path['path'], array());
           unset($relevant_paths[$package_path['path']]);
         }
       }
 
       if ($remove) {
         foreach ($relevant_paths as $fragment => $fragment_paths) {
           $relevant_paths[$fragment] = array_diff_key($fragment_paths, $remove);
         }
       }
 
       $relevant_paths = array_filter($relevant_paths);
       if ($relevant_paths) {
         $ids[$id] = max(array_map('strlen', array_keys($relevant_paths)));
       }
     }
 
     return $ids;
   }
 
   private function getActor() {
     // TODO: This should be cleaner, but we'd likely need to move the whole
     // thing to an Editor (T603).
     return PhabricatorUser::getOmnipotentUser();
   }
 
   public function save() {
 
     if ($this->getID()) {
       $is_new = false;
     } else {
       $is_new = true;
     }
 
     $this->openTransaction();
 
     $ret = parent::save();
 
     $add_owners = array();
     $remove_owners = array();
     $all_owners = array();
     if ($this->unsavedOwners) {
       $new_owners = array_fill_keys($this->unsavedOwners, true);
       $cur_owners = array();
       foreach ($this->loadOwners() as $owner) {
         if (empty($new_owners[$owner->getUserPHID()])) {
           $remove_owners[$owner->getUserPHID()] = true;
           $owner->delete();
           continue;
         }
         $cur_owners[$owner->getUserPHID()] = true;
       }
 
       $add_owners = array_diff_key($new_owners, $cur_owners);
       $all_owners = array_merge(
         array($this->getPrimaryOwnerPHID() => true),
         $new_owners,
         $remove_owners);
       foreach ($add_owners as $phid => $ignored) {
         $owner = new PhabricatorOwnersOwner();
         $owner->setPackageID($this->getID());
         $owner->setUserPHID($phid);
         $owner->save();
       }
       unset($this->unsavedOwners);
     }
 
     $add_paths = array();
     $remove_paths = array();
     $touched_repos = array();
     if ($this->unsavedPaths) {
       $new_paths = igroup($this->unsavedPaths, 'repositoryPHID', 'path');
       $cur_paths = $this->loadPaths();
       foreach ($cur_paths as $key => $path) {
         $repository_phid = $path->getRepositoryPHID();
         $new_path = head(idx(
           idx($new_paths, $repository_phid, array()),
           $path->getPath(),
           array()));
         $excluded = $path->getExcluded();
         if (!$new_path || idx($new_path, 'excluded') != $excluded) {
           $touched_repos[$repository_phid] = true;
           $remove_paths[$repository_phid][$path->getPath()] = $excluded;
           $path->delete();
           unset($cur_paths[$key]);
         }
       }
 
       $cur_paths = mgroup($cur_paths, 'getRepositoryPHID', 'getPath');
       foreach ($new_paths as $repository_phid => $paths) {
         // TODO: (T603) Thread policy stuff in here.
 
         // get repository object for path validation
         $repository = id(new PhabricatorRepository())->loadOneWhere(
           'phid = %s',
           $repository_phid);
         if (!$repository) {
           continue;
         }
         foreach ($paths as $path => $dicts) {
           $path = ltrim($path, '/');
           // build query to validate path
           $drequest = DiffusionRequest::newFromDictionary(
             array(
               'user' => $this->getActor(),
               'repository'  => $repository,
               'path'        => $path,
             ));
           $results = DiffusionBrowseResultSet::newFromConduit(
             DiffusionQuery::callConduitWithDiffusionRequest(
               $this->getActor(),
               $drequest,
               'diffusion.browsequery',
               array(
                 'commit' => $drequest->getCommit(),
                 'path' => $path,
                 'needValidityOnly' => true)));
           $valid = $results->isValidResults();
           $is_directory = true;
           if (!$valid) {
             switch ($results->getReasonForEmptyResultSet()) {
               case DiffusionBrowseResultSet::REASON_IS_FILE:
                 $valid = true;
                 $is_directory = false;
                 break;
               case DiffusionBrowseResultSet::REASON_IS_EMPTY:
                 $valid = true;
                 break;
             }
           }
           if ($is_directory && substr($path, -1) != '/') {
             $path .= '/';
           }
           if (substr($path, 0, 1) != '/') {
             $path = '/'.$path;
           }
           if (empty($cur_paths[$repository_phid][$path]) && $valid) {
             $touched_repos[$repository_phid] = true;
             $excluded = idx(reset($dicts), 'excluded', 0);
             $add_paths[$repository_phid][$path] = $excluded;
             $obj = new PhabricatorOwnersPath();
             $obj->setPackageID($this->getID());
             $obj->setRepositoryPHID($repository_phid);
             $obj->setPath($path);
             $obj->setExcluded($excluded);
             $obj->save();
           }
         }
       }
       unset($this->unsavedPaths);
     }
 
     $this->saveTransaction();
 
     if ($is_new) {
       $mail = new PackageCreateMail($this);
     } else {
       $mail = new PackageModifyMail(
         $this,
         array_keys($add_owners),
         array_keys($remove_owners),
         array_keys($all_owners),
         array_keys($touched_repos),
         $add_paths,
         $remove_paths);
     }
     $mail->setActor($this->getActor());
     $mail->send();
 
     return $ret;
   }
 
   public function delete() {
     $mails = id(new PackageDeleteMail($this))
       ->setActor($this->getActor())
       ->prepareMails();
 
     $this->openTransaction();
     foreach ($this->loadOwners() as $owner) {
       $owner->delete();
     }
     foreach ($this->loadPaths() as $path) {
       $path->delete();
     }
 
     $ret = parent::delete();
 
     $this->saveTransaction();
 
     foreach ($mails as $mail) {
       $mail->saveAndSend();
     }
 
     return $ret;
   }
 
   private static function splitPath($path) {
     $result = array('/');
     $trailing_slash = preg_match('@/$@', $path) ? '/' : '';
     $path = trim($path, '/');
     $parts = explode('/', $path);
     while (count($parts)) {
       $result[] = '/'.implode('/', $parts).$trailing_slash;
       $trailing_slash = '/';
       array_pop($parts);
     }
     return $result;
   }
 }
diff --git a/src/applications/people/storage/PhabricatorExternalAccount.php b/src/applications/people/storage/PhabricatorExternalAccount.php
index 6d4a832cf2..27f9122fb8 100644
--- a/src/applications/people/storage/PhabricatorExternalAccount.php
+++ b/src/applications/people/storage/PhabricatorExternalAccount.php
@@ -1,165 +1,165 @@
 <?php
 
 final class PhabricatorExternalAccount extends PhabricatorUserDAO
   implements PhabricatorPolicyInterface {
 
   protected $userPHID;
   protected $accountType;
   protected $accountDomain;
   protected $accountSecret;
   protected $accountID;
   protected $displayName;
   protected $username;
   protected $realName;
   protected $email;
   protected $emailVerified = 0;
   protected $accountURI;
   protected $profileImagePHID;
   protected $properties = array();
 
   private $profileImageFile = self::ATTACHABLE;
 
   public function getProfileImageFile() {
     return $this->assertAttached($this->profileImageFile);
   }
 
   public function attachProfileImageFile(PhabricatorFile $file) {
     $this->profileImageFile = $file;
     return $this;
   }
 
   public function generatePHID() {
     return PhabricatorPHID::generateNewPHID(
       PhabricatorPeopleExternalPHIDType::TYPECONST);
   }
 
   public function getConfiguration() {
     return array(
       self::CONFIG_AUX_PHID => true,
       self::CONFIG_SERIALIZATION => array(
         'properties' => self::SERIALIZATION_JSON,
       ),
       self::CONFIG_COLUMN_SCHEMA => array(
         'userPHID' => 'phid?',
         'accountType' => 'text16',
         'accountDomain' => 'text64',
         'accountSecret' => 'text?',
-        'accountID' => 'text160',
+        'accountID' => 'text64',
         'displayName' => 'text255?',
         'username' => 'text255?',
         'realName' => 'text255?',
         'email' => 'text255?',
         'emailVerified' => 'bool',
         'profileImagePHID' => 'phid?',
         'accountURI' => 'text255?',
       ),
       self::CONFIG_KEY_SCHEMA => array(
         'key_phid' => null,
         'phid' => array(
           'columns' => array('phid'),
           'unique' => true,
         ),
         'account_details' => array(
           'columns' => array('accountType', 'accountDomain', 'accountID'),
           'unique' => true,
         ),
       ),
     ) + parent::getConfiguration();
   }
 
   public function getPhabricatorUser() {
     $tmp_usr = id(new PhabricatorUser())
       ->makeEphemeral()
       ->setPHID($this->getPHID());
     return $tmp_usr;
   }
 
   public function getProviderKey() {
     return $this->getAccountType().':'.$this->getAccountDomain();
   }
 
   public function save() {
     if (!$this->getAccountSecret()) {
       $this->setAccountSecret(Filesystem::readRandomCharacters(32));
     }
     return parent::save();
   }
 
   public function setProperty($key, $value) {
     $this->properties[$key] = $value;
     return $this;
   }
 
   public function getProperty($key, $default = null) {
     return idx($this->properties, $key, $default);
   }
 
   public function isUsableForLogin() {
     $key = $this->getProviderKey();
     $provider = PhabricatorAuthProvider::getEnabledProviderByKey($key);
 
     if (!$provider) {
       return false;
     }
 
     if (!$provider->shouldAllowLogin()) {
       return false;
     }
 
     return true;
   }
 
   public function getDisplayName() {
     if (strlen($this->displayName)) {
       return $this->displayName;
     }
 
     // TODO: Figure out how much identifying information we're going to show
     // to users about external accounts. For now, just show a string which is
     // clearly not an error, but don't disclose any identifying information.
 
     $map = array(
       'email' => pht('Email User'),
     );
 
     $type = $this->getAccountType();
 
     return idx($map, $type, pht('"%s" User', $type));
   }
 
 
 
 /* -(  PhabricatorPolicyInterface  )----------------------------------------- */
 
 
   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 PhabricatorPolicies::POLICY_NOONE;
     }
   }
 
   public function hasAutomaticCapability($capability, PhabricatorUser $viewer) {
     return ($viewer->getPHID() == $this->getUserPHID());
   }
 
   public function describeAutomaticCapability($capability) {
     switch ($capability) {
       case PhabricatorPolicyCapability::CAN_VIEW:
         return null;
       case PhabricatorPolicyCapability::CAN_EDIT:
         return pht(
           'External accounts can only be edited by the account owner.');
     }
   }
 
 }
diff --git a/src/applications/people/storage/PhabricatorUserSchemaSpec.php b/src/applications/people/storage/PhabricatorUserSchemaSpec.php
index cf484bbc67..930baa0223 100644
--- a/src/applications/people/storage/PhabricatorUserSchemaSpec.php
+++ b/src/applications/people/storage/PhabricatorUserSchemaSpec.php
@@ -1,38 +1,38 @@
 <?php
 
 final class PhabricatorUserSchemaSpec extends PhabricatorConfigSchemaSpec {
 
   public function buildSchemata() {
     $this->buildLiskSchemata('PhabricatorUserDAO');
 
     $this->buildEdgeSchemata(new PhabricatorUser());
 
     $this->buildTransactionSchema(
       new PhabricatorUserTransaction());
 
     $this->buildCustomFieldSchemata(
       new PhabricatorUserConfiguredCustomFieldStorage(),
       array(
         new PhabricatorUserCustomFieldNumericIndex(),
         new PhabricatorUserCustomFieldStringIndex(),
       ));
 
     $this->buildRawSchema(
       id(new PhabricatorUser())->getApplicationName(),
       PhabricatorUser::NAMETOKEN_TABLE,
       array(
         'token' => 'text255',
         'userID' => 'id',
       ),
       array(
         'token' => array(
-          'columns' => array('token'),
+          'columns' => array('token(128)'),
         ),
         'userID' => array(
           'columns' => array('userID'),
         ),
       ));
 
   }
 
 }
diff --git a/src/applications/phame/storage/PhameBlog.php b/src/applications/phame/storage/PhameBlog.php
index d094359449..4dea551414 100644
--- a/src/applications/phame/storage/PhameBlog.php
+++ b/src/applications/phame/storage/PhameBlog.php
@@ -1,303 +1,303 @@
 <?php
 
 final class PhameBlog extends PhameDAO
   implements PhabricatorPolicyInterface, PhabricatorMarkupInterface {
 
   const MARKUP_FIELD_DESCRIPTION = 'markup:description';
 
   const SKIN_DEFAULT = 'oblivious';
 
   protected $name;
   protected $description;
   protected $domain;
   protected $configData;
   protected $creatorPHID;
   protected $viewPolicy;
   protected $editPolicy;
   protected $joinPolicy;
 
   private $bloggerPHIDs = self::ATTACHABLE;
   private $bloggers = self::ATTACHABLE;
 
   static private $requestBlog;
 
   public function getConfiguration() {
     return array(
       self::CONFIG_AUX_PHID   => true,
       self::CONFIG_SERIALIZATION => array(
         'configData' => self::SERIALIZATION_JSON,
       ),
       self::CONFIG_COLUMN_SCHEMA => array(
         'name' => 'text64',
         'description' => 'text',
-        'domain' => 'text255?',
+        'domain' => 'text128?',
 
         // T6203/NULLABILITY
         // These policies should always be non-null.
         'joinPolicy' => 'policy?',
         'editPolicy' => 'policy?',
         'viewPolicy' => 'policy?',
       ),
       self::CONFIG_KEY_SCHEMA => array(
         'key_phid' => null,
         'phid' => array(
           'columns' => array('phid'),
           'unique' => true,
         ),
         'domain' => array(
           'columns' => array('domain'),
           'unique' => true,
         ),
       ),
     ) + parent::getConfiguration();
   }
 
   public function generatePHID() {
     return PhabricatorPHID::generateNewPHID(
       PhabricatorPhameBlogPHIDType::TYPECONST);
   }
 
   public function getSkinRenderer(AphrontRequest $request) {
     $spec = PhameSkinSpecification::loadOneSkinSpecification(
       $this->getSkin());
 
     if (!$spec) {
       $spec = PhameSkinSpecification::loadOneSkinSpecification(
         self::SKIN_DEFAULT);
     }
 
     if (!$spec) {
       throw new Exception(
         'This blog has an invalid skin, and the default skin failed to '.
         'load.');
     }
 
     $skin = newv($spec->getSkinClass(), array($request));
     $skin->setSpecification($spec);
 
     return $skin;
   }
 
   /**
    * Makes sure a given custom blog uri is properly configured in DNS
    * to point at this Phabricator instance. If there is an error in
    * the configuration, return a string describing the error and how
    * to fix it. If there is no error, return an empty string.
    *
    * @return string
    */
   public function validateCustomDomain($custom_domain) {
     $example_domain = 'blog.example.com';
     $label = pht('Invalid');
 
     // note this "uri" should be pretty busted given the desired input
     // so just use it to test if there's a protocol specified
     $uri = new PhutilURI($custom_domain);
     if ($uri->getProtocol()) {
       return array($label,
         pht(
           'The custom domain should not include a protocol. Just provide '.
           'the bare domain name (for example, "%s").',
           $example_domain));
     }
 
     if ($uri->getPort()) {
       return array($label,
         pht(
           'The custom domain should not include a port number. Just provide '.
           'the bare domain name (for example, "%s").',
           $example_domain));
     }
 
     if (strpos($custom_domain, '/') !== false) {
       return array($label,
         pht(
           'The custom domain should not specify a path (hosting a Phame '.
           'blog at a path is currently not supported). Instead, just provide '.
           'the bare domain name (for example, "%s").',
           $example_domain));
     }
 
     if (strpos($custom_domain, '.') === false) {
       return array($label,
         pht(
           'The custom domain should contain at least one dot (.) because '.
           'some browsers fail to set cookies on domains without a dot. '.
           'Instead, use a normal looking domain name like "%s".',
           $example_domain));
     }
 
     if (!PhabricatorEnv::getEnvConfig('policy.allow-public')) {
       $href = PhabricatorEnv::getProductionURI(
         '/config/edit/policy.allow-public/');
       return array(pht('Fix Configuration'),
         pht(
           'For custom domains to work, this Phabricator instance must be '.
           'configured to allow the public access policy. Configure this '.
           'setting %s, or ask an administrator to configure this setting. '.
           'The domain can be specified later once this setting has been '.
           'changed.',
           phutil_tag(
             'a',
             array('href' => $href),
             pht('here'))));
     }
 
     return null;
   }
 
   public function getBloggerPHIDs() {
     return $this->assertAttached($this->bloggerPHIDs);
   }
 
   public function attachBloggers(array $bloggers) {
     assert_instances_of($bloggers, 'PhabricatorObjectHandle');
 
     $this->bloggers = $bloggers;
 
     return $this;
   }
 
   public function getBloggers() {
     return $this->assertAttached($this->bloggers);
   }
 
   public function getSkin() {
     $config = coalesce($this->getConfigData(), array());
     return idx($config, 'skin', self::SKIN_DEFAULT);
   }
 
   public function setSkin($skin) {
     $config = coalesce($this->getConfigData(), array());
     $config['skin'] = $skin;
     return $this->setConfigData($config);
   }
 
   static public function getSkinOptionsForSelect() {
     $classes = id(new PhutilSymbolLoader())
       ->setAncestorClass('PhameBlogSkin')
       ->setType('class')
       ->setConcreteOnly(true)
       ->selectSymbolsWithoutLoading();
 
     return ipull($classes, 'name', 'name');
   }
 
   public static function setRequestBlog(PhameBlog $blog) {
     self::$requestBlog = $blog;
   }
 
   public static function getRequestBlog() {
     return self::$requestBlog;
   }
 
   public function getLiveURI(PhamePost $post = null) {
     if ($this->getDomain()) {
       $base = new PhutilURI('http://'.$this->getDomain().'/');
     } else {
       $base = '/phame/live/'.$this->getID().'/';
       $base = PhabricatorEnv::getURI($base);
     }
 
     if ($post) {
       $base .= '/post/'.$post->getPhameTitle();
     }
 
     return $base;
   }
 
 
 /* -(  PhabricatorPolicyInterface Implementation  )-------------------------- */
 
 
   public function getCapabilities() {
     return array(
       PhabricatorPolicyCapability::CAN_VIEW,
       PhabricatorPolicyCapability::CAN_EDIT,
       PhabricatorPolicyCapability::CAN_JOIN,
     );
   }
 
 
   public function getPolicy($capability) {
     switch ($capability) {
       case PhabricatorPolicyCapability::CAN_VIEW:
         return $this->getViewPolicy();
       case PhabricatorPolicyCapability::CAN_EDIT:
         return $this->getEditPolicy();
       case PhabricatorPolicyCapability::CAN_JOIN:
         return $this->getJoinPolicy();
     }
   }
 
   public function hasAutomaticCapability($capability, PhabricatorUser $user) {
     $can_edit = PhabricatorPolicyCapability::CAN_EDIT;
     $can_join = PhabricatorPolicyCapability::CAN_JOIN;
 
     switch ($capability) {
       case PhabricatorPolicyCapability::CAN_VIEW:
         // Users who can edit or post to a blog can always view it.
         if (PhabricatorPolicyFilter::hasCapability($user, $this, $can_edit)) {
           return true;
         }
         if (PhabricatorPolicyFilter::hasCapability($user, $this, $can_join)) {
           return true;
         }
         break;
       case PhabricatorPolicyCapability::CAN_JOIN:
         // Users who can edit a blog can always post to it.
         if (PhabricatorPolicyFilter::hasCapability($user, $this, $can_edit)) {
           return true;
         }
         break;
     }
 
     return false;
   }
 
 
   public function describeAutomaticCapability($capability) {
     switch ($capability) {
       case PhabricatorPolicyCapability::CAN_VIEW:
         return pht(
           'Users who can edit or post on a blog can always view it.');
       case PhabricatorPolicyCapability::CAN_JOIN:
         return pht(
           'Users who can edit a blog can always post on it.');
     }
 
     return null;
   }
 
 
 /* -(  PhabricatorMarkupInterface Implementation  )-------------------------- */
 
 
   public function getMarkupFieldKey($field) {
     $hash = PhabricatorHash::digest($this->getMarkupText($field));
     return $this->getPHID().':'.$field.':'.$hash;
   }
 
 
   public function newMarkupEngine($field) {
     return PhabricatorMarkupEngine::newPhameMarkupEngine();
   }
 
 
   public function getMarkupText($field) {
     return $this->getDescription();
   }
 
 
   public function didMarkupText(
     $field,
     $output,
     PhutilMarkupEngine $engine) {
     return $output;
   }
 
   public function shouldUseMarkupCache($field) {
     return (bool)$this->getPHID();
   }
 
 }
diff --git a/src/applications/phragment/storage/PhragmentFragment.php b/src/applications/phragment/storage/PhragmentFragment.php
index 9ff3b769d1..17da8ae69a 100644
--- a/src/applications/phragment/storage/PhragmentFragment.php
+++ b/src/applications/phragment/storage/PhragmentFragment.php
@@ -1,351 +1,351 @@
 <?php
 
 final class PhragmentFragment extends PhragmentDAO
   implements PhabricatorPolicyInterface {
 
   protected $path;
   protected $depth;
   protected $latestVersionPHID;
   protected $viewPolicy;
   protected $editPolicy;
 
   private $latestVersion = self::ATTACHABLE;
 
   public function getConfiguration() {
     return array(
       self::CONFIG_AUX_PHID => true,
       self::CONFIG_COLUMN_SCHEMA => array(
-        'path' => 'text255',
+        'path' => 'text128',
         'depth' => 'uint32',
         'latestVersionPHID' => 'phid?',
       ),
       self::CONFIG_KEY_SCHEMA => array(
         'key_path' => array(
           'columns' => array('path'),
           'unique' => true,
         ),
       ),
     ) + parent::getConfiguration();
   }
 
   public function generatePHID() {
     return PhabricatorPHID::generateNewPHID(
       PhragmentFragmentPHIDType::TYPECONST);
   }
 
   public function getURI() {
     return '/phragment/browse/'.$this->getPath();
   }
 
   public function getName() {
     return basename($this->path);
   }
 
   public function getFile() {
     return $this->assertAttached($this->file);
   }
 
   public function attachFile(PhabricatorFile $file) {
     return $this->file = $file;
   }
 
   public function isDirectory() {
     return $this->latestVersionPHID === null;
   }
 
   public function isDeleted() {
     return $this->getLatestVersion()->getFilePHID() === null;
   }
 
   public function getLatestVersion() {
     if ($this->latestVersionPHID === null) {
       return null;
     }
     return $this->assertAttached($this->latestVersion);
   }
 
   public function attachLatestVersion(PhragmentFragmentVersion $version) {
     return $this->latestVersion = $version;
   }
 
 
 /* -(  Updating  )  --------------------------------------------------------- */
 
 
   /**
    * Create a new fragment from a file.
    */
   public static function createFromFile(
     PhabricatorUser $viewer,
     PhabricatorFile $file = null,
     $path,
     $view_policy,
     $edit_policy) {
 
     $fragment = id(new PhragmentFragment());
     $fragment->setPath($path);
     $fragment->setDepth(count(explode('/', $path)));
     $fragment->setLatestVersionPHID(null);
     $fragment->setViewPolicy($view_policy);
     $fragment->setEditPolicy($edit_policy);
     $fragment->save();
 
     // Directory fragments have no versions associated with them, so we
     // just return the fragment at this point.
     if ($file === null) {
       return $fragment;
     }
 
     if ($file->getMimeType() === 'application/zip') {
       $fragment->updateFromZIP($viewer, $file);
     } else {
       $fragment->updateFromFile($viewer, $file);
     }
 
     return $fragment;
   }
 
 
   /**
    * Set the specified file as the next version for the fragment.
    */
   public function updateFromFile(
     PhabricatorUser $viewer,
     PhabricatorFile $file) {
 
     $existing = id(new PhragmentFragmentVersionQuery())
       ->setViewer($viewer)
       ->withFragmentPHIDs(array($this->getPHID()))
       ->execute();
     $sequence = count($existing);
 
     $this->openTransaction();
       $version = id(new PhragmentFragmentVersion());
       $version->setSequence($sequence);
       $version->setFragmentPHID($this->getPHID());
       $version->setFilePHID($file->getPHID());
       $version->save();
 
       $this->setLatestVersionPHID($version->getPHID());
       $this->save();
     $this->saveTransaction();
 
     $file->attachToObject($version->getPHID());
   }
 
   /**
    * Apply the specified ZIP archive onto the fragment, removing
    * and creating fragments as needed.
    */
   public function updateFromZIP(
     PhabricatorUser $viewer,
     PhabricatorFile $file) {
 
     if ($file->getMimeType() !== 'application/zip') {
       throw new Exception("File must have mimetype 'application/zip'");
     }
 
     // First apply the ZIP as normal.
     $this->updateFromFile($viewer, $file);
 
     // Ensure we have ZIP support.
     $zip = null;
     try {
       $zip = new ZipArchive();
     } catch (Exception $e) {
       // The server doesn't have php5-zip, so we can't do recursive updates.
       return;
     }
 
     $temp = new TempFile();
     Filesystem::writeFile($temp, $file->loadFileData());
     if (!$zip->open($temp)) {
       throw new Exception('Unable to open ZIP');
     }
 
     // Get all of the paths and their data from the ZIP.
     $mappings = array();
     for ($i = 0; $i < $zip->numFiles; $i++) {
       $path = trim($zip->getNameIndex($i), '/');
       $stream = $zip->getStream($path);
       $data = null;
       // If the stream is false, then it is a directory entry. We leave
       // $data set to null for directories so we know not to create a
       // version entry for them.
       if ($stream !== false) {
         $data = stream_get_contents($stream);
         fclose($stream);
       }
       $mappings[$path] = $data;
     }
 
     // We need to detect any directories that are in the ZIP folder that
     // aren't explicitly noted in the ZIP. This can happen if the file
     // entries in the ZIP look like:
     //
     //  * something/blah.png
     //  * something/other.png
     //  * test.png
     //
     // Where there is no explicit "something/" entry.
     foreach ($mappings as $path_key => $data) {
       if ($data === null) {
         continue;
       }
       $directory = dirname($path_key);
       while ($directory !== '.') {
         if (!array_key_exists($directory, $mappings)) {
           $mappings[$directory] = null;
         }
         if (dirname($directory) === $directory) {
           // dirname() will not reduce this directory any further; to
           // prevent infinite loop we just break out here.
           break;
         }
         $directory = dirname($directory);
       }
     }
 
     // Adjust the paths relative to this fragment so we can look existing
     // fragments up in the DB.
     $base_path = $this->getPath();
     $paths = array();
     foreach ($mappings as $p => $data) {
       $paths[] = $base_path.'/'.$p;
     }
 
     // FIXME: What happens when a child exists, but the current user
     // can't see it. We're going to create a new child with the exact
     // same path and then bad things will happen.
     $children = id(new PhragmentFragmentQuery())
       ->setViewer($viewer)
       ->needLatestVersion(true)
       ->withLeadingPath($this->getPath().'/')
       ->execute();
     $children = mpull($children, null, 'getPath');
 
     // Iterate over the existing fragments.
     foreach ($children as $full_path => $child) {
       $path = substr($full_path, strlen($base_path) + 1);
       if (array_key_exists($path, $mappings)) {
         if ($child->isDirectory() && $mappings[$path] === null) {
           // Don't create a version entry for a directory
           // (unless it's been converted into a file).
           continue;
         }
 
         // The file is being updated.
         $file = PhabricatorFile::newFromFileData(
           $mappings[$path],
           array('name' => basename($path)));
         $child->updateFromFile($viewer, $file);
       } else {
         // The file is being deleted.
         $child->deleteFile($viewer);
       }
     }
 
     // Iterate over the mappings to find new files.
     foreach ($mappings as $path => $data) {
       if (!array_key_exists($base_path.'/'.$path, $children)) {
         // The file is being created. If the data is null,
         // then this is explicitly a directory being created.
         $file = null;
         if ($mappings[$path] !== null) {
           $file = PhabricatorFile::newFromFileData(
             $mappings[$path],
             array('name' => basename($path)));
         }
         PhragmentFragment::createFromFile(
           $viewer,
           $file,
           $base_path.'/'.$path,
           $this->getViewPolicy(),
           $this->getEditPolicy());
       }
     }
   }
 
   /**
    * Delete the contents of the specified fragment.
    */
   public function deleteFile(PhabricatorUser $viewer) {
     $existing = id(new PhragmentFragmentVersionQuery())
       ->setViewer($viewer)
       ->withFragmentPHIDs(array($this->getPHID()))
       ->execute();
     $sequence = count($existing);
 
     $this->openTransaction();
       $version = id(new PhragmentFragmentVersion());
       $version->setSequence($sequence);
       $version->setFragmentPHID($this->getPHID());
       $version->setFilePHID(null);
       $version->save();
 
       $this->setLatestVersionPHID($version->getPHID());
       $this->save();
     $this->saveTransaction();
   }
 
 
 /* -(  Utility  )  ---------------------------------------------------------- */
 
 
   public function getFragmentMappings(
     PhabricatorUser $viewer,
     $base_path) {
 
     $children = id(new PhragmentFragmentQuery())
       ->setViewer($viewer)
       ->needLatestVersion(true)
       ->withLeadingPath($this->getPath().'/')
       ->withDepths(array($this->getDepth() + 1))
       ->execute();
 
     if (count($children) === 0) {
       $path = substr($this->getPath(), strlen($base_path) + 1);
       return array($path => $this);
     } else {
       $mappings = array();
       foreach ($children as $child) {
         $child_mappings = $child->getFragmentMappings(
           $viewer,
           $base_path);
         foreach ($child_mappings as $key => $value) {
           $mappings[$key] = $value;
         }
       }
       return $mappings;
     }
   }
 
 
 /* -(  Policy Interface  )--------------------------------------------------- */
 
 
   public function getCapabilities() {
     return array(
       PhabricatorPolicyCapability::CAN_VIEW,
       PhabricatorPolicyCapability::CAN_EDIT,
     );
   }
 
   public function getPolicy($capability) {
     switch ($capability) {
       case PhabricatorPolicyCapability::CAN_VIEW:
         return $this->getViewPolicy();
       case PhabricatorPolicyCapability::CAN_EDIT:
         return $this->getEditPolicy();
     }
   }
 
   public function hasAutomaticCapability($capability, PhabricatorUser $viewer) {
     return false;
   }
 
   public function describeAutomaticCapability($capability) {
     return null;
   }
 
 }
diff --git a/src/applications/phragment/storage/PhragmentSnapshot.php b/src/applications/phragment/storage/PhragmentSnapshot.php
index be6f36c639..eb2e063d03 100644
--- a/src/applications/phragment/storage/PhragmentSnapshot.php
+++ b/src/applications/phragment/storage/PhragmentSnapshot.php
@@ -1,76 +1,76 @@
 <?php
 
 final class PhragmentSnapshot extends PhragmentDAO
   implements PhabricatorPolicyInterface {
 
   protected $primaryFragmentPHID;
   protected $name;
 
   private $primaryFragment = self::ATTACHABLE;
 
   public function getConfiguration() {
     return array(
       self::CONFIG_AUX_PHID => true,
       self::CONFIG_COLUMN_SCHEMA => array(
-        'name' => 'text255',
+        'name' => 'text128',
       ),
       self::CONFIG_KEY_SCHEMA => array(
         'key_name' => array(
           'columns' => array('primaryFragmentPHID', 'name'),
           'unique' => true,
         ),
       ),
     ) + parent::getConfiguration();
   }
 
   public function generatePHID() {
     return PhabricatorPHID::generateNewPHID(
       PhragmentSnapshotPHIDType::TYPECONST);
   }
 
   public function getURI() {
     return '/phragment/snapshot/view/'.$this->getID().'/';
   }
 
   public function getPrimaryFragment() {
     return $this->assertAttached($this->primaryFragment);
   }
 
   public function attachPrimaryFragment(PhragmentFragment $fragment) {
     return $this->primaryFragment = $fragment;
   }
 
   public function delete() {
     $children = id(new PhragmentSnapshotChild())
       ->loadAllWhere('snapshotPHID = %s', $this->getPHID());
     $this->openTransaction();
       foreach ($children as $child) {
         $child->delete();
       }
       $result = parent::delete();
     $this->saveTransaction();
     return $result;
   }
 
 
 /* -(  Policy Interface  )--------------------------------------------------- */
 
 
   public function getCapabilities() {
     return $this->getPrimaryFragment()->getCapabilities();
   }
 
   public function getPolicy($capability) {
     return $this->getPrimaryFragment()->getPolicy($capability);
   }
 
   public function hasAutomaticCapability($capability, PhabricatorUser $viewer) {
     return $this->getPrimaryFragment()
       ->hasAutomaticCapability($capability, $viewer);
   }
 
   public function describeAutomaticCapability($capability) {
     return $this->getPrimaryFragment()
       ->describeAutomaticCapability($capability);
   }
 }
diff --git a/src/applications/phriction/storage/PhrictionContent.php b/src/applications/phriction/storage/PhrictionContent.php
index 07ffc3347a..5ae4e225fe 100644
--- a/src/applications/phriction/storage/PhrictionContent.php
+++ b/src/applications/phriction/storage/PhrictionContent.php
@@ -1,125 +1,125 @@
 <?php
 
 /**
  * @task markup Markup Interface
  */
 final class PhrictionContent extends PhrictionDAO
   implements PhabricatorMarkupInterface {
 
   const MARKUP_FIELD_BODY = 'markup:body';
 
   protected $id;
   protected $documentID;
   protected $version;
   protected $authorPHID;
 
   protected $title;
   protected $slug;
   protected $content;
   protected $description;
 
   protected $changeType;
   protected $changeRef;
 
   public function renderContent(PhabricatorUser $viewer) {
     return PhabricatorMarkupEngine::renderOneObject(
       $this,
       self::MARKUP_FIELD_BODY,
       $viewer);
   }
 
   public function getConfiguration() {
     return array(
       self::CONFIG_COLUMN_SCHEMA => array(
         'version' => 'uint32',
         'title' => 'text',
         'slug' => 'text128',
         'content' => 'text',
         'changeType' => 'uint32',
         'changeRef' => 'uint32?',
 
         // T6203/NULLABILITY
         // This should just be empty if not provided?
         'description' => 'text?',
       ),
       self::CONFIG_KEY_SCHEMA => array(
         'documentID' => array(
           'columns' => array('documentID', 'version'),
           'unique' => true,
         ),
         'authorPHID' => array(
           'columns' => array('authorPHID'),
         ),
         'slug' => array(
-          'columns' => array('slug(255)'),
+          'columns' => array('slug'),
         ),
       ),
     ) + parent::getConfiguration();
   }
 
 
 /* -(  Markup Interface  )--------------------------------------------------- */
 
 
   /**
    * @task markup
    */
   public function getMarkupFieldKey($field) {
     if ($this->shouldUseMarkupCache($field)) {
       $id = $this->getID();
     } else {
       $id = PhabricatorHash::digest($this->getMarkupText($field));
     }
     return "phriction:{$field}:{$id}";
   }
 
 
   /**
    * @task markup
    */
   public function getMarkupText($field) {
     return $this->getContent();
   }
 
 
   /**
    * @task markup
    */
   public function newMarkupEngine($field) {
     return PhabricatorMarkupEngine::newPhrictionMarkupEngine();
   }
 
 
   /**
    * @task markup
    */
   public function didMarkupText(
     $field,
     $output,
     PhutilMarkupEngine $engine) {
 
     $toc = PhutilRemarkupHeaderBlockRule::renderTableOfContents(
       $engine);
 
     if ($toc) {
       $toc = phutil_tag_div('phabricator-remarkup-toc', array(
         phutil_tag_div(
           'phabricator-remarkup-toc-header',
           pht('Table of Contents')),
         $toc,
       ));
     }
 
     return phutil_tag_div('phabricator-remarkup', array($toc, $output));
   }
 
 
   /**
    * @task markup
    */
   public function shouldUseMarkupCache($field) {
     return (bool)$this->getID();
   }
 
 
 }
diff --git a/src/applications/project/storage/PhabricatorProject.php b/src/applications/project/storage/PhabricatorProject.php
index 3617ad12e0..d3538332ae 100644
--- a/src/applications/project/storage/PhabricatorProject.php
+++ b/src/applications/project/storage/PhabricatorProject.php
@@ -1,372 +1,372 @@
 <?php
 
 final class PhabricatorProject extends PhabricatorProjectDAO
   implements
     PhabricatorFlaggableInterface,
     PhabricatorPolicyInterface,
     PhabricatorSubscribableInterface,
     PhabricatorCustomFieldInterface,
     PhabricatorDestructibleInterface {
 
   protected $name;
   protected $status = PhabricatorProjectStatus::STATUS_ACTIVE;
   protected $authorPHID;
   protected $subprojectPHIDs = array();
   protected $phrictionSlug;
   protected $profileImagePHID;
   protected $icon;
   protected $color;
 
   protected $viewPolicy;
   protected $editPolicy;
   protected $joinPolicy;
   protected $isMembershipLocked;
 
   private $memberPHIDs = self::ATTACHABLE;
   private $watcherPHIDs = self::ATTACHABLE;
   private $sparseWatchers = self::ATTACHABLE;
   private $sparseMembers = self::ATTACHABLE;
   private $customFields = self::ATTACHABLE;
   private $profileImageFile = self::ATTACHABLE;
   private $slugs = self::ATTACHABLE;
 
   const DEFAULT_ICON = 'fa-briefcase';
   const DEFAULT_COLOR = 'blue';
 
   const TABLE_DATASOURCE_TOKEN = 'project_datasourcetoken';
 
   public static function initializeNewProject(PhabricatorUser $actor) {
     return id(new PhabricatorProject())
       ->setName('')
       ->setAuthorPHID($actor->getPHID())
       ->setIcon(self::DEFAULT_ICON)
       ->setColor(self::DEFAULT_COLOR)
       ->setViewPolicy(PhabricatorPolicies::POLICY_USER)
       ->setEditPolicy(PhabricatorPolicies::POLICY_USER)
       ->setJoinPolicy(PhabricatorPolicies::POLICY_USER)
       ->setIsMembershipLocked(0)
       ->attachMemberPHIDs(array());
   }
 
   public function getCapabilities() {
     return array(
       PhabricatorPolicyCapability::CAN_VIEW,
       PhabricatorPolicyCapability::CAN_EDIT,
       PhabricatorPolicyCapability::CAN_JOIN,
     );
   }
 
   public function getPolicy($capability) {
     switch ($capability) {
       case PhabricatorPolicyCapability::CAN_VIEW:
         return $this->getViewPolicy();
       case PhabricatorPolicyCapability::CAN_EDIT:
         return $this->getEditPolicy();
       case PhabricatorPolicyCapability::CAN_JOIN:
         return $this->getJoinPolicy();
     }
   }
 
   public function hasAutomaticCapability($capability, PhabricatorUser $viewer) {
 
     switch ($capability) {
       case PhabricatorPolicyCapability::CAN_VIEW:
         if ($this->isUserMember($viewer->getPHID())) {
           // Project members can always view a project.
           return true;
         }
         break;
       case PhabricatorPolicyCapability::CAN_EDIT:
         break;
       case PhabricatorPolicyCapability::CAN_JOIN:
         $can_edit = PhabricatorPolicyCapability::CAN_EDIT;
         if (PhabricatorPolicyFilter::hasCapability($viewer, $this, $can_edit)) {
           // Project editors can always join a project.
           return true;
         }
         break;
     }
 
     return false;
   }
 
   public function describeAutomaticCapability($capability) {
     switch ($capability) {
       case PhabricatorPolicyCapability::CAN_VIEW:
         return pht('Members of a project can always view it.');
       case PhabricatorPolicyCapability::CAN_JOIN:
         return pht('Users who can edit a project can always join it.');
     }
     return null;
   }
 
   public function isUserMember($user_phid) {
     if ($this->memberPHIDs !== self::ATTACHABLE) {
       return in_array($user_phid, $this->memberPHIDs);
     }
     return $this->assertAttachedKey($this->sparseMembers, $user_phid);
   }
 
   public function setIsUserMember($user_phid, $is_member) {
     if ($this->sparseMembers === self::ATTACHABLE) {
       $this->sparseMembers = array();
     }
     $this->sparseMembers[$user_phid] = $is_member;
     return $this;
   }
 
   public function getConfiguration() {
     return array(
       self::CONFIG_AUX_PHID => true,
       self::CONFIG_SERIALIZATION => array(
         'subprojectPHIDs' => self::SERIALIZATION_JSON,
       ),
       self::CONFIG_COLUMN_SCHEMA => array(
-        'name' => 'text255',
+        'name' => 'text128',
         'status' => 'text32',
         'phrictionSlug' => 'text128?',
         'isMembershipLocked' => 'bool',
         'profileImagePHID' => 'phid?',
         'icon' => 'text32',
         'color' => 'text32',
 
         // T6203/NULLABILITY
         // These are definitely wrong and should always exist.
         'editPolicy' => 'policy?',
         'viewPolicy' => 'policy?',
         'joinPolicy' => 'policy?',
       ),
       self::CONFIG_KEY_SCHEMA => array(
         'key_phid' => null,
         'phid' => array(
           'columns' => array('phid'),
           'unique' => true,
         ),
         'key_icon' => array(
           'columns' => array('icon'),
         ),
         'key_color' => array(
           'columns' => array('color'),
         ),
         'phrictionSlug' => array(
           'columns' => array('phrictionSlug'),
           'unique' => true,
         ),
         'name' => array(
           'columns' => array('name'),
           'unique' => true,
         ),
       ),
     ) + parent::getConfiguration();
   }
 
   public function generatePHID() {
     return PhabricatorPHID::generateNewPHID(
       PhabricatorProjectProjectPHIDType::TYPECONST);
   }
 
   public function attachMemberPHIDs(array $phids) {
     $this->memberPHIDs = $phids;
     return $this;
   }
 
   public function getMemberPHIDs() {
     return $this->assertAttached($this->memberPHIDs);
   }
 
   public function setPhrictionSlug($slug) {
 
     // NOTE: We're doing a little magic here and stripping out '/' so that
     // project pages always appear at top level under projects/ even if the
     // display name is "Hack / Slash" or similar (it will become
     // 'hack_slash' instead of 'hack/slash').
 
     $slug = str_replace('/', ' ', $slug);
     $slug = PhabricatorSlug::normalize($slug);
     $this->phrictionSlug = $slug;
     return $this;
   }
 
   public function getFullPhrictionSlug() {
     $slug = $this->getPhrictionSlug();
     return 'projects/'.$slug;
   }
 
   // TODO - once we sever project => phriction automagicalness,
   // migrate getPhrictionSlug to have no trailing slash and be called
   // getPrimarySlug
   public function getPrimarySlug() {
     $slug = $this->getPhrictionSlug();
     return rtrim($slug, '/');
   }
 
   public function isArchived() {
     return ($this->getStatus() == PhabricatorProjectStatus::STATUS_ARCHIVED);
   }
 
   public function getProfileImageURI() {
     return $this->getProfileImageFile()->getBestURI();
   }
 
   public function attachProfileImageFile(PhabricatorFile $file) {
     $this->profileImageFile = $file;
     return $this;
   }
 
   public function getProfileImageFile() {
     return $this->assertAttached($this->profileImageFile);
   }
 
 
   public function isUserWatcher($user_phid) {
     if ($this->watcherPHIDs !== self::ATTACHABLE) {
       return in_array($user_phid, $this->watcherPHIDs);
     }
     return $this->assertAttachedKey($this->sparseWatchers, $user_phid);
   }
 
   public function setIsUserWatcher($user_phid, $is_watcher) {
     if ($this->sparseWatchers === self::ATTACHABLE) {
       $this->sparseWatchers = array();
     }
     $this->sparseWatchers[$user_phid] = $is_watcher;
     return $this;
   }
 
   public function attachWatcherPHIDs(array $phids) {
     $this->watcherPHIDs = $phids;
     return $this;
   }
 
   public function getWatcherPHIDs() {
     return $this->assertAttached($this->watcherPHIDs);
   }
 
   public function attachSlugs(array $slugs) {
     $this->slugs = $slugs;
     return $this;
   }
 
   public function getSlugs() {
     return $this->assertAttached($this->slugs);
   }
 
   public function getColor() {
     if ($this->isArchived()) {
       return PHUITagView::COLOR_DISABLED;
     }
 
     return $this->color;
   }
 
   public function save() {
     $this->openTransaction();
       $result = parent::save();
       $this->updateDatasourceTokens();
     $this->saveTransaction();
 
     return $result;
   }
 
   public function updateDatasourceTokens() {
     $table = self::TABLE_DATASOURCE_TOKEN;
     $conn_w = $this->establishConnection('w');
     $id = $this->getID();
 
     $slugs = queryfx_all(
       $conn_w,
       'SELECT * FROM %T WHERE projectPHID = %s',
       id(new PhabricatorProjectSlug())->getTableName(),
       $this->getPHID());
 
     $all_strings = ipull($slugs, 'slug');
     $all_strings[] = $this->getName();
     $all_strings = implode(' ', $all_strings);
 
     $tokens = PhabricatorTypeaheadDatasource::tokenizeString($all_strings);
 
     $sql = array();
     foreach ($tokens as $token) {
       $sql[] = qsprintf($conn_w, '(%d, %s)', $id, $token);
     }
 
     $this->openTransaction();
       queryfx(
         $conn_w,
         'DELETE FROM %T WHERE projectID = %d',
         $table,
         $id);
 
       foreach (PhabricatorLiskDAO::chunkSQL($sql) as $chunk) {
         queryfx(
           $conn_w,
           'INSERT INTO %T (projectID, token) VALUES %Q',
           $table,
           $chunk);
       }
     $this->saveTransaction();
   }
 
 
 /* -(  PhabricatorSubscribableInterface  )----------------------------------- */
 
 
   public function isAutomaticallySubscribed($phid) {
     return false;
   }
 
   public function shouldShowSubscribersProperty() {
     return false;
   }
 
   public function shouldAllowSubscription($phid) {
     return $this->isUserMember($phid) &&
            !$this->isUserWatcher($phid);
   }
 
 
 /* -(  PhabricatorCustomFieldInterface  )------------------------------------ */
 
 
   public function getCustomFieldSpecificationForRole($role) {
     return PhabricatorEnv::getEnvConfig('projects.fields');
   }
 
   public function getCustomFieldBaseClass() {
     return 'PhabricatorProjectCustomField';
   }
 
   public function getCustomFields() {
     return $this->assertAttached($this->customFields);
   }
 
   public function attachCustomFields(PhabricatorCustomFieldAttachment $fields) {
     $this->customFields = $fields;
     return $this;
   }
 
 
 /* -(  PhabricatorDestructibleInterface  )----------------------------------- */
 
   public function destroyObjectPermanently(
     PhabricatorDestructionEngine $engine) {
 
     $this->openTransaction();
       $this->delete();
 
       $columns = id(new PhabricatorProjectColumn())
         ->loadAllWhere('projectPHID = %s', $this->getPHID());
       foreach ($columns as $column) {
         $engine->destroyObject($column);
       }
 
       $slugs = id(new PhabricatorProjectSlug())
         ->loadAllWhere('projectPHID = %s', $this->getPHID());
       foreach ($slugs as $slug) {
         $slug->delete();
       }
 
     $this->saveTransaction();
   }
 
 }
diff --git a/src/applications/releeph/storage/ReleephProject.php b/src/applications/releeph/storage/ReleephProject.php
index 0465541c60..b4397ebf75 100644
--- a/src/applications/releeph/storage/ReleephProject.php
+++ b/src/applications/releeph/storage/ReleephProject.php
@@ -1,146 +1,146 @@
 <?php
 
 final class ReleephProject extends ReleephDAO
   implements PhabricatorPolicyInterface {
 
   const DEFAULT_BRANCH_NAMESPACE = 'releeph-releases';
   const SYSTEM_AGENT_USERNAME_PREFIX = 'releeph-agent-';
 
   protected $name;
 
   // Specifying the place to pick from is a requirement for svn, though not
   // for git. It's always useful though for reasoning about what revs have
   // been picked and which haven't.
   protected $trunkBranch;
 
   protected $repositoryPHID;
   protected $isActive;
   protected $createdByUserPHID;
   protected $arcanistProjectID;
 
   protected $details = array();
 
   private $repository = self::ATTACHABLE;
   private $arcanistProject = self::ATTACHABLE;
 
   public function getConfiguration() {
     return array(
       self::CONFIG_AUX_PHID => true,
       self::CONFIG_SERIALIZATION => array(
         'details' => self::SERIALIZATION_JSON,
       ),
       self::CONFIG_COLUMN_SCHEMA => array(
-        'name' => 'text255',
+        'name' => 'text128',
         'trunkBranch' => 'text255',
         'isActive' => 'bool',
       ),
       self::CONFIG_KEY_SCHEMA => array(
         'projectName' => array(
           'columns' => array('name'),
           'unique' => true,
         ),
       ),
     ) + parent::getConfiguration();
   }
 
   public function generatePHID() {
     return PhabricatorPHID::generateNewPHID(ReleephProductPHIDType::TYPECONST);
   }
 
   public function getDetail($key, $default = null) {
     return idx($this->details, $key, $default);
   }
 
   public function getURI($path = null) {
     $components = array(
       '/releeph/product',
       $this->getID(),
       $path
     );
     return implode('/', $components);
   }
 
   public function setDetail($key, $value) {
     $this->details[$key] = $value;
     return $this;
   }
 
   public function getArcanistProject() {
     return $this->assertAttached($this->arcanistProject);
   }
 
   public function attachArcanistProject(
     PhabricatorRepositoryArcanistProject $arcanist_project = null) {
     $this->arcanistProject = $arcanist_project;
     return $this;
   }
 
   public function getPushers() {
     return $this->getDetail('pushers', array());
   }
 
   public function isPusher(PhabricatorUser $user) {
     // TODO Deprecate this once `isPusher` is out of the Facebook codebase.
     return $this->isAuthoritative($user);
   }
 
   public function isAuthoritative(PhabricatorUser $user) {
     return $this->isAuthoritativePHID($user->getPHID());
   }
 
   public function isAuthoritativePHID($phid) {
     $pushers = $this->getPushers();
     if (!$pushers) {
       return true;
     } else {
       return in_array($phid, $pushers);
     }
   }
 
   public function attachRepository(PhabricatorRepository $repository) {
     $this->repository = $repository;
     return $this;
   }
 
   public function getRepository() {
     return $this->assertAttached($this->repository);
   }
 
   public function getReleephFieldSelector() {
     return new ReleephDefaultFieldSelector();
   }
 
   public function isTestFile($filename) {
     $test_paths = $this->getDetail('testPaths', array());
 
     foreach ($test_paths as $test_path) {
       if (preg_match($test_path, $filename)) {
         return true;
       }
     }
     return false;
   }
 
 /* -(  PhabricatorPolicyInterface  )----------------------------------------- */
 
   public function getCapabilities() {
     return array(
       PhabricatorPolicyCapability::CAN_VIEW,
       PhabricatorPolicyCapability::CAN_EDIT,
     );
   }
 
   public function getPolicy($capability) {
     return PhabricatorPolicies::POLICY_USER;
   }
 
   public function hasAutomaticCapability($capability, PhabricatorUser $viewer) {
     return false;
   }
 
   public function describeAutomaticCapability($capability) {
     return null;
   }
 
 
 }
diff --git a/src/applications/repository/storage/PhabricatorRepository.php b/src/applications/repository/storage/PhabricatorRepository.php
index 858729d6dd..e1a96149e5 100644
--- a/src/applications/repository/storage/PhabricatorRepository.php
+++ b/src/applications/repository/storage/PhabricatorRepository.php
@@ -1,1591 +1,1591 @@
 <?php
 
 /**
  * @task uri        Repository URI Management
  * @task autoclose  Autoclose
  */
 final class PhabricatorRepository extends PhabricatorRepositoryDAO
   implements
     PhabricatorPolicyInterface,
     PhabricatorFlaggableInterface,
     PhabricatorMarkupInterface,
     PhabricatorDestructibleInterface,
     PhabricatorProjectInterface {
 
   /**
    * Shortest hash we'll recognize in raw "a829f32" form.
    */
   const MINIMUM_UNQUALIFIED_HASH = 7;
 
   /**
    * Shortest hash we'll recognize in qualified "rXab7ef2f8" form.
    */
   const MINIMUM_QUALIFIED_HASH = 5;
 
   const TABLE_PATH = 'repository_path';
   const TABLE_PATHCHANGE = 'repository_pathchange';
   const TABLE_FILESYSTEM = 'repository_filesystem';
   const TABLE_SUMMARY = 'repository_summary';
   const TABLE_BADCOMMIT = 'repository_badcommit';
   const TABLE_LINTMESSAGE = 'repository_lintmessage';
   const TABLE_PARENTS = 'repository_parents';
   const TABLE_COVERAGE = 'repository_coverage';
 
   const SERVE_OFF = 'off';
   const SERVE_READONLY = 'readonly';
   const SERVE_READWRITE = 'readwrite';
 
   const BECAUSE_REPOSITORY_IMPORTING = 'auto/importing';
   const BECAUSE_AUTOCLOSE_DISABLED = 'auto/disabled';
   const BECAUSE_NOT_ON_AUTOCLOSE_BRANCH = 'auto/nobranch';
   const BECAUSE_BRANCH_UNTRACKED = 'auto/notrack';
   const BECAUSE_BRANCH_NOT_AUTOCLOSE = 'auto/noclose';
 
   protected $name;
   protected $callsign;
   protected $uuid;
   protected $viewPolicy;
   protected $editPolicy;
   protected $pushPolicy;
 
   protected $versionControlSystem;
   protected $details = array();
   protected $credentialPHID;
 
   private $commitCount = self::ATTACHABLE;
   private $mostRecentCommit = self::ATTACHABLE;
   private $projectPHIDs = self::ATTACHABLE;
 
   public static function initializeNewRepository(PhabricatorUser $actor) {
     $app = id(new PhabricatorApplicationQuery())
       ->setViewer($actor)
       ->withClasses(array('PhabricatorDiffusionApplication'))
       ->executeOne();
 
     $view_policy = $app->getPolicy(DiffusionDefaultViewCapability::CAPABILITY);
     $edit_policy = $app->getPolicy(DiffusionDefaultEditCapability::CAPABILITY);
     $push_policy = $app->getPolicy(DiffusionDefaultPushCapability::CAPABILITY);
 
     return id(new PhabricatorRepository())
       ->setViewPolicy($view_policy)
       ->setEditPolicy($edit_policy)
       ->setPushPolicy($push_policy);
   }
 
   public function getConfiguration() {
     return array(
       self::CONFIG_AUX_PHID => true,
       self::CONFIG_SERIALIZATION => array(
         'details' => self::SERIALIZATION_JSON,
       ),
       self::CONFIG_COLUMN_SCHEMA => array(
         'name' => 'text255',
         'callsign' => 'text32',
         'versionControlSystem' => 'text32',
         'uuid' => 'text64?',
         'pushPolicy' => 'policy',
         'credentialPHID' => 'phid?',
       ),
       self::CONFIG_KEY_SCHEMA => array(
         'key_phid' => null,
         'phid' => array(
           'columns' => array('phid'),
           'unique' => true,
         ),
         'callsign' => array(
           'columns' => array('callsign'),
           'unique' => true,
         ),
         'key_name' => array(
-          'columns' => array('name'),
+          'columns' => array('name(128)'),
         ),
         'key_vcs' => array(
           'columns' => array('versionControlSystem'),
         ),
       ),
     ) + parent::getConfiguration();
   }
 
   public function generatePHID() {
     return PhabricatorPHID::generateNewPHID(
       PhabricatorRepositoryRepositoryPHIDType::TYPECONST);
   }
 
   public function toDictionary() {
     return array(
       'id'          => $this->getID(),
       'name'        => $this->getName(),
       'phid'        => $this->getPHID(),
       'callsign'    => $this->getCallsign(),
       'monogram'    => $this->getMonogram(),
       'vcs'         => $this->getVersionControlSystem(),
       'uri'         => PhabricatorEnv::getProductionURI($this->getURI()),
       'remoteURI'   => (string)$this->getRemoteURI(),
       'description' => $this->getDetail('description'),
       'isActive'    => $this->isTracked(),
       'isHosted'    => $this->isHosted(),
       'isImporting' => $this->isImporting(),
     );
   }
 
   public function getMonogram() {
     return 'r'.$this->getCallsign();
   }
 
   public function getDetail($key, $default = null) {
     return idx($this->details, $key, $default);
   }
 
   public function getHumanReadableDetail($key, $default = null) {
     $value = $this->getDetail($key, $default);
 
     switch ($key) {
       case 'branch-filter':
       case 'close-commits-filter':
         $value = array_keys($value);
         $value = implode(', ', $value);
         break;
     }
 
     return $value;
   }
 
   public function setDetail($key, $value) {
     $this->details[$key] = $value;
     return $this;
   }
 
   public function attachCommitCount($count) {
     $this->commitCount = $count;
     return $this;
   }
 
   public function getCommitCount() {
     return $this->assertAttached($this->commitCount);
   }
 
   public function attachMostRecentCommit(
     PhabricatorRepositoryCommit $commit = null) {
     $this->mostRecentCommit = $commit;
     return $this;
   }
 
   public function getMostRecentCommit() {
     return $this->assertAttached($this->mostRecentCommit);
   }
 
   public function getDiffusionBrowseURIForPath(
     PhabricatorUser $user,
     $path,
     $line = null,
     $branch = null) {
 
     $drequest = DiffusionRequest::newFromDictionary(
       array(
         'user' => $user,
         'repository' => $this,
         'path' => $path,
         'branch' => $branch,
       ));
 
     return $drequest->generateURI(
       array(
         'action' => 'browse',
         'line'   => $line,
       ));
   }
 
   public function getLocalPath() {
     return $this->getDetail('local-path');
   }
 
   public function getSubversionBaseURI($commit = null) {
     $subpath = $this->getDetail('svn-subpath');
     if (!strlen($subpath)) {
       $subpath = null;
     }
     return $this->getSubversionPathURI($subpath, $commit);
   }
 
   public function getSubversionPathURI($path = null, $commit = null) {
     $vcs = $this->getVersionControlSystem();
     if ($vcs != PhabricatorRepositoryType::REPOSITORY_TYPE_SVN) {
       throw new Exception('Not a subversion repository!');
     }
 
     if ($this->isHosted()) {
       $uri = 'file://'.$this->getLocalPath();
     } else {
       $uri = $this->getDetail('remote-uri');
     }
 
     $uri = rtrim($uri, '/');
 
     if (strlen($path)) {
       $path = rawurlencode($path);
       $path = str_replace('%2F', '/', $path);
       $uri = $uri.'/'.ltrim($path, '/');
     }
 
     if ($path !== null || $commit !== null) {
       $uri .= '@';
     }
 
     if ($commit !== null) {
       $uri .= $commit;
     }
 
     return $uri;
   }
 
   public function attachProjectPHIDs(array $project_phids) {
     $this->projectPHIDs = $project_phids;
     return $this;
   }
 
   public function getProjectPHIDs() {
     return $this->assertAttached($this->projectPHIDs);
   }
 
 
   /**
    * Get the name of the directory this repository should clone or checkout
    * into. For example, if the repository name is "Example Repository", a
    * reasonable name might be "example-repository". This is used to help users
    * get reasonable results when cloning repositories, since they generally do
    * not want to clone into directories called "X/" or "Example Repository/".
    *
    * @return string
    */
   public function getCloneName() {
     $name = $this->getDetail('clone-name');
 
     // Make some reasonable effort to produce reasonable default directory
     // names from repository names.
     if (!strlen($name)) {
       $name = $this->getName();
       $name = phutil_utf8_strtolower($name);
       $name = preg_replace('@[/ -:]+@', '-', $name);
       $name = trim($name, '-');
       if (!strlen($name)) {
         $name = $this->getCallsign();
       }
     }
 
     return $name;
   }
 
 
 /* -(  Remote Command Execution  )------------------------------------------- */
 
 
   public function execRemoteCommand($pattern /* , $arg, ... */) {
     $args = func_get_args();
     return $this->newRemoteCommandFuture($args)->resolve();
   }
 
   public function execxRemoteCommand($pattern /* , $arg, ... */) {
     $args = func_get_args();
     return $this->newRemoteCommandFuture($args)->resolvex();
   }
 
   public function getRemoteCommandFuture($pattern /* , $arg, ... */) {
     $args = func_get_args();
     return $this->newRemoteCommandFuture($args);
   }
 
   public function passthruRemoteCommand($pattern /* , $arg, ... */) {
     $args = func_get_args();
     return $this->newRemoteCommandPassthru($args)->execute();
   }
 
   private function newRemoteCommandFuture(array $argv) {
     $argv = $this->formatRemoteCommand($argv);
     $future = newv('ExecFuture', $argv);
     $future->setEnv($this->getRemoteCommandEnvironment());
     return $future;
   }
 
   private function newRemoteCommandPassthru(array $argv) {
     $argv = $this->formatRemoteCommand($argv);
     $passthru = newv('PhutilExecPassthru', $argv);
     $passthru->setEnv($this->getRemoteCommandEnvironment());
     return $passthru;
   }
 
 
 /* -(  Local Command Execution  )-------------------------------------------- */
 
 
   public function execLocalCommand($pattern /* , $arg, ... */) {
     $args = func_get_args();
     return $this->newLocalCommandFuture($args)->resolve();
   }
 
   public function execxLocalCommand($pattern /* , $arg, ... */) {
     $args = func_get_args();
     return $this->newLocalCommandFuture($args)->resolvex();
   }
 
   public function getLocalCommandFuture($pattern /* , $arg, ... */) {
     $args = func_get_args();
     return $this->newLocalCommandFuture($args);
   }
 
   public function passthruLocalCommand($pattern /* , $arg, ... */) {
     $args = func_get_args();
     return $this->newLocalCommandPassthru($args)->execute();
   }
 
   private function newLocalCommandFuture(array $argv) {
     $this->assertLocalExists();
 
     $argv = $this->formatLocalCommand($argv);
     $future = newv('ExecFuture', $argv);
     $future->setEnv($this->getLocalCommandEnvironment());
 
     if ($this->usesLocalWorkingCopy()) {
       $future->setCWD($this->getLocalPath());
     }
 
     return $future;
   }
 
   private function newLocalCommandPassthru(array $argv) {
     $this->assertLocalExists();
 
     $argv = $this->formatLocalCommand($argv);
     $future = newv('PhutilExecPassthru', $argv);
     $future->setEnv($this->getLocalCommandEnvironment());
 
     if ($this->usesLocalWorkingCopy()) {
       $future->setCWD($this->getLocalPath());
     }
 
     return $future;
   }
 
 
 /* -(  Command Infrastructure  )--------------------------------------------- */
 
 
   private function getSSHWrapper() {
     $root = dirname(phutil_get_library_root('phabricator'));
     return $root.'/bin/ssh-connect';
   }
 
   private function getCommonCommandEnvironment() {
     $env = array(
       // NOTE: Force the language to "en_US.UTF-8", which overrides locale
       // settings. This makes stuff print in English instead of, e.g., French,
       // so we can parse the output of some commands, error messages, etc.
       'LANG' => 'en_US.UTF-8',
 
       // Propagate PHABRICATOR_ENV explicitly. For discussion, see T4155.
       'PHABRICATOR_ENV' => PhabricatorEnv::getSelectedEnvironmentName(),
     );
 
     switch ($this->getVersionControlSystem()) {
       case PhabricatorRepositoryType::REPOSITORY_TYPE_SVN:
         break;
       case PhabricatorRepositoryType::REPOSITORY_TYPE_GIT:
         // NOTE: See T2965. Some time after Git 1.7.5.4, Git started fataling if
         // it can not read $HOME. For many users, $HOME points at /root (this
         // seems to be a default result of Apache setup). Instead, explicitly
         // point $HOME at a readable, empty directory so that Git looks for the
         // config file it's after, fails to locate it, and moves on. This is
         // really silly, but seems like the least damaging approach to
         // mitigating the issue.
 
         $root = dirname(phutil_get_library_root('phabricator'));
         $env['HOME'] = $root.'/support/empty/';
         break;
       case PhabricatorRepositoryType::REPOSITORY_TYPE_MERCURIAL:
         // NOTE: This overrides certain configuration, extensions, and settings
         // which make Mercurial commands do random unusual things.
         $env['HGPLAIN'] = 1;
         break;
       default:
         throw new Exception('Unrecognized version control system.');
     }
 
     return $env;
   }
 
   private function getLocalCommandEnvironment() {
     return $this->getCommonCommandEnvironment();
   }
 
   private function getRemoteCommandEnvironment() {
     $env = $this->getCommonCommandEnvironment();
 
     if ($this->shouldUseSSH()) {
       // NOTE: This is read by `bin/ssh-connect`, and tells it which credentials
       // to use.
       $env['PHABRICATOR_CREDENTIAL'] = $this->getCredentialPHID();
       switch ($this->getVersionControlSystem()) {
         case PhabricatorRepositoryType::REPOSITORY_TYPE_SVN:
           // Force SVN to use `bin/ssh-connect`.
           $env['SVN_SSH'] = $this->getSSHWrapper();
           break;
         case PhabricatorRepositoryType::REPOSITORY_TYPE_GIT:
           // Force Git to use `bin/ssh-connect`.
           $env['GIT_SSH'] = $this->getSSHWrapper();
           break;
         case PhabricatorRepositoryType::REPOSITORY_TYPE_MERCURIAL:
           // We force Mercurial through `bin/ssh-connect` too, but it uses a
           // command-line flag instead of an environmental variable.
           break;
         default:
           throw new Exception('Unrecognized version control system.');
       }
     }
 
     return $env;
   }
 
   private function formatRemoteCommand(array $args) {
     $pattern = $args[0];
     $args = array_slice($args, 1);
 
     switch ($this->getVersionControlSystem()) {
       case PhabricatorRepositoryType::REPOSITORY_TYPE_SVN:
         if ($this->shouldUseHTTP() || $this->shouldUseSVNProtocol()) {
           $flags = array();
           $flag_args = array();
           $flags[] = '--non-interactive';
           $flags[] = '--no-auth-cache';
           if ($this->shouldUseHTTP()) {
             $flags[] = '--trust-server-cert';
           }
 
           $credential_phid = $this->getCredentialPHID();
           if ($credential_phid) {
             $key = PassphrasePasswordKey::loadFromPHID(
               $credential_phid,
               PhabricatorUser::getOmnipotentUser());
             $flags[] = '--username %P';
             $flags[] = '--password %P';
             $flag_args[] = $key->getUsernameEnvelope();
             $flag_args[] = $key->getPasswordEnvelope();
           }
 
           $flags = implode(' ', $flags);
           $pattern = "svn {$flags} {$pattern}";
           $args = array_mergev(array($flag_args, $args));
         } else {
           $pattern = "svn --non-interactive {$pattern}";
         }
         break;
       case PhabricatorRepositoryType::REPOSITORY_TYPE_GIT:
         $pattern = "git {$pattern}";
         break;
       case PhabricatorRepositoryType::REPOSITORY_TYPE_MERCURIAL:
         if ($this->shouldUseSSH()) {
           $pattern = "hg --config ui.ssh=%s {$pattern}";
           array_unshift(
             $args,
             $this->getSSHWrapper());
         } else {
           $pattern = "hg {$pattern}";
         }
         break;
       default:
         throw new Exception('Unrecognized version control system.');
     }
 
     array_unshift($args, $pattern);
 
     return $args;
   }
 
   private function formatLocalCommand(array $args) {
     $pattern = $args[0];
     $args = array_slice($args, 1);
 
     switch ($this->getVersionControlSystem()) {
       case PhabricatorRepositoryType::REPOSITORY_TYPE_SVN:
         $pattern = "svn --non-interactive {$pattern}";
         break;
       case PhabricatorRepositoryType::REPOSITORY_TYPE_GIT:
         $pattern = "git {$pattern}";
         break;
       case PhabricatorRepositoryType::REPOSITORY_TYPE_MERCURIAL:
         $pattern = "hg {$pattern}";
         break;
       default:
         throw new Exception('Unrecognized version control system.');
     }
 
     array_unshift($args, $pattern);
 
     return $args;
   }
 
   /**
    * Sanitize output of an `hg` command invoked with the `--debug` flag to make
    * it usable.
    *
    * @param string Output from `hg --debug ...`
    * @return string Usable output.
    */
   public static function filterMercurialDebugOutput($stdout) {
     // When hg commands are run with `--debug` and some config file isn't
     // trusted, Mercurial prints out a warning to stdout, twice, after Feb 2011.
     //
     // http://selenic.com/pipermail/mercurial-devel/2011-February/028541.html
 
     $lines = preg_split('/(?<=\n)/', $stdout);
     $regex = '/ignoring untrusted configuration option .*\n$/';
 
     foreach ($lines as $key => $line) {
       $lines[$key] = preg_replace($regex, '', $line);
     }
 
     return implode('', $lines);
   }
 
   public function getURI() {
     return '/diffusion/'.$this->getCallsign().'/';
   }
 
   public function getNormalizedPath() {
     $uri = (string)$this->getCloneURIObject();
 
     switch ($this->getVersionControlSystem()) {
       case PhabricatorRepositoryType::REPOSITORY_TYPE_GIT:
         $normalized_uri = new PhabricatorRepositoryURINormalizer(
           PhabricatorRepositoryURINormalizer::TYPE_GIT,
           $uri);
         break;
       case PhabricatorRepositoryType::REPOSITORY_TYPE_SVN:
         $normalized_uri = new PhabricatorRepositoryURINormalizer(
           PhabricatorRepositoryURINormalizer::TYPE_SVN,
           $uri);
         break;
       case PhabricatorRepositoryType::REPOSITORY_TYPE_MERCURIAL:
         $normalized_uri = new PhabricatorRepositoryURINormalizer(
           PhabricatorRepositoryURINormalizer::TYPE_MERCURIAL,
           $uri);
         break;
       default:
         throw new Exception('Unrecognized version control system.');
     }
 
     return $normalized_uri->getNormalizedPath();
   }
 
   public function isTracked() {
     return $this->getDetail('tracking-enabled', false);
   }
 
   public function getDefaultBranch() {
     $default = $this->getDetail('default-branch');
     if (strlen($default)) {
       return $default;
     }
 
     $default_branches = array(
       PhabricatorRepositoryType::REPOSITORY_TYPE_GIT        => 'master',
       PhabricatorRepositoryType::REPOSITORY_TYPE_MERCURIAL  => 'default',
     );
 
     return idx($default_branches, $this->getVersionControlSystem());
   }
 
   public function getDefaultArcanistBranch() {
     return coalesce($this->getDefaultBranch(), 'svn');
   }
 
   private function isBranchInFilter($branch, $filter_key) {
     $vcs = $this->getVersionControlSystem();
 
     $is_git = ($vcs == PhabricatorRepositoryType::REPOSITORY_TYPE_GIT);
 
     $use_filter = ($is_git);
     if (!$use_filter) {
       // If this VCS doesn't use filters, pass everything through.
       return true;
     }
 
 
     $filter = $this->getDetail($filter_key, array());
 
     // If there's no filter set, let everything through.
     if (!$filter) {
       return true;
     }
 
     // If this branch isn't literally named `regexp(...)`, and it's in the
     // filter list, let it through.
     if (isset($filter[$branch])) {
       if (self::extractBranchRegexp($branch) === null) {
         return true;
       }
     }
 
     // If the branch matches a regexp, let it through.
     foreach ($filter as $pattern => $ignored) {
       $regexp = self::extractBranchRegexp($pattern);
       if ($regexp !== null) {
         if (preg_match($regexp, $branch)) {
           return true;
         }
       }
     }
 
     // Nothing matched, so filter this branch out.
     return false;
   }
 
   public static function extractBranchRegexp($pattern) {
     $matches = null;
     if (preg_match('/^regexp\\((.*)\\)\z/', $pattern, $matches)) {
       return $matches[1];
     }
     return null;
   }
 
   public function shouldTrackBranch($branch) {
     return $this->isBranchInFilter($branch, 'branch-filter');
   }
 
   public function formatCommitName($commit_identifier) {
     $vcs = $this->getVersionControlSystem();
 
     $type_git = PhabricatorRepositoryType::REPOSITORY_TYPE_GIT;
     $type_hg = PhabricatorRepositoryType::REPOSITORY_TYPE_MERCURIAL;
 
     $is_git = ($vcs == $type_git);
     $is_hg = ($vcs == $type_hg);
     if ($is_git || $is_hg) {
       $short_identifier = substr($commit_identifier, 0, 12);
     } else {
       $short_identifier = $commit_identifier;
     }
 
     return 'r'.$this->getCallsign().$short_identifier;
   }
 
   public function isImporting() {
     return (bool)$this->getDetail('importing', false);
   }
 
 
 /* -(  Autoclose  )---------------------------------------------------------- */
 
 
   /**
    * Determine if autoclose is active for a branch.
    *
    * For more details about why, use @{method:shouldSkipAutocloseBranch}.
    *
    * @param string Branch name to check.
    * @return bool True if autoclose is active for the branch.
    * @task autoclose
    */
   public function shouldAutocloseBranch($branch) {
     return ($this->shouldSkipAutocloseBranch($branch) === null);
   }
 
   /**
    * Determine if autoclose is active for a commit.
    *
    * For more details about why, use @{method:shouldSkipAutocloseCommit}.
    *
    * @param PhabricatorRepositoryCommit Commit to check.
    * @return bool True if autoclose is active for the commit.
    * @task autoclose
    */
   public function shouldAutocloseCommit(PhabricatorRepositoryCommit $commit) {
     return ($this->shouldSkipAutocloseCommit($commit) === null);
   }
 
 
   /**
    * Determine why autoclose should be skipped for a branch.
    *
    * This method gives a detailed reason why autoclose will be skipped. To
    * perform a simple test, use @{method:shouldAutocloseBranch}.
    *
    * @param string Branch name to check.
    * @return const|null Constant identifying reason to skip this branch, or null
    *   if autoclose is active.
    * @task autoclose
    */
   public function shouldSkipAutocloseBranch($branch) {
     $all_reason = $this->shouldSkipAllAutoclose();
     if ($all_reason) {
       return $all_reason;
     }
 
     if (!$this->shouldTrackBranch($branch)) {
       return self::BECAUSE_BRANCH_UNTRACKED;
     }
 
     if (!$this->isBranchInFilter($branch, 'close-commits-filter')) {
       return self::BECAUSE_BRANCH_NOT_AUTOCLOSE;
     }
 
     return null;
   }
 
 
   /**
    * Determine why autoclose should be skipped for a commit.
    *
    * This method gives a detailed reason why autoclose will be skipped. To
    * perform a simple test, use @{method:shouldAutocloseCommit}.
    *
    * @param PhabricatorRepositoryCommit Commit to check.
    * @return const|null Constant identifying reason to skip this commit, or null
    *   if autoclose is active.
    * @task autoclose
    */
   public function shouldSkipAutocloseCommit(
     PhabricatorRepositoryCommit $commit) {
 
     $all_reason = $this->shouldSkipAllAutoclose();
     if ($all_reason) {
       return $all_reason;
     }
 
     switch ($this->getVersionControlSystem()) {
       case PhabricatorRepositoryType::REPOSITORY_TYPE_SVN:
       case PhabricatorRepositoryType::REPOSITORY_TYPE_MERCURIAL:
         return null;
       case PhabricatorRepositoryType::REPOSITORY_TYPE_GIT:
         break;
       default:
         throw new Exception('Unrecognized version control system.');
     }
 
     $closeable_flag = PhabricatorRepositoryCommit::IMPORTED_CLOSEABLE;
     if (!$commit->isPartiallyImported($closeable_flag)) {
       return self::BECAUSE_NOT_ON_AUTOCLOSE_BRANCH;
     }
 
     return null;
   }
 
 
   /**
    * Determine why all autoclose operations should be skipped for this
    * repository.
    *
    * @return const|null Constant identifying reason to skip all autoclose
    *   operations, or null if autoclose operations are not blocked at the
    *   repository level.
    * @task autoclose
    */
   private function shouldSkipAllAutoclose() {
     if ($this->isImporting()) {
       return self::BECAUSE_REPOSITORY_IMPORTING;
     }
 
     if ($this->getDetail('disable-autoclose', false)) {
       return self::BECAUSE_AUTOCLOSE_DISABLED;
     }
 
     return null;
   }
 
 
 /* -(  Repository URI Management  )------------------------------------------ */
 
 
   /**
    * Get the remote URI for this repository.
    *
    * @return string
    * @task uri
    */
   public function getRemoteURI() {
     return (string)$this->getRemoteURIObject();
   }
 
 
   /**
    * Get the remote URI for this repository, including credentials if they're
    * used by this repository.
    *
    * @return PhutilOpaqueEnvelope URI, possibly including credentials.
    * @task uri
    */
   public function getRemoteURIEnvelope() {
     $uri = $this->getRemoteURIObject();
 
     $remote_protocol = $this->getRemoteProtocol();
     if ($remote_protocol == 'http' || $remote_protocol == 'https') {
       // For SVN, we use `--username` and `--password` flags separately, so
       // don't add any credentials here.
       if (!$this->isSVN()) {
         $credential_phid = $this->getCredentialPHID();
         if ($credential_phid) {
           $key = PassphrasePasswordKey::loadFromPHID(
             $credential_phid,
             PhabricatorUser::getOmnipotentUser());
 
           $uri->setUser($key->getUsernameEnvelope()->openEnvelope());
           $uri->setPass($key->getPasswordEnvelope()->openEnvelope());
         }
       }
     }
 
     return new PhutilOpaqueEnvelope((string)$uri);
   }
 
 
   /**
    * Get the clone (or checkout) URI for this repository, without authentication
    * information.
    *
    * @return string Repository URI.
    * @task uri
    */
   public function getPublicCloneURI() {
     $uri = $this->getCloneURIObject();
 
     // Make sure we don't leak anything if this repo is using HTTP Basic Auth
     // with the credentials in the URI or something zany like that.
 
     // If repository is not accessed over SSH we remove both username and
     // password.
     if (!$this->isHosted()) {
       if (!$this->shouldUseSSH()) {
         $uri->setUser(null);
 
         // This might be a Git URI or a normal URI. If it's Git, there's no
         // password support.
         if ($uri instanceof PhutilURI) {
           $uri->setPass(null);
         }
       }
     }
 
     return (string)$uri;
   }
 
 
   /**
    * Get the protocol for the repository's remote.
    *
    * @return string Protocol, like "ssh" or "git".
    * @task uri
    */
   public function getRemoteProtocol() {
     $uri = $this->getRemoteURIObject();
 
     if ($uri instanceof PhutilGitURI) {
       return 'ssh';
     } else {
       return $uri->getProtocol();
     }
   }
 
 
   /**
    * Get a parsed object representation of the repository's remote URI. This
    * may be a normal URI (returned as a @{class@libphutil:PhutilURI}) or a git
    * URI (returned as a @{class@libphutil:PhutilGitURI}).
    *
    * @return wild A @{class@libphutil:PhutilURI} or
    *              @{class@libphutil:PhutilGitURI}.
    * @task uri
    */
   public function getRemoteURIObject() {
     $raw_uri = $this->getDetail('remote-uri');
     if (!$raw_uri) {
       return new PhutilURI('');
     }
 
     if (!strncmp($raw_uri, '/', 1)) {
       return new PhutilURI('file://'.$raw_uri);
     }
 
     $uri = new PhutilURI($raw_uri);
     if ($uri->getProtocol()) {
       return $uri;
     }
 
     $uri = new PhutilGitURI($raw_uri);
     if ($uri->getDomain()) {
       return $uri;
     }
 
     throw new Exception("Remote URI '{$raw_uri}' could not be parsed!");
   }
 
 
   /**
    * Get the "best" clone/checkout URI for this repository, on any protocol.
    */
   public function getCloneURIObject() {
     if (!$this->isHosted()) {
       if ($this->isSVN()) {
         // Make sure we pick up the "Import Only" path for Subversion, so
         // the user clones the repository starting at the correct path, not
         // from the root.
         $base_uri = $this->getSubversionBaseURI();
         $base_uri = new PhutilURI($base_uri);
         $path = $base_uri->getPath();
         if (!$path) {
           $path = '/';
         }
 
         // If the trailing "@" is not required to escape the URI, strip it for
         // readability.
         if (!preg_match('/@.*@/', $path)) {
           $path = rtrim($path, '@');
         }
 
         $base_uri->setPath($path);
         return $base_uri;
       } else {
         return $this->getRemoteURIObject();
       }
     }
 
     // Choose the best URI: pick a read/write URI over a URI which is not
     // read/write, and SSH over HTTP.
 
     $serve_ssh = $this->getServeOverSSH();
     $serve_http = $this->getServeOverHTTP();
 
     if ($serve_ssh === self::SERVE_READWRITE) {
       return $this->getSSHCloneURIObject();
     } else if ($serve_http === self::SERVE_READWRITE) {
       return $this->getHTTPCloneURIObject();
     } else if ($serve_ssh !== self::SERVE_OFF) {
       return $this->getSSHCloneURIObject();
     } else if ($serve_http !== self::SERVE_OFF) {
       return $this->getHTTPCloneURIObject();
     } else {
       return null;
     }
   }
 
 
   /**
    * Get the repository's SSH clone/checkout URI, if one exists.
    */
   public function getSSHCloneURIObject() {
     if (!$this->isHosted()) {
       if ($this->shouldUseSSH()) {
         return $this->getRemoteURIObject();
       } else {
         return null;
       }
     }
 
     $serve_ssh = $this->getServeOverSSH();
     if ($serve_ssh === self::SERVE_OFF) {
       return null;
     }
 
     $uri = new PhutilURI(PhabricatorEnv::getProductionURI($this->getURI()));
 
     if ($this->isSVN()) {
       $uri->setProtocol('svn+ssh');
     } else {
       $uri->setProtocol('ssh');
     }
 
     if ($this->isGit()) {
       $uri->setPath($uri->getPath().$this->getCloneName().'.git');
     } else if ($this->isHg()) {
       $uri->setPath($uri->getPath().$this->getCloneName().'/');
     }
 
     $ssh_user = PhabricatorEnv::getEnvConfig('diffusion.ssh-user');
     if ($ssh_user) {
       $uri->setUser($ssh_user);
     }
 
     $uri->setPort(PhabricatorEnv::getEnvConfig('diffusion.ssh-port'));
 
     return $uri;
   }
 
 
   /**
    * Get the repository's HTTP clone/checkout URI, if one exists.
    */
   public function getHTTPCloneURIObject() {
     if (!$this->isHosted()) {
       if ($this->shouldUseHTTP()) {
         return $this->getRemoteURIObject();
       } else {
         return null;
       }
     }
 
     $serve_http = $this->getServeOverHTTP();
     if ($serve_http === self::SERVE_OFF) {
       return null;
     }
 
     $uri = PhabricatorEnv::getProductionURI($this->getURI());
     $uri = new PhutilURI($uri);
 
     if ($this->isGit()) {
       $uri->setPath($uri->getPath().$this->getCloneName().'.git');
     } else if ($this->isHg()) {
       $uri->setPath($uri->getPath().$this->getCloneName().'/');
     }
 
     return $uri;
   }
 
 
   /**
    * Determine if we should connect to the remote using SSH flags and
    * credentials.
    *
    * @return bool True to use the SSH protocol.
    * @task uri
    */
   private function shouldUseSSH() {
     if ($this->isHosted()) {
       return false;
     }
 
     $protocol = $this->getRemoteProtocol();
     if ($this->isSSHProtocol($protocol)) {
       return true;
     }
 
     return false;
   }
 
 
   /**
    * Determine if we should connect to the remote using HTTP flags and
    * credentials.
    *
    * @return bool True to use the HTTP protocol.
    * @task uri
    */
   private function shouldUseHTTP() {
     if ($this->isHosted()) {
       return false;
     }
 
     $protocol = $this->getRemoteProtocol();
     return ($protocol == 'http' || $protocol == 'https');
   }
 
 
   /**
    * Determine if we should connect to the remote using SVN flags and
    * credentials.
    *
    * @return bool True to use the SVN protocol.
    * @task uri
    */
   private function shouldUseSVNProtocol() {
     if ($this->isHosted()) {
       return false;
     }
 
     $protocol = $this->getRemoteProtocol();
     return ($protocol == 'svn');
   }
 
 
   /**
    * Determine if a protocol is SSH or SSH-like.
    *
    * @param string A protocol string, like "http" or "ssh".
    * @return bool True if the protocol is SSH-like.
    * @task uri
    */
   private function isSSHProtocol($protocol) {
     return ($protocol == 'ssh' || $protocol == 'svn+ssh');
   }
 
   public function delete() {
     $this->openTransaction();
 
       $paths = id(new PhabricatorOwnersPath())
         ->loadAllWhere('repositoryPHID = %s', $this->getPHID());
       foreach ($paths as $path) {
         $path->delete();
       }
 
       $projects = id(new PhabricatorRepositoryArcanistProject())
         ->loadAllWhere('repositoryID = %d', $this->getID());
       foreach ($projects as $project) {
         // note each project deletes its PhabricatorRepositorySymbols
         $project->delete();
       }
 
       $commits = id(new PhabricatorRepositoryCommit())
         ->loadAllWhere('repositoryID = %d', $this->getID());
       foreach ($commits as $commit) {
         // note PhabricatorRepositoryAuditRequests and
         // PhabricatorRepositoryCommitData are deleted here too.
         $commit->delete();
       }
 
       $mirrors = id(new PhabricatorRepositoryMirror())
         ->loadAllWhere('repositoryPHID = %s', $this->getPHID());
       foreach ($mirrors as $mirror) {
         $mirror->delete();
       }
 
       $ref_cursors = id(new PhabricatorRepositoryRefCursor())
         ->loadAllWhere('repositoryPHID = %s', $this->getPHID());
       foreach ($ref_cursors as $cursor) {
         $cursor->delete();
       }
 
       $conn_w = $this->establishConnection('w');
 
       queryfx(
         $conn_w,
         'DELETE FROM %T WHERE repositoryID = %d',
         self::TABLE_FILESYSTEM,
         $this->getID());
 
       queryfx(
         $conn_w,
         'DELETE FROM %T WHERE repositoryID = %d',
         self::TABLE_PATHCHANGE,
         $this->getID());
 
       queryfx(
         $conn_w,
         'DELETE FROM %T WHERE repositoryID = %d',
         self::TABLE_SUMMARY,
         $this->getID());
 
       $result = parent::delete();
 
     $this->saveTransaction();
     return $result;
   }
 
   public function isGit() {
     $vcs = $this->getVersionControlSystem();
     return ($vcs == PhabricatorRepositoryType::REPOSITORY_TYPE_GIT);
   }
 
   public function isSVN() {
     $vcs = $this->getVersionControlSystem();
     return ($vcs == PhabricatorRepositoryType::REPOSITORY_TYPE_SVN);
   }
 
   public function isHg() {
     $vcs = $this->getVersionControlSystem();
     return ($vcs == PhabricatorRepositoryType::REPOSITORY_TYPE_MERCURIAL);
   }
 
   public function isHosted() {
     return (bool)$this->getDetail('hosting-enabled', false);
   }
 
   public function setHosted($enabled) {
     return $this->setDetail('hosting-enabled', $enabled);
   }
 
   public function getServeOverHTTP() {
     if ($this->isSVN()) {
       return self::SERVE_OFF;
     }
     $serve = $this->getDetail('serve-over-http', self::SERVE_OFF);
     return $this->normalizeServeConfigSetting($serve);
   }
 
   public function setServeOverHTTP($mode) {
     return $this->setDetail('serve-over-http', $mode);
   }
 
   public function getServeOverSSH() {
     $serve = $this->getDetail('serve-over-ssh', self::SERVE_OFF);
     return $this->normalizeServeConfigSetting($serve);
   }
 
   public function setServeOverSSH($mode) {
     return $this->setDetail('serve-over-ssh', $mode);
   }
 
   public static function getProtocolAvailabilityName($constant) {
     switch ($constant) {
       case self::SERVE_OFF:
         return pht('Off');
       case self::SERVE_READONLY:
         return pht('Read Only');
       case self::SERVE_READWRITE:
         return pht('Read/Write');
       default:
         return pht('Unknown');
     }
   }
 
   private function normalizeServeConfigSetting($value) {
     switch ($value) {
       case self::SERVE_OFF:
       case self::SERVE_READONLY:
         return $value;
       case self::SERVE_READWRITE:
         if ($this->isHosted()) {
           return self::SERVE_READWRITE;
         } else {
           return self::SERVE_READONLY;
         }
       default:
         return self::SERVE_OFF;
     }
   }
 
 
   /**
    * Raise more useful errors when there are basic filesystem problems.
    */
   private function assertLocalExists() {
     if (!$this->usesLocalWorkingCopy()) {
       return;
     }
 
     $local = $this->getLocalPath();
     Filesystem::assertExists($local);
     Filesystem::assertIsDirectory($local);
     Filesystem::assertReadable($local);
   }
 
   /**
    * Determine if the working copy is bare or not. In Git, this corresponds
    * to `--bare`. In Mercurial, `--noupdate`.
    */
   public function isWorkingCopyBare() {
     switch ($this->getVersionControlSystem()) {
       case PhabricatorRepositoryType::REPOSITORY_TYPE_SVN:
       case PhabricatorRepositoryType::REPOSITORY_TYPE_MERCURIAL:
         return false;
       case PhabricatorRepositoryType::REPOSITORY_TYPE_GIT:
         $local = $this->getLocalPath();
         if (Filesystem::pathExists($local.'/.git')) {
           return false;
         } else {
           return true;
         }
     }
   }
 
   public function usesLocalWorkingCopy() {
     switch ($this->getVersionControlSystem()) {
       case PhabricatorRepositoryType::REPOSITORY_TYPE_SVN:
         return $this->isHosted();
       case PhabricatorRepositoryType::REPOSITORY_TYPE_GIT:
       case PhabricatorRepositoryType::REPOSITORY_TYPE_MERCURIAL:
         return true;
     }
   }
 
   public function getHookDirectories() {
     $directories = array();
     if (!$this->isHosted()) {
       return $directories;
     }
 
     $root = $this->getLocalPath();
 
     switch ($this->getVersionControlSystem()) {
       case PhabricatorRepositoryType::REPOSITORY_TYPE_GIT:
         if ($this->isWorkingCopyBare()) {
           $directories[] = $root.'/hooks/pre-receive-phabricator.d/';
         } else {
           $directories[] = $root.'/.git/hooks/pre-receive-phabricator.d/';
         }
         break;
       case PhabricatorRepositoryType::REPOSITORY_TYPE_SVN:
         $directories[] = $root.'/hooks/pre-commit-phabricator.d/';
         break;
       case PhabricatorRepositoryType::REPOSITORY_TYPE_MERCURIAL:
         // NOTE: We don't support custom Mercurial hooks for now because they're
         // messy and we can't easily just drop a `hooks.d/` directory next to
         // the hooks.
         break;
     }
 
     return $directories;
   }
 
   public function canDestroyWorkingCopy() {
     if ($this->isHosted()) {
       // Never destroy hosted working copies.
       return false;
     }
 
     $default_path = PhabricatorEnv::getEnvConfig(
       'repository.default-local-path');
     return Filesystem::isDescendant($this->getLocalPath(), $default_path);
   }
 
   public function canUsePathTree() {
     return !$this->isSVN();
   }
 
   public function canMirror() {
     if ($this->isGit() || $this->isHg()) {
       return true;
     }
 
     return false;
   }
 
   public function canAllowDangerousChanges() {
     if (!$this->isHosted()) {
       return false;
     }
 
     if ($this->isGit() || $this->isHg()) {
       return true;
     }
 
     return false;
   }
 
   public function shouldAllowDangerousChanges() {
     return (bool)$this->getDetail('allow-dangerous-changes');
   }
 
   public function writeStatusMessage(
     $status_type,
     $status_code,
     array $parameters = array()) {
 
     $table = new PhabricatorRepositoryStatusMessage();
     $conn_w = $table->establishConnection('w');
     $table_name = $table->getTableName();
 
     if ($status_code === null) {
       queryfx(
         $conn_w,
         'DELETE FROM %T WHERE repositoryID = %d AND statusType = %s',
         $table_name,
         $this->getID(),
         $status_type);
     } else {
       queryfx(
         $conn_w,
         'INSERT INTO %T
           (repositoryID, statusType, statusCode, parameters, epoch)
           VALUES (%d, %s, %s, %s, %d)
           ON DUPLICATE KEY UPDATE
             statusCode = VALUES(statusCode),
             parameters = VALUES(parameters),
             epoch = VALUES(epoch)',
         $table_name,
         $this->getID(),
         $status_type,
         $status_code,
         json_encode($parameters),
         time());
     }
 
     return $this;
   }
 
   public static function getRemoteURIProtocol($raw_uri) {
     $uri = new PhutilURI($raw_uri);
     if ($uri->getProtocol()) {
       return strtolower($uri->getProtocol());
     }
 
     $git_uri = new PhutilGitURI($raw_uri);
     if (strlen($git_uri->getDomain()) && strlen($git_uri->getPath())) {
       return 'ssh';
     }
 
     return null;
   }
 
   public static function assertValidRemoteURI($uri) {
     if (trim($uri) != $uri) {
       throw new Exception(
         pht(
           'The remote URI has leading or trailing whitespace.'));
     }
 
     $protocol = self::getRemoteURIProtocol($uri);
 
     // Catch confusion between Git/SCP-style URIs and normal URIs. See T3619
     // for discussion. This is usually a user adding "ssh://" to an implicit
     // SSH Git URI.
     if ($protocol == 'ssh') {
       if (preg_match('(^[^:@]+://[^/:]+:[^\d])', $uri)) {
         throw new Exception(
           pht(
             "The remote URI is not formatted correctly. Remote URIs ".
             "with an explicit protocol should be in the form ".
             "'proto://domain/path', not 'proto://domain:/path'. ".
             "The ':/path' syntax is only valid in SCP-style URIs."));
       }
     }
 
     switch ($protocol) {
       case 'ssh':
       case 'http':
       case 'https':
       case 'git':
       case 'svn':
       case 'svn+ssh':
         break;
       default:
         // NOTE: We're explicitly rejecting 'file://' because it can be
         // used to clone from the working copy of another repository on disk
         // that you don't normally have permission to access.
 
         throw new Exception(
           pht(
             "The URI protocol is unrecognized. It should begin ".
             "'ssh://', 'http://', 'https://', 'git://', 'svn://', ".
             "'svn+ssh://', or be in the form 'git@domain.com:path'."));
     }
 
     return true;
   }
 
 
   /**
    * Load the pull frequency for this repository, based on the time since the
    * last activity.
    *
    * We pull rarely used repositories less frequently. This finds the most
    * recent commit which is older than the current time (which prevents us from
    * spinning on repositories with a silly commit post-dated to some time in
    * 2037). We adjust the pull frequency based on when the most recent commit
    * occurred.
    *
    * @param   int   The minimum update interval to use, in seconds.
    * @return  int   Repository update interval, in seconds.
    */
   public function loadUpdateInterval($minimum = 15) {
     // If a repository is still importing, always pull it as frequently as
     // possible. This prevents us from hanging for a long time at 99.9% when
     // importing an inactive repository.
     if ($this->isImporting()) {
       return $minimum;
     }
 
     $window_start = (PhabricatorTime::getNow() + $minimum);
 
     $table = id(new PhabricatorRepositoryCommit());
     $last_commit = queryfx_one(
       $table->establishConnection('r'),
       'SELECT epoch FROM %T
         WHERE repositoryID = %d AND epoch <= %d
         ORDER BY epoch DESC LIMIT 1',
       $table->getTableName(),
       $this->getID(),
       $window_start);
     if ($last_commit) {
       $time_since_commit = ($window_start - $last_commit['epoch']);
 
       $last_few_days = phutil_units('3 days in seconds');
 
       if ($time_since_commit <= $last_few_days) {
         // For repositories with activity in the recent past, we wait one
         // extra second for every 10 minutes since the last commit. This
         // shorter backoff is intended to handle weekends and other short
         // breaks from development.
         $smart_wait = ($time_since_commit / 600);
       } else {
         // For repositories without recent activity, we wait one extra second
         // for every 4 minutes since the last commit. This longer backoff
         // handles rarely used repositories, up to the maximum.
         $smart_wait = ($time_since_commit / 240);
       }
 
       // We'll never wait more than 6 hours to pull a repository.
       $longest_wait = phutil_units('6 hours in seconds');
       $smart_wait = min($smart_wait, $longest_wait);
 
       $smart_wait = max($minimum, $smart_wait);
     } else {
       $smart_wait = $minimum;
     }
 
     return $smart_wait;
   }
 
 
 /* -(  PhabricatorPolicyInterface  )----------------------------------------- */
 
 
   public function getCapabilities() {
     return array(
       PhabricatorPolicyCapability::CAN_VIEW,
       PhabricatorPolicyCapability::CAN_EDIT,
       DiffusionPushCapability::CAPABILITY,
     );
   }
 
   public function getPolicy($capability) {
     switch ($capability) {
       case PhabricatorPolicyCapability::CAN_VIEW:
         return $this->getViewPolicy();
       case PhabricatorPolicyCapability::CAN_EDIT:
         return $this->getEditPolicy();
       case DiffusionPushCapability::CAPABILITY:
         return $this->getPushPolicy();
     }
   }
 
   public function hasAutomaticCapability($capability, PhabricatorUser $user) {
     return false;
   }
 
   public function describeAutomaticCapability($capability) {
     return null;
   }
 
 
 
 /* -(  PhabricatorMarkupInterface  )----------------------------------------- */
 
 
   public function getMarkupFieldKey($field) {
     $hash = PhabricatorHash::digestForIndex($this->getMarkupText($field));
     return "repo:{$hash}";
   }
 
   public function newMarkupEngine($field) {
     return PhabricatorMarkupEngine::newMarkupEngine(array());
   }
 
   public function getMarkupText($field) {
     return $this->getDetail('description');
   }
 
   public function didMarkupText(
     $field,
     $output,
     PhutilMarkupEngine $engine) {
     require_celerity_resource('phabricator-remarkup-css');
     return phutil_tag(
       'div',
       array(
         'class' => 'phabricator-remarkup',
       ),
       $output);
   }
 
   public function shouldUseMarkupCache($field) {
     return true;
   }
 
 
 /* -(  PhabricatorDestructibleInterface  )----------------------------------- */
 
   public function destroyObjectPermanently(
     PhabricatorDestructionEngine $engine) {
 
     $this->openTransaction();
     $this->delete();
     $this->saveTransaction();
   }
 
 }
diff --git a/src/applications/repository/storage/PhabricatorRepositoryArcanistProject.php b/src/applications/repository/storage/PhabricatorRepositoryArcanistProject.php
index 9f51be32c1..7511add7d2 100644
--- a/src/applications/repository/storage/PhabricatorRepositoryArcanistProject.php
+++ b/src/applications/repository/storage/PhabricatorRepositoryArcanistProject.php
@@ -1,118 +1,118 @@
 <?php
 
 final class PhabricatorRepositoryArcanistProject
   extends PhabricatorRepositoryDAO
   implements
     PhabricatorPolicyInterface,
     PhabricatorDestructibleInterface {
 
   protected $name;
   protected $repositoryID;
 
   protected $symbolIndexLanguages = array();
   protected $symbolIndexProjects  = array();
 
   private $repository = self::ATTACHABLE;
 
   public function getConfiguration() {
     return array(
       self::CONFIG_AUX_PHID   => true,
       self::CONFIG_TIMESTAMPS => false,
       self::CONFIG_SERIALIZATION => array(
         'symbolIndexLanguages' => self::SERIALIZATION_JSON,
         'symbolIndexProjects'  => self::SERIALIZATION_JSON,
       ),
       self::CONFIG_COLUMN_SCHEMA => array(
-        'name' => 'text255',
+        'name' => 'text128',
         'repositoryID' => 'id?',
       ),
       self::CONFIG_KEY_SCHEMA => array(
         'key_phid' => null,
         'phid' => array(
           'columns' => array('phid'),
           'unique' => true,
         ),
         'name' => array(
           'columns' => array('name'),
           'unique' => true,
         ),
       ),
     ) + parent::getConfiguration();
   }
 
   public function generatePHID() {
     return PhabricatorPHID::generateNewPHID(
       PhabricatorRepositoryArcanistProjectPHIDType::TYPECONST);
   }
 
   // TODO: Remove. Also, T603.
   public function loadRepository() {
     if (!$this->getRepositoryID()) {
       return null;
     }
     return id(new PhabricatorRepository())->load($this->getRepositoryID());
   }
 
   public function delete() {
     $this->openTransaction();
 
       queryfx(
         $this->establishConnection('w'),
         'DELETE FROM %T WHERE arcanistProjectID = %d',
         id(new PhabricatorRepositorySymbol())->getTableName(),
         $this->getID());
 
       $result = parent::delete();
     $this->saveTransaction();
     return $result;
   }
 
   public function getRepository() {
     return $this->assertAttached($this->repository);
   }
 
   public function attachRepository(PhabricatorRepository $repository = null) {
     $this->repository = $repository;
     return $this;
   }
 
 
 
 /* -(  PhabricatorPolicyInterface  )----------------------------------------- */
 
   public function getCapabilities() {
     return array(
       PhabricatorPolicyCapability::CAN_VIEW,
       PhabricatorPolicyCapability::CAN_EDIT,
     );
   }
 
   public function getPolicy($capability) {
     switch ($capability) {
       case PhabricatorPolicyCapability::CAN_VIEW:
         return PhabricatorPolicies::POLICY_USER;
       case PhabricatorPolicyCapability::CAN_EDIT:
         return PhabricatorPolicies::POLICY_ADMIN;
     }
   }
 
   public function hasAutomaticCapability($capability, PhabricatorUser $viewer) {
     return false;
   }
 
   public function describeAutomaticCapability($capability) {
     return null;
   }
 
 
 /* -(  PhabricatorDestructibleInterface  )----------------------------------- */
 
   public function destroyObjectPermanently(
     PhabricatorDestructionEngine $engine) {
 
     $this->openTransaction();
     $this->delete();
     $this->saveTransaction();
   }
 
 }
diff --git a/src/applications/repository/storage/PhabricatorRepositoryBranch.php b/src/applications/repository/storage/PhabricatorRepositoryBranch.php
index c6eccb902a..9a8aca87ff 100644
--- a/src/applications/repository/storage/PhabricatorRepositoryBranch.php
+++ b/src/applications/repository/storage/PhabricatorRepositoryBranch.php
@@ -1,43 +1,43 @@
 <?php
 
 final class PhabricatorRepositoryBranch extends PhabricatorRepositoryDAO {
 
   protected $repositoryID;
   protected $name;
   protected $lintCommit;
 
   public function getConfiguration() {
     return array(
       self::CONFIG_COLUMN_SCHEMA => array(
-        'name' => 'text255',
+        'name' => 'text128',
         'lintCommit' => 'text40?',
       ),
       self::CONFIG_KEY_SCHEMA => array(
         'repositoryID' => array(
           'columns' => array('repositoryID', 'name'),
           'unique' => true,
         ),
       ),
     ) + parent::getConfiguration();
   }
 
   public static function loadBranch($repository_id, $branch_name) {
     return id(new PhabricatorRepositoryBranch())->loadOneWhere(
       'repositoryID = %d AND name = %s',
       $repository_id,
       $branch_name);
   }
 
   public static function loadOrCreateBranch($repository_id, $branch_name) {
     $branch = self::loadBranch($repository_id, $branch_name);
     if ($branch) {
       return $branch;
     }
 
     return id(new PhabricatorRepositoryBranch())
       ->setRepositoryID($repository_id)
       ->setName($branch_name)
       ->save();
   }
 
 }
diff --git a/src/applications/repository/storage/PhabricatorRepositoryCommitData.php b/src/applications/repository/storage/PhabricatorRepositoryCommitData.php
index 474a8a239d..bc8cc42dc2 100644
--- a/src/applications/repository/storage/PhabricatorRepositoryCommitData.php
+++ b/src/applications/repository/storage/PhabricatorRepositoryCommitData.php
@@ -1,76 +1,73 @@
 <?php
 
 final class PhabricatorRepositoryCommitData extends PhabricatorRepositoryDAO {
 
   /**
    * NOTE: We denormalize this into the commit table; make sure the sizes
    * match up.
    */
   const SUMMARY_MAX_LENGTH = 80;
 
   protected $commitID;
   protected $authorName    = '';
   protected $commitMessage = '';
   protected $commitDetails = array();
 
   public function getConfiguration() {
     return array(
       self::CONFIG_TIMESTAMPS => false,
       self::CONFIG_SERIALIZATION => array(
         'commitDetails' => self::SERIALIZATION_JSON,
       ),
       self::CONFIG_COLUMN_SCHEMA => array(
-        'authorName' => 'text255',
+        'authorName' => 'text',
         'commitMessage' => 'text',
       ),
       self::CONFIG_KEY_SCHEMA => array(
         'commitID' => array(
           'columns' => array('commitID'),
           'unique' => true,
         ),
-        'authorName' => array(
-          'columns' => array('authorName'),
-        ),
       ),
     ) + parent::getConfiguration();
   }
 
   public function getSummary() {
     $message = $this->getCommitMessage();
     return self::summarizeCommitMessage($message);
   }
 
   public static function summarizeCommitMessage($message) {
     $summary = phutil_split_lines($message, $retain_endings = false);
     $summary = head($summary);
     $summary = id(new PhutilUTF8StringTruncator())
       ->setMaximumCodepoints(self::SUMMARY_MAX_LENGTH)
       ->truncateString($summary);
 
     return $summary;
   }
 
   public function getCommitDetail($key, $default = null) {
     return idx($this->commitDetails, $key, $default);
   }
 
   public function setCommitDetail($key, $value) {
     $this->commitDetails[$key] = $value;
     return $this;
   }
 
   public function toDictionary() {
     return array(
       'commitID' => $this->commitID,
       'authorName' => $this->authorName,
       'commitMessage' => $this->commitMessage,
       'commitDetails' => json_encode($this->commitDetails),
     );
   }
 
   public static function newFromDictionary(array $dict) {
     return id(new PhabricatorRepositoryCommitData())
       ->loadFromArray($dict);
   }
 
 }
diff --git a/src/applications/repository/storage/PhabricatorRepositorySchemaSpec.php b/src/applications/repository/storage/PhabricatorRepositorySchemaSpec.php
index 92014e738e..e2254eea90 100644
--- a/src/applications/repository/storage/PhabricatorRepositorySchemaSpec.php
+++ b/src/applications/repository/storage/PhabricatorRepositorySchemaSpec.php
@@ -1,185 +1,185 @@
 <?php
 
 final class PhabricatorRepositorySchemaSpec
   extends PhabricatorConfigSchemaSpec {
 
   public function buildSchemata() {
     $this->buildLiskSchemata('PhabricatorRepositoryDAO');
 
     $this->buildEdgeSchemata(new PhabricatorRepository());
 
     $this->buildTransactionSchema(
       new PhabricatorRepositoryTransaction());
 
     $this->buildRawSchema(
       id(new PhabricatorRepository())->getApplicationName(),
       PhabricatorRepository::TABLE_BADCOMMIT,
       array(
-        'fullCommitName' => 'text255',
+        'fullCommitName' => 'text64',
         'description' => 'text',
       ),
       array(
         'PRIMARY' => array(
           'columns' => array('fullCommitName'),
           'unique' => true,
         ),
       ));
 
     $this->buildRawSchema(
       id(new PhabricatorRepository())->getApplicationName(),
       PhabricatorRepository::TABLE_COVERAGE,
       array(
         'id' => 'id',
         'branchID' => 'id',
         'commitID' => 'id',
         'pathID' => 'id',
         'coverage' => 'bytes',
       ),
       array(
         'PRIMARY' => array(
           'columns' => array('id'),
           'unique' => true,
         ),
         'key_path' => array(
           'columns' => array('branchID', 'pathID', 'commitID'),
         ),
       ));
 
     $this->buildRawSchema(
       id(new PhabricatorRepository())->getApplicationName(),
       PhabricatorRepository::TABLE_FILESYSTEM,
       array(
         'repositoryID' => 'id',
         'parentID' => 'id',
         'svnCommit' => 'uint32',
         'pathID' => 'id',
         'existed' => 'bool',
         'fileType' => 'uint32',
       ),
       array(
         'PRIMARY' => array(
           'columns' => array('repositoryID', 'parentID', 'pathID', 'svnCommit'),
           'unique' => true,
         ),
         'repositoryID' => array(
           'columns' => array('repositoryID', 'svnCommit'),
         ),
       ));
 
     $this->buildRawSchema(
       id(new PhabricatorRepository())->getApplicationName(),
       PhabricatorRepository::TABLE_LINTMESSAGE,
       array(
         'id' => 'id',
         'branchID' => 'id',
         'path' => 'text',
         'line' => 'uint32',
         'authorPHID' => 'phid?',
         'code' => 'text32',
         'severity' => 'text16',
         'name' => 'text255',
         'description' => 'text',
       ),
       array(
         'PRIMARY' => array(
           'columns' => array('id'),
           'unique' => true,
         ),
         'branchID' => array(
           'columns' => array('branchID', 'path(64)'),
         ),
         'branchID_2' => array(
           'columns' => array('branchID', 'code', 'path(64)'),
         ),
         'key_author' => array(
           'columns' => array('authorPHID'),
         ),
       ));
 
     $this->buildRawSchema(
       id(new PhabricatorRepository())->getApplicationName(),
       PhabricatorRepository::TABLE_PARENTS,
       array(
         'id' => 'id',
         'childCommitID' => 'id',
         'parentCommitID' => 'id',
       ),
       array(
         'PRIMARY' => array(
           'columns' => array('id'),
           'unique' => true,
         ),
         'key_child' => array(
           'columns' => array('childCommitID', 'parentCommitID'),
           'unique' => true,
         ),
         'key_parent' => array(
           'columns' => array('parentCommitID'),
         ),
       ));
 
     $this->buildRawSchema(
       id(new PhabricatorRepository())->getApplicationName(),
       PhabricatorRepository::TABLE_PATH,
       array(
         'id' => 'id',
         'path' => 'text',
         'pathHash' => 'bytes32',
       ),
       array(
         'PRIMARY' => array(
           'columns' => array('id'),
           'unique' => true,
         ),
         'pathHash' => array(
           'columns' => array('pathHash'),
           'unique' => true,
         ),
       ));
 
     $this->buildRawSchema(
       id(new PhabricatorRepository())->getApplicationName(),
       PhabricatorRepository::TABLE_PATHCHANGE,
       array(
         'repositoryID' => 'id',
         'pathID' => 'id',
         'commitID' => 'id',
         'targetPathID' => 'id?',
         'targetCommitID' => 'id?',
         'changeType' => 'uint32',
         'fileType' => 'uint32',
         'isDirect' => 'bool',
         'commitSequence' => 'uint32',
       ),
       array(
         'PRIMARY' => array(
           'columns' => array('commitID', 'pathID'),
           'unique' => true,
         ),
         'repositoryID' => array(
           'columns' => array('repositoryID', 'pathID', 'commitSequence'),
         ),
       ));
 
     $this->buildRawSchema(
       id(new PhabricatorRepository())->getApplicationName(),
       PhabricatorRepository::TABLE_SUMMARY,
       array(
         'repositoryID' => 'id',
         'size' => 'uint32',
         'lastCommitID' => 'id',
         'epoch' => 'epoch?',
       ),
       array(
         'PRIMARY' => array(
           'columns' => array('repositoryID'),
           'unique' => true,
         ),
         'key_epoch' => array(
           'columns' => array('epoch'),
         ),
       ));
 
   }
 
 }
diff --git a/src/applications/search/storage/document/PhabricatorSearchDocumentField.php b/src/applications/search/storage/document/PhabricatorSearchDocumentField.php
index c0b858e274..68b44423d5 100644
--- a/src/applications/search/storage/document/PhabricatorSearchDocumentField.php
+++ b/src/applications/search/storage/document/PhabricatorSearchDocumentField.php
@@ -1,38 +1,37 @@
 <?php
 
 final class PhabricatorSearchDocumentField extends PhabricatorSearchDAO {
 
   protected $phidType;
   protected $field;
   protected $auxPHID;
   protected $corpus;
 
   public function getConfiguration() {
     return array(
       self::CONFIG_TIMESTAMPS => false,
       self::CONFIG_IDS        => self::IDS_MANUAL,
       self::CONFIG_COLUMN_SCHEMA => array(
         'phidType' => 'text4',
         'field' => 'text4',
         'auxPHID' => 'phid?',
         'corpus' => 'text?',
       ),
       self::CONFIG_KEY_SCHEMA => array(
         'key_phid' => null,
         'phid' => array(
           'columns' => array('phid'),
         ),
-
-        // NOTE: This is a fulltext index! Be careful!
         'corpus' => array(
           'columns' => array('corpus'),
+          'type' => 'FULLTEXT',
         ),
       ),
     ) + parent::getConfiguration();
   }
 
   public function getIDKey() {
     return 'phid';
   }
 
 }
diff --git a/src/infrastructure/daemon/workers/storage/PhabricatorWorkerTask.php b/src/infrastructure/daemon/workers/storage/PhabricatorWorkerTask.php
index 43b598ece1..b02c0727a9 100644
--- a/src/infrastructure/daemon/workers/storage/PhabricatorWorkerTask.php
+++ b/src/infrastructure/daemon/workers/storage/PhabricatorWorkerTask.php
@@ -1,69 +1,69 @@
 <?php
 
 abstract class PhabricatorWorkerTask extends PhabricatorWorkerDAO {
 
   // NOTE: If you provide additional fields here, make sure they are handled
   // correctly in the archiving process.
   protected $taskClass;
   protected $leaseOwner;
   protected $leaseExpires;
   protected $failureCount;
   protected $dataID;
   protected $priority;
 
   private $data;
   private $executionException;
 
   public function getConfiguration() {
     return array(
       self::CONFIG_COLUMN_SCHEMA => array(
-        'taskClass' => 'text255',
-        'leaseOwner' => 'text255?',
+        'taskClass' => 'text64',
+        'leaseOwner' => 'text64?',
         'leaseExpires' => 'epoch?',
         'failureCount' => 'uint32',
         'failureTime' => 'epoch?',
         'priority' => 'uint32',
       ),
     ) + parent::getConfiguration();
   }
 
   final public function setExecutionException(Exception $execution_exception) {
     $this->executionException = $execution_exception;
     return $this;
   }
 
   final public function getExecutionException() {
     return $this->executionException;
   }
 
   final public function setData($data) {
     $this->data = $data;
     return $this;
   }
 
   final public function getData() {
     return $this->data;
   }
 
   final public function isArchived() {
     return ($this instanceof PhabricatorWorkerArchiveTask);
   }
 
   final public function getWorkerInstance() {
     $id = $this->getID();
     $class = $this->getTaskClass();
 
     if (!class_exists($class)) {
       throw new PhabricatorWorkerPermanentFailureException(
         "Task class '{$class}' does not exist!");
     }
 
     if (!is_subclass_of($class, 'PhabricatorWorker')) {
       throw new PhabricatorWorkerPermanentFailureException(
         "Task class '{$class}' does not extend PhabricatorWorker.");
     }
 
     return newv($class, array($this->getData()));
   }
 
 }
diff --git a/src/infrastructure/storage/management/workflow/PhabricatorStorageManagementAdjustWorkflow.php b/src/infrastructure/storage/management/workflow/PhabricatorStorageManagementAdjustWorkflow.php
index 8210ddef49..c2f492cd54 100644
--- a/src/infrastructure/storage/management/workflow/PhabricatorStorageManagementAdjustWorkflow.php
+++ b/src/infrastructure/storage/management/workflow/PhabricatorStorageManagementAdjustWorkflow.php
@@ -1,424 +1,464 @@
 <?php
 
 final class PhabricatorStorageManagementAdjustWorkflow
   extends PhabricatorStorageManagementWorkflow {
 
   public function didConstruct() {
     $this
       ->setName('adjust')
       ->setExamples('**adjust** [__options__]')
       ->setSynopsis(
         pht(
           'Make schemata adjustments to correct issues with characters sets, '.
           'collations, and keys.'));
   }
 
   public function execute(PhutilArgumentParser $args) {
+    $force = $args->getArg('force');
+
     $this->requireAllPatchesApplied();
-    $this->adjustSchemata();
+    $this->adjustSchemata($force);
     return 0;
   }
 
   private function requireAllPatchesApplied() {
     $api = $this->getAPI();
     $applied = $api->getAppliedPatches();
 
     if ($applied === null) {
       throw new PhutilArgumentUsageException(
         pht(
           'You have not initialized the database yet. You must initialize '.
           'the database before you can adjust schemata. Run `storage upgrade` '.
           'to initialize the database.'));
     }
 
     $applied = array_fuse($applied);
 
     $patches = $this->getPatches();
     $patches = mpull($patches, null, 'getFullKey');
     $missing = array_diff_key($patches, $applied);
 
     if ($missing) {
       throw new PhutilArgumentUsageException(
         pht(
           'You have not applied all available storage patches yet. You must '.
           'apply all available patches before you can adjust schemata. '.
           'Run `storage status` to show patch status, and `storage upgrade` '.
           'to apply missing patches.'));
     }
   }
 
   private function loadSchemata() {
     $query = id(new PhabricatorConfigSchemaQuery())
       ->setAPI($this->getAPI());
 
     $actual = $query->loadActualSchema();
     $expect = $query->loadExpectedSchema();
     $comp = $query->buildComparisonSchema($expect, $actual);
 
     return array($comp, $expect, $actual);
   }
 
-  private function adjustSchemata() {
+  private function adjustSchemata($force) {
     $console = PhutilConsole::getConsole();
 
     $console->writeOut(
       "%s\n",
       pht('Verifying database schemata...'));
 
     $adjustments = $this->findAdjustments();
 
     if (!$adjustments) {
       $console->writeOut(
         "%s\n",
         pht('Found no issues with schemata.'));
       return;
     }
 
     $table = id(new PhutilConsoleTable())
       ->addColumn('database', array('title' => pht('Database')))
       ->addColumn('table', array('title' => pht('Table')))
       ->addColumn('name', array('title' => pht('Name')))
       ->addColumn('info', array('title' => pht('Issues')));
 
     foreach ($adjustments as $adjust) {
       $info = array();
       foreach ($adjust['issues'] as $issue) {
         $info[] = PhabricatorConfigStorageSchema::getIssueName($issue);
       }
 
       $table->addRow(array(
         'database' => $adjust['database'],
         'table' => idx($adjust, 'table'),
         'name' => idx($adjust, 'name'),
         'info' => implode(', ', $info),
       ));
     }
 
     $console->writeOut("\n\n");
 
     $table->draw();
 
-    $console->writeOut(
-      "\n%s\n",
-      pht(
-        "Found %s issues(s) with schemata, detailed above.\n\n".
-        "You can review issues in more detail from the web interface, ".
-        "in Config > Database Status.\n\n".
-        "MySQL needs to copy table data to make some adjustments, so these ".
-        "migrations may take some time.".
-
-        // TODO: Remove warning once this stabilizes.
-        "\n\n".
-        "WARNING: This workflow is new and unstable. If you continue, you ".
-        "may unrecoverably destory data. Make sure you have a backup before ".
-        "you proceed.",
-
-        new PhutilNumber(count($adjustments))));
-
-    $prompt = pht('Fix these schema issues?');
-    if (!phutil_console_confirm($prompt, $default_no = true)) {
-      return;
+    if (!$force) {
+      $console->writeOut(
+        "\n%s\n",
+        pht(
+          "Found %s issues(s) with schemata, detailed above.\n\n".
+          "You can review issues in more detail from the web interface, ".
+          "in Config > Database Status.\n\n".
+          "MySQL needs to copy table data to make some adjustments, so these ".
+          "migrations may take some time.".
+
+          // TODO: Remove warning once this stabilizes.
+          "\n\n".
+          "WARNING: This workflow is new and unstable. If you continue, you ".
+          "may unrecoverably destory data. Make sure you have a backup before ".
+          "you proceed.",
+
+          new PhutilNumber(count($adjustments))));
+
+      $prompt = pht('Fix these schema issues?');
+      if (!phutil_console_confirm($prompt, $default_no = true)) {
+        return;
+      }
     }
 
     $console->writeOut(
       "%s\n",
       pht('Fixing schema issues...'));
 
     $api = $this->getAPI();
     $conn = $api->getConn(null);
 
     $failed = array();
 
     // We make changes in three phases:
     //
     // Phase 0: Drop all keys which we're going to adjust. This prevents them
     // from interfering with column changes.
     //
     // Phase 1: Apply all database, table, and column changes.
     //
     // Phase 2: Restore adjusted keys.
     $phases = 3;
 
     $bar = id(new PhutilConsoleProgressBar())
       ->setTotal(count($adjustments) * $phases);
 
     for ($phase = 0; $phase < $phases; $phase++) {
       foreach ($adjustments as $adjust) {
         try {
           switch ($adjust['kind']) {
             case 'database':
               if ($phase != 1) {
                 break;
               }
               queryfx(
                 $conn,
                 'ALTER DATABASE %T CHARACTER SET = %s COLLATE = %s',
                 $adjust['database'],
                 $adjust['charset'],
                 $adjust['collation']);
               break;
             case 'table':
               if ($phase != 1) {
                 break;
               }
               queryfx(
                 $conn,
                 'ALTER TABLE %T.%T COLLATE = %s',
                 $adjust['database'],
                 $adjust['table'],
                 $adjust['collation']);
               break;
             case 'column':
               if ($phase != 1) {
                 break;
               }
               $parts = array();
               if ($adjust['charset']) {
                 $parts[] = qsprintf(
                   $conn,
                   'CHARACTER SET %Q COLLATE %Q',
                   $adjust['charset'],
                   $adjust['collation']);
               }
 
               queryfx(
                 $conn,
                 'ALTER TABLE %T.%T MODIFY %T %Q %Q %Q',
                 $adjust['database'],
                 $adjust['table'],
                 $adjust['name'],
                 $adjust['type'],
                 implode(' ', $parts),
                 $adjust['nullable'] ? 'NULL' : 'NOT NULL');
 
               break;
             case 'key':
               if (($phase == 0) && $adjust['exists']) {
+                if ($adjust['name'] == 'PRIMARY') {
+                  $key_name = 'PRIMARY KEY';
+                } else {
+                  $key_name = qsprintf($conn, 'KEY %T', $adjust['name']);
+                }
+
                 queryfx(
                   $conn,
-                  'ALTER TABLE %T.%T DROP KEY %T',
+                  'ALTER TABLE %T.%T DROP %Q',
                   $adjust['database'],
                   $adjust['table'],
-                  $adjust['name']);
+                  $key_name);
               }
 
               if (($phase == 2) && $adjust['keep']) {
+                // Different keys need different creation syntax. Notable
+                // special cases are primary keys and fulltext keys.
+                if ($adjust['name'] == 'PRIMARY') {
+                  $key_name = 'PRIMARY KEY';
+                } else if ($adjust['indexType'] == 'FULLTEXT') {
+                  $key_name = qsprintf($conn, 'FULLTEXT %T', $adjust['name']);
+                } else {
+                  if ($adjust['unique']) {
+                    $key_name = qsprintf(
+                      $conn,
+                      'UNIQUE KEY %T',
+                      $adjust['name']);
+                  } else {
+                    $key_name = qsprintf(
+                      $conn,
+                      '/* NONUNIQUE */ KEY %T',
+                      $adjust['name']);
+                  }
+                }
+
                 queryfx(
                   $conn,
-                  'ALTER TABLE %T.%T ADD %Q KEY %T (%Q)',
+                  'ALTER TABLE %T.%T ADD %Q (%Q)',
                   $adjust['database'],
                   $adjust['table'],
-                  $adjust['unique'] ? 'UNIQUE' : '/* NONUNIQUE */',
-                  $adjust['name'],
+                  $key_name,
                   implode(', ', $adjust['columns']));
               }
               break;
             default:
               throw new Exception(
                 pht('Unknown schema adjustment kind "%s"!', $adjust['kind']));
           }
         } catch (AphrontQueryException $ex) {
           $failed[] = array($adjust, $ex);
         }
         $bar->update(1);
       }
     }
     $bar->done();
 
     if (!$failed) {
       $console->writeOut(
         "%s\n",
         pht('Completed fixing all schema issues.'));
       return;
     }
 
     $table = id(new PhutilConsoleTable())
       ->addColumn('target', array('title' => pht('Target')))
       ->addColumn('error', array('title' => pht('Error')));
 
     foreach ($failed as $failure) {
       list($adjust, $ex) = $failure;
 
-      $pieces = array_select_keys($adjust, array('database', 'table', 'naeme'));
+      $pieces = array_select_keys($adjust, array('database', 'table', 'name'));
       $pieces = array_filter($pieces);
       $target = implode('.', $pieces);
 
       $table->addRow(
         array(
           'target' => $target,
           'error' => $ex->getMessage(),
         ));
     }
 
     $console->writeOut("\n");
     $table->draw();
     $console->writeOut(
       "\n%s\n",
       pht('Failed to make some schema adjustments, detailed above.'));
 
     return 1;
   }
 
   private function findAdjustments() {
     list($comp, $expect, $actual) = $this->loadSchemata();
 
     $issue_charset = PhabricatorConfigStorageSchema::ISSUE_CHARSET;
     $issue_collation = PhabricatorConfigStorageSchema::ISSUE_COLLATION;
     $issue_columntype = PhabricatorConfigStorageSchema::ISSUE_COLUMNTYPE;
     $issue_surpluskey = PhabricatorConfigStorageSchema::ISSUE_SURPLUSKEY;
     $issue_missingkey = PhabricatorConfigStorageSchema::ISSUE_MISSINGKEY;
     $issue_columns = PhabricatorConfigStorageSchema::ISSUE_KEYCOLUMNS;
     $issue_unique = PhabricatorConfigStorageSchema::ISSUE_UNIQUE;
-
+    $issue_longkey = PhabricatorConfigStorageSchema::ISSUE_LONGKEY;
 
     $adjustments = array();
     foreach ($comp->getDatabases() as $database_name => $database) {
       $expect_database = $expect->getDatabase($database_name);
       $actual_database = $actual->getDatabase($database_name);
 
       if (!$expect_database || !$actual_database) {
         // If there's a real issue here, skip this stuff.
         continue;
       }
 
       $issues = array();
       if ($database->hasIssue($issue_charset)) {
         $issues[] = $issue_charset;
       }
       if ($database->hasIssue($issue_collation)) {
         $issues[] = $issue_collation;
       }
 
       if ($issues) {
         $adjustments[] = array(
           'kind' => 'database',
           'database' => $database_name,
           'issues' => $issues,
           'charset' => $expect_database->getCharacterSet(),
           'collation' => $expect_database->getCollation(),
         );
       }
 
       foreach ($database->getTables() as $table_name => $table) {
         $expect_table = $expect_database->getTable($table_name);
         $actual_table = $actual_database->getTable($table_name);
 
         if (!$expect_table || !$actual_table) {
           continue;
         }
 
         $issues = array();
         if ($table->hasIssue($issue_collation)) {
           $issues[] = $issue_collation;
         }
 
         if ($issues) {
           $adjustments[] = array(
             'kind' => 'table',
             'database' => $database_name,
             'table' => $table_name,
             'issues' => $issues,
             'collation' => $expect_table->getCollation(),
           );
         }
 
         foreach ($table->getColumns() as $column_name => $column) {
           $expect_column = $expect_table->getColumn($column_name);
           $actual_column = $actual_table->getColumn($column_name);
 
           if (!$expect_column || !$actual_column) {
             continue;
           }
 
           $issues = array();
           if ($column->hasIssue($issue_collation)) {
             $issues[] = $issue_collation;
           }
           if ($column->hasIssue($issue_charset)) {
             $issues[] = $issue_charset;
           }
           if ($column->hasIssue($issue_columntype)) {
             $issues[] = $issue_columntype;
           }
 
           if ($issues) {
             if ($expect_column->getCharacterSet() === null) {
               // For non-text columns, we won't be specifying a collation or
               // character set.
               $charset = null;
               $collation = null;
             } else {
               $charset = $expect_column->getCharacterSet();
               $collation = $expect_column->getCollation();
             }
 
 
             $adjustments[] = array(
               'kind' => 'column',
               'database' => $database_name,
               'table' => $table_name,
               'name' => $column_name,
               'issues' => $issues,
               'collation' => $collation,
               'charset' => $charset,
               'type' => $expect_column->getColumnType(),
 
               // NOTE: We don't adjust column nullability because it is
               // dangerous, so always use the current nullability.
               'nullable' => $actual_column->getNullable(),
             );
           }
         }
 
         foreach ($table->getKeys() as $key_name => $key) {
           $expect_key = $expect_table->getKey($key_name);
           $actual_key = $actual_table->getKey($key_name);
 
           $issues = array();
           $keep_key = true;
           if ($key->hasIssue($issue_surpluskey)) {
             $issues[] = $issue_surpluskey;
             $keep_key = false;
           }
 
           if ($key->hasIssue($issue_missingkey)) {
             $issues[] = $issue_missingkey;
           }
 
           if ($key->hasIssue($issue_columns)) {
             $issues[] = $issue_columns;
           }
 
           if ($key->hasIssue($issue_unique)) {
             $issues[] = $issue_unique;
           }
 
+          // NOTE: We can't really fix this, per se, but we may need to remove
+          // the key to change the column type. In the best case, the new
+          // column type won't be overlong and recreating the key really will
+          // fix the issue. In the worst case, we get the right column type and
+          // lose the key, which is still better than retaining the key having
+          // the wrong column type.
+          if ($key->hasIssue($issue_longkey)) {
+            $issues[] = $issue_longkey;
+          }
+
           if ($issues) {
             $adjustment = array(
               'kind' => 'key',
               'database' => $database_name,
               'table' => $table_name,
               'name' => $key_name,
               'issues' => $issues,
               'exists' => (bool)$actual_key,
               'keep' => $keep_key,
             );
 
             if ($keep_key) {
               $adjustment += array(
                 'columns' => $expect_key->getColumnNames(),
                 'unique' => $expect_key->getUnique(),
+                'indexType' => $expect_key->getIndexType(),
               );
             }
 
             $adjustments[] = $adjustment;
           }
         }
       }
     }
 
     return $adjustments;
   }
 
 
 }
diff --git a/src/infrastructure/storage/schema/PhabricatorStorageSchemaSpec.php b/src/infrastructure/storage/schema/PhabricatorStorageSchemaSpec.php
index 39a1f1c2d9..886df14e2c 100644
--- a/src/infrastructure/storage/schema/PhabricatorStorageSchemaSpec.php
+++ b/src/infrastructure/storage/schema/PhabricatorStorageSchemaSpec.php
@@ -1,22 +1,22 @@
 <?php
 
 final class PhabricatorStorageSchemaSpec
   extends PhabricatorConfigSchemaSpec {
 
   public function buildSchemata() {
     $this->buildRawSchema(
       'meta_data',
       'patch_status',
       array(
-        'patch' => 'text255',
+        'patch' => 'text128',
         'applied' => 'uint32',
       ),
       array(
         'PRIMARY' => array(
           'columns' => array('patch'),
           'unique' => true,
         ),
       ));
   }
 
 }