diff --git a/resources/sql/autopatches/20150805.paste.status.1.sql b/resources/sql/autopatches/20150805.paste.status.1.sql
new file mode 100644
index 0000000000..c9b98bf58c
--- /dev/null
+++ b/resources/sql/autopatches/20150805.paste.status.1.sql
@@ -0,0 +1,2 @@
+ALTER TABLE {$NAMESPACE}_pastebin.pastebin_paste
+  ADD status VARCHAR(32) NOT NULL COLLATE {$COLLATE_TEXT};
diff --git a/resources/sql/autopatches/20150805.paste.status.2.sql b/resources/sql/autopatches/20150805.paste.status.2.sql
new file mode 100644
index 0000000000..be2fe2c485
--- /dev/null
+++ b/resources/sql/autopatches/20150805.paste.status.2.sql
@@ -0,0 +1,2 @@
+UPDATE {$NAMESPACE}_pastebin.pastebin_paste
+  SET status = 'active' WHERE status = '';
diff --git a/src/applications/paste/controller/PhabricatorPasteEditController.php b/src/applications/paste/controller/PhabricatorPasteEditController.php
index db9ca7de99..19b394c18a 100644
--- a/src/applications/paste/controller/PhabricatorPasteEditController.php
+++ b/src/applications/paste/controller/PhabricatorPasteEditController.php
@@ -1,238 +1,250 @@
 <?php
 
 final class PhabricatorPasteEditController extends PhabricatorPasteController {
 
   public function handleRequest(AphrontRequest $request) {
     $viewer = $request->getViewer();
     $id = $request->getURIData('id');
 
     $parent = null;
     $parent_id = null;
     if (!$id) {
       $is_create = true;
 
       $paste = PhabricatorPaste::initializeNewPaste($viewer);
 
       $parent_id = $request->getStr('parent');
       if ($parent_id) {
         // NOTE: If the Paste is forked from a paste which the user no longer
         // has permission to see, we still let them edit it.
         $parent = id(new PhabricatorPasteQuery())
           ->setViewer($viewer)
           ->withIDs(array($parent_id))
           ->needContent(true)
           ->needRawContent(true)
           ->execute();
         $parent = head($parent);
 
         if ($parent) {
           $paste->setParentPHID($parent->getPHID());
           $paste->setViewPolicy($parent->getViewPolicy());
         }
       }
 
       $paste->setAuthorPHID($viewer->getPHID());
       $paste->attachRawContent('');
     } else {
       $is_create = false;
 
       $paste = id(new PhabricatorPasteQuery())
         ->setViewer($viewer)
         ->requireCapabilities(
           array(
             PhabricatorPolicyCapability::CAN_VIEW,
             PhabricatorPolicyCapability::CAN_EDIT,
           ))
         ->withIDs(array($id))
         ->needRawContent(true)
         ->executeOne();
       if (!$paste) {
         return new Aphront404Response();
       }
     }
 
     $v_space = $paste->getSpacePHID();
     if ($is_create && $parent) {
       $v_title = pht('Fork of %s', $parent->getFullName());
       $v_language = $parent->getLanguage();
       $v_text = $parent->getRawContent();
       $v_space = $parent->getSpacePHID();
     } else {
       $v_title = $paste->getTitle();
       $v_language = $paste->getLanguage();
       $v_text = $paste->getRawContent();
     }
     $v_view_policy = $paste->getViewPolicy();
     $v_edit_policy = $paste->getEditPolicy();
+    $v_status = $paste->getStatus();
 
     if ($is_create) {
       $v_projects = array();
     } else {
       $v_projects = PhabricatorEdgeQuery::loadDestinationPHIDs(
         $paste->getPHID(),
         PhabricatorProjectObjectHasProjectEdgeType::EDGECONST);
       $v_projects = array_reverse($v_projects);
     }
 
     $validation_exception = null;
     if ($request->isFormPost()) {
       $xactions = array();
 
       $v_text = $request->getStr('text');
       $v_title = $request->getStr('title');
       $v_language = $request->getStr('language');
       $v_view_policy = $request->getStr('can_view');
       $v_edit_policy = $request->getStr('can_edit');
       $v_projects = $request->getArr('projects');
       $v_space = $request->getStr('spacePHID');
+      $v_status = $request->getStr('status');
 
       // NOTE: The author is the only editor and can always view the paste,
       // so it's impossible for them to choose an invalid policy.
 
       if ($is_create || ($v_text !== $paste->getRawContent())) {
         $file = PhabricatorPasteEditor::initializeFileForPaste(
           $viewer,
           $v_title,
           $v_text);
 
         $xactions[] = id(new PhabricatorPasteTransaction())
           ->setTransactionType(PhabricatorPasteTransaction::TYPE_CONTENT)
           ->setNewValue($file->getPHID());
       }
 
       $xactions[] = id(new PhabricatorPasteTransaction())
         ->setTransactionType(PhabricatorPasteTransaction::TYPE_TITLE)
         ->setNewValue($v_title);
       $xactions[] = id(new PhabricatorPasteTransaction())
         ->setTransactionType(PhabricatorPasteTransaction::TYPE_LANGUAGE)
         ->setNewValue($v_language);
       $xactions[] = id(new PhabricatorPasteTransaction())
         ->setTransactionType(PhabricatorTransactions::TYPE_VIEW_POLICY)
         ->setNewValue($v_view_policy);
       $xactions[] = id(new PhabricatorPasteTransaction())
         ->setTransactionType(PhabricatorTransactions::TYPE_EDIT_POLICY)
         ->setNewValue($v_edit_policy);
       $xactions[] = id(new PhabricatorPasteTransaction())
         ->setTransactionType(PhabricatorTransactions::TYPE_SPACE)
         ->setNewValue($v_space);
+      $xactions[] = id(new PhabricatorPasteTransaction())
+        ->setTransactionType(PhabricatorPasteTransaction::TYPE_STATUS)
+        ->setNewValue($v_status);
 
       $proj_edge_type = PhabricatorProjectObjectHasProjectEdgeType::EDGECONST;
       $xactions[] = id(new PhabricatorPasteTransaction())
         ->setTransactionType(PhabricatorTransactions::TYPE_EDGE)
         ->setMetadataValue('edge:type', $proj_edge_type)
         ->setNewValue(array('=' => array_fuse($v_projects)));
 
       $editor = id(new PhabricatorPasteEditor())
         ->setActor($viewer)
         ->setContentSourceFromRequest($request)
         ->setContinueOnNoEffect(true);
 
       try {
         $xactions = $editor->applyTransactions($paste, $xactions);
         return id(new AphrontRedirectResponse())->setURI($paste->getURI());
       } catch (PhabricatorApplicationTransactionValidationException $ex) {
         $validation_exception = $ex;
       }
     }
 
     $form = new AphrontFormView();
 
     $langs = array(
       '' => pht('(Detect From Filename in Title)'),
     ) + PhabricatorEnv::getEnvConfig('pygments.dropdown-choices');
 
     $form
       ->setUser($viewer)
       ->addHiddenInput('parent', $parent_id)
       ->appendChild(
         id(new AphrontFormTextControl())
           ->setLabel(pht('Title'))
           ->setValue($v_title)
           ->setName('title'))
       ->appendChild(
         id(new AphrontFormSelectControl())
           ->setLabel(pht('Language'))
           ->setName('language')
           ->setValue($v_language)
           ->setOptions($langs));
 
     $policies = id(new PhabricatorPolicyQuery())
       ->setViewer($viewer)
       ->setObject($paste)
       ->execute();
 
     $form->appendChild(
       id(new AphrontFormPolicyControl())
         ->setUser($viewer)
         ->setCapability(PhabricatorPolicyCapability::CAN_VIEW)
         ->setPolicyObject($paste)
         ->setPolicies($policies)
         ->setValue($v_view_policy)
         ->setSpacePHID($v_space)
         ->setName('can_view'));
 
     $form->appendChild(
       id(new AphrontFormPolicyControl())
         ->setUser($viewer)
         ->setCapability(PhabricatorPolicyCapability::CAN_EDIT)
         ->setPolicyObject($paste)
         ->setPolicies($policies)
         ->setValue($v_edit_policy)
         ->setName('can_edit'));
 
+    $form->appendChild(
+        id(new AphrontFormSelectControl())
+          ->setLabel(pht('Status'))
+          ->setName('status')
+          ->setValue($v_status)
+          ->setOptions($paste->getStatusNameMap()));
+
     $form->appendControl(
       id(new AphrontFormTokenizerControl())
         ->setLabel(pht('Projects'))
         ->setName('projects')
         ->setValue($v_projects)
         ->setDatasource(new PhabricatorProjectDatasource()));
 
     $form
       ->appendChild(
         id(new AphrontFormTextAreaControl())
           ->setLabel(pht('Text'))
           ->setValue($v_text)
           ->setHeight(AphrontFormTextAreaControl::HEIGHT_VERY_TALL)
           ->setCustomClass('PhabricatorMonospaced')
           ->setName('text'));
 
     $submit = new AphrontFormSubmitControl();
 
     if (!$is_create) {
       $submit->addCancelButton($paste->getURI());
       $submit->setValue(pht('Save Paste'));
       $title = pht('Edit %s', $paste->getFullName());
       $short = pht('Edit');
     } else {
       $submit->setValue(pht('Create Paste'));
       $title = pht('Create New Paste');
       $short = pht('Create');
     }
 
     $form->appendChild($submit);
 
     $form_box = id(new PHUIObjectBoxView())
       ->setHeaderText($title)
       ->setForm($form);
 
     if ($validation_exception) {
       $form_box->setValidationException($validation_exception);
     }
 
     $crumbs = $this->buildApplicationCrumbs($this->buildSideNavView());
     if (!$is_create) {
       $crumbs->addTextCrumb('P'.$paste->getID(), '/P'.$paste->getID());
     }
     $crumbs->addTextCrumb($short);
 
     return $this->buildApplicationPage(
       array(
         $crumbs,
         $form_box,
       ),
       array(
         'title' => $title,
       ));
   }
 
 }
diff --git a/src/applications/paste/controller/PhabricatorPasteViewController.php b/src/applications/paste/controller/PhabricatorPasteViewController.php
index ebdf4e48c3..0273636d00 100644
--- a/src/applications/paste/controller/PhabricatorPasteViewController.php
+++ b/src/applications/paste/controller/PhabricatorPasteViewController.php
@@ -1,202 +1,214 @@
 <?php
 
 /**
  * group paste
  */
 final class PhabricatorPasteViewController extends PhabricatorPasteController {
 
   private $highlightMap;
 
   public function shouldAllowPublic() {
     return true;
   }
 
   public function willProcessRequest(array $data) {
     $raw_lines = idx($data, 'lines');
     $map = array();
     if ($raw_lines) {
       $lines = explode('-', $raw_lines);
       $first = idx($lines, 0, 0);
       $last = idx($lines, 1);
       if ($last) {
         $min = min($first, $last);
         $max = max($first, $last);
         $map = array_fuse(range($min, $max));
       } else {
         $map[$first] = $first;
       }
     }
     $this->highlightMap = $map;
   }
 
   public function handleRequest(AphrontRequest $request) {
     $viewer = $request->getViewer();
     $id = $request->getURIData('id');
 
     $paste = id(new PhabricatorPasteQuery())
       ->setViewer($viewer)
       ->withIDs(array($id))
       ->needContent(true)
       ->executeOne();
     if (!$paste) {
       return new Aphront404Response();
     }
 
     $file = id(new PhabricatorFileQuery())
       ->setViewer($viewer)
       ->withPHIDs(array($paste->getFilePHID()))
       ->executeOne();
     if (!$file) {
       return new Aphront400Response();
     }
 
     $forks = id(new PhabricatorPasteQuery())
       ->setViewer($viewer)
       ->withParentPHIDs(array($paste->getPHID()))
       ->execute();
     $fork_phids = mpull($forks, 'getPHID');
 
     $header = $this->buildHeaderView($paste);
     $actions = $this->buildActionView($viewer, $paste, $file);
     $properties = $this->buildPropertyView($paste, $fork_phids, $actions);
 
     $object_box = id(new PHUIObjectBoxView())
       ->setHeader($header)
       ->addPropertyList($properties);
 
     $source_code = $this->buildSourceCodeView(
       $paste,
       null,
       $this->highlightMap);
 
     $source_code = id(new PHUIBoxView())
       ->appendChild($source_code)
       ->addMargin(PHUI::MARGIN_LARGE_LEFT)
       ->addMargin(PHUI::MARGIN_LARGE_RIGHT)
       ->addMargin(PHUI::MARGIN_LARGE_TOP);
 
     $crumbs = $this->buildApplicationCrumbs($this->buildSideNavView())
       ->addTextCrumb('P'.$paste->getID(), '/P'.$paste->getID());
 
     $timeline = $this->buildTransactionTimeline(
       $paste,
       new PhabricatorPasteTransactionQuery());
 
     $is_serious = PhabricatorEnv::getEnvConfig('phabricator.serious-business');
 
     $add_comment_header = $is_serious
       ? pht('Add Comment')
       : pht('Eat Paste');
 
     $draft = PhabricatorDraft::newFromUserAndKey($viewer, $paste->getPHID());
 
     $add_comment_form = id(new PhabricatorApplicationTransactionCommentView())
       ->setUser($viewer)
       ->setObjectPHID($paste->getPHID())
       ->setDraft($draft)
       ->setHeaderText($add_comment_header)
       ->setAction($this->getApplicationURI('/comment/'.$paste->getID().'/'))
       ->setSubmitButtonName(pht('Add Comment'));
 
     return $this->buildApplicationPage(
       array(
         $crumbs,
         $object_box,
         $source_code,
         $timeline,
         $add_comment_form,
       ),
       array(
         'title' => $paste->getFullName(),
         'pageObjects' => array($paste->getPHID()),
       ));
   }
 
   private function buildHeaderView(PhabricatorPaste $paste) {
     $title = (nonempty($paste->getTitle())) ?
       $paste->getTitle() : pht('(An Untitled Masterwork)');
+
+    if ($paste->isArchived()) {
+      $header_icon = 'fa-ban';
+      $header_name = pht('Archived');
+      $header_color = 'dark';
+    } else {
+      $header_icon = 'fa-check';
+      $header_name = pht('Active');
+      $header_color = 'bluegrey';
+    }
+
     $header = id(new PHUIHeaderView())
       ->setHeader($title)
       ->setUser($this->getRequest()->getUser())
+      ->setStatus($header_icon, $header_color, $header_name)
       ->setPolicyObject($paste);
 
     return $header;
   }
 
   private function buildActionView(
     PhabricatorUser $viewer,
     PhabricatorPaste $paste,
     PhabricatorFile $file) {
 
     $can_edit = PhabricatorPolicyFilter::hasCapability(
       $viewer,
       $paste,
       PhabricatorPolicyCapability::CAN_EDIT);
 
     $can_fork = $viewer->isLoggedIn();
     $fork_uri = $this->getApplicationURI('/create/?parent='.$paste->getID());
 
     return id(new PhabricatorActionListView())
       ->setUser($viewer)
       ->setObject($paste)
       ->setObjectURI($this->getRequest()->getRequestURI())
       ->addAction(
         id(new PhabricatorActionView())
           ->setName(pht('Edit Paste'))
           ->setIcon('fa-pencil')
           ->setDisabled(!$can_edit)
           ->setWorkflow(!$can_edit)
           ->setHref($this->getApplicationURI('/edit/'.$paste->getID().'/')))
       ->addAction(
         id(new PhabricatorActionView())
           ->setName(pht('Fork This Paste'))
           ->setIcon('fa-code-fork')
           ->setDisabled(!$can_fork)
           ->setWorkflow(!$can_fork)
           ->setHref($fork_uri))
       ->addAction(
         id(new PhabricatorActionView())
           ->setName(pht('View Raw File'))
           ->setIcon('fa-file-text-o')
           ->setHref($file->getBestURI()));
   }
 
   private function buildPropertyView(
     PhabricatorPaste $paste,
     array $child_phids,
     PhabricatorActionListView $actions) {
     $viewer = $this->getViewer();
 
     $properties = id(new PHUIPropertyListView())
       ->setUser($viewer)
       ->setObject($paste)
       ->setActionList($actions);
 
     $properties->addProperty(
       pht('Author'),
       $viewer->renderHandle($paste->getAuthorPHID()));
 
     $properties->addProperty(
       pht('Created'),
       phabricator_datetime($paste->getDateCreated(), $viewer));
 
     if ($paste->getParentPHID()) {
       $properties->addProperty(
         pht('Forked From'),
         $viewer->renderHandle($paste->getParentPHID()));
     }
 
     if ($child_phids) {
       $properties->addProperty(
         pht('Forks'),
         $viewer->renderHandleList($child_phids));
     }
 
     $descriptions = PhabricatorPolicyQuery::renderPolicyDescriptions(
       $viewer,
       $paste);
 
     return $properties;
   }
 
 }
diff --git a/src/applications/paste/editor/PhabricatorPasteEditor.php b/src/applications/paste/editor/PhabricatorPasteEditor.php
index 732db28bd7..bae2003afe 100644
--- a/src/applications/paste/editor/PhabricatorPasteEditor.php
+++ b/src/applications/paste/editor/PhabricatorPasteEditor.php
@@ -1,187 +1,195 @@
 <?php
 
 final class PhabricatorPasteEditor
   extends PhabricatorApplicationTransactionEditor {
 
   public function getEditorApplicationClass() {
     return 'PhabricatorPasteApplication';
   }
 
   public function getEditorObjectsDescription() {
     return pht('Pastes');
   }
 
   public static function initializeFileForPaste(
     PhabricatorUser $actor,
     $name,
     $data) {
 
     return PhabricatorFile::newFromFileData(
       $data,
       array(
         'name' => $name,
         'mime-type' => 'text/plain; charset=utf-8',
         'authorPHID' => $actor->getPHID(),
         'viewPolicy' => PhabricatorPolicies::POLICY_NOONE,
         'editPolicy' => PhabricatorPolicies::POLICY_NOONE,
       ));
   }
 
   public function getTransactionTypes() {
     $types = parent::getTransactionTypes();
 
     $types[] = PhabricatorPasteTransaction::TYPE_CONTENT;
     $types[] = PhabricatorPasteTransaction::TYPE_TITLE;
     $types[] = PhabricatorPasteTransaction::TYPE_LANGUAGE;
+    $types[] = PhabricatorPasteTransaction::TYPE_STATUS;
     $types[] = PhabricatorTransactions::TYPE_VIEW_POLICY;
     $types[] = PhabricatorTransactions::TYPE_EDIT_POLICY;
     $types[] = PhabricatorTransactions::TYPE_COMMENT;
 
     return $types;
   }
 
   protected function getCustomTransactionOldValue(
     PhabricatorLiskDAO $object,
     PhabricatorApplicationTransaction $xaction) {
 
     switch ($xaction->getTransactionType()) {
       case PhabricatorPasteTransaction::TYPE_CONTENT:
         return $object->getFilePHID();
       case PhabricatorPasteTransaction::TYPE_TITLE:
         return $object->getTitle();
       case PhabricatorPasteTransaction::TYPE_LANGUAGE:
         return $object->getLanguage();
+      case PhabricatorPasteTransaction::TYPE_STATUS:
+        return $object->getStatus();
     }
   }
 
   protected function getCustomTransactionNewValue(
     PhabricatorLiskDAO $object,
     PhabricatorApplicationTransaction $xaction) {
 
     switch ($xaction->getTransactionType()) {
       case PhabricatorPasteTransaction::TYPE_CONTENT:
       case PhabricatorPasteTransaction::TYPE_TITLE:
       case PhabricatorPasteTransaction::TYPE_LANGUAGE:
+      case PhabricatorPasteTransaction::TYPE_STATUS:
         return $xaction->getNewValue();
     }
   }
 
   protected function applyCustomInternalTransaction(
     PhabricatorLiskDAO $object,
     PhabricatorApplicationTransaction $xaction) {
 
     switch ($xaction->getTransactionType()) {
       case PhabricatorPasteTransaction::TYPE_CONTENT:
         $object->setFilePHID($xaction->getNewValue());
         return;
       case PhabricatorPasteTransaction::TYPE_TITLE:
         $object->setTitle($xaction->getNewValue());
         return;
       case PhabricatorPasteTransaction::TYPE_LANGUAGE:
         $object->setLanguage($xaction->getNewValue());
         return;
+      case PhabricatorPasteTransaction::TYPE_STATUS:
+        $object->setStatus($xaction->getNewValue());
+        return;
     }
 
     return parent::applyCustomInternalTransaction($object, $xaction);
   }
 
   protected function applyCustomExternalTransaction(
     PhabricatorLiskDAO $object,
     PhabricatorApplicationTransaction $xaction) {
 
     switch ($xaction->getTransactionType()) {
       case PhabricatorPasteTransaction::TYPE_CONTENT:
       case PhabricatorPasteTransaction::TYPE_TITLE:
       case PhabricatorPasteTransaction::TYPE_LANGUAGE:
+      case PhabricatorPasteTransaction::TYPE_STATUS:
         return;
     }
 
     return parent::applyCustomExternalTransaction($object, $xaction);
   }
 
   protected function extractFilePHIDsFromCustomTransaction(
     PhabricatorLiskDAO $object,
     PhabricatorApplicationTransaction $xaction) {
 
     switch ($xaction->getTransactionType()) {
       case PhabricatorPasteTransaction::TYPE_CONTENT:
         return array($xaction->getNewValue());
     }
 
     return parent::extractFilePHIDsFromCustomTransaction($object, $xaction);
   }
 
   protected function shouldSendMail(
     PhabricatorLiskDAO $object,
     array $xactions) {
     foreach ($xactions as $xaction) {
       switch ($xaction->getTransactionType()) {
         case PhabricatorPasteTransaction::TYPE_CONTENT:
           return false;
         default:
           break;
       }
     }
     return true;
   }
 
   protected function getMailSubjectPrefix() {
     return PhabricatorEnv::getEnvConfig('metamta.paste.subject-prefix');
   }
 
   protected function getMailTo(PhabricatorLiskDAO $object) {
     return array(
       $object->getAuthorPHID(),
       $this->getActingAsPHID(),
     );
   }
 
   public function getMailTagsMap() {
     return array(
       PhabricatorPasteTransaction::MAILTAG_CONTENT =>
         pht('Paste title, language or text changes.'),
       PhabricatorPasteTransaction::MAILTAG_COMMENT =>
         pht('Someone comments on a paste.'),
       PhabricatorPasteTransaction::MAILTAG_OTHER =>
         pht('Other paste activity not listed above occurs.'),
     );
   }
 
   protected function buildReplyHandler(PhabricatorLiskDAO $object) {
     return id(new PasteReplyHandler())
       ->setMailReceiver($object);
   }
 
   protected function buildMailTemplate(PhabricatorLiskDAO $object) {
     $id = $object->getID();
     $name = $object->getTitle();
 
     return id(new PhabricatorMetaMTAMail())
       ->setSubject("P{$id}: {$name}")
       ->addHeader('Thread-Topic', "P{$id}");
   }
 
   protected function buildMailBody(
     PhabricatorLiskDAO $object,
     array $xactions) {
 
     $body = parent::buildMailBody($object, $xactions);
 
     $body->addLinkSection(
       pht('PASTE DETAIL'),
       PhabricatorEnv::getProductionURI('/P'.$object->getID()));
 
     return $body;
   }
 
   protected function shouldPublishFeedStory(
     PhabricatorLiskDAO $object,
     array $xactions) {
     return true;
   }
 
   protected function supportsSearch() {
     return false;
   }
 
 }
diff --git a/src/applications/paste/storage/PhabricatorPaste.php b/src/applications/paste/storage/PhabricatorPaste.php
index 661701ba09..0fab56b724 100644
--- a/src/applications/paste/storage/PhabricatorPaste.php
+++ b/src/applications/paste/storage/PhabricatorPaste.php
@@ -1,224 +1,241 @@
 <?php
 
 final class PhabricatorPaste extends PhabricatorPasteDAO
   implements
     PhabricatorSubscribableInterface,
     PhabricatorTokenReceiverInterface,
     PhabricatorFlaggableInterface,
     PhabricatorMentionableInterface,
     PhabricatorPolicyInterface,
     PhabricatorProjectInterface,
     PhabricatorDestructibleInterface,
     PhabricatorApplicationTransactionInterface,
     PhabricatorSpacesInterface {
 
   protected $title;
   protected $authorPHID;
   protected $filePHID;
   protected $language;
   protected $parentPHID;
   protected $viewPolicy;
   protected $editPolicy;
   protected $mailKey;
+  protected $status;
   protected $spacePHID;
 
+  const STATUS_ACTIVE = 'active';
+  const STATUS_ARCHIVED = 'archived';
+
   private $content = self::ATTACHABLE;
   private $rawContent = self::ATTACHABLE;
 
   public static function initializeNewPaste(PhabricatorUser $actor) {
     $app = id(new PhabricatorApplicationQuery())
       ->setViewer($actor)
       ->withClasses(array('PhabricatorPasteApplication'))
       ->executeOne();
 
     $view_policy = $app->getPolicy(PasteDefaultViewCapability::CAPABILITY);
     $edit_policy = $app->getPolicy(PasteDefaultEditCapability::CAPABILITY);
 
     return id(new PhabricatorPaste())
       ->setTitle('')
+      ->setStatus(self::STATUS_ACTIVE)
       ->setAuthorPHID($actor->getPHID())
       ->setViewPolicy($view_policy)
       ->setEditPolicy($edit_policy)
       ->setSpacePHID($actor->getDefaultSpacePHID());
   }
 
+  public static function getStatusNameMap() {
+    return array(
+      self::STATUS_ACTIVE => pht('Active'),
+      self::STATUS_ARCHIVED => pht('Archived'),
+    );
+  }
+
   public function getURI() {
     return '/'.$this->getMonogram();
   }
 
   public function getMonogram() {
     return 'P'.$this->getID();
   }
 
   protected function getConfiguration() {
     return array(
       self::CONFIG_AUX_PHID => true,
       self::CONFIG_COLUMN_SCHEMA => array(
+        'status' => 'text32',
         'title' => 'text255',
         'language' => 'text64',
         'mailKey' => 'bytes20',
         'parentPHID' => 'phid?',
 
         // T6203/NULLABILITY
         // Pastes should always have a view policy.
         'viewPolicy' => 'policy?',
       ),
       self::CONFIG_KEY_SCHEMA => array(
         'parentPHID' => array(
           'columns' => array('parentPHID'),
         ),
         'authorPHID' => array(
           'columns' => array('authorPHID'),
         ),
         'key_dateCreated' => array(
           'columns' => array('dateCreated'),
         ),
         'key_language' => array(
           'columns' => array('language'),
         ),
       ),
     ) + parent::getConfiguration();
   }
 
   public function generatePHID() {
     return PhabricatorPHID::generateNewPHID(
       PhabricatorPastePastePHIDType::TYPECONST);
   }
 
+  public function isArchived() {
+    return ($this->getStatus() == self::STATUS_ARCHIVED);
+  }
+
   public function save() {
     if (!$this->getMailKey()) {
       $this->setMailKey(Filesystem::readRandomCharacters(20));
     }
     return parent::save();
   }
 
   public function getFullName() {
     $title = $this->getTitle();
     if (!$title) {
       $title = pht('(An Untitled Masterwork)');
     }
     return 'P'.$this->getID().' '.$title;
   }
 
   public function getContent() {
     return $this->assertAttached($this->content);
   }
 
   public function attachContent($content) {
     $this->content = $content;
     return $this;
   }
 
   public function getRawContent() {
     return $this->assertAttached($this->rawContent);
   }
 
   public function attachRawContent($raw_content) {
     $this->rawContent = $raw_content;
     return $this;
   }
 
 /* -(  PhabricatorSubscribableInterface  )----------------------------------- */
 
 
   public function isAutomaticallySubscribed($phid) {
     return ($this->authorPHID == $phid);
   }
 
   public function shouldShowSubscribersProperty() {
     return true;
   }
 
   public function shouldAllowSubscription($phid) {
     return true;
   }
 
 
 /* -(  PhabricatorTokenReceiverInterface  )---------------------------------- */
 
   public function getUsersToNotifyOfTokenGiven() {
     return array(
       $this->getAuthorPHID(),
     );
   }
 
 
 /* -(  PhabricatorPolicyInterface  )----------------------------------------- */
 
 
   public function getCapabilities() {
     return array(
       PhabricatorPolicyCapability::CAN_VIEW,
       PhabricatorPolicyCapability::CAN_EDIT,
     );
   }
 
   public function getPolicy($capability) {
     if ($capability == PhabricatorPolicyCapability::CAN_VIEW) {
       return $this->viewPolicy;
     } else if ($capability == PhabricatorPolicyCapability::CAN_EDIT) {
       return $this->editPolicy;
     }
     return PhabricatorPolicies::POLICY_NOONE;
   }
 
   public function hasAutomaticCapability($capability, PhabricatorUser $user) {
     return ($user->getPHID() == $this->getAuthorPHID());
   }
 
   public function describeAutomaticCapability($capability) {
     return pht('The author of a paste can always view and edit it.');
   }
 
 
 /* -(  PhabricatorDestructibleInterface  )----------------------------------- */
 
 
   public function destroyObjectPermanently(
     PhabricatorDestructionEngine $engine) {
 
     if ($this->filePHID) {
       $file = id(new PhabricatorFileQuery())
         ->setViewer($engine->getViewer())
         ->withPHIDs(array($this->filePHID))
         ->executeOne();
       if ($file) {
         $engine->destroyObject($file);
       }
     }
 
     $this->delete();
   }
 
 
 /* -(  PhabricatorApplicationTransactionInterface  )------------------------- */
 
 
   public function getApplicationTransactionEditor() {
     return new PhabricatorPasteEditor();
   }
 
   public function getApplicationTransactionObject() {
     return $this;
   }
 
   public function getApplicationTransactionTemplate() {
     return new PhabricatorPasteTransaction();
   }
 
   public function willRenderTimeline(
     PhabricatorApplicationTransactionView $timeline,
     AphrontRequest $request) {
 
     return $timeline;
   }
 
 
 /* -(  PhabricatorSpacesInterface  )----------------------------------------- */
 
 
   public function getSpacePHID() {
     return $this->spacePHID;
   }
 
 }
diff --git a/src/applications/paste/storage/PhabricatorPasteTransaction.php b/src/applications/paste/storage/PhabricatorPasteTransaction.php
index 34cc6bd92d..6372f38a2b 100644
--- a/src/applications/paste/storage/PhabricatorPasteTransaction.php
+++ b/src/applications/paste/storage/PhabricatorPasteTransaction.php
@@ -1,207 +1,228 @@
 <?php
 
 final class PhabricatorPasteTransaction
   extends PhabricatorApplicationTransaction {
 
   const TYPE_CONTENT = 'paste.create';
   const TYPE_TITLE = 'paste.title';
   const TYPE_LANGUAGE = 'paste.language';
+  const TYPE_STATUS = 'paste.status';
 
   const MAILTAG_CONTENT = 'paste-content';
   const MAILTAG_OTHER = 'paste-other';
   const MAILTAG_COMMENT = 'paste-comment';
 
   public function getApplicationName() {
     return 'pastebin';
   }
 
   public function getApplicationTransactionType() {
     return PhabricatorPastePastePHIDType::TYPECONST;
   }
 
   public function getApplicationTransactionCommentObject() {
     return new PhabricatorPasteTransactionComment();
   }
 
   public function getRequiredHandlePHIDs() {
     $phids = parent::getRequiredHandlePHIDs();
 
     switch ($this->getTransactionType()) {
       case self::TYPE_CONTENT:
         $phids[] = $this->getObjectPHID();
         break;
     }
 
     return $phids;
   }
 
   public function shouldHide() {
     $old = $this->getOldValue();
     switch ($this->getTransactionType()) {
       case self::TYPE_TITLE:
       case self::TYPE_LANGUAGE:
         return ($old === null);
     }
     return parent::shouldHide();
   }
 
   public function getIcon() {
     switch ($this->getTransactionType()) {
       case self::TYPE_CONTENT:
         return 'fa-plus';
         break;
       case self::TYPE_TITLE:
       case self::TYPE_LANGUAGE:
         return 'fa-pencil';
         break;
     }
     return parent::getIcon();
   }
 
   public function getTitle() {
     $author_phid = $this->getAuthorPHID();
     $object_phid = $this->getObjectPHID();
 
     $old = $this->getOldValue();
     $new = $this->getNewValue();
 
     $type = $this->getTransactionType();
     switch ($type) {
       case self::TYPE_CONTENT:
         if ($old === null) {
           return pht(
             '%s created this paste.',
             $this->renderHandleLink($author_phid));
         } else {
           return pht(
             '%s edited the content of this paste.',
             $this->renderHandleLink($author_phid));
         }
         break;
       case self::TYPE_TITLE:
         return pht(
           '%s updated the paste\'s title to "%s".',
           $this->renderHandleLink($author_phid),
           $new);
         break;
       case self::TYPE_LANGUAGE:
         return pht(
           "%s updated the paste's language.",
           $this->renderHandleLink($author_phid));
         break;
+      case self::TYPE_STATUS:
+        return pht(
+          "%s updated the paste's status.",
+          $this->renderHandleLink($author_phid));
+        break;
+
     }
 
     return parent::getTitle();
   }
 
   public function getTitleForFeed() {
     $author_phid = $this->getAuthorPHID();
     $object_phid = $this->getObjectPHID();
 
     $old = $this->getOldValue();
     $new = $this->getNewValue();
 
     $type = $this->getTransactionType();
     switch ($type) {
       case self::TYPE_CONTENT:
         if ($old === null) {
           return pht(
             '%s created %s.',
             $this->renderHandleLink($author_phid),
             $this->renderHandleLink($object_phid));
         } else {
           return pht(
             '%s edited %s.',
             $this->renderHandleLink($author_phid),
             $this->renderHandleLink($object_phid));
         }
         break;
       case self::TYPE_TITLE:
         return pht(
           '%s updated the title for %s.',
           $this->renderHandleLink($author_phid),
           $this->renderHandleLink($object_phid));
         break;
       case self::TYPE_LANGUAGE:
         return pht(
           '%s updated the language for %s.',
           $this->renderHandleLink($author_phid),
           $this->renderHandleLink($object_phid));
         break;
+      case self::TYPE_STATUS:
+        switch ($new) {
+          case self::STATUS_OPEN:
+            return pht(
+              '%s activated %s.',
+              $this->renderHandleLink($author_phid),
+              $this->renderHandleLink($object_phid));
+          case self::STATUS_CLOSED:
+            return pht(
+              '%s archived %s.',
+              $this->renderHandleLink($author_phid),
+              $this->renderHandleLink($object_phid));
+        }
+        break;
     }
 
     return parent::getTitleForFeed();
   }
 
   public function getColor() {
     $old = $this->getOldValue();
     $new = $this->getNewValue();
 
     switch ($this->getTransactionType()) {
       case self::TYPE_CONTENT:
         return PhabricatorTransactions::COLOR_GREEN;
     }
 
     return parent::getColor();
   }
 
 
   public function hasChangeDetails() {
     switch ($this->getTransactionType()) {
       case self::TYPE_CONTENT:
         return ($this->getOldValue() !== null);
     }
 
     return parent::hasChangeDetails();
   }
 
   public function renderChangeDetails(PhabricatorUser $viewer) {
     switch ($this->getTransactionType()) {
       case self::TYPE_CONTENT:
         $old = $this->getOldValue();
         $new = $this->getNewValue();
 
         $files = id(new PhabricatorFileQuery())
           ->setViewer($viewer)
           ->withPHIDs(array_filter(array($old, $new)))
           ->execute();
         $files = mpull($files, null, 'getPHID');
 
         $old_text = '';
         if (idx($files, $old)) {
           $old_text = $files[$old]->loadFileData();
         }
 
         $new_text = '';
         if (idx($files, $new)) {
           $new_text = $files[$new]->loadFileData();
         }
 
         return $this->renderTextCorpusChangeDetails(
           $viewer,
           $old_text,
           $new_text);
     }
 
     return parent::renderChangeDetails($viewer);
   }
 
   public function getMailTags() {
     $tags = array();
     switch ($this->getTransactionType()) {
       case self::TYPE_TITLE:
       case self::TYPE_CONTENT:
       case self::TYPE_LANGUAGE:
         $tags[] = self::MAILTAG_CONTENT;
         break;
       case PhabricatorTransactions::TYPE_COMMENT:
         $tags[] = self::MAILTAG_COMMENT;
         break;
       default:
         $tags[] = self::MAILTAG_OTHER;
         break;
     }
     return $tags;
   }
 
 }