diff --git a/src/applications/config/schema/PhabricatorConfigStorageSchema.php b/src/applications/config/schema/PhabricatorConfigStorageSchema.php
index 8b59d8f1fe..e1c8bda4cd 100644
--- a/src/applications/config/schema/PhabricatorConfigStorageSchema.php
+++ b/src/applications/config/schema/PhabricatorConfigStorageSchema.php
@@ -1,219 +1,219 @@
 <?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_SUBNOTE = 'subnote';
   const ISSUE_SUBWARN = 'subwarn';
   const ISSUE_SUBFAIL = 'subfail';
 
   const STATUS_OKAY = 'okay';
   const STATUS_NOTE = 'note';
   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_NOTE:
           $issues[self::ISSUE_SUBNOTE] = self::ISSUE_SUBNOTE;
           break;
         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_SUBNOTE:
         return pht('Subschemata Have Notices');
       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.');
       case self::ISSUE_UNIQUE:
         return pht('This key has the wrong uniqueness setting.');
       case self::ISSUE_SUBNOTE:
         return pht('Subschemata have setup notices.');
       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_SUBFAIL:
       case self::ISSUE_SURPLUS:
+      case self::ISSUE_SUBFAIL:
         return self::STATUS_FAIL;
       case self::ISSUE_SUBWARN:
       case self::ISSUE_COLUMNTYPE:
-      case self::ISSUE_KEYCOLUMNS:
       case self::ISSUE_NULLABLE:
         return self::STATUS_WARN;
       case self::ISSUE_SUBNOTE:
       case self::ISSUE_CHARSET:
       case self::ISSUE_COLLATION:
       case self::ISSUE_MISSINGKEY:
       case self::ISSUE_SURPLUSKEY:
       case self::ISSUE_UNIQUE:
+      case self::ISSUE_KEYCOLUMNS:
         return self::STATUS_NOTE;
       default:
         throw new Exception(pht('Unknown schema issue "%s"!', $issue));
     }
   }
 
   public static function getStatusSeverity($status) {
     switch ($status) {
       case self::STATUS_FAIL:
         return 3;
       case self::STATUS_WARN:
         return 2;
       case self::STATUS_NOTE:
         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/nuance/storage/NuanceItem.php b/src/applications/nuance/storage/NuanceItem.php
index fe02f7679a..f27151e786 100644
--- a/src/applications/nuance/storage/NuanceItem.php
+++ b/src/applications/nuance/storage/NuanceItem.php
@@ -1,137 +1,137 @@
 <?php
 
 final class NuanceItem
   extends NuanceDAO
   implements PhabricatorPolicyInterface {
 
   const STATUS_OPEN     = 0;
   const STATUS_ASSIGNED = 10;
   const STATUS_CLOSED   = 20;
 
   protected $status;
   protected $ownerPHID;
   protected $requestorPHID;
   protected $sourcePHID;
   protected $sourceLabel;
   protected $data;
   protected $mailKey;
   protected $dateNuanced;
 
   public static function initializeNewItem(PhabricatorUser $user) {
     return id(new NuanceItem())
       ->setDateNuanced(time())
       ->setStatus(NuanceItem::STATUS_OPEN);
   }
 
   public function getConfiguration() {
     return array(
       self::CONFIG_AUX_PHID => true,
       self::CONFIG_SERIALIZATION => array(
         'data' => self::SERIALIZATION_JSON,
       ),
       self::CONFIG_COLUMN_SCHEMA => array(
         'ownerPHID' => 'phid?',
         'sourceLabel' => 'text255?',
         'status' => 'uint32',
         'mailKey' => 'bytes20',
         'dateNuanced' => 'epoch',
       ),
       self::CONFIG_KEY_SCHEMA => array(
         'key_source' => array(
-          'columns' => array('sourcePHID', 'status', 'dateNuanced'),
+          'columns' => array('sourcePHID', 'status', 'dateNuanced', 'id'),
         ),
         'key_owner' => array(
-          'columns' => array('ownerPHID', 'status', 'dateNuanced'),
+          'columns' => array('ownerPHID', 'status', 'dateNuanced', 'id'),
         ),
         'key_contacter' => array(
-          'columns' => array('requestorPHID', 'status', 'dateNuanced'),
+          'columns' => array('requestorPHID', 'status', 'dateNuanced', 'id'),
         ),
       ),
     ) + parent::getConfiguration();
   }
 
   public function generatePHID() {
     return PhabricatorPHID::generateNewPHID(
       NuanceItemPHIDType::TYPECONST);
   }
 
   public function save() {
     if (!$this->getMailKey()) {
       $this->setMailKey(Filesystem::readRandomCharacters(20));
     }
     return parent::save();
   }
 
   public function getURI() {
     return '/nuance/item/view/'.$this->getID().'/';
   }
 
   public function getLabel(PhabricatorUser $viewer) {
     // this is generated at the time the item is created based on
     // the configuration from the item source. It is typically
     // something like 'Twitter'.
     $source_label = $this->getSourceLabel();
 
     return pht(
       'Item via %s @ %s.',
       $source_label,
       phabricator_datetime($this->getDateCreated(), $viewer));
   }
 
   public function getRequestor() {
     return $this->assertAttached($this->requestor);
   }
 
   public function attachRequestor(NuanceRequestor $requestor) {
     return $this->requestor = $requestor;
   }
 
   public function getSource() {
     return $this->assertAttached($this->source);
   }
 
   public function attachSource(NuanceSource $source) {
     $this->source = $source;
   }
 
   public function getCapabilities() {
     return array(
       PhabricatorPolicyCapability::CAN_VIEW,
       PhabricatorPolicyCapability::CAN_EDIT,
     );
   }
 
   public function getPolicy($capability) {
     // TODO - this should be based on the queues the item currently resides in
     return PhabricatorPolicies::POLICY_USER;
   }
 
   public function hasAutomaticCapability($capability, PhabricatorUser $viewer) {
     // TODO - requestors should get auto access too!
     return $viewer->getPHID() == $this->ownerPHID;
   }
 
   public function describeAutomaticCapability($capability) {
     switch ($capability) {
       case PhabricatorPolicyCapability::CAN_VIEW:
         return pht('Owners of an item can always view it.');
       case PhabricatorPolicyCapability::CAN_EDIT:
         return pht('Owners of an item can always edit it.');
     }
     return null;
   }
 
   public function toDictionary() {
     return array(
       'id' => $this->getID(),
       'phid' => $this->getPHID(),
       'ownerPHID' => $this->getOwnerPHID(),
       'requestorPHID' => $this->getRequestorPHID(),
       'sourcePHID' => $this->getSourcePHID(),
       'sourceLabel' => $this->getSourceLabel(),
       'dateCreated' => $this->getDateCreated(),
       'dateModified' => $this->getDateModified(),
       'dateNuanced' => $this->getDateNuanced(),
     );
   }
 }
diff --git a/src/applications/nuance/storage/NuanceQueueItem.php b/src/applications/nuance/storage/NuanceQueueItem.php
index 3fbaecd099..027ed99e69 100644
--- a/src/applications/nuance/storage/NuanceQueueItem.php
+++ b/src/applications/nuance/storage/NuanceQueueItem.php
@@ -1,29 +1,34 @@
 <?php
 
 final class NuanceQueueItem
   extends NuanceDAO {
 
   protected $queuePHID;
   protected $itemPHID;
   protected $itemStatus;
   protected $itemDateNuanced;
 
   public function getConfiguration() {
     return array(
       self::CONFIG_COLUMN_SCHEMA => array(
         'itemStatus' => 'uint32',
         'itemDateNuanced' => 'epoch',
       ),
       self::CONFIG_KEY_SCHEMA => array(
         'key_one_per_queue' => array(
           'columns' => array('itemPHID', 'queuePHID'),
           'unique' => true,
         ),
         'key_queue' => array(
-          'columns' => array('queuePHID', 'itemStatus', 'itemDateNuanced'),
+          'columns' => array(
+            'queuePHID',
+            'itemStatus',
+            'itemDateNuanced',
+            'id',
+          ),
         ),
       ),
     ) + parent::getConfiguration();
   }
 
 }
diff --git a/src/applications/phame/storage/PhamePost.php b/src/applications/phame/storage/PhamePost.php
index bef665b7d6..ee98628e70 100644
--- a/src/applications/phame/storage/PhamePost.php
+++ b/src/applications/phame/storage/PhamePost.php
@@ -1,251 +1,256 @@
 <?php
 
 final class PhamePost extends PhameDAO
   implements
     PhabricatorPolicyInterface,
     PhabricatorMarkupInterface,
     PhabricatorTokenReceiverInterface {
 
   const MARKUP_FIELD_BODY    = 'markup:body';
   const MARKUP_FIELD_SUMMARY = 'markup:summary';
 
   const VISIBILITY_DRAFT     = 0;
   const VISIBILITY_PUBLISHED = 1;
 
   protected $bloggerPHID;
   protected $title;
   protected $phameTitle;
   protected $body;
   protected $visibility;
   protected $configData;
   protected $datePublished;
   protected $blogPHID;
 
   private $blog;
 
   public static function initializePost(
     PhabricatorUser $blogger,
     PhameBlog $blog) {
 
     $post = id(new PhamePost())
       ->setBloggerPHID($blogger->getPHID())
       ->setBlogPHID($blog->getPHID())
       ->setBlog($blog)
       ->setDatePublished(0)
       ->setVisibility(self::VISIBILITY_DRAFT);
     return $post;
   }
 
   public function setBlog(PhameBlog $blog) {
     $this->blog = $blog;
     return $this;
   }
 
   public function getBlog() {
     return $this->blog;
   }
 
   public function getViewURI() {
     // go for the pretty uri if we can
     $domain = ($this->blog ? $this->blog->getDomain() : '');
     if ($domain) {
       $phame_title = PhabricatorSlug::normalize($this->getPhameTitle());
       return 'http://'.$domain.'/post/'.$phame_title;
     }
     $uri = '/phame/post/view/'.$this->getID().'/';
     return PhabricatorEnv::getProductionURI($uri);
   }
 
   public function getEditURI() {
     return '/phame/post/edit/'.$this->getID().'/';
   }
 
   public function isDraft() {
     return $this->getVisibility() == self::VISIBILITY_DRAFT;
   }
 
   public function getHumanName() {
     if ($this->isDraft()) {
       $name = 'draft';
     } else {
       $name = 'post';
     }
 
     return $name;
   }
 
   public function getCommentsWidget() {
     $config_data = $this->getConfigData();
     if (empty($config_data)) {
       return 'none';
     }
     return idx($config_data, 'comments_widget', 'none');
   }
 
   public function getConfiguration() {
     return array(
       self::CONFIG_AUX_PHID   => true,
       self::CONFIG_SERIALIZATION => array(
         'configData' => self::SERIALIZATION_JSON,
       ),
       self::CONFIG_COLUMN_SCHEMA => array(
         'title' => 'text255',
         'phameTitle' => 'text64',
         'body' => 'text',
         'visibility' => 'uint32',
         'datePublished' => 'epoch?',
       ),
       self::CONFIG_KEY_SCHEMA => array(
         'key_phid' => null,
         'phid' => array(
           'columns' => array('phid'),
           'unique' => true,
         ),
         'phameTitle' => array(
           'columns' => array('bloggerPHID', 'phameTitle'),
           'unique' => true,
         ),
         'bloggerPosts' => array(
-          'columns' => array('bloggerPHID', 'visibility', 'datePublished'),
+          'columns' => array(
+            'bloggerPHID',
+            'visibility',
+            'datePublished',
+            'id',
+          ),
         ),
       ),
     ) + parent::getConfiguration();
   }
 
   public function generatePHID() {
     return PhabricatorPHID::generateNewPHID(
       PhabricatorPhamePostPHIDType::TYPECONST);
   }
 
   public function toDictionary() {
     return array(
       'id'            => $this->getID(),
       'phid'          => $this->getPHID(),
       'blogPHID'      => $this->getBlogPHID(),
       'bloggerPHID'   => $this->getBloggerPHID(),
       'viewURI'       => $this->getViewURI(),
       'title'         => $this->getTitle(),
       'phameTitle'    => $this->getPhameTitle(),
       'body'          => $this->getBody(),
       'summary'       => PhabricatorMarkupEngine::summarize($this->getBody()),
       'datePublished' => $this->getDatePublished(),
       'published'     => !$this->isDraft(),
     );
   }
 
   public static function getVisibilityOptionsForSelect() {
     return array(
       self::VISIBILITY_DRAFT     => 'Draft: visible only to me.',
       self::VISIBILITY_PUBLISHED => 'Published: visible to the whole world.',
     );
   }
 
   public function getCommentsWidgetOptionsForSelect() {
     $current = $this->getCommentsWidget();
     $options = array();
 
     if ($current == 'facebook' ||
         PhabricatorFacebookAuthProvider::getFacebookApplicationID()) {
       $options['facebook'] = 'Facebook';
     }
     if ($current == 'disqus' ||
         PhabricatorEnv::getEnvConfig('disqus.shortname')) {
       $options['disqus'] = 'Disqus';
     }
     $options['none'] = 'None';
 
     return $options;
   }
 
 
 /* -(  PhabricatorPolicyInterface Implementation  )-------------------------- */
 
 
   public function getCapabilities() {
     return array(
       PhabricatorPolicyCapability::CAN_VIEW,
       PhabricatorPolicyCapability::CAN_EDIT,
     );
   }
 
 
   public function getPolicy($capability) {
     // Draft posts are visible only to the author. Published posts are visible
     // to whoever the blog is visible to.
 
     switch ($capability) {
       case PhabricatorPolicyCapability::CAN_VIEW:
         if (!$this->isDraft() && $this->getBlog()) {
           return $this->getBlog()->getViewPolicy();
         } else {
           return PhabricatorPolicies::POLICY_NOONE;
         }
         break;
       case PhabricatorPolicyCapability::CAN_EDIT:
         return PhabricatorPolicies::POLICY_NOONE;
     }
   }
 
 
   public function hasAutomaticCapability($capability, PhabricatorUser $user) {
     // A blog post's author can always view it, and is the only user allowed
     // to edit it.
 
     switch ($capability) {
       case PhabricatorPolicyCapability::CAN_VIEW:
       case PhabricatorPolicyCapability::CAN_EDIT:
         return ($user->getPHID() == $this->getBloggerPHID());
     }
   }
 
 
   public function describeAutomaticCapability($capability) {
     return pht(
       'The author of a blog post can always view and edit it.');
   }
 
 
 /* -(  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) {
     switch ($field) {
       case self::MARKUP_FIELD_BODY:
         return $this->getBody();
       case self::MARKUP_FIELD_SUMMARY:
         return PhabricatorMarkupEngine::summarize($this->getBody());
     }
   }
 
   public function didMarkupText(
     $field,
     $output,
     PhutilMarkupEngine $engine) {
     return $output;
   }
 
 
   public function shouldUseMarkupCache($field) {
     return (bool)$this->getPHID();
   }
 
 /* -(  PhabricatorTokenReceiverInterface  )---------------------------------- */
 
   public function getUsersToNotifyOfTokenGiven() {
     return array(
       $this->getBloggerPHID(),
     );
   }
 
 }