diff --git a/src/applications/legalpad/query/LegalpadDocumentQuery.php b/src/applications/legalpad/query/LegalpadDocumentQuery.php
index b178f443c..4936433c9 100644
--- a/src/applications/legalpad/query/LegalpadDocumentQuery.php
+++ b/src/applications/legalpad/query/LegalpadDocumentQuery.php
@@ -1,245 +1,274 @@
 <?php
 
 final class LegalpadDocumentQuery
   extends PhabricatorCursorPagedPolicyAwareQuery {
 
   private $ids;
   private $phids;
   private $creatorPHIDs;
   private $contributorPHIDs;
   private $signerPHIDs;
   private $dateCreatedAfter;
   private $dateCreatedBefore;
 
   private $needDocumentBodies;
   private $needContributors;
   private $needSignatures;
+  private $needViewerSignatures;
 
   public function withIDs(array $ids) {
     $this->ids = $ids;
     return $this;
   }
 
   public function withPHIDs(array $phids) {
     $this->phids = $phids;
     return $this;
   }
 
   public function withCreatorPHIDs(array $phids) {
     $this->creatorPHIDs = $phids;
     return $this;
   }
 
   public function withContributorPHIDs(array $phids) {
     $this->contributorPHIDs = $phids;
     return $this;
   }
 
   public function withSignerPHIDs(array $phids) {
     $this->signerPHIDs = $phids;
     return $this;
   }
 
   public function needDocumentBodies($need_bodies) {
     $this->needDocumentBodies = $need_bodies;
     return $this;
   }
 
   public function needContributors($need_contributors) {
     $this->needContributors = $need_contributors;
     return $this;
   }
 
   public function needSignatures($need_signatures) {
     $this->needSignatures = $need_signatures;
     return $this;
   }
 
   public function withDateCreatedBefore($date_created_before) {
     $this->dateCreatedBefore = $date_created_before;
     return $this;
   }
 
   public function withDateCreatedAfter($date_created_after) {
     $this->dateCreatedAfter = $date_created_after;
     return $this;
   }
 
+  public function needViewerSignatures($need) {
+    $this->needViewerSignatures = $need;
+    return $this;
+  }
+
   protected function loadPage() {
     $table = new LegalpadDocument();
     $conn_r = $table->establishConnection('r');
 
     $data = queryfx_all(
       $conn_r,
       'SELECT d.* FROM %T d %Q %Q %Q %Q',
       $table->getTableName(),
       $this->buildJoinClause($conn_r),
       $this->buildWhereClause($conn_r),
       $this->buildOrderClause($conn_r),
       $this->buildLimitClause($conn_r));
 
     $documents = $table->loadAllFromArray($data);
 
     return $documents;
   }
 
   protected function willFilterPage(array $documents) {
     if ($this->signerPHIDs) {
       $document_map = mpull($documents, null, 'getPHID');
       $signatures = id(new LegalpadDocumentSignatureQuery())
         ->setViewer($this->getViewer())
         ->withDocumentPHIDs(array_keys($document_map))
         ->withSignerPHIDs($this->signerPHIDs)
         ->execute();
       $signatures = mgroup($signatures, 'getDocumentPHID');
       foreach ($document_map as $document_phid => $document) {
         $sigs = idx($signatures, $document_phid, array());
         foreach ($sigs as $index => $sig) {
           if ($sig->getDocumentVersion() != $document->getVersions()) {
             unset($sigs[$index]);
           }
         }
         $signer_phids = mpull($sigs, 'getSignerPHID');
         if (array_diff($this->signerPHIDs, $signer_phids)) {
           unset($documents[$document->getID()]);
         }
       }
     }
 
     if ($this->needDocumentBodies) {
       $documents = $this->loadDocumentBodies($documents);
     }
 
     if ($this->needContributors) {
       $documents = $this->loadContributors($documents);
     }
 
     if ($this->needSignatures) {
       $documents = $this->loadSignatures($documents);
     }
 
+    if ($this->needViewerSignatures) {
+      if ($documents) {
+
+        if ($this->getViewer()->getPHID()) {
+          $signatures = id(new LegalpadDocumentSignatureQuery())
+            ->setViewer($this->getViewer())
+            ->withSignerPHIDs(array($this->getViewer()->getPHID()))
+            ->withDocumentPHIDs(mpull($documents, 'getPHID'))
+            ->execute();
+          $signatures = mpull($signatures, null, 'getDocumentPHID');
+        } else {
+          $signatures = array();
+        }
+
+        foreach ($documents as $document) {
+          $signature = idx($signatures, $document->getPHID());
+          $document->attachUserSignature(
+            $this->getViewer()->getPHID(),
+            $signature);
+        }
+      }
+    }
+
     return $documents;
   }
 
   private function buildJoinClause($conn_r) {
     $joins = array();
 
     if ($this->contributorPHIDs) {
       $joins[] = qsprintf(
         $conn_r,
         'JOIN edge e ON e.src = d.phid');
     }
 
     return implode(' ', $joins);
   }
 
   protected function buildWhereClause($conn_r) {
     $where = array();
 
     $where[] = $this->buildPagingClause($conn_r);
 
     if ($this->ids) {
       $where[] = qsprintf(
         $conn_r,
         'd.id IN (%Ld)',
         $this->ids);
     }
 
     if ($this->phids) {
       $where[] = qsprintf(
         $conn_r,
         'd.phid IN (%Ls)',
         $this->phids);
     }
 
     if ($this->creatorPHIDs) {
       $where[] = qsprintf(
         $conn_r,
         'd.creatorPHID IN (%Ls)',
         $this->creatorPHIDs);
     }
 
     if ($this->dateCreatedAfter) {
       $where[] = qsprintf(
         $conn_r,
         'd.dateCreated >= %d',
         $this->dateCreatedAfter);
     }
 
     if ($this->dateCreatedBefore) {
       $where[] = qsprintf(
         $conn_r,
         'd.dateCreated <= %d',
         $this->dateCreatedBefore);
     }
 
     if ($this->contributorPHIDs) {
       $where[] = qsprintf(
         $conn_r,
         'e.type = %s AND e.dst IN (%Ls)',
         PhabricatorEdgeConfig::TYPE_OBJECT_HAS_CONTRIBUTOR,
         $this->contributorPHIDs);
     }
 
     return $this->formatWhereClause($where);
   }
 
   private function loadDocumentBodies(array $documents) {
     $body_phids = mpull($documents, 'getDocumentBodyPHID');
     $bodies = id(new LegalpadDocumentBody())->loadAllWhere(
       'phid IN (%Ls)',
       $body_phids);
     $bodies = mpull($bodies, null, 'getPHID');
 
     foreach ($documents as $document) {
       $body = idx($bodies, $document->getDocumentBodyPHID());
       $document->attachDocumentBody($body);
     }
 
     return $documents;
   }
 
   private function loadContributors(array $documents) {
     $document_map = mpull($documents, null, 'getPHID');
     $edge_type = PhabricatorEdgeConfig::TYPE_OBJECT_HAS_CONTRIBUTOR;
     $contributor_data = id(new PhabricatorEdgeQuery())
       ->withSourcePHIDs(array_keys($document_map))
       ->withEdgeTypes(array($edge_type))
       ->execute();
 
     foreach ($document_map as $document_phid => $document) {
       $data = $contributor_data[$document_phid];
       $contributors = array_keys(idx($data, $edge_type, array()));
       $document->attachContributors($contributors);
     }
 
     return $documents;
   }
 
   private function loadSignatures(array $documents) {
     $document_map = mpull($documents, null, 'getPHID');
 
     $signatures = id(new LegalpadDocumentSignatureQuery())
       ->setViewer($this->getViewer())
       ->withDocumentPHIDs(array_keys($document_map))
       ->execute();
     $signatures = mgroup($signatures, 'getDocumentPHID');
 
     foreach ($documents as $document) {
       $sigs = idx($signatures, $document->getPHID(), array());
       foreach ($sigs as $index => $sig) {
         if ($sig->getDocumentVersion() != $document->getVersions()) {
           unset($sigs[$index]);
         }
       }
       $document->attachSignatures($sigs);
     }
 
     return $documents;
   }
 
   public function getQueryApplicationClass() {
     return 'PhabricatorApplicationLegalpad';
   }
 
 }
diff --git a/src/applications/legalpad/query/LegalpadDocumentSearchEngine.php b/src/applications/legalpad/query/LegalpadDocumentSearchEngine.php
index 71b166d8e..951838d7f 100644
--- a/src/applications/legalpad/query/LegalpadDocumentSearchEngine.php
+++ b/src/applications/legalpad/query/LegalpadDocumentSearchEngine.php
@@ -1,149 +1,171 @@
 <?php
 
 final class LegalpadDocumentSearchEngine
   extends PhabricatorApplicationSearchEngine {
 
   public function getResultTypeDescription() {
     return pht('Legalpad Documents');
   }
 
   public function getApplicationClassName() {
     return 'PhabricatorApplicationLegalpad';
   }
 
   public function buildSavedQueryFromRequest(AphrontRequest $request) {
     $saved = new PhabricatorSavedQuery();
     $saved->setParameter(
       'creatorPHIDs',
       $this->readUsersFromRequest($request, 'creators'));
 
     $saved->setParameter(
       'contributorPHIDs',
       $this->readUsersFromRequest($request, 'contributors'));
 
     $saved->setParameter('createdStart', $request->getStr('createdStart'));
     $saved->setParameter('createdEnd', $request->getStr('createdEnd'));
 
     return $saved;
   }
 
   public function buildQueryFromSavedQuery(PhabricatorSavedQuery $saved) {
     $query = id(new LegalpadDocumentQuery())
+      ->needViewerSignatures(true)
       ->withCreatorPHIDs($saved->getParameter('creatorPHIDs', array()))
       ->withContributorPHIDs($saved->getParameter('contributorPHIDs', array()));
 
     $start = $this->parseDateTime($saved->getParameter('createdStart'));
     $end = $this->parseDateTime($saved->getParameter('createdEnd'));
 
     if ($start) {
       $query->withDateCreatedAfter($start);
     }
 
     if ($end) {
       $query->withDateCreatedBefore($end);
     }
 
     return $query;
   }
 
   public function buildSearchForm(
     AphrontFormView $form,
     PhabricatorSavedQuery $saved_query) {
 
     $creator_phids = $saved_query->getParameter('creatorPHIDs', array());
     $contributor_phids = $saved_query->getParameter(
       'contributorPHIDs', array());
     $phids = array_merge($creator_phids, $contributor_phids);
     $handles = id(new PhabricatorHandleQuery())
       ->setViewer($this->requireViewer())
       ->withPHIDs($phids)
       ->execute();
 
     $form
       ->appendChild(
         id(new AphrontFormTokenizerControl())
           ->setDatasource('/typeahead/common/users/')
           ->setName('creators')
           ->setLabel(pht('Creators'))
           ->setValue(array_select_keys($handles, $creator_phids)))
       ->appendChild(
         id(new AphrontFormTokenizerControl())
           ->setDatasource('/typeahead/common/users/')
           ->setName('contributors')
           ->setLabel(pht('Contributors'))
           ->setValue(array_select_keys($handles, $contributor_phids)));
 
     $this->buildDateRange(
       $form,
       $saved_query,
       'createdStart',
       pht('Created After'),
       'createdEnd',
       pht('Created Before'));
 
   }
 
   protected function getURI($path) {
     return '/legalpad/'.$path;
   }
 
   public function getBuiltinQueryNames() {
     $names = array(
       'all' => pht('All Documents'),
     );
 
     return $names;
   }
 
   public function buildSavedQueryFromBuiltin($query_key) {
 
     $query = $this->newSavedQuery();
     $query->setQueryKey($query_key);
 
     switch ($query_key) {
       case 'all':
         return $query;
     }
 
     return parent::buildSavedQueryFromBuiltin($query_key);
   }
 
   protected function getRequiredHandlePHIDsForResultList(
     array $documents,
     PhabricatorSavedQuery $query) {
-    return array_mergev(mpull($documents, 'getRecentContributorPHIDs'));
+    return array();
   }
 
   protected function renderResultList(
     array $documents,
     PhabricatorSavedQuery $query,
     array $handles) {
     assert_instances_of($documents, 'LegalpadDocument');
 
     $viewer = $this->requireViewer();
 
     $list = new PHUIObjectItemListView();
     $list->setUser($viewer);
     foreach ($documents as $document) {
       $last_updated = phabricator_date($document->getDateModified(), $viewer);
-      $recent_contributors = $document->getRecentContributorPHIDs();
-      $updater = $handles[reset($recent_contributors)]->renderLink();
 
       $title = $document->getTitle();
 
       $item = id(new PHUIObjectItemView())
         ->setObjectName($document->getMonogram())
         ->setHeader($title)
         ->setHref('/'.$document->getMonogram())
         ->setObject($document)
-        ->addIcon('none', pht('Last updated: %s', $last_updated))
-        ->addByline(pht('Updated by: %s', $updater))
-        ->addAttribute(pht('Versions: %d', $document->getVersions()));
+        ->addIcon('none', pht('Version %d', $document->getVersions()))
+        ->addIcon('none', pht('Updated %s', $last_updated));
+
+      if ($viewer->getPHID()) {
+        $signature = $document->getUserSignature($viewer->getPHID());
+      } else {
+        $signature = null;
+      }
+
+      if ($signature) {
+        $item->addAttribute(
+          array(
+            id(new PHUIIconView())->setIconFont('fa-check-square-o', 'green'),
+            ' ',
+            pht(
+              'Signed on %s',
+              phabricator_date($signature->getDateCreated(), $viewer)),
+          ));
+      } else {
+        $item->addAttribute(
+          array(
+            id(new PHUIIconView())->setIconFont('fa-square-o', 'grey'),
+            ' ',
+            pht('Not Signed'),
+          ));
+      }
 
       $list->addItem($item);
     }
 
     return $list;
   }
 
 }
diff --git a/src/applications/legalpad/storage/LegalpadDocument.php b/src/applications/legalpad/storage/LegalpadDocument.php
index 7218639c2..4f8378f0a 100644
--- a/src/applications/legalpad/storage/LegalpadDocument.php
+++ b/src/applications/legalpad/storage/LegalpadDocument.php
@@ -1,161 +1,173 @@
 <?php
 
 final class LegalpadDocument extends LegalpadDAO
   implements
     PhabricatorPolicyInterface,
     PhabricatorSubscribableInterface,
     PhabricatorApplicationTransactionInterface {
 
   protected $title;
   protected $contributorCount;
   protected $recentContributorPHIDs = array();
   protected $creatorPHID;
   protected $versions;
   protected $documentBodyPHID;
   protected $viewPolicy;
   protected $editPolicy;
   protected $mailKey;
 
   private $documentBody = self::ATTACHABLE;
   private $contributors = self::ATTACHABLE;
-  private $signatures   = self::ATTACHABLE;
+  private $signatures = self::ATTACHABLE;
+  private $userSignatures = array();
 
   public static function initializeNewDocument(PhabricatorUser $actor) {
     $app = id(new PhabricatorApplicationQuery())
       ->setViewer($actor)
       ->withClasses(array('PhabricatorApplicationLegalpad'))
       ->executeOne();
 
     $view_policy = $app->getPolicy(LegalpadCapabilityDefaultView::CAPABILITY);
     $edit_policy = $app->getPolicy(LegalpadCapabilityDefaultEdit::CAPABILITY);
 
     return id(new LegalpadDocument())
       ->setVersions(0)
       ->setCreatorPHID($actor->getPHID())
       ->setContributorCount(0)
       ->setRecentContributorPHIDs(array())
       ->attachSignatures(array())
       ->setViewPolicy($view_policy)
       ->setEditPolicy($edit_policy);
   }
 
   public function getConfiguration() {
     return array(
       self::CONFIG_AUX_PHID => true,
       self::CONFIG_SERIALIZATION => array(
         'recentContributorPHIDs' => self::SERIALIZATION_JSON,
       ),
     ) + parent::getConfiguration();
   }
 
   public function generatePHID() {
     return PhabricatorPHID::generateNewPHID(
       PhabricatorLegalpadPHIDTypeDocument::TYPECONST);
   }
 
   public function getDocumentBody() {
     return $this->assertAttached($this->documentBody);
   }
 
   public function attachDocumentBody(LegalpadDocumentBody $body) {
     $this->documentBody = $body;
     return $this;
   }
 
   public function getContributors() {
     return $this->assertAttached($this->contributors);
   }
 
   public function attachContributors(array $contributors) {
     $this->contributors = $contributors;
     return $this;
   }
 
   public function getSignatures() {
     return $this->assertAttached($this->signatures);
   }
 
   public function attachSignatures(array $signatures) {
     $this->signatures = $signatures;
     return $this;
   }
 
   public function save() {
     if (!$this->getMailKey()) {
       $this->setMailKey(Filesystem::readRandomCharacters(20));
     }
     return parent::save();
   }
 
   public function getMonogram() {
     return 'L'.$this->getID();
   }
 
+  public function getUserSignature($phid) {
+    return $this->assertAttachedKey($this->userSignatures, $phid);
+  }
+
+  public function attachUserSignature(
+    $user_phid,
+    LegalpadDocumentSignature $signature = null) {
+    $this->userSignatures[$user_phid] = $signature;
+    return $this;
+  }
+
 
 /* -(  PhabricatorSubscribableInterface  )----------------------------------- */
 
 
   public function isAutomaticallySubscribed($phid) {
     return ($this->creatorPHID == $phid);
   }
 
   public function shouldShowSubscribersProperty() {
     return true;
   }
 
   public function shouldAllowSubscription($phid) {
     return true;
   }
 
 
 /* -(  PhabricatorPolicyInterface  )----------------------------------------- */
 
 
   public function getCapabilities() {
     return array(
       PhabricatorPolicyCapability::CAN_VIEW,
       PhabricatorPolicyCapability::CAN_EDIT,
     );
   }
 
   public function getPolicy($capability) {
     switch ($capability) {
       case PhabricatorPolicyCapability::CAN_VIEW:
         $policy = $this->viewPolicy;
         break;
       case PhabricatorPolicyCapability::CAN_EDIT:
         $policy = $this->editPolicy;
         break;
       default:
         $policy = PhabricatorPolicies::POLICY_NOONE;
         break;
     }
     return $policy;
   }
 
   public function hasAutomaticCapability($capability, PhabricatorUser $user) {
     return ($user->getPHID() == $this->getCreatorPHID());
   }
 
   public function describeAutomaticCapability($capability) {
     return pht(
       'The author of a document can always view and edit it.');
   }
 
 
 /* -(  PhabricatorApplicationTransactionInterface  )------------------------- */
 
 
   public function getApplicationTransactionEditor() {
     return new LegalpadDocumentEditor();
   }
 
   public function getApplicationTransactionObject() {
     return $this;
   }
 
   public function getApplicationTransactionTemplate() {
     return new LegalpadTransaction();
   }
 
 }