diff --git a/resources/sql/autopatches/20150212.legalpad.session.1.sql b/resources/sql/autopatches/20150212.legalpad.session.1.sql
new file mode 100644
index 0000000000..7f7c5df79f
--- /dev/null
+++ b/resources/sql/autopatches/20150212.legalpad.session.1.sql
@@ -0,0 +1,5 @@
+ALTER TABLE {$NAMESPACE}_user.phabricator_session
+  ADD signedLegalpadDocuments BOOL NOT NULL DEFAULT 0;
+
+ALTER TABLE {$NAMESPACE}_legalpad.legalpad_document
+  ADD requireSignature BOOL NOT NULL DEFAULT 0;
diff --git a/resources/sql/autopatches/20150212.legalpad.session.2.sql b/resources/sql/autopatches/20150212.legalpad.session.2.sql
new file mode 100644
index 0000000000..a712c6001a
--- /dev/null
+++ b/resources/sql/autopatches/20150212.legalpad.session.2.sql
@@ -0,0 +1,2 @@
+ALTER TABLE {$NAMESPACE}_legalpad.legalpad_document
+  ADD KEY `key_required` (requireSignature, dateModified);
diff --git a/src/applications/auth/controller/PhabricatorAuthFinishController.php b/src/applications/auth/controller/PhabricatorAuthFinishController.php
index 4f7bccdac7..a94bc63a06 100644
--- a/src/applications/auth/controller/PhabricatorAuthFinishController.php
+++ b/src/applications/auth/controller/PhabricatorAuthFinishController.php
@@ -1,80 +1,84 @@
 <?php
 
 final class PhabricatorAuthFinishController
   extends PhabricatorAuthController {
 
   public function shouldRequireLogin() {
     return false;
   }
 
   public function shouldAllowPartialSessions() {
     return true;
   }
 
+  public function shouldAllowLegallyNonCompliantUsers() {
+    return true;
+  }
+
   public function processRequest() {
     $request = $this->getRequest();
     $viewer = $request->getUser();
 
     // If the user already has a full session, just kick them out of here.
     $has_partial_session = $viewer->hasSession() &&
                            $viewer->getSession()->getIsPartial();
     if (!$has_partial_session) {
       return id(new AphrontRedirectResponse())->setURI('/');
     }
 
     $engine = new PhabricatorAuthSessionEngine();
 
     // If this cookie is set, the user is headed into a high security area
     // after login (normally because of a password reset) so if they are
     // able to pass the checkpoint we just want to put their account directly
     // into high security mode, rather than prompt them again for the same
     // set of credentials.
     $jump_into_hisec = $request->getCookie(PhabricatorCookies::COOKIE_HISEC);
 
     try {
       $token = $engine->requireHighSecuritySession(
         $viewer,
         $request,
         '/logout/',
         $jump_into_hisec);
     } catch (PhabricatorAuthHighSecurityRequiredException $ex) {
       $form = id(new PhabricatorAuthSessionEngine())->renderHighSecurityForm(
         $ex->getFactors(),
         $ex->getFactorValidationResults(),
         $viewer,
         $request);
 
       return $this->newDialog()
         ->setTitle(pht('Provide Multi-Factor Credentials'))
         ->setShortTitle(pht('Multi-Factor Login'))
         ->setWidth(AphrontDialogView::WIDTH_FORM)
         ->addHiddenInput(AphrontRequest::TYPE_HISEC, true)
         ->appendParagraph(
           pht(
             'Welcome, %s. To complete the login process, provide your '.
             'multi-factor credentials.',
             phutil_tag('strong', array(), $viewer->getUsername())))
         ->appendChild($form->buildLayoutView())
         ->setSubmitURI($request->getPath())
         ->addCancelButton($ex->getCancelURI())
         ->addSubmitButton(pht('Continue'));
     }
 
     // Upgrade the partial session to a full session.
     $engine->upgradePartialSession($viewer);
 
     // TODO: It might be nice to add options like "bind this session to my IP"
     // here, even for accounts without multi-factor auth attached to them.
 
     $next = PhabricatorCookies::getNextURICookie($request);
     $request->clearCookie(PhabricatorCookies::COOKIE_NEXTURI);
     $request->clearCookie(PhabricatorCookies::COOKIE_HISEC);
 
     if (!PhabricatorEnv::isValidLocalWebResource($next)) {
       $next = '/';
     }
 
     return id(new AphrontRedirectResponse())->setURI($next);
   }
 
 }
diff --git a/src/applications/auth/controller/PhabricatorAuthValidateController.php b/src/applications/auth/controller/PhabricatorAuthValidateController.php
index ebb7a41ba7..c91f3c4504 100644
--- a/src/applications/auth/controller/PhabricatorAuthValidateController.php
+++ b/src/applications/auth/controller/PhabricatorAuthValidateController.php
@@ -1,72 +1,76 @@
 <?php
 
 final class PhabricatorAuthValidateController
   extends PhabricatorAuthController {
 
   public function shouldRequireLogin() {
     return false;
   }
 
   public function shouldAllowPartialSessions() {
     return true;
   }
 
+  public function shouldAllowLegallyNonCompliantUsers() {
+    return true;
+  }
+
   public function processRequest() {
     $request = $this->getRequest();
     $viewer = $request->getUser();
 
     $failures = array();
 
     if (!strlen($request->getStr('expect'))) {
       return $this->renderErrors(
         array(
           pht(
             'Login validation is missing expected parameter ("%s").',
             'phusr'),
         ));
     }
 
     $expect_phusr = $request->getStr('expect');
     $actual_phusr = $request->getCookie(PhabricatorCookies::COOKIE_USERNAME);
     if ($actual_phusr != $expect_phusr) {
       if ($actual_phusr) {
         $failures[] = pht(
           "Attempted to set '%s' cookie to '%s', but your browser sent back ".
           "a cookie with the value '%s'. Clear your browser's cookies and ".
           "try again.",
           'phusr',
           $expect_phusr,
           $actual_phusr);
       } else {
         $failures[] = pht(
           "Attempted to set '%s' cookie to '%s', but your browser did not ".
           "accept the cookie. Check that cookies are enabled, clear them, ".
           "and try again.",
           'phusr',
           $expect_phusr);
       }
     }
 
     if (!$failures) {
       if (!$viewer->getPHID()) {
         $failures[] = pht(
           'Login cookie was set correctly, but your login session is not '.
           'valid. Try clearing cookies and logging in again.');
       }
     }
 
     if ($failures) {
       return $this->renderErrors($failures);
     }
 
     $finish_uri = $this->getApplicationURI('finish/');
     return id(new AphrontRedirectResponse())->setURI($finish_uri);
   }
 
   private function renderErrors(array $messages) {
     return $this->renderErrorPage(
       pht('Login Failure'),
       $messages);
   }
 
 }
diff --git a/src/applications/auth/controller/PhabricatorLogoutController.php b/src/applications/auth/controller/PhabricatorLogoutController.php
index cc9c63770c..127e5b5e1f 100644
--- a/src/applications/auth/controller/PhabricatorLogoutController.php
+++ b/src/applications/auth/controller/PhabricatorLogoutController.php
@@ -1,69 +1,73 @@
 <?php
 
 final class PhabricatorLogoutController
   extends PhabricatorAuthController {
 
   public function shouldRequireLogin() {
     return true;
   }
 
   public function shouldRequireEmailVerification() {
     // Allow unverified users to logout.
     return false;
   }
 
   public function shouldRequireEnabledUser() {
     // Allow disabled users to logout.
     return false;
   }
 
   public function shouldAllowPartialSessions() {
     return true;
   }
 
+  public function shouldAllowLegallyNonCompliantUsers() {
+    return true;
+  }
+
   public function handleRequest(AphrontRequest $request) {
     $request = $this->getRequest();
     $user = $request->getUser();
 
     if ($request->isFormPost()) {
 
       $log = PhabricatorUserLog::initializeNewLog(
         $user,
         $user->getPHID(),
         PhabricatorUserLog::ACTION_LOGOUT);
       $log->save();
 
       // Destroy the user's session in the database so logout works even if
       // their cookies have some issues. We'll detect cookie issues when they
       // try to login again and tell them to clear any junk.
       $phsid = $request->getCookie(PhabricatorCookies::COOKIE_SESSION);
       if (strlen($phsid)) {
         $session = id(new PhabricatorAuthSessionQuery())
           ->setViewer($user)
           ->withSessionKeys(array($phsid))
           ->executeOne();
         if ($session) {
           $session->delete();
         }
       }
       $request->clearCookie(PhabricatorCookies::COOKIE_SESSION);
 
       return id(new AphrontRedirectResponse())
         ->setURI('/auth/loggedout/');
     }
 
     if ($user->getPHID()) {
       $dialog = id(new AphrontDialogView())
         ->setUser($user)
         ->setTitle(pht('Log out of Phabricator?'))
         ->appendChild(pht('Are you sure you want to log out?'))
         ->addSubmitButton(pht('Logout'))
         ->addCancelButton('/');
 
       return id(new AphrontDialogResponse())->setDialog($dialog);
     }
 
     return id(new AphrontRedirectResponse())->setURI('/');
   }
 
 }
diff --git a/src/applications/auth/engine/PhabricatorAuthSessionEngine.php b/src/applications/auth/engine/PhabricatorAuthSessionEngine.php
index 718f48c42c..3d030769da 100644
--- a/src/applications/auth/engine/PhabricatorAuthSessionEngine.php
+++ b/src/applications/auth/engine/PhabricatorAuthSessionEngine.php
@@ -1,661 +1,709 @@
 <?php
 
 /**
  *
  * @task use      Using Sessions
  * @task new      Creating Sessions
  * @task hisec    High Security
  * @task partial  Partial Sessions
  * @task onetime  One Time Login URIs
  */
 final class PhabricatorAuthSessionEngine extends Phobject {
 
   /**
    * Session issued to normal users after they login through a standard channel.
    * Associates the client with a standard user identity.
    */
   const KIND_USER      = 'U';
 
 
   /**
    * Session issued to users who login with some sort of credentials but do not
    * have full accounts. These are sometimes called "grey users".
    *
    * TODO: We do not currently issue these sessions, see T4310.
    */
   const KIND_EXTERNAL  = 'X';
 
 
   /**
    * Session issued to logged-out users which has no real identity information.
    * Its purpose is to protect logged-out users from CSRF.
    */
   const KIND_ANONYMOUS = 'A';
 
 
   /**
    * Session kind isn't known.
    */
   const KIND_UNKNOWN   = '?';
 
 
   /**
    * Temporary tokens for one time logins.
    */
   const ONETIME_TEMPORARY_TOKEN_TYPE = 'login:onetime';
 
 
   /**
    * Temporary tokens for password recovery after one time login.
    */
   const PASSWORD_TEMPORARY_TOKEN_TYPE = 'login:password';
 
   const ONETIME_RECOVER = 'recover';
   const ONETIME_RESET = 'reset';
   const ONETIME_WELCOME = 'welcome';
   const ONETIME_USERNAME = 'rename';
 
 
   /**
    * Get the session kind (e.g., anonymous, user, external account) from a
    * session token. Returns a `KIND_` constant.
    *
    * @param   string  Session token.
    * @return  const   Session kind constant.
    */
   public static function getSessionKindFromToken($session_token) {
     if (strpos($session_token, '/') === false) {
       // Old-style session, these are all user sessions.
       return self::KIND_USER;
     }
 
     list($kind, $key) = explode('/', $session_token, 2);
 
     switch ($kind) {
       case self::KIND_ANONYMOUS:
       case self::KIND_USER:
       case self::KIND_EXTERNAL:
         return $kind;
       default:
         return self::KIND_UNKNOWN;
     }
   }
 
 
   /**
    * Load the user identity associated with a session of a given type,
    * identified by token.
    *
    * When the user presents a session token to an API, this method verifies
    * it is of the correct type and loads the corresponding identity if the
    * session exists and is valid.
    *
    * NOTE: `$session_type` is the type of session that is required by the
    * loading context. This prevents use of a Conduit sesssion as a Web
    * session, for example.
    *
    * @param const The type of session to load.
    * @param string The session token.
    * @return PhabricatorUser|null
    * @task use
    */
   public function loadUserForSession($session_type, $session_token) {
     $session_kind = self::getSessionKindFromToken($session_token);
     switch ($session_kind) {
       case self::KIND_ANONYMOUS:
         // Don't bother trying to load a user for an anonymous session, since
         // neither the session nor the user exist.
         return null;
       case self::KIND_UNKNOWN:
         // If we don't know what kind of session this is, don't go looking for
         // it.
         return null;
       case self::KIND_USER:
         break;
       case self::KIND_EXTERNAL:
         // TODO: Implement these (T4310).
         return null;
     }
 
     $session_table = new PhabricatorAuthSession();
     $user_table = new PhabricatorUser();
     $conn_r = $session_table->establishConnection('r');
     $session_key = PhabricatorHash::digest($session_token);
 
     // NOTE: We're being clever here because this happens on every page load,
     // and by joining we can save a query. This might be getting too clever
     // for its own good, though...
 
     $info = queryfx_one(
       $conn_r,
       'SELECT
           s.id AS s_id,
           s.sessionExpires AS s_sessionExpires,
           s.sessionStart AS s_sessionStart,
           s.highSecurityUntil AS s_highSecurityUntil,
           s.isPartial AS s_isPartial,
+          s.signedLegalpadDocuments as s_signedLegalpadDocuments,
           u.*
         FROM %T u JOIN %T s ON u.phid = s.userPHID
         AND s.type = %s AND s.sessionKey = %s',
       $user_table->getTableName(),
       $session_table->getTableName(),
       $session_type,
       $session_key);
 
     if (!$info) {
       return null;
     }
 
     $session_dict = array(
       'userPHID' => $info['phid'],
       'sessionKey' => $session_key,
       'type' => $session_type,
     );
     foreach ($info as $key => $value) {
       if (strncmp($key, 's_', 2) === 0) {
         unset($info[$key]);
         $session_dict[substr($key, 2)] = $value;
       }
     }
     $session = id(new PhabricatorAuthSession())->loadFromArray($session_dict);
 
     $ttl = PhabricatorAuthSession::getSessionTypeTTL($session_type);
 
     // If more than 20% of the time on this session has been used, refresh the
     // TTL back up to the full duration. The idea here is that sessions are
     // good forever if used regularly, but get GC'd when they fall out of use.
 
     // NOTE: If we begin rotating session keys when extending sessions, the
     // CSRF code needs to be updated so CSRF tokens survive session rotation.
 
     if (time() + (0.80 * $ttl) > $session->getSessionExpires()) {
       $unguarded = AphrontWriteGuard::beginScopedUnguardedWrites();
         $conn_w = $session_table->establishConnection('w');
         queryfx(
           $conn_w,
           'UPDATE %T SET sessionExpires = UNIX_TIMESTAMP() + %d WHERE id = %d',
           $session->getTableName(),
           $ttl,
           $session->getID());
       unset($unguarded);
     }
 
     $user = $user_table->loadFromArray($info);
     $user->attachSession($session);
     return $user;
   }
 
 
   /**
    * Issue a new session key for a given identity. Phabricator supports
    * different types of sessions (like "web" and "conduit") and each session
    * type may have multiple concurrent sessions (this allows a user to be
    * logged in on multiple browsers at the same time, for instance).
    *
    * Note that this method is transport-agnostic and does not set cookies or
    * issue other types of tokens, it ONLY generates a new session key.
    *
    * You can configure the maximum number of concurrent sessions for various
    * session types in the Phabricator configuration.
    *
    * @param   const     Session type constant (see
    *                    @{class:PhabricatorAuthSession}).
    * @param   phid|null Identity to establish a session for, usually a user
    *                    PHID. With `null`, generates an anonymous session.
    * @param   bool      True to issue a partial session.
    * @return  string    Newly generated session key.
    */
   public function establishSession($session_type, $identity_phid, $partial) {
     // Consume entropy to generate a new session key, forestalling the eventual
     // heat death of the universe.
     $session_key = Filesystem::readRandomCharacters(40);
 
     if ($identity_phid === null) {
       return self::KIND_ANONYMOUS.'/'.$session_key;
     }
 
     $session_table = new PhabricatorAuthSession();
     $conn_w = $session_table->establishConnection('w');
 
     // This has a side effect of validating the session type.
     $session_ttl = PhabricatorAuthSession::getSessionTypeTTL($session_type);
 
     $digest_key = PhabricatorHash::digest($session_key);
 
     // Logging-in users don't have CSRF stuff yet, so we have to unguard this
     // write.
     $unguarded = AphrontWriteGuard::beginScopedUnguardedWrites();
       id(new PhabricatorAuthSession())
         ->setUserPHID($identity_phid)
         ->setType($session_type)
         ->setSessionKey($digest_key)
         ->setSessionStart(time())
         ->setSessionExpires(time() + $session_ttl)
         ->setIsPartial($partial ? 1 : 0)
+        ->setSignedLegalpadDocuments(0)
         ->save();
 
       $log = PhabricatorUserLog::initializeNewLog(
         null,
         $identity_phid,
         ($partial
           ? PhabricatorUserLog::ACTION_LOGIN_PARTIAL
           : PhabricatorUserLog::ACTION_LOGIN));
 
       $log->setDetails(
         array(
           'session_type' => $session_type,
         ));
       $log->setSession($digest_key);
       $log->save();
     unset($unguarded);
 
     return $session_key;
   }
 
 
   /**
    * Terminate all of a user's login sessions.
    *
    * This is used when users change passwords, linked accounts, or add
    * multifactor authentication.
    *
    * @param PhabricatorUser User whose sessions should be terminated.
    * @param string|null Optionally, one session to keep. Normally, the current
    *   login session.
    *
    * @return void
    */
   public function terminateLoginSessions(
     PhabricatorUser $user,
     $except_session = null) {
 
     $sessions = id(new PhabricatorAuthSessionQuery())
       ->setViewer($user)
       ->withIdentityPHIDs(array($user->getPHID()))
       ->execute();
 
     if ($except_session !== null) {
       $except_session = PhabricatorHash::digest($except_session);
     }
 
     foreach ($sessions as $key => $session) {
       if ($except_session !== null) {
         if ($except_session == $session->getSessionKey()) {
           continue;
         }
       }
 
       $session->delete();
     }
   }
 
 
 /* -(  High Security  )------------------------------------------------------ */
 
 
   /**
    * Require high security, or prompt the user to enter high security.
    *
    * If the user's session is in high security, this method will return a
    * token. Otherwise, it will throw an exception which will eventually
    * be converted into a multi-factor authentication workflow.
    *
    * @param PhabricatorUser User whose session needs to be in high security.
    * @param AphrontReqeust  Current request.
    * @param string          URI to return the user to if they cancel.
    * @param bool            True to jump partial sessions directly into high
    *                        security instead of just upgrading them to full
    *                        sessions.
    * @return PhabricatorAuthHighSecurityToken Security token.
    * @task hisec
    */
   public function requireHighSecuritySession(
     PhabricatorUser $viewer,
     AphrontRequest $request,
     $cancel_uri,
     $jump_into_hisec = false) {
 
     if (!$viewer->hasSession()) {
       throw new Exception(
         pht('Requiring a high-security session from a user with no session!'));
     }
 
     $session = $viewer->getSession();
 
     // Check if the session is already in high security mode.
     $token = $this->issueHighSecurityToken($session);
     if ($token) {
       return $token;
     }
 
     // Load the multi-factor auth sources attached to this account.
     $factors = id(new PhabricatorAuthFactorConfig())->loadAllWhere(
       'userPHID = %s',
       $viewer->getPHID());
 
     // If the account has no associated multi-factor auth, just issue a token
     // without putting the session into high security mode. This is generally
     // easier for users. A minor but desirable side effect is that when a user
     // adds an auth factor, existing sessions won't get a free pass into hisec,
     // since they never actually got marked as hisec.
     if (!$factors) {
       return $this->issueHighSecurityToken($session, true);
     }
 
     // Check for a rate limit without awarding points, so the user doesn't
     // get partway through the workflow only to get blocked.
     PhabricatorSystemActionEngine::willTakeAction(
       array($viewer->getPHID()),
       new PhabricatorAuthTryFactorAction(),
       0);
 
     $validation_results = array();
     if ($request->isHTTPPost()) {
       $request->validateCSRF();
       if ($request->getExists(AphrontRequest::TYPE_HISEC)) {
 
         // Limit factor verification rates to prevent brute force attacks.
         PhabricatorSystemActionEngine::willTakeAction(
           array($viewer->getPHID()),
           new PhabricatorAuthTryFactorAction(),
           1);
 
         $ok = true;
         foreach ($factors as $factor) {
           $id = $factor->getID();
           $impl = $factor->requireImplementation();
 
           $validation_results[$id] = $impl->processValidateFactorForm(
             $factor,
             $viewer,
             $request);
 
           if (!$impl->isFactorValid($factor, $validation_results[$id])) {
             $ok = false;
           }
         }
 
         if ($ok) {
           // Give the user a credit back for a successful factor verification.
           PhabricatorSystemActionEngine::willTakeAction(
             array($viewer->getPHID()),
             new PhabricatorAuthTryFactorAction(),
             -1);
 
           if ($session->getIsPartial() && !$jump_into_hisec) {
             // If we have a partial session and are not jumping directly into
             // hisec, just issue a token without putting it in high security
             // mode.
             return $this->issueHighSecurityToken($session, true);
           }
 
           $until = time() + phutil_units('15 minutes in seconds');
           $session->setHighSecurityUntil($until);
 
           queryfx(
             $session->establishConnection('w'),
             'UPDATE %T SET highSecurityUntil = %d WHERE id = %d',
             $session->getTableName(),
             $until,
             $session->getID());
 
           $log = PhabricatorUserLog::initializeNewLog(
             $viewer,
             $viewer->getPHID(),
             PhabricatorUserLog::ACTION_ENTER_HISEC);
           $log->save();
         } else {
           $log = PhabricatorUserLog::initializeNewLog(
             $viewer,
             $viewer->getPHID(),
             PhabricatorUserLog::ACTION_FAIL_HISEC);
           $log->save();
         }
       }
     }
 
     $token = $this->issueHighSecurityToken($session);
     if ($token) {
       return $token;
     }
 
     throw id(new PhabricatorAuthHighSecurityRequiredException())
       ->setCancelURI($cancel_uri)
       ->setFactors($factors)
       ->setFactorValidationResults($validation_results);
   }
 
 
   /**
    * Issue a high security token for a session, if authorized.
    *
    * @param PhabricatorAuthSession Session to issue a token for.
    * @param bool Force token issue.
    * @return PhabricatorAuthHighSecurityToken|null Token, if authorized.
    * @task hisec
    */
   private function issueHighSecurityToken(
     PhabricatorAuthSession $session,
     $force = false) {
 
     $until = $session->getHighSecurityUntil();
     if ($until > time() || $force) {
       return new PhabricatorAuthHighSecurityToken();
     }
 
     return null;
   }
 
 
   /**
    * Render a form for providing relevant multi-factor credentials.
    *
    * @param PhabricatorUser Viewing user.
    * @param AphrontRequest Current request.
    * @return AphrontFormView Renderable form.
    * @task hisec
    */
   public function renderHighSecurityForm(
     array $factors,
     array $validation_results,
     PhabricatorUser $viewer,
     AphrontRequest $request) {
 
     $form = id(new AphrontFormView())
       ->setUser($viewer)
       ->appendRemarkupInstructions('');
 
     foreach ($factors as $factor) {
       $factor->requireImplementation()->renderValidateFactorForm(
         $factor,
         $form,
         $viewer,
         idx($validation_results, $factor->getID()));
     }
 
     $form->appendRemarkupInstructions('');
 
     return $form;
   }
 
 
   /**
    * Strip the high security flag from a session.
    *
    * Kicks a session out of high security and logs the exit.
    *
    * @param PhabricatorUser Acting user.
    * @param PhabricatorAuthSession Session to return to normal security.
    * @return void
    * @task hisec
    */
   public function exitHighSecurity(
     PhabricatorUser $viewer,
     PhabricatorAuthSession $session) {
 
     if (!$session->getHighSecurityUntil()) {
       return;
     }
 
     queryfx(
       $session->establishConnection('w'),
       'UPDATE %T SET highSecurityUntil = NULL WHERE id = %d',
       $session->getTableName(),
       $session->getID());
 
     $log = PhabricatorUserLog::initializeNewLog(
       $viewer,
       $viewer->getPHID(),
       PhabricatorUserLog::ACTION_EXIT_HISEC);
     $log->save();
   }
 
 
 /* -(  Partial Sessions  )--------------------------------------------------- */
 
 
   /**
    * Upgrade a partial session to a full session.
    *
    * @param PhabricatorAuthSession Session to upgrade.
    * @return void
    * @task partial
    */
   public function upgradePartialSession(PhabricatorUser $viewer) {
 
     if (!$viewer->hasSession()) {
       throw new Exception(
         pht('Upgrading partial session of user with no session!'));
     }
 
     $session = $viewer->getSession();
 
     if (!$session->getIsPartial()) {
       throw new Exception(pht('Session is not partial!'));
     }
 
     $unguarded = AphrontWriteGuard::beginScopedUnguardedWrites();
       $session->setIsPartial(0);
 
       queryfx(
         $session->establishConnection('w'),
         'UPDATE %T SET isPartial = %d WHERE id = %d',
         $session->getTableName(),
         0,
         $session->getID());
 
       $log = PhabricatorUserLog::initializeNewLog(
         $viewer,
         $viewer->getPHID(),
         PhabricatorUserLog::ACTION_LOGIN_FULL);
       $log->save();
     unset($unguarded);
   }
 
 
+/* -(  Legalpad Documents )-------------------------------------------------- */
+
+
+  /**
+   * Upgrade a session to have all legalpad documents signed.
+   *
+   * @param PhabricatorUser User whose session should upgrade.
+   * @param array LegalpadDocument objects
+   * @return void
+   * @task partial
+   */
+  public function signLegalpadDocuments(PhabricatorUser $viewer, array $docs) {
+
+    if (!$viewer->hasSession()) {
+      throw new Exception(
+        pht('Signing session legalpad documents of user with no session!'));
+    }
+
+    $session = $viewer->getSession();
+
+    if ($session->getSignedLegalpadDocuments()) {
+      throw new Exception(pht(
+        'Session has already signed required legalpad documents!'));
+    }
+
+    $unguarded = AphrontWriteGuard::beginScopedUnguardedWrites();
+      $session->setSignedLegalpadDocuments(1);
+
+      queryfx(
+        $session->establishConnection('w'),
+        'UPDATE %T SET signedLegalpadDocuments = %d WHERE id = %d',
+        $session->getTableName(),
+        1,
+        $session->getID());
+
+      if (!empty($docs)) {
+        $log = PhabricatorUserLog::initializeNewLog(
+          $viewer,
+          $viewer->getPHID(),
+          PhabricatorUserLog::ACTION_LOGIN_LEGALPAD);
+        $log->save();
+      }
+    unset($unguarded);
+  }
+
+
 /* -(  One Time Login URIs  )------------------------------------------------ */
 
 
   /**
    * Retrieve a temporary, one-time URI which can log in to an account.
    *
    * These URIs are used for password recovery and to regain access to accounts
    * which users have been locked out of.
    *
    * @param PhabricatorUser User to generate a URI for.
    * @param PhabricatorUserEmail Optionally, email to verify when
    *  link is used.
    * @param string Optional context string for the URI. This is purely cosmetic
    *  and used only to customize workflow and error messages.
    * @return string Login URI.
    * @task onetime
    */
   public function getOneTimeLoginURI(
     PhabricatorUser $user,
     PhabricatorUserEmail $email = null,
     $type = self::ONETIME_RESET) {
 
     $key = Filesystem::readRandomCharacters(32);
     $key_hash = $this->getOneTimeLoginKeyHash($user, $email, $key);
 
     $unguarded = AphrontWriteGuard::beginScopedUnguardedWrites();
       id(new PhabricatorAuthTemporaryToken())
         ->setObjectPHID($user->getPHID())
         ->setTokenType(self::ONETIME_TEMPORARY_TOKEN_TYPE)
         ->setTokenExpires(time() + phutil_units('1 day in seconds'))
         ->setTokenCode($key_hash)
         ->save();
     unset($unguarded);
 
     $uri = '/login/once/'.$type.'/'.$user->getID().'/'.$key.'/';
     if ($email) {
       $uri = $uri.$email->getID().'/';
     }
 
     try {
       $uri = PhabricatorEnv::getProductionURI($uri);
     } catch (Exception $ex) {
       // If a user runs `bin/auth recover` before configuring the base URI,
       // just show the path. We don't have any way to figure out the domain.
       // See T4132.
     }
 
     return $uri;
   }
 
 
   /**
    * Load the temporary token associated with a given one-time login key.
    *
    * @param PhabricatorUser User to load the token for.
    * @param PhabricatorUserEmail Optionally, email to verify when
    *  link is used.
    * @param string Key user is presenting as a valid one-time login key.
    * @return PhabricatorAuthTemporaryToken|null Token, if one exists.
    * @task onetime
    */
   public function loadOneTimeLoginKey(
     PhabricatorUser $user,
     PhabricatorUserEmail $email = null,
     $key = null) {
 
     $key_hash = $this->getOneTimeLoginKeyHash($user, $email, $key);
 
     return id(new PhabricatorAuthTemporaryTokenQuery())
       ->setViewer($user)
       ->withObjectPHIDs(array($user->getPHID()))
       ->withTokenTypes(array(self::ONETIME_TEMPORARY_TOKEN_TYPE))
       ->withTokenCodes(array($key_hash))
       ->withExpired(false)
       ->executeOne();
   }
 
 
   /**
    * Hash a one-time login key for storage as a temporary token.
    *
    * @param PhabricatorUser User this key is for.
    * @param PhabricatorUserEmail Optionally, email to verify when
    *  link is used.
    * @param string The one time login key.
    * @return string Hash of the key.
    * task onetime
    */
   private function getOneTimeLoginKeyHash(
     PhabricatorUser $user,
     PhabricatorUserEmail $email = null,
     $key = null) {
 
     $parts = array(
       $key,
       $user->getAccountSecret(),
     );
 
     if ($email) {
       $parts[] = $email->getVerificationCode();
     }
 
     return PhabricatorHash::digest(implode(':', $parts));
   }
 
 }
diff --git a/src/applications/auth/storage/PhabricatorAuthSession.php b/src/applications/auth/storage/PhabricatorAuthSession.php
index 5102c09aff..b0b4996c93 100644
--- a/src/applications/auth/storage/PhabricatorAuthSession.php
+++ b/src/applications/auth/storage/PhabricatorAuthSession.php
@@ -1,107 +1,109 @@
 <?php
 
 final class PhabricatorAuthSession extends PhabricatorAuthDAO
   implements PhabricatorPolicyInterface {
 
   const TYPE_WEB      = 'web';
   const TYPE_CONDUIT  = 'conduit';
 
   protected $userPHID;
   protected $type;
   protected $sessionKey;
   protected $sessionStart;
   protected $sessionExpires;
   protected $highSecurityUntil;
   protected $isPartial;
+  protected $signedLegalpadDocuments;
 
   private $identityObject = self::ATTACHABLE;
 
   protected function getConfiguration() {
     return array(
       self::CONFIG_TIMESTAMPS => false,
       self::CONFIG_COLUMN_SCHEMA => array(
         'type' => 'text32',
         'sessionKey' => 'bytes40',
         'sessionStart' => 'epoch',
         'sessionExpires' => 'epoch',
         'highSecurityUntil' => 'epoch?',
         'isPartial' => 'bool',
+        'signedLegalpadDocuments' => 'bool',
       ),
       self::CONFIG_KEY_SCHEMA => array(
         'sessionKey' => array(
           'columns' => array('sessionKey'),
           'unique' => true,
         ),
         'key_identity' => array(
           'columns' => array('userPHID', 'type'),
         ),
         'key_expires' => array(
           'columns' => array('sessionExpires'),
         ),
       ),
     ) + parent::getConfiguration();
   }
 
   public function getApplicationName() {
     // This table predates the "Auth" application, and really all applications.
     return 'user';
   }
 
   public function getTableName() {
     // This is a very old table with a nonstandard name.
     return PhabricatorUser::SESSION_TABLE;
   }
 
   public function attachIdentityObject($identity_object) {
     $this->identityObject = $identity_object;
     return $this;
   }
 
   public function getIdentityObject() {
     return $this->assertAttached($this->identityObject);
   }
 
   public static function getSessionTypeTTL($session_type) {
     switch ($session_type) {
       case self::TYPE_WEB:
         return phutil_units('30 days in seconds');
       case self::TYPE_CONDUIT:
         return phutil_units('24 hours in seconds');
       default:
         throw new Exception(pht('Unknown session type "%s".', $session_type));
     }
   }
 
 /* -(  PhabricatorPolicyInterface  )----------------------------------------- */
 
 
   public function getCapabilities() {
     return array(
       PhabricatorPolicyCapability::CAN_VIEW,
     );
   }
 
   public function getPolicy($capability) {
     return PhabricatorPolicies::POLICY_NOONE;
   }
 
   public function hasAutomaticCapability($capability, PhabricatorUser $viewer) {
     if (!$viewer->getPHID()) {
       return false;
     }
 
     $object = $this->getIdentityObject();
     if ($object instanceof PhabricatorUser) {
       return ($object->getPHID() == $viewer->getPHID());
     } else if ($object instanceof PhabricatorExternalAccount) {
       return ($object->getUserPHID() == $viewer->getPHID());
     }
 
     return false;
   }
 
   public function describeAutomaticCapability($capability) {
     return pht('A session is visible only to its owner.');
   }
 
 }
diff --git a/src/applications/base/controller/PhabricatorController.php b/src/applications/base/controller/PhabricatorController.php
index b5aee9f017..0095bfb939 100644
--- a/src/applications/base/controller/PhabricatorController.php
+++ b/src/applications/base/controller/PhabricatorController.php
@@ -1,582 +1,627 @@
 <?php
 
 abstract class PhabricatorController extends AphrontController {
 
   private $handles;
 
   public function shouldRequireLogin() {
     return true;
   }
 
   public function shouldRequireAdmin() {
     return false;
   }
 
   public function shouldRequireEnabledUser() {
     return true;
   }
 
   public function shouldAllowPublic() {
     return false;
   }
 
   public function shouldAllowPartialSessions() {
     return false;
   }
 
   public function shouldRequireEmailVerification() {
     return PhabricatorUserEmail::isEmailVerificationRequired();
   }
 
   public function shouldAllowRestrictedParameter($parameter_name) {
     return false;
   }
 
   public function shouldRequireMultiFactorEnrollment() {
     if (!$this->shouldRequireLogin()) {
       return false;
     }
 
     if (!$this->shouldRequireEnabledUser()) {
       return false;
     }
 
     if ($this->shouldAllowPartialSessions()) {
       return false;
     }
 
     $user = $this->getRequest()->getUser();
     if (!$user->getIsStandardUser()) {
       return false;
     }
 
     return PhabricatorEnv::getEnvConfig('security.require-multi-factor-auth');
   }
 
+  public function shouldAllowLegallyNonCompliantUsers() {
+    return false;
+  }
+
   public function willBeginExecution() {
     $request = $this->getRequest();
 
     if ($request->getUser()) {
       // NOTE: Unit tests can set a user explicitly. Normal requests are not
       // permitted to do this.
       PhabricatorTestCase::assertExecutingUnitTests();
       $user = $request->getUser();
     } else {
       $user = new PhabricatorUser();
       $session_engine = new PhabricatorAuthSessionEngine();
 
       $phsid = $request->getCookie(PhabricatorCookies::COOKIE_SESSION);
       if (strlen($phsid)) {
         $session_user = $session_engine->loadUserForSession(
           PhabricatorAuthSession::TYPE_WEB,
           $phsid);
         if ($session_user) {
           $user = $session_user;
         }
       } else {
         // If the client doesn't have a session token, generate an anonymous
         // session. This is used to provide CSRF protection to logged-out users.
         $phsid = $session_engine->establishSession(
           PhabricatorAuthSession::TYPE_WEB,
           null,
           $partial = false);
 
         // This may be a resource request, in which case we just don't set
         // the cookie.
         if ($request->canSetCookies()) {
           $request->setCookie(PhabricatorCookies::COOKIE_SESSION, $phsid);
         }
       }
 
 
       if (!$user->isLoggedIn()) {
         $user->attachAlternateCSRFString(PhabricatorHash::digest($phsid));
       }
 
       $request->setUser($user);
     }
 
     $locale_code = $user->getTranslation();
     if ($locale_code) {
       PhabricatorEnv::setLocaleCode($locale_code);
     }
 
     $preferences = $user->loadPreferences();
     if (PhabricatorEnv::getEnvConfig('darkconsole.enabled')) {
       $dark_console = PhabricatorUserPreferences::PREFERENCE_DARK_CONSOLE;
       if ($preferences->getPreference($dark_console) ||
          PhabricatorEnv::getEnvConfig('darkconsole.always-on')) {
         $console = new DarkConsoleCore();
         $request->getApplicationConfiguration()->setConsole($console);
       }
     }
 
     // NOTE: We want to set up the user first so we can render a real page
     // here, but fire this before any real logic.
     $restricted = array(
       'code',
     );
     foreach ($restricted as $parameter) {
       if ($request->getExists($parameter)) {
         if (!$this->shouldAllowRestrictedParameter($parameter)) {
           throw new Exception(
             pht(
               'Request includes restricted parameter "%s", but this '.
               'controller ("%s") does not whitelist it. Refusing to '.
               'serve this request because it might be part of a redirection '.
               'attack.',
               $parameter,
               get_class($this)));
         }
       }
     }
 
     if ($this->shouldRequireEnabledUser()) {
       if ($user->isLoggedIn() && !$user->getIsApproved()) {
         $controller = new PhabricatorAuthNeedsApprovalController();
         return $this->delegateToController($controller);
       }
       if ($user->getIsDisabled()) {
         $controller = new PhabricatorDisabledUserController();
         return $this->delegateToController($controller);
       }
     }
 
     $event = new PhabricatorEvent(
       PhabricatorEventType::TYPE_CONTROLLER_CHECKREQUEST,
       array(
         'request' => $request,
         'controller' => $this,
       ));
     $event->setUser($user);
     PhutilEventEngine::dispatchEvent($event);
     $checker_controller = $event->getValue('controller');
     if ($checker_controller != $this) {
       return $this->delegateToController($checker_controller);
     }
 
     $auth_class = 'PhabricatorAuthApplication';
     $auth_application = PhabricatorApplication::getByClass($auth_class);
 
     // Require partial sessions to finish login before doing anything.
     if (!$this->shouldAllowPartialSessions()) {
       if ($user->hasSession() &&
           $user->getSession()->getIsPartial()) {
         $login_controller = new PhabricatorAuthFinishController();
         $this->setCurrentApplication($auth_application);
         return $this->delegateToController($login_controller);
       }
     }
 
     // Check if the user needs to configure MFA.
     $need_mfa = $this->shouldRequireMultiFactorEnrollment();
     $have_mfa = $user->getIsEnrolledInMultiFactor();
     if ($need_mfa && !$have_mfa) {
       // Check if the cache is just out of date. Otherwise, roadblock the user
       // and require MFA enrollment.
       $user->updateMultiFactorEnrollment();
       if (!$user->getIsEnrolledInMultiFactor()) {
         $mfa_controller = new PhabricatorAuthNeedsMultiFactorController();
         $this->setCurrentApplication($auth_application);
         return $this->delegateToController($mfa_controller);
       }
     }
 
     if ($this->shouldRequireLogin()) {
       // This actually means we need either:
       //   - a valid user, or a public controller; and
       //   - permission to see the application.
 
       $allow_public = $this->shouldAllowPublic() &&
                       PhabricatorEnv::getEnvConfig('policy.allow-public');
 
       // If this controller isn't public, and the user isn't logged in, require
       // login.
       if (!$allow_public && !$user->isLoggedIn()) {
         $login_controller = new PhabricatorAuthStartController();
         $this->setCurrentApplication($auth_application);
         return $this->delegateToController($login_controller);
       }
 
       if ($user->isLoggedIn()) {
         if ($this->shouldRequireEmailVerification()) {
           if (!$user->getIsEmailVerified()) {
             $controller = new PhabricatorMustVerifyEmailController();
             $this->setCurrentApplication($auth_application);
             return $this->delegateToController($controller);
           }
         }
       }
 
       // If the user doesn't have access to the application, don't let them use
       // any of its controllers. We query the application in order to generate
       // a policy exception if the viewer doesn't have permission.
 
       $application = $this->getCurrentApplication();
       if ($application) {
         id(new PhabricatorApplicationQuery())
           ->setViewer($user)
           ->withPHIDs(array($application->getPHID()))
           ->executeOne();
       }
     }
 
+
+    if (!$this->shouldAllowLegallyNonCompliantUsers()) {
+      $legalpad_class = 'PhabricatorLegalpadApplication';
+      $legalpad = id(new PhabricatorApplicationQuery())
+        ->setViewer($user)
+        ->withClasses(array($legalpad_class))
+        ->withInstalled(true)
+        ->execute();
+      $legalpad = head($legalpad);
+
+      $doc_query = id(new LegalpadDocumentQuery())
+        ->setViewer($user)
+        ->withSignatureRequired(1)
+        ->needViewerSignatures(true);
+
+      if ($user->hasSession() &&
+          !$user->getSession()->getIsPartial() &&
+          !$user->getSession()->getSignedLegalpadDocuments() &&
+          $user->isLoggedIn() &&
+          $legalpad) {
+
+        $sign_docs = $doc_query->execute();
+        $must_sign_docs = array();
+        foreach ($sign_docs as $sign_doc) {
+          if (!$sign_doc->getUserSignature($user->getPHID())) {
+            $must_sign_docs[] = $sign_doc;
+          }
+        }
+        if ($must_sign_docs) {
+          $controller = new LegalpadDocumentSignController();
+          $this->getRequest()->setURIMap(array(
+            'id' => head($must_sign_docs)->getID(),));
+          $this->setCurrentApplication($legalpad);
+          return $this->delegateToController($controller);
+        } else {
+          $engine = id(new PhabricatorAuthSessionEngine())
+            ->signLegalpadDocuments($user, $sign_docs);
+        }
+      }
+    }
+
     // NOTE: We do this last so that users get a login page instead of a 403
     // if they need to login.
     if ($this->shouldRequireAdmin() && !$user->getIsAdmin()) {
       return new Aphront403Response();
     }
   }
 
   public function buildStandardPageView() {
     $view = new PhabricatorStandardPageView();
     $view->setRequest($this->getRequest());
     $view->setController($this);
     return $view;
   }
 
   public function buildStandardPageResponse($view, array $data) {
     $page = $this->buildStandardPageView();
     $page->appendChild($view);
     return $this->buildPageResponse($page);
   }
 
   private function buildPageResponse($page) {
     if ($this->getRequest()->isQuicksand()) {
       $response = id(new AphrontAjaxResponse())
         ->setContent($page->renderForQuicksand());
     } else {
       $response = id(new AphrontWebpageResponse())
         ->setContent($page->render());
     }
 
     return $response;
   }
 
   public function getApplicationURI($path = '') {
     if (!$this->getCurrentApplication()) {
       throw new Exception('No application!');
     }
     return $this->getCurrentApplication()->getApplicationURI($path);
   }
 
   public function buildApplicationPage($view, array $options) {
     $page = $this->buildStandardPageView();
 
     $title = PhabricatorEnv::getEnvConfig('phabricator.serious-business') ?
       'Phabricator' :
       pht('Bacon Ice Cream for Breakfast');
 
     $application = $this->getCurrentApplication();
     $page->setTitle(idx($options, 'title', $title));
     if ($application) {
       $page->setApplicationName($application->getName());
       if ($application->getTitleGlyph()) {
         $page->setGlyph($application->getTitleGlyph());
       }
     }
 
     if (!($view instanceof AphrontSideNavFilterView)) {
       $nav = new AphrontSideNavFilterView();
       $nav->appendChild($view);
       $view = $nav;
     }
 
     $user = $this->getRequest()->getUser();
     $view->setUser($user);
 
     $page->appendChild($view);
 
     $object_phids = idx($options, 'pageObjects', array());
     if ($object_phids) {
       $page->appendPageObjects($object_phids);
       foreach ($object_phids as $object_phid) {
         PhabricatorFeedStoryNotification::updateObjectNotificationViews(
           $user,
           $object_phid);
       }
     }
 
     if (idx($options, 'device', true)) {
       $page->setDeviceReady(true);
     }
 
     $page->setShowFooter(idx($options, 'showFooter', true));
     $page->setShowChrome(idx($options, 'chrome', true));
 
     $application_menu = $this->buildApplicationMenu();
     if ($application_menu) {
       $page->setApplicationMenu($application_menu);
     }
 
     return $this->buildPageResponse($page);
   }
 
   public function didProcessRequest($response) {
     // If a bare DialogView is returned, wrap it in a DialogResponse.
     if ($response instanceof AphrontDialogView) {
       $response = id(new AphrontDialogResponse())->setDialog($response);
     }
 
     $request = $this->getRequest();
     $response->setRequest($request);
 
     $seen = array();
     while ($response instanceof AphrontProxyResponse) {
       $hash = spl_object_hash($response);
       if (isset($seen[$hash])) {
         $seen[] = get_class($response);
         throw new Exception(
           'Cycle while reducing proxy responses: '.
           implode(' -> ', $seen));
       }
       $seen[$hash] = get_class($response);
 
       $response = $response->reduceProxyResponse();
     }
 
     if ($response instanceof AphrontDialogResponse) {
       if (!$request->isAjax() && !$request->isQuicksand()) {
         $dialog = $response->getDialog();
 
         $title = $dialog->getTitle();
         $short = $dialog->getShortTitle();
 
         $crumbs = $this->buildApplicationCrumbs();
         $crumbs->addTextCrumb(coalesce($short, $title));
 
         $page_content = array(
           $crumbs,
           $response->buildResponseString(),
         );
 
         $view = id(new PhabricatorStandardPageView())
           ->setRequest($request)
           ->setController($this)
           ->setDeviceReady(true)
           ->setTitle($title)
           ->appendChild($page_content);
 
         $response = id(new AphrontWebpageResponse())
           ->setContent($view->render())
           ->setHTTPResponseCode($response->getHTTPResponseCode());
       } else {
         $response->getDialog()->setIsStandalone(true);
 
         return id(new AphrontAjaxResponse())
           ->setContent(array(
             'dialog' => $response->buildResponseString(),
           ));
       }
     } else if ($response instanceof AphrontRedirectResponse) {
       if ($request->isAjax()) {
         return id(new AphrontAjaxResponse())
           ->setContent(
             array(
               'redirect' => $response->getURI(),
             ));
       }
     }
 
     return $response;
   }
 
   protected function getHandle($phid) {
     if (empty($this->handles[$phid])) {
       throw new Exception(
         "Attempting to access handle which wasn't loaded: {$phid}");
     }
     return $this->handles[$phid];
   }
 
   protected function loadHandles(array $phids) {
     $phids = array_filter($phids);
     $this->handles = $this->loadViewerHandles($phids);
     return $this;
   }
 
   protected function getLoadedHandles() {
     return $this->handles;
   }
 
   protected function loadViewerHandles(array $phids) {
     return id(new PhabricatorHandleQuery())
       ->setViewer($this->getRequest()->getUser())
       ->withPHIDs($phids)
       ->execute();
   }
 
   /**
    * Render a list of links to handles, identified by PHIDs. The handles must
    * already be loaded.
    *
    * @param   list<phid>  List of PHIDs to render links to.
    * @param   string      Style, one of "\n" (to put each item on its own line)
    *                      or "," (to list items inline, separated by commas).
    * @return  string      Rendered list of handle links.
    */
   protected function renderHandlesForPHIDs(array $phids, $style = "\n") {
     $style_map = array(
       "\n"  => phutil_tag('br'),
       ','   => ', ',
     );
 
     if (empty($style_map[$style])) {
       throw new Exception("Unknown handle list style '{$style}'!");
     }
 
     return implode_selected_handle_links($style_map[$style],
       $this->getLoadedHandles(),
       array_filter($phids));
   }
 
   public function buildApplicationMenu() {
     return null;
   }
 
   protected function buildApplicationCrumbs() {
     $crumbs = array();
 
     $application = $this->getCurrentApplication();
     if ($application) {
       $icon = $application->getFontIcon();
       if (!$icon) {
         $icon = 'fa-puzzle';
       }
 
       $crumbs[] = id(new PHUICrumbView())
         ->setHref($this->getApplicationURI())
         ->setName($application->getName())
         ->setIcon($icon);
     }
 
     $view = new PHUICrumbsView();
     foreach ($crumbs as $crumb) {
       $view->addCrumb($crumb);
     }
 
     return $view;
   }
 
   protected function hasApplicationCapability($capability) {
     return PhabricatorPolicyFilter::hasCapability(
       $this->getRequest()->getUser(),
       $this->getCurrentApplication(),
       $capability);
   }
 
   protected function requireApplicationCapability($capability) {
     PhabricatorPolicyFilter::requireCapability(
       $this->getRequest()->getUser(),
       $this->getCurrentApplication(),
       $capability);
   }
 
   protected function explainApplicationCapability(
     $capability,
     $positive_message,
     $negative_message) {
 
     $can_act = $this->hasApplicationCapability($capability);
     if ($can_act) {
       $message = $positive_message;
       $icon_name = 'fa-play-circle-o lightgreytext';
     } else {
       $message = $negative_message;
       $icon_name = 'fa-lock';
     }
 
     $icon = id(new PHUIIconView())
       ->setIconFont($icon_name);
 
     require_celerity_resource('policy-css');
 
     $phid = $this->getCurrentApplication()->getPHID();
     $explain_uri = "/policy/explain/{$phid}/{$capability}/";
 
     $message = phutil_tag(
       'div',
       array(
         'class' => 'policy-capability-explanation',
       ),
       array(
         $icon,
         javelin_tag(
           'a',
           array(
             'href' => $explain_uri,
             'sigil' => 'workflow',
           ),
           $message),
       ));
 
     return array($can_act, $message);
   }
 
   public function getDefaultResourceSource() {
     return 'phabricator';
   }
 
   /**
    * Create a new @{class:AphrontDialogView} with defaults filled in.
    *
    * @return AphrontDialogView New dialog.
    */
   public function newDialog() {
     $submit_uri = new PhutilURI($this->getRequest()->getRequestURI());
     $submit_uri = $submit_uri->getPath();
 
     return id(new AphrontDialogView())
       ->setUser($this->getRequest()->getUser())
       ->setSubmitURI($submit_uri);
   }
 
   protected function buildTransactionTimeline(
     PhabricatorApplicationTransactionInterface $object,
     PhabricatorApplicationTransactionQuery $query,
     PhabricatorMarkupEngine $engine = null,
     $render_data = array()) {
 
     $viewer = $this->getRequest()->getUser();
     $xaction = $object->getApplicationTransactionTemplate();
     $view = $xaction->getApplicationTransactionViewObject();
 
     $pager = id(new AphrontCursorPagerView())
       ->readFromRequest($this->getRequest())
       ->setURI(new PhutilURI(
         '/transactions/showolder/'.$object->getPHID().'/'));
 
     $xactions = $query
       ->setViewer($viewer)
       ->withObjectPHIDs(array($object->getPHID()))
       ->needComments(true)
       ->setReversePaging(false)
       ->executeWithCursorPager($pager);
     $xactions = array_reverse($xactions);
 
     if ($engine) {
       foreach ($xactions as $xaction) {
         if ($xaction->getComment()) {
           $engine->addObject(
             $xaction->getComment(),
             PhabricatorApplicationTransactionComment::MARKUP_FIELD_COMMENT);
         }
       }
       $engine->process();
       $view->setMarkupEngine($engine);
     }
 
     $timeline = $view
       ->setUser($viewer)
       ->setObjectPHID($object->getPHID())
       ->setTransactions($xactions)
       ->setPager($pager)
       ->setRenderData($render_data)
       ->setQuoteTargetID($this->getRequest()->getStr('quoteTargetID'))
       ->setQuoteRef($this->getRequest()->getStr('quoteRef'));
     $object->willRenderTimeline($timeline, $this->getRequest());
 
     return $timeline;
   }
 
 }
diff --git a/src/applications/base/controller/__tests__/PhabricatorAccessControlTestCase.php b/src/applications/base/controller/__tests__/PhabricatorAccessControlTestCase.php
index 2e71dca34a..3791d7462a 100644
--- a/src/applications/base/controller/__tests__/PhabricatorAccessControlTestCase.php
+++ b/src/applications/base/controller/__tests__/PhabricatorAccessControlTestCase.php
@@ -1,281 +1,281 @@
 <?php
 
 final class PhabricatorAccessControlTestCase extends PhabricatorTestCase {
 
   protected function getPhabricatorTestCaseConfiguration() {
     return array(
       self::PHABRICATOR_TESTCONFIG_BUILD_STORAGE_FIXTURES => true,
     );
   }
 
   public function testControllerAccessControls() {
     $root = dirname(phutil_get_library_root('phabricator'));
     require_once $root.'/support/PhabricatorStartup.php';
 
     $application_configuration = new AphrontDefaultApplicationConfiguration();
 
     $host = 'meow.example.com';
 
     $_SERVER['REQUEST_METHOD'] = 'GET';
 
     $request = id(new AphrontRequest($host, '/'))
       ->setApplicationConfiguration($application_configuration)
       ->setRequestData(array());
 
     $controller = new PhabricatorTestController();
     $controller->setRequest($request);
 
     $u_public = id(new PhabricatorUser())
       ->setUsername('public');
 
     $u_unverified = $this->generateNewTestUser()
       ->setUsername('unverified')
       ->save();
     $u_unverified->setIsEmailVerified(0)->save();
 
     $u_normal = $this->generateNewTestUser()
       ->setUsername('normal')
       ->save();
 
     $u_disabled = $this->generateNewTestUser()
       ->setIsDisabled(true)
       ->setUsername('disabled')
       ->save();
 
     $u_admin = $this->generateNewTestUser()
       ->setIsAdmin(true)
       ->setUsername('admin')
       ->save();
 
     $u_notapproved = $this->generateNewTestUser()
       ->setIsApproved(0)
       ->setUsername('notapproved')
       ->save();
 
     $env = PhabricatorEnv::beginScopedEnv();
     $env->overrideEnvConfig('phabricator.base-uri', 'http://'.$host);
     $env->overrideEnvConfig('policy.allow-public', false);
     $env->overrideEnvConfig('auth.require-email-verification', false);
     $env->overrideEnvConfig('auth.email-domains', array());
     $env->overrideEnvConfig('security.require-multi-factor-auth', false);
 
 
     // Test standard defaults.
 
     $this->checkAccess(
       'Default',
       id(clone $controller),
       $request,
       array(
         $u_normal,
         $u_admin,
         $u_unverified,
       ),
       array(
         $u_public,
         $u_disabled,
         $u_notapproved,
       ));
 
 
     // Test email verification.
 
     $env->overrideEnvConfig('auth.require-email-verification', true);
     $this->checkAccess(
       'Email Verification Required',
       id(clone $controller),
       $request,
       array(
         $u_normal,
         $u_admin,
       ),
       array(
         $u_unverified,
         $u_public,
         $u_disabled,
         $u_notapproved,
       ));
 
     $this->checkAccess(
       'Email Verification Required, With Exception',
       id(clone $controller)->setConfig('email', false),
       $request,
       array(
         $u_normal,
         $u_admin,
         $u_unverified,
       ),
       array(
         $u_public,
         $u_disabled,
         $u_notapproved,
       ));
     $env->overrideEnvConfig('auth.require-email-verification', false);
 
 
     // Test admin access.
 
     $this->checkAccess(
       'Admin Required',
       id(clone $controller)->setConfig('admin', true),
       $request,
       array(
         $u_admin,
       ),
       array(
         $u_normal,
         $u_unverified,
         $u_public,
         $u_disabled,
         $u_notapproved,
       ));
 
 
     // Test disabled access.
 
     $this->checkAccess(
       'Allow Disabled',
       id(clone $controller)->setConfig('enabled', false),
       $request,
       array(
         $u_normal,
         $u_unverified,
         $u_admin,
         $u_disabled,
         $u_notapproved,
       ),
       array(
         $u_public,
       ));
 
 
     // Test no login required.
 
     $this->checkAccess(
       'No Login Required',
       id(clone $controller)->setConfig('login', false),
       $request,
       array(
         $u_normal,
         $u_unverified,
         $u_admin,
         $u_public,
       ),
       array(
         $u_disabled,
         $u_notapproved,
       ));
 
 
     // Test public access.
 
     $this->checkAccess(
-      'No Login Required',
+      'Public Access',
       id(clone $controller)->setConfig('public', true),
       $request,
       array(
         $u_normal,
         $u_unverified,
         $u_admin,
       ),
       array(
         $u_disabled,
         $u_public,
       ));
 
     $env->overrideEnvConfig('policy.allow-public', true);
     $this->checkAccess(
       'Public + configured',
       id(clone $controller)->setConfig('public', true),
       $request,
       array(
         $u_normal,
         $u_unverified,
         $u_admin,
         $u_public,
       ),
       array(
         $u_disabled,
         $u_notapproved,
       ));
     $env->overrideEnvConfig('policy.allow-public', false);
 
 
     $app = PhabricatorApplication::getByClass('PhabricatorTestApplication');
     $app->reset();
     $app->setPolicy(
       PhabricatorPolicyCapability::CAN_VIEW,
       PhabricatorPolicies::POLICY_NOONE);
 
     $app_controller = id(clone $controller)->setCurrentApplication($app);
 
     $this->checkAccess(
       'Application Controller',
       $app_controller,
       $request,
       array(
       ),
       array(
         $u_normal,
         $u_unverified,
         $u_admin,
         $u_public,
         $u_disabled,
         $u_notapproved,
       ));
 
     $this->checkAccess(
       'Application Controller',
       id(clone $app_controller)->setConfig('login', false),
       $request,
       array(
         $u_normal,
         $u_unverified,
         $u_admin,
         $u_public,
       ),
       array(
         $u_disabled,
         $u_notapproved,
       ));
   }
 
   private function checkAccess(
     $label,
     $controller,
     $request,
     array $yes,
     array $no) {
 
     foreach ($yes as $user) {
       $request->setUser($user);
       $uname = $user->getUsername();
 
       try {
         $result = id(clone $controller)->willBeginExecution();
       } catch (Exception $ex) {
         $result = $ex;
       }
 
       $this->assertTrue(
         ($result === null),
         "Expect user '{$uname}' to be allowed access to '{$label}'.");
     }
 
     foreach ($no as $user) {
       $request->setUser($user);
       $uname = $user->getUsername();
 
       try {
         $result = id(clone $controller)->willBeginExecution();
       } catch (Exception $ex) {
         $result = $ex;
       }
 
       $this->assertFalse(
         ($result === null),
         "Expect user '{$uname}' to be denied access to '{$label}'.");
     }
   }
 
 }
diff --git a/src/applications/celerity/controller/CelerityResourceController.php b/src/applications/celerity/controller/CelerityResourceController.php
index bfd0685649..e99a58c51c 100644
--- a/src/applications/celerity/controller/CelerityResourceController.php
+++ b/src/applications/celerity/controller/CelerityResourceController.php
@@ -1,159 +1,163 @@
 <?php
 
 abstract class CelerityResourceController extends PhabricatorController {
 
   protected function buildResourceTransformer() {
     return null;
   }
 
   public function shouldRequireLogin() {
     return false;
   }
 
   public function shouldRequireEnabledUser() {
     return false;
   }
 
   public function shouldAllowPartialSessions() {
     return true;
   }
 
+  public function shouldAllowLegallyNonCompliantUsers() {
+    return true;
+  }
+
   abstract public function getCelerityResourceMap();
 
   protected function serveResource($path, $package_hash = null) {
     // Sanity checking to keep this from exposing anything sensitive, since it
     // ultimately boils down to disk reads.
     if (preg_match('@(//|\.\.)@', $path)) {
       return new Aphront400Response();
     }
 
     $type = CelerityResourceTransformer::getResourceType($path);
     $type_map = self::getSupportedResourceTypes();
 
     if (empty($type_map[$type])) {
       throw new Exception('Only static resources may be served.');
     }
 
     $dev_mode = PhabricatorEnv::getEnvConfig('phabricator.developer-mode');
 
     if (AphrontRequest::getHTTPHeader('If-Modified-Since') && !$dev_mode) {
       // Return a "304 Not Modified". We don't care about the value of this
       // field since we never change what resource is served by a given URI.
       return $this->makeResponseCacheable(new Aphront304Response());
     }
 
     $is_cacheable = (!$dev_mode) &&
                     $this->isCacheableResourceType($type);
 
     $cache = null;
     $data = null;
     if ($is_cacheable) {
       $cache = PhabricatorCaches::getImmutableCache();
 
       $request_path = $this->getRequest()->getPath();
       $cache_key = $this->getCacheKey($request_path);
 
       $data = $cache->getKey($cache_key);
     }
 
     if ($data === null) {
       $map = $this->getCelerityResourceMap();
 
       if ($map->isPackageResource($path)) {
         $resource_names = $map->getResourceNamesForPackageName($path);
         if (!$resource_names) {
           return new Aphront404Response();
         }
 
         try {
           $data = array();
           foreach ($resource_names as $resource_name) {
             $data[] = $map->getResourceDataForName($resource_name);
           }
           $data = implode("\n\n", $data);
         } catch (Exception $ex) {
           return new Aphront404Response();
         }
       } else {
         try {
           $data = $map->getResourceDataForName($path);
         } catch (Exception $ex) {
           return new Aphront404Response();
         }
       }
 
       $xformer = $this->buildResourceTransformer();
       if ($xformer) {
         $data = $xformer->transformResource($path, $data);
       }
 
       if ($cache) {
         $cache->setKey($cache_key, $data);
       }
     }
 
     $response = new AphrontFileResponse();
     $response->setContent($data);
     $response->setMimeType($type_map[$type]);
 
     // NOTE: This is a piece of magic required to make WOFF fonts work in
     // Firefox. Possibly we should generalize this.
     if ($type == 'woff' || $type == 'woff2') {
       // We could be more tailored here, but it's not currently trivial to
       // generate a comprehensive list of valid origins (an install may have
       // arbitrarily many Phame blogs, for example), and we lose nothing by
       // allowing access from anywhere.
       $response->addAllowOrigin('*');
     }
 
     return $this->makeResponseCacheable($response);
   }
 
   public static function getSupportedResourceTypes() {
     return array(
       'css' => 'text/css; charset=utf-8',
       'js'  => 'text/javascript; charset=utf-8',
       'png' => 'image/png',
       'gif' => 'image/gif',
       'jpg' => 'image/jpeg',
       'swf' => 'application/x-shockwave-flash',
       'woff' => 'font/woff',
       'woff2' => 'font/woff2',
       'eot' => 'font/eot',
       'ttf' => 'font/ttf',
     );
   }
 
   private function makeResponseCacheable(AphrontResponse $response) {
     $response->setCacheDurationInSeconds(60 * 60 * 24 * 30);
     $response->setLastModified(time());
 
     return $response;
   }
 
 
   /**
    * Is it appropriate to cache the data for this resource type in the fast
    * immutable cache?
    *
    * Generally, text resources (which are small, and expensive to process)
    * are cached, while other types of resources (which are large, and cheap
    * to process) are not.
    *
    * @param string  Resource type.
    * @return bool   True to enable caching.
    */
   private function isCacheableResourceType($type) {
     $types = array(
       'js' => true,
       'css' => true,
     );
 
     return isset($types[$type]);
   }
 
   private function getCacheKey($path) {
     return 'celerity:'.$path;
   }
 
 }
diff --git a/src/applications/legalpad/constants/LegalpadTransactionType.php b/src/applications/legalpad/constants/LegalpadTransactionType.php
index 1ad854b199..81f5b159b8 100644
--- a/src/applications/legalpad/constants/LegalpadTransactionType.php
+++ b/src/applications/legalpad/constants/LegalpadTransactionType.php
@@ -1,10 +1,11 @@
 <?php
 
 final class LegalpadTransactionType extends LegalpadConstants {
 
   const TYPE_TITLE = 'title';
   const TYPE_TEXT = 'text';
   const TYPE_SIGNATURE_TYPE = 'legalpad:signature-type';
   const TYPE_PREAMBLE = 'legalpad:premable';
+  const TYPE_REQUIRE_SIGNATURE = 'legalpad:require-signature';
 
 }
diff --git a/src/applications/legalpad/controller/LegalpadDocumentEditController.php b/src/applications/legalpad/controller/LegalpadDocumentEditController.php
index c2414e4b37..53bb693757 100644
--- a/src/applications/legalpad/controller/LegalpadDocumentEditController.php
+++ b/src/applications/legalpad/controller/LegalpadDocumentEditController.php
@@ -1,230 +1,261 @@
 <?php
 
 final class LegalpadDocumentEditController extends LegalpadController {
 
-  private $id;
-
-  public function willProcessRequest(array $data) {
-    $this->id = idx($data, 'id');
-  }
-
-  public function processRequest() {
-    $request = $this->getRequest();
+  public function handleRequest(AphrontRequest $request) {
     $user = $request->getUser();
 
-    if (!$this->id) {
+    $id = $request->getURIData('id');
+    if (!$id) {
       $is_create = true;
 
       $this->requireApplicationCapability(
         LegalpadCreateDocumentsCapability::CAPABILITY);
 
       $document = LegalpadDocument::initializeNewDocument($user);
       $body = id(new LegalpadDocumentBody())
         ->setCreatorPHID($user->getPHID());
       $document->attachDocumentBody($body);
       $document->setDocumentBodyPHID(PhabricatorPHIDConstants::PHID_VOID);
     } else {
       $is_create = false;
 
       $document = id(new LegalpadDocumentQuery())
         ->setViewer($user)
         ->needDocumentBodies(true)
         ->requireCapabilities(
           array(
             PhabricatorPolicyCapability::CAN_VIEW,
             PhabricatorPolicyCapability::CAN_EDIT,
           ))
-        ->withIDs(array($this->id))
+        ->withIDs(array($id))
         ->executeOne();
       if (!$document) {
         return new Aphront404Response();
       }
     }
 
     $e_title = true;
     $e_text = true;
 
     $title = $document->getDocumentBody()->getTitle();
     $text = $document->getDocumentBody()->getText();
     $v_signature_type = $document->getSignatureType();
     $v_preamble = $document->getPreamble();
+    $v_require_signature = $document->getRequireSignature();
 
     $errors = array();
     $can_view = null;
     $can_edit = null;
     if ($request->isFormPost()) {
 
       $xactions = array();
 
       $title = $request->getStr('title');
       if (!strlen($title)) {
         $e_title = pht('Required');
         $errors[] = pht('The document title may not be blank.');
       } else {
         $xactions[] = id(new LegalpadTransaction())
           ->setTransactionType(LegalpadTransactionType::TYPE_TITLE)
           ->setNewValue($title);
       }
 
       $text = $request->getStr('text');
       if (!strlen($text)) {
         $e_text = pht('Required');
         $errors[] = pht('The document may not be blank.');
       } else {
         $xactions[] = id(new LegalpadTransaction())
           ->setTransactionType(LegalpadTransactionType::TYPE_TEXT)
           ->setNewValue($text);
       }
 
       $can_view = $request->getStr('can_view');
       $xactions[] = id(new LegalpadTransaction())
         ->setTransactionType(PhabricatorTransactions::TYPE_VIEW_POLICY)
         ->setNewValue($can_view);
       $can_edit = $request->getStr('can_edit');
       $xactions[] = id(new LegalpadTransaction())
         ->setTransactionType(PhabricatorTransactions::TYPE_EDIT_POLICY)
         ->setNewValue($can_edit);
 
       if ($is_create) {
         $v_signature_type = $request->getStr('signatureType');
         $xactions[] = id(new LegalpadTransaction())
           ->setTransactionType(LegalpadTransactionType::TYPE_SIGNATURE_TYPE)
           ->setNewValue($v_signature_type);
       }
 
       $v_preamble = $request->getStr('preamble');
       $xactions[] = id(new LegalpadTransaction())
         ->setTransactionType(LegalpadTransactionType::TYPE_PREAMBLE)
         ->setNewValue($v_preamble);
 
+      $v_require_signature = $request->getBool('requireSignature', 0);
+      if ($v_require_signature) {
+        if (!$user->getIsAdmin()) {
+          $errors[] = pht('Only admins may require signature.');
+        }
+        $corp = LegalpadDocument::SIGNATURE_TYPE_CORPORATION;
+        if ($v_signature_type == $corp) {
+          $errors[] = pht(
+            'Only documents with signature type "individual" may require '.
+            'signing to use Phabricator.');
+        }
+      }
+      if ($user->getIsAdmin()) {
+        $xactions[] = id(new LegalpadTransaction())
+          ->setTransactionType(LegalpadTransactionType::TYPE_REQUIRE_SIGNATURE)
+          ->setNewValue($v_require_signature);
+      }
+
       if (!$errors) {
         $editor = id(new LegalpadDocumentEditor())
           ->setContentSourceFromRequest($request)
           ->setContinueOnNoEffect(true)
           ->setActor($user);
 
         $xactions = $editor->applyTransactions($document, $xactions);
 
         return id(new AphrontRedirectResponse())
           ->setURI($this->getApplicationURI('view/'.$document->getID()));
       }
     }
 
     if ($errors) {
       // set these to what was specified in the form on post
       $document->setViewPolicy($can_view);
       $document->setEditPolicy($can_edit);
     }
 
     $form = id(new AphrontFormView())
       ->setUser($user)
       ->appendChild(
         id(new AphrontFormTextControl())
         ->setID('document-title')
         ->setLabel(pht('Title'))
         ->setError($e_title)
         ->setValue($title)
         ->setName('title'));
 
     if ($is_create) {
       $form->appendChild(
         id(new AphrontFormSelectControl())
           ->setLabel(pht('Who Should Sign?'))
           ->setName(pht('signatureType'))
           ->setValue($v_signature_type)
           ->setOptions(LegalpadDocument::getSignatureTypeMap()));
+      $show_require = true;
     } else {
       $form->appendChild(
         id(new AphrontFormMarkupControl())
           ->setLabel(pht('Who Should Sign?'))
           ->setValue($document->getSignatureTypeName()));
+      $individual = LegalpadDocument::SIGNATURE_TYPE_INDIVIDUAL;
+      $show_require = $document->getSignatureType() == $individual;
+    }
+
+    if ($show_require) {
+      $form
+        ->appendChild(
+          id(new AphrontFormCheckboxControl())
+          ->setDisabled(!$user->getIsAdmin())
+          ->setLabel(pht('Require Signature'))
+          ->addCheckbox(
+            'requireSignature',
+            'requireSignature',
+            pht(
+              'Should signing this document be required to use Phabricator? '.
+              'Applies to invidivuals only.'),
+            $v_require_signature));
     }
 
     $form
       ->appendChild(
         id(new PhabricatorRemarkupControl())
           ->setUser($user)
           ->setID('preamble')
           ->setLabel(pht('Preamble'))
           ->setValue($v_preamble)
           ->setName('preamble')
           ->setCaption(
             pht('Optional help text for users signing this document.')))
       ->appendChild(
         id(new PhabricatorRemarkupControl())
           ->setUser($user)
           ->setID('document-text')
           ->setLabel(pht('Document Body'))
           ->setError($e_text)
           ->setValue($text)
           ->setHeight(AphrontFormTextAreaControl::HEIGHT_VERY_TALL)
           ->setName('text'));
 
     $policies = id(new PhabricatorPolicyQuery())
       ->setViewer($user)
       ->setObject($document)
       ->execute();
 
     $form
       ->appendChild(
         id(new AphrontFormPolicyControl())
         ->setUser($user)
         ->setCapability(PhabricatorPolicyCapability::CAN_VIEW)
         ->setPolicyObject($document)
         ->setPolicies($policies)
         ->setName('can_view'))
       ->appendChild(
         id(new AphrontFormPolicyControl())
         ->setUser($user)
         ->setCapability(PhabricatorPolicyCapability::CAN_EDIT)
         ->setPolicyObject($document)
         ->setPolicies($policies)
         ->setName('can_edit'));
 
     $crumbs = $this->buildApplicationCrumbs($this->buildSideNav());
     $submit = new AphrontFormSubmitControl();
     if ($is_create) {
       $submit->setValue(pht('Create Document'));
       $submit->addCancelButton($this->getApplicationURI());
       $title = pht('Create Document');
       $short = pht('Create');
     } else {
       $submit->setValue(pht('Save Document'));
       $submit->addCancelButton(
           $this->getApplicationURI('view/'.$document->getID()));
       $title = pht('Edit Document');
       $short = pht('Edit');
 
       $crumbs->addTextCrumb(
         $document->getMonogram(),
         $this->getApplicationURI('view/'.$document->getID()));
     }
 
     $form
       ->appendChild($submit);
 
     $form_box = id(new PHUIObjectBoxView())
       ->setHeaderText($title)
       ->setFormErrors($errors)
       ->setForm($form);
 
     $crumbs->addTextCrumb($short);
 
     $preview = id(new PHUIRemarkupPreviewPanel())
       ->setHeader(pht('Document Preview'))
       ->setPreviewURI($this->getApplicationURI('document/preview/'))
       ->setControlID('document-text')
       ->setSkin('document');
 
     return $this->buildApplicationPage(
       array(
         $crumbs,
         $form_box,
         $preview,
       ),
       array(
         'title' => $title,
       ));
   }
 
 }
diff --git a/src/applications/legalpad/controller/LegalpadDocumentSignController.php b/src/applications/legalpad/controller/LegalpadDocumentSignController.php
index 080b6dd594..0faad2db36 100644
--- a/src/applications/legalpad/controller/LegalpadDocumentSignController.php
+++ b/src/applications/legalpad/controller/LegalpadDocumentSignController.php
@@ -1,648 +1,641 @@
 <?php
 
 final class LegalpadDocumentSignController extends LegalpadController {
 
-  private $id;
-
   public function shouldAllowPublic() {
     return true;
   }
 
-  public function willProcessRequest(array $data) {
-    $this->id = $data['id'];
-  }
-
-  public function processRequest() {
-    $request = $this->getRequest();
+  public function handleRequest(AphrontRequest $request) {
     $viewer = $request->getUser();
 
     $document = id(new LegalpadDocumentQuery())
       ->setViewer($viewer)
-      ->withIDs(array($this->id))
+      ->withIDs(array($request->getURIData('id')))
       ->needDocumentBodies(true)
       ->executeOne();
     if (!$document) {
       return new Aphront404Response();
     }
 
     list($signer_phid, $signature_data) = $this->readSignerInformation(
       $document,
       $request);
 
     $signature = null;
 
     $type_individual = LegalpadDocument::SIGNATURE_TYPE_INDIVIDUAL;
     $is_individual = ($document->getSignatureType() == $type_individual);
     if ($is_individual) {
       if ($signer_phid) {
         // TODO: This is odd and should probably be adjusted after grey/external
         // accounts work better, but use the omnipotent viewer to check for a
         // signature so we can pick up anonymous/grey signatures.
 
         $signature = id(new LegalpadDocumentSignatureQuery())
           ->setViewer(PhabricatorUser::getOmnipotentUser())
           ->withDocumentPHIDs(array($document->getPHID()))
           ->withSignerPHIDs(array($signer_phid))
           ->executeOne();
 
         if ($signature && !$viewer->isLoggedIn()) {
           return $this->newDialog()
             ->setTitle(pht('Already Signed'))
             ->appendParagraph(pht('You have already signed this document!'))
             ->addCancelButton('/'.$document->getMonogram(), pht('Okay'));
         }
       }
 
       $signed_status = null;
       if (!$signature) {
         $has_signed = false;
         $signature = id(new LegalpadDocumentSignature())
           ->setSignerPHID($signer_phid)
           ->setDocumentPHID($document->getPHID())
           ->setDocumentVersion($document->getVersions());
 
         // If the user is logged in, show a notice that they haven't signed.
         // If they aren't logged in, we can't be as sure, so don't show
         // anything.
         if ($viewer->isLoggedIn()) {
           $signed_status = id(new PHUIErrorView())
             ->setSeverity(PHUIErrorView::SEVERITY_WARNING)
             ->setErrors(
               array(
                 pht('You have not signed this document yet.'),
               ));
         }
       } else {
         $has_signed = true;
         $signature_data = $signature->getSignatureData();
 
         // In this case, we know they've signed.
         $signed_at = $signature->getDateCreated();
 
         if ($signature->getIsExemption()) {
           $exemption_phid = $signature->getExemptionPHID();
           $handles = $this->loadViewerHandles(array($exemption_phid));
           $exemption_handle = $handles[$exemption_phid];
 
           $signed_text = pht(
             'You do not need to sign this document. '.
             '%s added a signature exemption for you on %s.',
             $exemption_handle->renderLink(),
             phabricator_datetime($signed_at, $viewer));
         } else {
           $signed_text = pht(
             'You signed this document on %s.',
             phabricator_datetime($signed_at, $viewer));
         }
 
         $signed_status = id(new PHUIErrorView())
           ->setSeverity(PHUIErrorView::SEVERITY_NOTICE)
           ->setErrors(array($signed_text));
       }
 
       $field_errors = array(
         'name' => true,
         'email' => true,
         'agree' => true,
       );
     } else {
       $signature = id(new LegalpadDocumentSignature())
         ->setDocumentPHID($document->getPHID())
         ->setDocumentVersion($document->getVersions());
 
       if ($viewer->isLoggedIn()) {
         $has_signed = false;
 
         $signed_status = null;
       } else {
         // This just hides the form.
         $has_signed = true;
 
         $login_text = pht(
           'This document requires a corporate signatory. You must log in to '.
           'accept this document on behalf of a company you represent.');
         $signed_status = id(new PHUIErrorView())
           ->setSeverity(PHUIErrorView::SEVERITY_WARNING)
           ->setErrors(array($login_text));
       }
 
       $field_errors = array(
         'name' => true,
         'address' => true,
         'contact.name' => true,
         'email' => true,
       );
     }
 
     $signature->setSignatureData($signature_data);
 
     $errors = array();
     if ($request->isFormOrHisecPost() && !$has_signed) {
 
       // Require two-factor auth to sign legal documents.
       if ($viewer->isLoggedIn()) {
         $engine = new PhabricatorAuthSessionEngine();
         $engine->requireHighSecuritySession(
           $viewer,
           $request,
           '/'.$document->getMonogram());
       }
 
       list($form_data, $errors, $field_errors) = $this->readSignatureForm(
         $document,
         $request);
 
       $signature_data = $form_data + $signature_data;
 
       $signature->setSignatureData($signature_data);
       $signature->setSignatureType($document->getSignatureType());
       $signature->setSignerName((string)idx($signature_data, 'name'));
       $signature->setSignerEmail((string)idx($signature_data, 'email'));
 
       $agree = $request->getExists('agree');
       if (!$agree) {
         $errors[] = pht(
           'You must check "I agree to the terms laid forth above."');
         $field_errors['agree'] = pht('Required');
       }
 
       if ($viewer->isLoggedIn() && $is_individual) {
         $verified = LegalpadDocumentSignature::VERIFIED;
       } else {
         $verified = LegalpadDocumentSignature::UNVERIFIED;
       }
       $signature->setVerified($verified);
 
       if (!$errors) {
         $signature->save();
 
         // If the viewer is logged in, send them to the document page, which
         // will show that they have signed the document. Otherwise, send them
         // to a completion page.
         if ($viewer->isLoggedIn() && $is_individual) {
           $next_uri = '/'.$document->getMonogram();
         } else {
           $this->sendVerifySignatureEmail(
             $document,
             $signature);
 
           $next_uri = $this->getApplicationURI('done/');
         }
 
         return id(new AphrontRedirectResponse())->setURI($next_uri);
       }
     }
 
     $document_body = $document->getDocumentBody();
     $engine = id(new PhabricatorMarkupEngine())
       ->setViewer($viewer);
     $engine->addObject(
       $document_body,
       LegalpadDocumentBody::MARKUP_FIELD_TEXT);
     $engine->process();
 
     $document_markup = $engine->getOutput(
       $document_body,
       LegalpadDocumentBody::MARKUP_FIELD_TEXT);
 
     $title = $document_body->getTitle();
 
     $manage_uri = $this->getApplicationURI('view/'.$document->getID().'/');
 
     $can_edit = PhabricatorPolicyFilter::hasCapability(
       $viewer,
       $document,
       PhabricatorPolicyCapability::CAN_EDIT);
 
     $header = id(new PHUIHeaderView())
       ->setHeader($title)
       ->addActionLink(
         id(new PHUIButtonView())
           ->setTag('a')
           ->setIcon(
             id(new PHUIIconView())
               ->setIconFont('fa-pencil'))
           ->setText(pht('Manage Document'))
           ->setHref($manage_uri)
           ->setDisabled(!$can_edit)
           ->setWorkflow(!$can_edit));
 
     $preamble = null;
     if (strlen($document->getPreamble())) {
       $preamble_text = PhabricatorMarkupEngine::renderOneObject(
         id(new PhabricatorMarkupOneOff())->setContent(
           $document->getPreamble()),
         'default',
         $viewer);
 
       $preamble = id(new PHUIPropertyListView())
         ->addSectionHeader(pht('Preamble'))
         ->addTextContent($preamble_text);
     }
 
     $content = id(new PHUIDocumentView())
       ->addClass('legalpad')
       ->setHeader($header)
       ->setFontKit(PHUIDocumentView::FONT_SOURCE_SANS)
       ->appendChild(
         array(
           $signed_status,
           $preamble,
           $document_markup,
         ));
 
     if (!$has_signed) {
       $error_view = null;
       if ($errors) {
         $error_view = id(new PHUIErrorView())
           ->setErrors($errors);
       }
 
       $signature_form = $this->buildSignatureForm(
         $document,
         $signature,
         $field_errors);
 
       $subheader = id(new PHUIHeaderView())
         ->setHeader(pht('Agree and Sign Document'))
         ->setBleedHeader(true);
 
       $content->appendChild(
         array(
           $subheader,
           $error_view,
           $signature_form,
         ));
     }
 
     $crumbs = $this->buildApplicationCrumbs();
     $crumbs->setBorder(true);
     $crumbs->addTextCrumb($document->getMonogram());
 
     return $this->buildApplicationPage(
       array(
         $crumbs,
         $content,
       ),
       array(
         'title' => $title,
         'pageObjects' => array($document->getPHID()),
       ));
   }
 
   private function readSignerInformation(
     LegalpadDocument $document,
     AphrontRequest $request) {
 
     $viewer = $request->getUser();
     $signer_phid = null;
     $signature_data = array();
 
     switch ($document->getSignatureType()) {
       case LegalpadDocument::SIGNATURE_TYPE_INDIVIDUAL:
         if ($viewer->isLoggedIn()) {
           $signer_phid = $viewer->getPHID();
           $signature_data = array(
             'name' => $viewer->getRealName(),
             'email' => $viewer->loadPrimaryEmailAddress(),
           );
         } else if ($request->isFormPost()) {
           $email = new PhutilEmailAddress($request->getStr('email'));
           if (strlen($email->getDomainName())) {
             $email_obj = id(new PhabricatorUserEmail())
               ->loadOneWhere('address = %s', $email->getAddress());
             if ($email_obj) {
               return $this->signInResponse();
             }
             $external_account = id(new PhabricatorExternalAccountQuery())
               ->setViewer($viewer)
               ->withAccountTypes(array('email'))
               ->withAccountDomains(array($email->getDomainName()))
               ->withAccountIDs(array($email->getAddress()))
               ->loadOneOrCreate();
             if ($external_account->getUserPHID()) {
               return $this->signInResponse();
             }
             $signer_phid = $external_account->getPHID();
           }
         }
         break;
       case LegalpadDocument::SIGNATURE_TYPE_CORPORATION:
         $signer_phid = $viewer->getPHID();
         if ($signer_phid) {
           $signature_data = array(
             'contact.name' => $viewer->getRealName(),
             'email' => $viewer->loadPrimaryEmailAddress(),
             'actorPHID' => $viewer->getPHID(),
           );
         }
         break;
     }
 
     return array($signer_phid, $signature_data);
   }
 
   private function buildSignatureForm(
     LegalpadDocument $document,
     LegalpadDocumentSignature $signature,
     array $errors) {
 
     $viewer = $this->getRequest()->getUser();
     $data = $signature->getSignatureData();
 
     $form = id(new AphrontFormView())
       ->setUser($viewer);
 
     $signature_type = $document->getSignatureType();
     switch ($signature_type) {
       case LegalpadDocument::SIGNATURE_TYPE_INDIVIDUAL:
         $this->buildIndividualSignatureForm(
           $form,
           $document,
           $signature,
           $errors);
         break;
       case LegalpadDocument::SIGNATURE_TYPE_CORPORATION:
         $this->buildCorporateSignatureForm(
           $form,
           $document,
           $signature,
           $errors);
         break;
       default:
         throw new Exception(
           pht(
             'This document has an unknown signature type ("%s").',
             $signature_type));
     }
 
     $form
       ->appendChild(
         id(new AphrontFormCheckboxControl())
           ->setError(idx($errors, 'agree', null))
           ->addCheckbox(
             'agree',
             'agree',
             pht('I agree to the terms laid forth above.'),
             false))
       ->appendChild(
         id(new AphrontFormSubmitControl())
           ->setValue(pht('Sign Document'))
           ->addCancelButton($this->getApplicationURI()));
 
     return $form;
   }
 
   private function buildIndividualSignatureForm(
     AphrontFormView $form,
     LegalpadDocument $document,
     LegalpadDocumentSignature $signature,
     array $errors) {
 
     $data = $signature->getSignatureData();
 
     $form
       ->appendChild(
         id(new AphrontFormTextControl())
         ->setLabel(pht('Name'))
         ->setValue(idx($data, 'name', ''))
         ->setName('name')
         ->setError(idx($errors, 'name', null)));
 
     $viewer = $this->getRequest()->getUser();
     if (!$viewer->isLoggedIn()) {
       $form->appendChild(
         id(new AphrontFormTextControl())
           ->setLabel(pht('Email'))
           ->setValue(idx($data, 'email', ''))
           ->setName('email')
           ->setError(idx($errors, 'email', null)));
     }
 
     return $form;
   }
 
   private function buildCorporateSignatureForm(
     AphrontFormView $form,
     LegalpadDocument $document,
     LegalpadDocumentSignature $signature,
     array $errors) {
 
     $data = $signature->getSignatureData();
 
     $form
       ->appendChild(
         id(new AphrontFormTextControl())
         ->setLabel(pht('Company Name'))
         ->setValue(idx($data, 'name', ''))
         ->setName('name')
         ->setError(idx($errors, 'name', null)))
       ->appendChild(
         id(new AphrontFormTextAreaControl())
         ->setLabel(pht('Company Address'))
         ->setValue(idx($data, 'address', ''))
         ->setName('address')
         ->setError(idx($errors, 'address', null)))
       ->appendChild(
         id(new AphrontFormTextControl())
         ->setLabel(pht('Contact Name'))
         ->setValue(idx($data, 'contact.name', ''))
         ->setName('contact.name')
         ->setError(idx($errors, 'contact.name', null)))
       ->appendChild(
         id(new AphrontFormTextControl())
         ->setLabel(pht('Contact Email'))
         ->setValue(idx($data, 'email', ''))
         ->setName('email')
         ->setError(idx($errors, 'email', null)));
 
     return $form;
   }
 
   private function readSignatureForm(
     LegalpadDocument $document,
     AphrontRequest $request) {
 
     $signature_type = $document->getSignatureType();
     switch ($signature_type) {
       case LegalpadDocument::SIGNATURE_TYPE_INDIVIDUAL:
         $result = $this->readIndividualSignatureForm(
           $document,
           $request);
         break;
       case LegalpadDocument::SIGNATURE_TYPE_CORPORATION:
         $result = $this->readCorporateSignatureForm(
           $document,
           $request);
         break;
       default:
         throw new Exception(
           pht(
             'This document has an unknown signature type ("%s").',
             $signature_type));
     }
 
     return $result;
   }
 
   private function readIndividualSignatureForm(
     LegalpadDocument $document,
     AphrontRequest $request) {
 
     $signature_data = array();
     $errors = array();
     $field_errors = array();
 
 
     $name = $request->getStr('name');
 
     if (!strlen($name)) {
       $field_errors['name'] = pht('Required');
       $errors[] = pht('Name field is required.');
     } else {
       $field_errors['name'] = null;
     }
     $signature_data['name'] = $name;
 
     $viewer = $request->getUser();
     if ($viewer->isLoggedIn()) {
       $email = $viewer->loadPrimaryEmailAddress();
     } else {
       $email = $request->getStr('email');
 
       $addr_obj = null;
       if (!strlen($email)) {
         $field_errors['email'] = pht('Required');
         $errors[] = pht('Email field is required.');
       } else {
         $addr_obj = new PhutilEmailAddress($email);
         $domain = $addr_obj->getDomainName();
         if (!$domain) {
           $field_errors['email'] = pht('Invalid');
           $errors[] = pht('A valid email is required.');
         } else {
           $field_errors['email'] = null;
         }
       }
     }
     $signature_data['email'] = $email;
 
     return array($signature_data, $errors, $field_errors);
   }
 
   private function readCorporateSignatureForm(
     LegalpadDocument $document,
     AphrontRequest $request) {
 
     $viewer = $request->getUser();
     if (!$viewer->isLoggedIn()) {
       throw new Exception(
         pht(
           'You can not sign a document on behalf of a corporation unless '.
           'you are logged in.'));
     }
 
     $signature_data = array();
     $errors = array();
     $field_errors = array();
 
     $name = $request->getStr('name');
 
     if (!strlen($name)) {
       $field_errors['name'] = pht('Required');
       $errors[] = pht('Company name is required.');
     } else {
       $field_errors['name'] = null;
     }
     $signature_data['name'] = $name;
 
     $address = $request->getStr('address');
     if (!strlen($address)) {
       $field_errors['address'] = pht('Required');
       $errors[] = pht('Company address is required.');
     } else {
       $field_errors['address'] = null;
     }
     $signature_data['address'] = $address;
 
     $contact_name = $request->getStr('contact.name');
     if (!strlen($contact_name)) {
       $field_errors['contact.name'] = pht('Required');
       $errors[] = pht('Contact name is required.');
     } else {
       $field_errors['contact.name'] = null;
     }
     $signature_data['contact.name'] = $contact_name;
 
     $email = $request->getStr('email');
     $addr_obj = null;
     if (!strlen($email)) {
       $field_errors['email'] = pht('Required');
       $errors[] = pht('Contact email is required.');
     } else {
       $addr_obj = new PhutilEmailAddress($email);
       $domain = $addr_obj->getDomainName();
       if (!$domain) {
         $field_errors['email'] = pht('Invalid');
         $errors[] = pht('A valid email is required.');
       } else {
         $field_errors['email'] = null;
       }
     }
     $signature_data['email'] = $email;
 
     return array($signature_data, $errors, $field_errors);
   }
 
   private function sendVerifySignatureEmail(
     LegalpadDocument $doc,
     LegalpadDocumentSignature $signature) {
 
     $signature_data = $signature->getSignatureData();
     $email = new PhutilEmailAddress($signature_data['email']);
     $doc_name = $doc->getTitle();
     $doc_link = PhabricatorEnv::getProductionURI('/'.$doc->getMonogram());
     $path = $this->getApplicationURI(sprintf(
       '/verify/%s/',
       $signature->getSecretKey()));
     $link = PhabricatorEnv::getProductionURI($path);
 
     $name = idx($signature_data, 'name');
 
     $body = <<<EOBODY
 {$name}:
 
 This email address was used to sign a Legalpad document in Phabricator:
 
   {$doc_name}
 
 Please verify you own this email address and accept the agreement by clicking
 this link:
 
   {$link}
 
 Your signature is not valid until you complete this verification step.
 
 You can review the document here:
 
   {$doc_link}
 
 EOBODY;
 
     id(new PhabricatorMetaMTAMail())
       ->addRawTos(array($email->getAddress()))
       ->setSubject(pht('[Legalpad] Signature Verification'))
       ->setForceDelivery(true)
       ->setBody($body)
       ->setRelatedPHID($signature->getDocumentPHID())
       ->saveAndSend();
   }
 
   private function signInResponse() {
     return id(new Aphront403Response())
       ->setForbiddenText(pht(
         'The email address specified is associated with an account. '.
         'Please login to that account and sign this document again.'));
   }
 
 }
diff --git a/src/applications/legalpad/controller/LegalpadDocumentSignatureAddController.php b/src/applications/legalpad/controller/LegalpadDocumentSignatureAddController.php
index 47ad308508..662d608aea 100644
--- a/src/applications/legalpad/controller/LegalpadDocumentSignatureAddController.php
+++ b/src/applications/legalpad/controller/LegalpadDocumentSignatureAddController.php
@@ -1,168 +1,162 @@
 <?php
 
 final class LegalpadDocumentSignatureAddController extends LegalpadController {
 
-  private $id;
-
-  public function willProcessRequest(array $data) {
-    $this->id = $data['id'];
-  }
-
-  public function processRequest() {
+  public function handleRequest(AphrontRequest $request) {
     $request = $this->getRequest();
     $viewer = $request->getUser();
 
     $document = id(new LegalpadDocumentQuery())
       ->setViewer($viewer)
       ->needDocumentBodies(true)
       ->requireCapabilities(
         array(
           PhabricatorPolicyCapability::CAN_VIEW,
           PhabricatorPolicyCapability::CAN_EDIT,
         ))
-      ->withIDs(array($this->id))
+      ->withIDs(array($request->getURIData('id')))
       ->executeOne();
     if (!$document) {
       return new Aphront404Response();
     }
 
     $next_uri = $this->getApplicationURI('signatures/'.$document->getID().'/');
 
     $e_name = true;
     $e_user = true;
     $v_users = array();
     $v_notes = '';
     $v_name = '';
     $errors = array();
 
     $type_individual = LegalpadDocument::SIGNATURE_TYPE_INDIVIDUAL;
     $is_individual = ($document->getSignatureType() == $type_individual);
 
     if ($request->isFormPost()) {
       $v_notes = $request->getStr('notes');
       $v_users = array_slice($request->getArr('users'), 0, 1);
       $v_name = $request->getStr('name');
 
       if ($is_individual) {
         $user_phid = head($v_users);
         if (!$user_phid) {
           $e_user = pht('Required');
           $errors[] = pht('You must choose a user to exempt.');
         } else {
           $user = id(new PhabricatorPeopleQuery())
             ->setViewer($viewer)
             ->withPHIDs(array($user_phid))
             ->executeOne();
 
           if (!$user) {
             $e_user = pht('Invalid');
             $errors[] = pht('That user does not exist.');
           } else {
             $signature = id(new LegalpadDocumentSignatureQuery())
               ->setViewer($viewer)
               ->withDocumentPHIDs(array($document->getPHID()))
               ->withSignerPHIDs(array($user->getPHID()))
               ->executeOne();
             if ($signature) {
               $e_user = pht('Signed');
               $errors[] = pht('That user has already signed this document.');
             } else {
               $e_user = null;
             }
           }
         }
       } else {
         $company_name = $v_name;
         if (!strlen($company_name)) {
           $e_name = pht('Required');
           $errors[] = pht('You must choose a company to add an exemption for.');
         }
       }
 
       if (!$errors) {
         if ($is_individual) {
           $name = $user->getRealName();
           $email = $user->loadPrimaryEmailAddress();
           $signer_phid = $user->getPHID();
           $signature_data = array(
             'name' => $name,
             'email' => $email,
             'notes' => $v_notes,
           );
         } else {
           $name = $company_name;
           $email = '';
           $signer_phid = null;
           $signature_data = array(
             'name' => $name,
             'email' => null,
             'notes' => $v_notes,
             'actorPHID' => $viewer->getPHID(),
           );
         }
 
         $signature = id(new LegalpadDocumentSignature())
           ->setDocumentPHID($document->getPHID())
           ->setDocumentVersion($document->getVersions())
           ->setSignerPHID($signer_phid)
           ->setSignerName($name)
           ->setSignerEmail($email)
           ->setSignatureType($document->getSignatureType())
           ->setIsExemption(1)
           ->setExemptionPHID($viewer->getPHID())
           ->setVerified(LegalpadDocumentSignature::VERIFIED)
           ->setSignatureData($signature_data);
 
         $signature->save();
 
         return id(new AphrontRedirectResponse())->setURI($next_uri);
       }
     }
 
     $form = id(new AphrontFormView())
       ->setUser($viewer);
 
     if ($is_individual) {
       $user_handles = $this->loadViewerHandles($v_users);
       $form
         ->appendChild(
           id(new AphrontFormTokenizerControl())
             ->setLabel(pht('Exempt User'))
             ->setName('users')
             ->setLimit(1)
             ->setDatasource(new PhabricatorPeopleDatasource())
             ->setValue($user_handles)
             ->setError($e_user));
     } else {
       $form
         ->appendChild(
           id(new AphrontFormTextControl())
             ->setLabel(pht('Company Name'))
             ->setName('name')
             ->setError($e_name)
             ->setValue($v_name));
     }
 
     $form
       ->appendChild(
         id(new AphrontFormTextAreaControl())
           ->setLabel(pht('Notes'))
           ->setName('notes')
           ->setValue($v_notes));
 
     return $this->newDialog()
       ->setTitle(pht('Add Signature Exemption'))
       ->setWidth(AphrontDialogView::WIDTH_FORM)
       ->setErrors($errors)
       ->appendParagraph(
         pht(
           'You can record a signature exemption if a user has signed an '.
           'equivalent document. Other applications will behave as through the '.
           'user has signed this document.'))
       ->appendParagraph(null)
       ->appendChild($form->buildLayoutView())
       ->addSubmitButton(pht('Add Exemption'))
       ->addCancelButton($next_uri);
   }
 
 }
diff --git a/src/applications/legalpad/editor/LegalpadDocumentEditor.php b/src/applications/legalpad/editor/LegalpadDocumentEditor.php
index 6062e082e1..32c8c690ec 100644
--- a/src/applications/legalpad/editor/LegalpadDocumentEditor.php
+++ b/src/applications/legalpad/editor/LegalpadDocumentEditor.php
@@ -1,219 +1,240 @@
 <?php
 
 final class LegalpadDocumentEditor
   extends PhabricatorApplicationTransactionEditor {
 
   private $isContribution = false;
 
   public function getEditorApplicationClass() {
     return 'PhabricatorLegalpadApplication';
   }
 
   public function getEditorObjectsDescription() {
     return pht('Legalpad Documents');
   }
 
   private function setIsContribution($is_contribution) {
     $this->isContribution = $is_contribution;
   }
 
   private function isContribution() {
     return $this->isContribution;
   }
 
   public function getTransactionTypes() {
     $types = parent::getTransactionTypes();
 
     $types[] = PhabricatorTransactions::TYPE_COMMENT;
     $types[] = PhabricatorTransactions::TYPE_VIEW_POLICY;
     $types[] = PhabricatorTransactions::TYPE_EDIT_POLICY;
 
     $types[] = LegalpadTransactionType::TYPE_TITLE;
     $types[] = LegalpadTransactionType::TYPE_TEXT;
     $types[] = LegalpadTransactionType::TYPE_SIGNATURE_TYPE;
     $types[] = LegalpadTransactionType::TYPE_PREAMBLE;
+    $types[] = LegalpadTransactionType::TYPE_REQUIRE_SIGNATURE;
 
     return $types;
   }
 
   protected function getCustomTransactionOldValue(
     PhabricatorLiskDAO $object,
     PhabricatorApplicationTransaction $xaction) {
 
     switch ($xaction->getTransactionType()) {
       case LegalpadTransactionType::TYPE_TITLE:
         return $object->getDocumentBody()->getTitle();
       case LegalpadTransactionType::TYPE_TEXT:
         return $object->getDocumentBody()->getText();
       case LegalpadTransactionType::TYPE_SIGNATURE_TYPE:
         return $object->getSignatureType();
       case LegalpadTransactionType::TYPE_PREAMBLE:
         return $object->getPreamble();
+      case LegalpadTransactionType::TYPE_REQUIRE_SIGNATURE:
+        return $object->getRequireSignature();
     }
   }
 
   protected function getCustomTransactionNewValue(
     PhabricatorLiskDAO $object,
     PhabricatorApplicationTransaction $xaction) {
 
     switch ($xaction->getTransactionType()) {
       case LegalpadTransactionType::TYPE_TITLE:
       case LegalpadTransactionType::TYPE_TEXT:
       case LegalpadTransactionType::TYPE_SIGNATURE_TYPE:
       case LegalpadTransactionType::TYPE_PREAMBLE:
+      case LegalpadTransactionType::TYPE_REQUIRE_SIGNATURE:
         return $xaction->getNewValue();
     }
   }
 
   protected function applyCustomInternalTransaction(
     PhabricatorLiskDAO $object,
     PhabricatorApplicationTransaction $xaction) {
 
     switch ($xaction->getTransactionType()) {
       case LegalpadTransactionType::TYPE_TITLE:
         $object->setTitle($xaction->getNewValue());
         $body = $object->getDocumentBody();
         $body->setTitle($xaction->getNewValue());
         $this->setIsContribution(true);
         break;
       case LegalpadTransactionType::TYPE_TEXT:
         $body = $object->getDocumentBody();
         $body->setText($xaction->getNewValue());
         $this->setIsContribution(true);
         break;
       case LegalpadTransactionType::TYPE_SIGNATURE_TYPE:
         $object->setSignatureType($xaction->getNewValue());
         break;
       case LegalpadTransactionType::TYPE_PREAMBLE:
         $object->setPreamble($xaction->getNewValue());
         break;
+      case LegalpadTransactionType::TYPE_REQUIRE_SIGNATURE:
+        $object->setRequireSignature($xaction->getNewValue());
+        break;
     }
   }
 
   protected function applyCustomExternalTransaction(
     PhabricatorLiskDAO $object,
     PhabricatorApplicationTransaction $xaction) {
+
+    switch ($xaction->getTransactionType()) {
+      case LegalpadTransactionType::TYPE_REQUIRE_SIGNATURE:
+        if ($xaction->getNewValue()) {
+          $session = new PhabricatorAuthSession();
+          queryfx(
+            $session->establishConnection('w'),
+            'UPDATE %T SET signedLegalpadDocuments = 0',
+            $session->getTableName());
+        }
+        break;
+    }
     return;
   }
 
   protected function applyFinalEffects(
     PhabricatorLiskDAO $object,
     array $xactions) {
 
     if ($this->isContribution()) {
       $object->setVersions($object->getVersions() + 1);
       $body = $object->getDocumentBody();
       $body->setVersion($object->getVersions());
       $body->setDocumentPHID($object->getPHID());
       $body->save();
 
       $object->setDocumentBodyPHID($body->getPHID());
 
       $actor = $this->getActor();
       $type = PhabricatorContributedToObjectEdgeType::EDGECONST;
       id(new PhabricatorEdgeEditor())
         ->addEdge($actor->getPHID(), $type, $object->getPHID())
         ->save();
 
       $type = PhabricatorObjectHasContributorEdgeType::EDGECONST;
       $contributors = PhabricatorEdgeQuery::loadDestinationPHIDs(
         $object->getPHID(),
         $type);
       $object->setRecentContributorPHIDs(array_slice($contributors, 0, 3));
       $object->setContributorCount(count($contributors));
 
       $object->save();
     }
 
     return $xactions;
   }
 
   protected function mergeTransactions(
     PhabricatorApplicationTransaction $u,
     PhabricatorApplicationTransaction $v) {
 
     $type = $u->getTransactionType();
     switch ($type) {
       case LegalpadTransactionType::TYPE_TITLE:
       case LegalpadTransactionType::TYPE_TEXT:
       case LegalpadTransactionType::TYPE_SIGNATURE_TYPE:
       case LegalpadTransactionType::TYPE_PREAMBLE:
+      case LegalpadTransactionType::TYPE_REQUIRE_SIGNATURE:
         return $v;
     }
 
     return parent::mergeTransactions($u, $v);
   }
 
 /* -(  Sending Mail  )------------------------------------------------------- */
 
   protected function shouldSendMail(
     PhabricatorLiskDAO $object,
     array $xactions) {
     return true;
   }
 
   protected function buildReplyHandler(PhabricatorLiskDAO $object) {
     return id(new LegalpadReplyHandler())
       ->setMailReceiver($object);
   }
 
   protected function buildMailTemplate(PhabricatorLiskDAO $object) {
     $id = $object->getID();
     $phid = $object->getPHID();
     $title = $object->getDocumentBody()->getTitle();
 
     return id(new PhabricatorMetaMTAMail())
       ->setSubject("L{$id}: {$title}")
       ->addHeader('Thread-Topic', "L{$id}: {$phid}");
   }
 
   protected function getMailTo(PhabricatorLiskDAO $object) {
     return array(
       $object->getCreatorPHID(),
       $this->requireActor()->getPHID(),
     );
   }
 
   protected function shouldImplyCC(
     PhabricatorLiskDAO $object,
     PhabricatorApplicationTransaction $xaction) {
 
     switch ($xaction->getTransactionType()) {
       case LegalpadTransactionType::TYPE_TEXT:
       case LegalpadTransactionType::TYPE_TITLE:
       case LegalpadTransactionType::TYPE_PREAMBLE:
+      case LegalpadTransactionType::TYPE_REQUIRE_SIGNATURE:
         return true;
     }
 
     return parent::shouldImplyCC($object, $xaction);
   }
 
   protected function buildMailBody(
     PhabricatorLiskDAO $object,
     array $xactions) {
 
     $body = parent::buildMailBody($object, $xactions);
 
     $body->addLinkSection(
       pht('DOCUMENT DETAIL'),
       PhabricatorEnv::getProductionURI('/legalpad/view/'.$object->getID().'/'));
 
     return $body;
   }
 
   protected function getMailSubjectPrefix() {
     return PhabricatorEnv::getEnvConfig('metamta.legalpad.subject-prefix');
   }
 
 
   protected function shouldPublishFeedStory(
     PhabricatorLiskDAO $object,
     array $xactions) {
     return false;
   }
 
   protected function supportsSearch() {
     return false;
   }
 
 }
diff --git a/src/applications/legalpad/query/LegalpadDocumentQuery.php b/src/applications/legalpad/query/LegalpadDocumentQuery.php
index 7c0a9ff6b9..03ec6b3d3c 100644
--- a/src/applications/legalpad/query/LegalpadDocumentQuery.php
+++ b/src/applications/legalpad/query/LegalpadDocumentQuery.php
@@ -1,265 +1,278 @@
 <?php
 
 final class LegalpadDocumentQuery
   extends PhabricatorCursorPagedPolicyAwareQuery {
 
   private $ids;
   private $phids;
   private $creatorPHIDs;
   private $contributorPHIDs;
   private $signerPHIDs;
   private $dateCreatedAfter;
   private $dateCreatedBefore;
+  private $signatureRequired;
 
   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 withSignatureRequired($bool) {
+    $this->signatureRequired = $bool;
+    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 %Q',
       $table->getTableName(),
       $this->buildJoinClause($conn_r),
       $this->buildWhereClause($conn_r),
       $this->buildGroupClause($conn_r),
       $this->buildOrderClause($conn_r),
       $this->buildLimitClause($conn_r));
 
     $documents = $table->loadAllFromArray($data);
 
     return $documents;
   }
 
   protected function willFilterPage(array $documents) {
     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 !== null) {
       $joins[] = qsprintf(
         $conn_r,
         'JOIN edge contributor ON contributor.src = d.phid
           AND contributor.type = %d',
         PhabricatorObjectHasContributorEdgeType::EDGECONST);
     }
 
     if ($this->signerPHIDs !== null) {
       $joins[] = qsprintf(
         $conn_r,
         'JOIN %T signer ON signer.documentPHID = d.phid
           AND signer.signerPHID IN (%Ls)',
         id(new LegalpadDocumentSignature())->getTableName(),
         $this->signerPHIDs);
     }
 
     return implode(' ', $joins);
   }
 
   private function buildGroupClause(AphrontDatabaseConnection $conn_r) {
     if ($this->contributorPHIDs || $this->signerPHIDs) {
       return 'GROUP BY d.id';
     } else {
       return '';
     }
   }
 
   protected function buildWhereClause($conn_r) {
     $where = array();
 
     if ($this->ids !== null) {
       $where[] = qsprintf(
         $conn_r,
         'd.id IN (%Ld)',
         $this->ids);
     }
 
     if ($this->phids !== null) {
       $where[] = qsprintf(
         $conn_r,
         'd.phid IN (%Ls)',
         $this->phids);
     }
 
     if ($this->creatorPHIDs !== null) {
       $where[] = qsprintf(
         $conn_r,
         'd.creatorPHID IN (%Ls)',
         $this->creatorPHIDs);
     }
 
     if ($this->dateCreatedAfter !== null) {
       $where[] = qsprintf(
         $conn_r,
         'd.dateCreated >= %d',
         $this->dateCreatedAfter);
     }
 
     if ($this->dateCreatedBefore !== null) {
       $where[] = qsprintf(
         $conn_r,
         'd.dateCreated <= %d',
         $this->dateCreatedBefore);
     }
 
     if ($this->contributorPHIDs !== null) {
       $where[] = qsprintf(
         $conn_r,
         'contributor.dst IN (%Ls)',
         $this->contributorPHIDs);
     }
 
+    if ($this->signatureRequired !== null) {
+      $where[] = qsprintf(
+        $conn_r,
+        'd.requireSignature = %d',
+        $this->signatureRequired);
+    }
+
     $where[] = $this->buildPagingClause($conn_r);
 
     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 = PhabricatorObjectHasContributorEdgeType::EDGECONST;
     $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());
       $document->attachSignatures($sigs);
     }
 
     return $documents;
   }
 
   public function getQueryApplicationClass() {
     return 'PhabricatorLegalpadApplication';
   }
 
 }
diff --git a/src/applications/legalpad/storage/LegalpadDocument.php b/src/applications/legalpad/storage/LegalpadDocument.php
index ad6214a8d1..c06d722fae 100644
--- a/src/applications/legalpad/storage/LegalpadDocument.php
+++ b/src/applications/legalpad/storage/LegalpadDocument.php
@@ -1,250 +1,256 @@
 <?php
 
 final class LegalpadDocument extends LegalpadDAO
   implements
     PhabricatorPolicyInterface,
     PhabricatorSubscribableInterface,
     PhabricatorApplicationTransactionInterface,
     PhabricatorDestructibleInterface {
 
   protected $title;
   protected $contributorCount;
   protected $recentContributorPHIDs = array();
   protected $creatorPHID;
   protected $versions;
   protected $documentBodyPHID;
   protected $viewPolicy;
   protected $editPolicy;
   protected $mailKey;
   protected $signatureType;
   protected $preamble;
+  protected $requireSignature;
 
   const SIGNATURE_TYPE_INDIVIDUAL = 'user';
   const SIGNATURE_TYPE_CORPORATION = 'corp';
 
   private $documentBody = self::ATTACHABLE;
   private $contributors = self::ATTACHABLE;
   private $signatures = self::ATTACHABLE;
   private $userSignatures = array();
 
   public static function initializeNewDocument(PhabricatorUser $actor) {
     $app = id(new PhabricatorApplicationQuery())
       ->setViewer($actor)
       ->withClasses(array('PhabricatorLegalpadApplication'))
       ->executeOne();
 
     $view_policy = $app->getPolicy(LegalpadDefaultViewCapability::CAPABILITY);
     $edit_policy = $app->getPolicy(LegalpadDefaultEditCapability::CAPABILITY);
 
     return id(new LegalpadDocument())
       ->setVersions(0)
       ->setCreatorPHID($actor->getPHID())
       ->setContributorCount(0)
       ->setRecentContributorPHIDs(array())
       ->attachSignatures(array())
       ->setSignatureType(self::SIGNATURE_TYPE_INDIVIDUAL)
       ->setPreamble('')
+      ->setRequireSignature(0)
       ->setViewPolicy($view_policy)
       ->setEditPolicy($edit_policy);
   }
 
   protected function getConfiguration() {
     return array(
       self::CONFIG_AUX_PHID => true,
       self::CONFIG_SERIALIZATION => array(
         'recentContributorPHIDs' => self::SERIALIZATION_JSON,
       ),
       self::CONFIG_COLUMN_SCHEMA => array(
         'title' => 'text255',
         'contributorCount' => 'uint32',
         'versions' => 'uint32',
         'mailKey' => 'bytes20',
         'signatureType' => 'text4',
         'preamble' => 'text',
+        'requireSignature' => 'bool',
       ),
       self::CONFIG_KEY_SCHEMA => array(
         'key_creator' => array(
           'columns' => array('creatorPHID', 'dateModified'),
         ),
+        'key_required' => array(
+          'columns' => array('requireSignature', 'dateModified'),
+        ),
       ),
     ) + parent::getConfiguration();
   }
 
   public function generatePHID() {
     return PhabricatorPHID::generateNewPHID(
       PhabricatorLegalpadDocumentPHIDType::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;
   }
 
   public static function getSignatureTypeMap() {
     return array(
       self::SIGNATURE_TYPE_INDIVIDUAL => pht('Individuals'),
       self::SIGNATURE_TYPE_CORPORATION => pht('Corporations'),
     );
   }
 
   public function getSignatureTypeName() {
     $type = $this->getSignatureType();
     return idx(self::getSignatureTypeMap(), $type, $type);
   }
 
   public function getSignatureTypeIcon() {
     $type = $this->getSignatureType();
     $map = array(
       self::SIGNATURE_TYPE_INDIVIDUAL => 'fa-user grey',
       self::SIGNATURE_TYPE_CORPORATION => 'fa-building-o grey',
     );
 
     return idx($map, $type, 'fa-user grey');
   }
 
 
 /* -(  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();
   }
 
   public function willRenderTimeline(
     PhabricatorApplicationTransactionView $timeline,
     AphrontRequest $request) {
 
     return $timeline;
   }
 
 
 /* -(  PhabricatorDestructibleInterface  )----------------------------------- */
 
 
   public function destroyObjectPermanently(
     PhabricatorDestructionEngine $engine) {
 
     $this->openTransaction();
       $this->delete();
 
       $bodies = id(new LegalpadDocumentBody())->loadAllWhere(
         'documentPHID = %s',
         $this->getPHID());
       foreach ($bodies as $body) {
         $body->delete();
       }
 
       $signatures = id(new LegalpadDocumentSignature())->loadAllWhere(
         'documentPHID = %s',
         $this->getPHID());
       foreach ($signatures as $signature) {
         $signature->delete();
       }
 
     $this->saveTransaction();
   }
 
 }
diff --git a/src/applications/legalpad/storage/LegalpadTransaction.php b/src/applications/legalpad/storage/LegalpadTransaction.php
index 9c81c9f7e3..37c81148f3 100644
--- a/src/applications/legalpad/storage/LegalpadTransaction.php
+++ b/src/applications/legalpad/storage/LegalpadTransaction.php
@@ -1,79 +1,90 @@
 <?php
 
 final class LegalpadTransaction extends PhabricatorApplicationTransaction {
 
   public function getApplicationName() {
     return 'legalpad';
   }
 
   public function getApplicationTransactionType() {
     return PhabricatorLegalpadDocumentPHIDType::TYPECONST;
   }
 
   public function getApplicationTransactionCommentObject() {
     return new LegalpadTransactionComment();
   }
 
   public function getApplicationTransactionViewObject() {
     return new LegalpadTransactionView();
   }
 
   public function shouldHide() {
     $old = $this->getOldValue();
 
     switch ($this->getTransactionType()) {
       case LegalpadTransactionType::TYPE_TITLE:
       case LegalpadTransactionType::TYPE_TEXT:
         return ($old === null);
       case LegalpadTransactionType::TYPE_SIGNATURE_TYPE:
         return true;
     }
 
     return parent::shouldHide();
   }
 
   public function getTitle() {
     $author_phid = $this->getAuthorPHID();
 
     $old = $this->getOldValue();
     $new = $this->getNewValue();
 
     $type = $this->getTransactionType();
     switch ($type) {
       case LegalpadTransactionType::TYPE_TITLE:
         return pht(
           '%s renamed this document from "%s" to "%s".',
           $this->renderHandleLink($author_phid),
           $old,
           $new);
       case LegalpadTransactionType::TYPE_TEXT:
         return pht(
           "%s updated the document's text.",
           $this->renderHandleLink($author_phid));
       case LegalpadTransactionType::TYPE_PREAMBLE:
         return pht(
           '%s updated the preamble.',
           $this->renderHandleLink($author_phid));
+      case LegalpadTransactionType::TYPE_REQUIRE_SIGNATURE:
+        if ($new) {
+          $text = pht(
+            '%s set the document to require signatures.',
+            $this->renderHandleLink($author_phid));
+        } else {
+          $text = pht(
+            '%s set the document to not require signatures.',
+            $this->renderHandleLink($author_phid));
+        }
+        return $text;
     }
 
     return parent::getTitle();
   }
 
   public function hasChangeDetails() {
     switch ($this->getTransactionType()) {
       case LegalpadTransactionType::TYPE_TITLE:
       case LegalpadTransactionType::TYPE_TEXT:
       case LegalpadTransactionType::TYPE_PREAMBLE:
         return true;
     }
     return parent::hasChangeDetails();
   }
 
   public function renderChangeDetails(PhabricatorUser $viewer) {
     return $this->renderTextCorpusChangeDetails(
       $viewer,
       $this->getOldValue(),
       $this->getNewValue());
   }
 
 }
diff --git a/src/applications/people/storage/PhabricatorUserLog.php b/src/applications/people/storage/PhabricatorUserLog.php
index 2db3bd1575..acdd7b1efe 100644
--- a/src/applications/people/storage/PhabricatorUserLog.php
+++ b/src/applications/people/storage/PhabricatorUserLog.php
@@ -1,208 +1,211 @@
 <?php
 
 final class PhabricatorUserLog extends PhabricatorUserDAO
   implements PhabricatorPolicyInterface {
 
   const ACTION_LOGIN          = 'login';
   const ACTION_LOGIN_PARTIAL  = 'login-partial';
   const ACTION_LOGIN_FULL     = 'login-full';
   const ACTION_LOGOUT         = 'logout';
   const ACTION_LOGIN_FAILURE  = 'login-fail';
+  const ACTION_LOGIN_LEGALPAD = 'login-legalpad';
   const ACTION_RESET_PASSWORD = 'reset-pass';
 
   const ACTION_CREATE         = 'create';
   const ACTION_EDIT           = 'edit';
 
   const ACTION_ADMIN          = 'admin';
   const ACTION_SYSTEM_AGENT   = 'system-agent';
   const ACTION_DISABLE        = 'disable';
   const ACTION_APPROVE        = 'approve';
   const ACTION_DELETE         = 'delete';
 
   const ACTION_CONDUIT_CERTIFICATE = 'conduit-cert';
   const ACTION_CONDUIT_CERTIFICATE_FAILURE = 'conduit-cert-fail';
 
   const ACTION_EMAIL_PRIMARY    = 'email-primary';
   const ACTION_EMAIL_REMOVE     = 'email-remove';
   const ACTION_EMAIL_ADD        = 'email-add';
   const ACTION_EMAIL_VERIFY     = 'email-verify';
   const ACTION_EMAIL_REASSIGN   = 'email-reassign';
 
   const ACTION_CHANGE_PASSWORD  = 'change-password';
   const ACTION_CHANGE_USERNAME  = 'change-username';
 
   const ACTION_ENTER_HISEC = 'hisec-enter';
   const ACTION_EXIT_HISEC = 'hisec-exit';
   const ACTION_FAIL_HISEC = 'hisec-fail';
 
   const ACTION_MULTI_ADD = 'multi-add';
   const ACTION_MULTI_REMOVE = 'multi-remove';
 
   protected $actorPHID;
   protected $userPHID;
   protected $action;
   protected $oldValue;
   protected $newValue;
   protected $details = array();
   protected $remoteAddr;
   protected $session;
 
   public static function getActionTypeMap() {
     return array(
       self::ACTION_LOGIN => pht('Login'),
       self::ACTION_LOGIN_PARTIAL => pht('Login: Partial Login'),
       self::ACTION_LOGIN_FULL => pht('Login: Upgrade to Full'),
       self::ACTION_LOGIN_FAILURE => pht('Login: Failure'),
+      self::ACTION_LOGIN_LEGALPAD =>
+        pht('Login: Signed Required Legalpad Documents'),
       self::ACTION_LOGOUT => pht('Logout'),
       self::ACTION_RESET_PASSWORD => pht('Reset Password'),
       self::ACTION_CREATE => pht('Create Account'),
       self::ACTION_EDIT => pht('Edit Account'),
       self::ACTION_ADMIN => pht('Add/Remove Administrator'),
       self::ACTION_SYSTEM_AGENT => pht('Add/Remove System Agent'),
       self::ACTION_DISABLE => pht('Enable/Disable'),
       self::ACTION_APPROVE => pht('Approve Registration'),
       self::ACTION_DELETE => pht('Delete User'),
       self::ACTION_CONDUIT_CERTIFICATE
         => pht('Conduit: Read Certificate'),
       self::ACTION_CONDUIT_CERTIFICATE_FAILURE
         => pht('Conduit: Read Certificate Failure'),
       self::ACTION_EMAIL_PRIMARY => pht('Email: Change Primary'),
       self::ACTION_EMAIL_ADD => pht('Email: Add Address'),
       self::ACTION_EMAIL_REMOVE => pht('Email: Remove Address'),
       self::ACTION_EMAIL_VERIFY => pht('Email: Verify'),
       self::ACTION_EMAIL_REASSIGN => pht('Email: Reassign'),
       self::ACTION_CHANGE_PASSWORD => pht('Change Password'),
       self::ACTION_CHANGE_USERNAME => pht('Change Username'),
       self::ACTION_ENTER_HISEC => pht('Hisec: Enter'),
       self::ACTION_EXIT_HISEC => pht('Hisec: Exit'),
       self::ACTION_FAIL_HISEC => pht('Hisec: Failed Attempt'),
       self::ACTION_MULTI_ADD => pht('Multi-Factor: Add Factor'),
       self::ACTION_MULTI_REMOVE => pht('Multi-Factor: Remove Factor'),
     );
   }
 
 
   public static function initializeNewLog(
     PhabricatorUser $actor = null,
     $object_phid,
     $action) {
 
     $log = new PhabricatorUserLog();
 
     if ($actor) {
       $log->setActorPHID($actor->getPHID());
       if ($actor->hasSession()) {
         $session = $actor->getSession();
 
         // NOTE: This is a hash of the real session value, so it's safe to
         // store it directly in the logs.
         $log->setSession($session->getSessionKey());
       }
     }
 
     $log->setUserPHID((string)$object_phid);
     $log->setAction($action);
 
     $log->remoteAddr = idx($_SERVER, 'REMOTE_ADDR', '');
 
     return $log;
   }
 
   public static function loadRecentEventsFromThisIP($action, $timespan) {
     return id(new PhabricatorUserLog())->loadAllWhere(
       'action = %s AND remoteAddr = %s AND dateCreated > %d
         ORDER BY dateCreated DESC',
       $action,
       idx($_SERVER, 'REMOTE_ADDR'),
       time() - $timespan);
   }
 
   public function save() {
     $this->details['host'] = php_uname('n');
     $this->details['user_agent'] = AphrontRequest::getHTTPHeader('User-Agent');
 
     return parent::save();
   }
 
   protected function getConfiguration() {
     return array(
       self::CONFIG_SERIALIZATION => array(
         'oldValue' => self::SERIALIZATION_JSON,
         'newValue' => self::SERIALIZATION_JSON,
         'details'  => self::SERIALIZATION_JSON,
       ),
       self::CONFIG_COLUMN_SCHEMA => array(
         'actorPHID' => 'phid?',
         'action' => 'text64',
         'remoteAddr' => 'text64',
         'session' => 'bytes40?',
       ),
       self::CONFIG_KEY_SCHEMA => array(
         'actorPHID' => array(
           'columns' => array('actorPHID', 'dateCreated'),
         ),
         'userPHID' => array(
           'columns' => array('userPHID', 'dateCreated'),
         ),
         'action' => array(
           'columns' => array('action', 'dateCreated'),
         ),
         'dateCreated' => array(
           'columns' => array('dateCreated'),
         ),
         'remoteAddr' => array(
           'columns' => array('remoteAddr', 'dateCreated'),
         ),
         'session' => array(
           'columns' => array('session', 'dateCreated'),
         ),
       ),
     ) + parent::getConfiguration();
   }
 
 
 /* -(  PhabricatorPolicyInterface  )----------------------------------------- */
 
 
   public function getCapabilities() {
     return array(
       PhabricatorPolicyCapability::CAN_VIEW,
     );
   }
 
   public function getPolicy($capability) {
     switch ($capability) {
       case PhabricatorPolicyCapability::CAN_VIEW:
         return PhabricatorPolicies::POLICY_NOONE;
     }
   }
 
   public function hasAutomaticCapability($capability, PhabricatorUser $viewer) {
     if ($viewer->getIsAdmin()) {
       return true;
     }
 
     $viewer_phid = $viewer->getPHID();
     if ($viewer_phid) {
       $user_phid = $this->getUserPHID();
       if ($viewer_phid == $user_phid) {
         return true;
       }
 
       $actor_phid = $this->getActorPHID();
       if ($viewer_phid == $actor_phid) {
         return true;
       }
     }
 
     return false;
   }
 
   public function describeAutomaticCapability($capability) {
     return array(
       pht('Users can view their activity and activity that affects them.'),
       pht('Administrators can always view all activity.'),
     );
   }
 
 }