diff --git a/src/applications/diffusion/controller/DiffusionController.php b/src/applications/diffusion/controller/DiffusionController.php
index 9d8f7c18cc..52a1e5208e 100644
--- a/src/applications/diffusion/controller/DiffusionController.php
+++ b/src/applications/diffusion/controller/DiffusionController.php
@@ -1,452 +1,458 @@
 <?php
 
 abstract class DiffusionController extends PhabricatorController {
 
   protected $diffusionRequest;
 
   public function willBeginExecution() {
     $request = $this->getRequest();
     $uri = $request->getRequestURI();
 
     // Check if this is a VCS request, e.g. from "git clone", "hg clone", or
     // "svn checkout". If it is, we jump off into repository serving code to
     // process the request.
 
     $regex = '@^/diffusion/(?P<callsign>[A-Z]+)(/|$)@';
     $matches = null;
     if (preg_match($regex, (string)$uri, $matches)) {
       $vcs = null;
 
       $content_type = $request->getHTTPHeader('Content-Type');
 
       if ($request->getExists('__vcs__')) {
         // This is magic to make it easier for us to debug stuff by telling
         // users to run:
         //
         //   curl http://example.phabricator.com/diffusion/X/?__vcs__=1
         //
         // ...to get a human-readable error.
         $vcs = $request->getExists('__vcs__');
       } else if ($request->getExists('service')) {
         $service = $request->getStr('service');
         // We get this initially for `info/refs`.
         // Git also gives us a User-Agent like "git/1.8.2.3".
         $vcs = PhabricatorRepositoryType::REPOSITORY_TYPE_GIT;
       } else if ($content_type == 'application/x-git-upload-pack-request') {
         // We get this for `git-upload-pack`.
         $vcs = PhabricatorRepositoryType::REPOSITORY_TYPE_GIT;
       } else if ($request->getExists('cmd')) {
         // Mercurial also sends an Accept header like
         // "application/mercurial-0.1", and a User-Agent like
         // "mercurial/proto-1.0".
         $vcs = PhabricatorRepositoryType::REPOSITORY_TYPE_MERCURIAL;
       } else {
         // Subversion also sends an initial OPTIONS request (vs GET/POST), and
         // has a User-Agent like "SVN/1.8.3 (x86_64-apple-darwin11.4.2)
         // serf/1.3.2".
         $dav = $request->getHTTPHeader('DAV');
         $dav = new PhutilURI($dav);
         if ($dav->getDomain() === 'subversion.tigris.org') {
           $vcs = PhabricatorRepositoryType::REPOSITORY_TYPE_SVN;
         }
       }
 
       if ($vcs) {
         return $this->processVCSRequest($matches['callsign']);
       }
     }
 
     parent::willBeginExecution();
   }
 
   private function processVCSRequest($callsign) {
 
     // TODO: Authenticate user.
 
     $viewer = new PhabricatorUser();
 
     $allow_public = PhabricatorEnv::getEnvConfig('policy.allow-public');
     if (!$allow_public) {
       if (!$viewer->isLoggedIn()) {
         return new PhabricatorVCSResponse(
           403,
           pht('You must log in to access repositories.'));
       }
     }
 
     try {
       $repository = id(new PhabricatorRepositoryQuery())
         ->setViewer($viewer)
         ->withCallsigns(array($callsign))
         ->executeOne();
       if (!$repository) {
         return new PhabricatorVCSResponse(
           404,
           pht('No such repository exists.'));
       }
     } catch (PhabricatorPolicyException $ex) {
       if ($viewer->isLoggedIn()) {
         return new PhabricatorVCSResponse(
           403,
           pht('You do not have permission to access this repository.'));
       } else {
         return new PhabricatorVCSResponse(
           401,
           pht('You must log in to access this repository.'));
       }
     }
 
+    if (!$repository->isTracked()) {
+      return new PhabricatorVCSResponse(
+        403,
+        pht('This repository is inactive.'));
+    }
+
     $is_push = !$this->isReadOnlyRequest($repository);
 
     switch ($repository->getServeOverHTTP()) {
       case PhabricatorRepository::SERVE_READONLY:
         if ($is_push) {
           return new PhabricatorVCSResponse(
             403,
             pht('This repository is read-only over HTTP.'));
         }
         break;
       case PhabricatorRepository::SERVE_READWRITE:
         if ($is_push) {
           $can_push = PhabricatorPolicyFilter::hasCapability(
             $viewer,
             $repository,
             DiffusionCapabilityPush::CAPABILITY);
           if (!$can_push) {
             if ($viewer->isLoggedIn()) {
               return new PhabricatorVCSResponse(
                 403,
                 pht('You do not have permission to push to this repository.'));
             } else {
               return new PhabricatorVCSResponse(
                 401,
                 pht('You must log in to push to this repository.'));
             }
           }
         }
         break;
       case PhabricatorRepository::SERVE_OFF:
       default:
         return new PhabricatorVCSResponse(
           403,
           pht('This repository is not available over HTTP.'));
     }
 
     switch ($repository->getVersionControlSystem()) {
       case PhabricatorRepositoryType::REPOSITORY_TYPE_GIT:
         return $this->serveGitRequest($repository);
       default:
         break;
     }
 
     return new PhabricatorVCSResponse(
       999,
       pht('TODO: Implement meaningful responses.'));
   }
 
   private function isReadOnlyRequest(
     PhabricatorRepository $repository) {
     $request = $this->getRequest();
     $method = $_SERVER['REQUEST_METHOD'];
 
     // TODO: This implementation is safe by default, but very incomplete.
 
     switch ($repository->getVersionControlSystem()) {
       case PhabricatorRepositoryType::REPOSITORY_TYPE_GIT:
         $service = $request->getStr('service');
         $path = $this->getRequestDirectoryPath();
         // NOTE: Service names are the reverse of what you might expect, as they
         // are from the point of view of the server. The main read service is
         // "git-upload-pack", and the main write service is "git-receive-pack".
 
         if ($method == 'GET' &&
             $path == '/info/refs' &&
             $service == 'git-upload-pack') {
           return true;
         }
 
         if ($path == '/git-upload-pack') {
           return true;
         }
 
         break;
       case PhabricatorRepositoryType::REPOSITORY_TYPE_MERCURIAL:
         $cmd = $request->getStr('cmd');
         switch ($cmd) {
           case 'capabilities':
             return true;
           default:
             return false;
         }
         break;
       case PhabricatorRepositoryType::REPOSITORY_TYPE_SUBVERSION:
         break;
     }
 
     return false;
   }
 
   public function willProcessRequest(array $data) {
     if (isset($data['callsign'])) {
       $drequest = DiffusionRequest::newFromAphrontRequestDictionary(
         $data,
         $this->getRequest());
       $this->diffusionRequest = $drequest;
     }
   }
 
   public function setDiffusionRequest(DiffusionRequest $request) {
     $this->diffusionRequest = $request;
     return $this;
   }
 
   protected function getDiffusionRequest() {
     if (!$this->diffusionRequest) {
       throw new Exception("No Diffusion request object!");
     }
     return $this->diffusionRequest;
   }
 
   public function buildCrumbs(array $spec = array()) {
     $crumbs = $this->buildApplicationCrumbs();
     $crumb_list = $this->buildCrumbList($spec);
     foreach ($crumb_list as $crumb) {
       $crumbs->addCrumb($crumb);
     }
     return $crumbs;
   }
 
   private function buildCrumbList(array $spec = array()) {
 
     $spec = $spec + array(
       'commit'  => null,
       'tags'    => null,
       'branches'    => null,
       'view'    => null,
     );
 
     $crumb_list = array();
 
     // On the home page, we don't have a DiffusionRequest.
     if ($this->diffusionRequest) {
       $drequest = $this->getDiffusionRequest();
       $repository = $drequest->getRepository();
     } else {
       $drequest = null;
       $repository = null;
     }
 
     if (!$repository) {
       return $crumb_list;
     }
 
     $callsign = $repository->getCallsign();
     $repository_name = 'r'.$callsign;
 
     if (!$spec['commit'] && !$spec['tags'] && !$spec['branches']) {
       $branch_name = $drequest->getBranch();
       if ($branch_name) {
         $repository_name .= ' ('.$branch_name.')';
       }
     }
 
     $crumb = id(new PhabricatorCrumbView())
       ->setName($repository_name);
     if (!$spec['view'] && !$spec['commit'] &&
         !$spec['tags'] && !$spec['branches']) {
       $crumb_list[] = $crumb;
       return $crumb_list;
     }
     $crumb->setHref(
       $drequest->generateURI(
         array(
           'action' => 'branch',
           'path' => '/',
         )));
     $crumb_list[] = $crumb;
 
     $raw_commit = $drequest->getRawCommit();
 
     if ($spec['tags']) {
       $crumb = new PhabricatorCrumbView();
       if ($spec['commit']) {
         $crumb->setName(
           pht("Tags for %s", 'r'.$callsign.$raw_commit));
         $crumb->setHref($drequest->generateURI(
           array(
             'action' => 'commit',
             'commit' => $raw_commit,
           )));
       } else {
         $crumb->setName(pht('Tags'));
       }
       $crumb_list[] = $crumb;
       return $crumb_list;
     }
 
     if ($spec['branches']) {
       $crumb = id(new PhabricatorCrumbView())
         ->setName(pht('Branches'));
       $crumb_list[] = $crumb;
       return $crumb_list;
     }
 
     if ($spec['commit']) {
       $crumb = id(new PhabricatorCrumbView())
         ->setName("r{$callsign}{$raw_commit}")
         ->setHref("r{$callsign}{$raw_commit}");
       $crumb_list[] = $crumb;
       return $crumb_list;
     }
 
     $crumb = new PhabricatorCrumbView();
     $view = $spec['view'];
 
     switch ($view) {
       case 'history':
         $view_name = pht('History');
         break;
       case 'browse':
         $view_name = pht('Browse');
         break;
       case 'lint':
         $view_name = pht('Lint');
         break;
       case 'change':
         $view_name = pht('Change');
         break;
     }
 
     $crumb = id(new PhabricatorCrumbView())
       ->setName($view_name);
 
     $crumb_list[] = $crumb;
     return $crumb_list;
   }
 
   protected function callConduitWithDiffusionRequest(
     $method,
     array $params = array()) {
 
     $user = $this->getRequest()->getUser();
     $drequest = $this->getDiffusionRequest();
 
     return DiffusionQuery::callConduitWithDiffusionRequest(
       $user,
       $drequest,
       $method,
       $params);
   }
 
   protected function getRepositoryControllerURI(
     PhabricatorRepository $repository,
     $path) {
     return $this->getApplicationURI($repository->getCallsign().'/'.$path);
   }
 
   protected function renderPathLinks(DiffusionRequest $drequest, $action) {
     $path = $drequest->getPath();
     $path_parts = array_filter(explode('/', trim($path, '/')));
 
     $divider = phutil_tag(
       'span',
       array(
         'class' => 'phui-header-divider'),
       '/');
 
     $links = array();
     if ($path_parts) {
       $links[] = phutil_tag(
         'a',
         array(
           'href' => $drequest->generateURI(
             array(
               'action' => $action,
               'path' => '',
             )),
         ),
         'r'.$drequest->getRepository()->getCallsign());
       $links[] = $divider;
       $accum = '';
       $last_key = last_key($path_parts);
       foreach ($path_parts as $key => $part) {
         $accum .= '/'.$part;
         if ($key === $last_key) {
           $links[] = $part;
         } else {
           $links[] = phutil_tag(
             'a',
             array(
               'href' => $drequest->generateURI(
                 array(
                   'action' => $action,
                   'path' => $accum.'/',
                 )),
             ),
             $part);
           $links[] = $divider;
         }
       }
     } else {
       $links[] = 'r'.$drequest->getRepository()->getCallsign();
       $links[] = $divider;
     }
 
     return $links;
   }
 
   /**
    * @phutil-external-symbol class PhabricatorStartup
    */
   private function serveGitRequest(PhabricatorRepository $repository) {
     $request = $this->getRequest();
 
     $request_path = $this->getRequestDirectoryPath();
     $repository_root = $repository->getLocalPath();
 
     // Rebuild the query string to strip `__magic__` parameters and prevent
     // issues where we might interpret inputs like "service=read&service=write"
     // differently than the server does and pass it an unsafe command.
     $query_data = $request->getPassthroughRequestParameters();
     $query_string = http_build_query($query_data, '', '&');
 
     // We're about to wipe out PATH with the rest of the environment, so
     // resolve the binary first.
     $bin = Filesystem::resolveBinary('git-http-backend');
     if (!$bin) {
       throw new Exception("Unable to find `git-http-backend` in PATH!");
     }
 
     $env = array(
       'REQUEST_METHOD' => $_SERVER['REQUEST_METHOD'],
       'QUERY_STRING' => $query_string,
       'CONTENT_TYPE' => $_SERVER['CONTENT_TYPE'],
       'REMOTE_USER' => '',
       'REMOTE_ADDR' => $_SERVER['REMOTE_ADDR'],
       'GIT_PROJECT_ROOT' => $repository_root,
       'GIT_HTTP_EXPORT_ALL' => '1',
       'PATH_INFO' => $request_path,
     );
 
     list($stdout) = id(new ExecFuture('%s', $bin))
       ->setEnv($env, true)
       ->write(PhabricatorStartup::getRawInput())
       ->resolvex();
 
     return id(new DiffusionGitResponse())->setGitData($stdout);
   }
 
   private function getRequestDirectoryPath() {
     $request = $this->getRequest();
     $request_path = $request->getRequestURI()->getPath();
     return preg_replace('@^/diffusion/[A-Z]+@', '', $request_path);
   }
 
   protected function renderStatusMessage($title, $body) {
     return id(new AphrontErrorView())
       ->setSeverity(AphrontErrorView::SEVERITY_WARNING)
       ->setTitle($title)
       ->appendChild($body);
   }
 }
 
diff --git a/src/applications/diffusion/controller/DiffusionRepositoryEditController.php b/src/applications/diffusion/controller/DiffusionRepositoryEditController.php
index 7909194e41..292597cbf5 100644
--- a/src/applications/diffusion/controller/DiffusionRepositoryEditController.php
+++ b/src/applications/diffusion/controller/DiffusionRepositoryEditController.php
@@ -1,28 +1,34 @@
 <?php
 
 abstract class DiffusionRepositoryEditController
   extends DiffusionController {
 
-  public function buildApplicationCrumbs() {
+  public function buildApplicationCrumbs($is_main = false) {
     $crumbs = parent::buildApplicationCrumbs();
 
     if ($this->diffusionRequest) {
       $repository = $this->getDiffusionRequest()->getRepository();
       $repo_uri = $this->getRepositoryControllerURI($repository, '');
       $edit_uri = $this->getRepositoryControllerURI($repository, 'edit/');
 
       $crumbs->addCrumb(
         id(new PhabricatorCrumbView())
           ->setName('r'.$repository->getCallsign())
           ->setHref($repo_uri));
 
-      $crumbs->addCrumb(
-        id(new PhabricatorCrumbView())
-          ->setName(pht('Edit'))
-          ->setHref($edit_uri));
+      if ($is_main) {
+        $crumbs->addCrumb(
+          id(new PhabricatorCrumbView())
+            ->setName(pht('Edit Repository')));
+      } else {
+        $crumbs->addCrumb(
+          id(new PhabricatorCrumbView())
+            ->setName(pht('Edit'))
+            ->setHref($edit_uri));
+      }
     }
 
     return $crumbs;
   }
 
 }
diff --git a/src/applications/diffusion/controller/DiffusionRepositoryEditMainController.php b/src/applications/diffusion/controller/DiffusionRepositoryEditMainController.php
index f0140ebdc7..1552d471df 100644
--- a/src/applications/diffusion/controller/DiffusionRepositoryEditMainController.php
+++ b/src/applications/diffusion/controller/DiffusionRepositoryEditMainController.php
@@ -1,565 +1,678 @@
 <?php
 
 final class DiffusionRepositoryEditMainController
   extends DiffusionRepositoryEditController {
 
   public function processRequest() {
     $request = $this->getRequest();
     $viewer = $request->getUser();
     $drequest = $this->diffusionRequest;
     $repository = $drequest->getRepository();
 
     PhabricatorPolicyFilter::requireCapability(
       $viewer,
       $repository,
       PhabricatorPolicyCapability::CAN_EDIT);
 
     $is_svn = false;
     $is_git = false;
     $is_hg = false;
     switch ($repository->getVersionControlSystem()) {
       case PhabricatorRepositoryType::REPOSITORY_TYPE_GIT:
-        $has_local = true;
         $is_git = true;
         break;
       case PhabricatorRepositoryType::REPOSITORY_TYPE_SVN:
-        $has_local = $repository->isHosted();
         $is_svn = true;
         break;
       case PhabricatorRepositoryType::REPOSITORY_TYPE_MERCURIAL:
-        $has_local = true;
         $is_hg = true;
         break;
     }
 
     $has_branches = ($is_git || $is_hg);
+    $has_local = $repository->usesLocalWorkingCopy();
 
-    $crumbs = $this->buildApplicationCrumbs();
+    $crumbs = $this->buildApplicationCrumbs($is_main = true);
 
     $title = pht('Edit %s', $repository->getName());
 
     $header = id(new PHUIHeaderView())
       ->setHeader($title);
     if ($repository->isTracked()) {
       $header->setStatus('oh-ok', '', pht('Active'));
     } else {
       $header->setStatus('policy-noone', '', pht('Inactive'));
     }
 
     $basic_actions = $this->buildBasicActions($repository);
     $basic_properties =
       $this->buildBasicProperties($repository, $basic_actions);
 
     $policy_actions = $this->buildPolicyActions($repository);
     $policy_properties =
       $this->buildPolicyProperties($repository, $policy_actions);
 
     $remote_properties = $this->buildRemoteProperties(
       $repository,
       $this->buildRemoteActions($repository));
 
     $encoding_actions = $this->buildEncodingActions($repository);
     $encoding_properties =
       $this->buildEncodingProperties($repository, $encoding_actions);
 
     $hosting_properties = $this->buildHostingProperties(
       $repository,
       $this->buildHostingActions($repository));
 
     $branches_properties = null;
     if ($has_branches) {
       $branches_properties = $this->buildBranchesProperties(
         $repository,
         $this->buildBranchesActions($repository));
     }
 
     $subversion_properties = null;
     if ($is_svn) {
       $subversion_properties = $this->buildSubversionProperties(
         $repository,
         $this->buildSubversionActions($repository));
     }
 
     $local_properties = null;
     if ($has_local) {
       $local_properties = $this->buildLocalProperties(
         $repository,
         $this->buildLocalActions($repository));
     }
 
     $actions_properties = $this->buildActionsProperties(
       $repository,
       $this->buildActionsActions($repository));
 
     $xactions = id(new PhabricatorRepositoryTransactionQuery())
       ->setViewer($viewer)
       ->withObjectPHIDs(array($repository->getPHID()))
       ->execute();
 
     $engine = id(new PhabricatorMarkupEngine())
       ->setViewer($viewer);
     foreach ($xactions as $xaction) {
       if ($xaction->getComment()) {
         $engine->addObject(
           $xaction->getComment(),
           PhabricatorApplicationTransactionComment::MARKUP_FIELD_COMMENT);
       }
     }
     $engine->process();
 
     $xaction_view = id(new PhabricatorApplicationTransactionView())
       ->setUser($viewer)
       ->setObjectPHID($repository->getPHID())
       ->setTransactions($xactions)
       ->setMarkupEngine($engine);
 
     $obj_box = id(new PHUIObjectBoxView())
       ->setHeader($header)
       ->addPropertyList($basic_properties)
       ->addPropertyList($policy_properties)
       ->addPropertyList($hosting_properties)
       ->addPropertyList($remote_properties);
 
     if ($local_properties) {
       $obj_box->addPropertyList($local_properties);
     }
 
     $obj_box->addPropertyList($encoding_properties);
 
     if ($branches_properties) {
       $obj_box->addPropertyList($branches_properties);
     }
 
     if ($subversion_properties) {
       $obj_box->addPropertyList($subversion_properties);
     }
 
     $obj_box->addPropertyList($actions_properties);
 
     return $this->buildApplicationPage(
       array(
         $crumbs,
         $obj_box,
         $xaction_view,
       ),
       array(
         'title' => $title,
         'device' => true,
       ));
   }
 
   private function buildBasicActions(PhabricatorRepository $repository) {
     $viewer = $this->getRequest()->getUser();
 
     $view = id(new PhabricatorActionListView())
       ->setObjectURI($this->getRequest()->getRequestURI())
       ->setUser($viewer);
 
     $edit = id(new PhabricatorActionView())
       ->setIcon('edit')
       ->setName(pht('Edit Basic Information'))
       ->setHref($this->getRepositoryControllerURI($repository, 'edit/basic/'));
     $view->addAction($edit);
 
     $activate = id(new PhabricatorActionView())
       ->setHref(
         $this->getRepositoryControllerURI($repository, 'edit/activate/'))
       ->setWorkflow(true);
 
     if ($repository->isTracked()) {
       $activate
         ->setIcon('disable')
         ->setName(pht('Deactivate Repository'));
     } else {
       $activate
         ->setIcon('enable')
         ->setName(pht('Activate Repository'));
     }
 
     $view->addAction($activate);
 
     $view->addAction(
       id(new PhabricatorActionView())
         ->setName(pht('Delete Repository'))
         ->setIcon('delete')
         ->setHref(
           $this->getRepositoryControllerURI($repository, 'edit/delete/'))
         ->setWorkflow(true));
 
     return $view;
   }
 
   private function buildBasicProperties(
     PhabricatorRepository $repository,
     PhabricatorActionListView $actions) {
 
     $viewer = $this->getRequest()->getUser();
 
     $view = id(new PHUIPropertyListView())
       ->setUser($viewer)
       ->setActionList($actions);
 
-    $view->addProperty(pht('Name'), $repository->getName());
-    $view->addProperty(pht('ID'), $repository->getID());
-    $view->addProperty(pht('PHID'), $repository->getPHID());
-
     $type = PhabricatorRepositoryType::getNameForRepositoryType(
       $repository->getVersionControlSystem());
 
     $view->addProperty(pht('Type'), $type);
     $view->addProperty(pht('Callsign'), $repository->getCallsign());
 
+    $view->addProperty(
+      pht('Status'),
+      $this->buildRepositoryStatus($repository));
+
     $description = $repository->getDetail('description');
     $view->addSectionHeader(pht('Description'));
     if (!strlen($description)) {
       $description = phutil_tag('em', array(), pht('No description provided.'));
     } else {
       $description = PhabricatorMarkupEngine::renderOneObject(
         $repository,
         'description',
         $viewer);
     }
     $view->addTextContent($description);
 
     return $view;
   }
 
   private function buildEncodingActions(PhabricatorRepository $repository) {
     $viewer = $this->getRequest()->getUser();
 
     $view = id(new PhabricatorActionListView())
       ->setObjectURI($this->getRequest()->getRequestURI())
       ->setUser($viewer);
 
     $edit = id(new PhabricatorActionView())
       ->setIcon('edit')
       ->setName(pht('Edit Text Encoding'))
       ->setHref(
         $this->getRepositoryControllerURI($repository, 'edit/encoding/'));
     $view->addAction($edit);
 
     return $view;
   }
 
   private function buildEncodingProperties(
     PhabricatorRepository $repository,
     PhabricatorActionListView $actions) {
 
     $viewer = $this->getRequest()->getUser();
 
     $view = id(new PHUIPropertyListView())
       ->setUser($viewer)
       ->setActionList($actions)
       ->addSectionHeader(pht('Text Encoding'));
 
     $encoding = $repository->getDetail('encoding');
     if (!$encoding) {
       $encoding = phutil_tag('em', array(), pht('Use Default (UTF-8)'));
     }
 
     $view->addProperty(pht('Encoding'), $encoding);
 
     return $view;
   }
 
   private function buildPolicyActions(PhabricatorRepository $repository) {
     $viewer = $this->getRequest()->getUser();
 
     $view = id(new PhabricatorActionListView())
       ->setObjectURI($this->getRequest()->getRequestURI())
       ->setUser($viewer);
 
     $edit = id(new PhabricatorActionView())
       ->setIcon('edit')
       ->setName(pht('Edit Policies'))
       ->setHref(
         $this->getRepositoryControllerURI($repository, 'edit/policy/'));
     $view->addAction($edit);
 
     return $view;
   }
 
   private function buildPolicyProperties(
     PhabricatorRepository $repository,
     PhabricatorActionListView $actions) {
 
     $viewer = $this->getRequest()->getUser();
 
     $view = id(new PHUIPropertyListView())
       ->setUser($viewer)
       ->setActionList($actions)
       ->addSectionHeader(pht('Policies'));
 
     $descriptions = PhabricatorPolicyQuery::renderPolicyDescriptions(
       $viewer,
       $repository);
 
     $view->addProperty(
       pht('Visible To'),
       $descriptions[PhabricatorPolicyCapability::CAN_VIEW]);
 
     $view->addProperty(
       pht('Editable By'),
       $descriptions[PhabricatorPolicyCapability::CAN_EDIT]);
 
     $pushable = $repository->isHosted()
       ? $descriptions[DiffusionCapabilityPush::CAPABILITY]
       : phutil_tag('em', array(), pht('Not a Hosted Repository'));
     $view->addProperty(pht('Pushable By'), $pushable);
 
     return $view;
   }
 
   private function buildBranchesActions(PhabricatorRepository $repository) {
     $viewer = $this->getRequest()->getUser();
 
     $view = id(new PhabricatorActionListView())
       ->setObjectURI($this->getRequest()->getRequestURI())
       ->setUser($viewer);
 
     $edit = id(new PhabricatorActionView())
       ->setIcon('edit')
       ->setName(pht('Edit Branches'))
       ->setHref(
         $this->getRepositoryControllerURI($repository, 'edit/branches/'));
     $view->addAction($edit);
 
     return $view;
   }
 
   private function buildBranchesProperties(
     PhabricatorRepository $repository,
     PhabricatorActionListView $actions) {
 
     $viewer = $this->getRequest()->getUser();
 
     $view = id(new PHUIPropertyListView())
       ->setUser($viewer)
       ->setActionList($actions)
       ->addSectionHeader(pht('Branches'));
 
     $default_branch = nonempty(
       $repository->getHumanReadableDetail('default-branch'),
       phutil_tag('em', array(), $repository->getDefaultBranch()));
     $view->addProperty(pht('Default Branch'), $default_branch);
 
     $track_only = nonempty(
       $repository->getHumanReadableDetail('branch-filter', array()),
       phutil_tag('em', array(), pht('Track All Branches')));
     $view->addProperty(pht('Track Only'), $track_only);
 
     $autoclose_only = nonempty(
       $repository->getHumanReadableDetail('close-commits-filter', array()),
       phutil_tag('em', array(), pht('Autoclose On All Branches')));
     $view->addProperty(pht('Autoclose Only'), $autoclose_only);
 
     return $view;
   }
 
   private function buildSubversionActions(PhabricatorRepository $repository) {
     $viewer = $this->getRequest()->getUser();
 
     $view = id(new PhabricatorActionListView())
       ->setObjectURI($this->getRequest()->getRequestURI())
       ->setUser($viewer);
 
     $edit = id(new PhabricatorActionView())
       ->setIcon('edit')
       ->setName(pht('Edit Subversion Info'))
       ->setHref(
         $this->getRepositoryControllerURI($repository, 'edit/subversion/'));
     $view->addAction($edit);
 
     return $view;
   }
 
   private function buildSubversionProperties(
     PhabricatorRepository $repository,
     PhabricatorActionListView $actions) {
 
     $viewer = $this->getRequest()->getUser();
 
     $view = id(new PHUIPropertyListView())
       ->setUser($viewer)
       ->setActionList($actions)
       ->addSectionHeader(pht('Subversion'));
 
     $svn_uuid = nonempty(
       $repository->getUUID(),
       phutil_tag('em', array(), pht('Not Configured')));
     $view->addProperty(pht('Subversion UUID'), $svn_uuid);
 
     $svn_subpath = nonempty(
       $repository->getHumanReadableDetail('svn-subpath'),
       phutil_tag('em', array(), pht('Import Entire Repository')));
     $view->addProperty(pht('Import Only'), $svn_subpath);
 
     return $view;
   }
 
   private function buildActionsActions(PhabricatorRepository $repository) {
     $viewer = $this->getRequest()->getUser();
 
     $view = id(new PhabricatorActionListView())
       ->setObjectURI($this->getRequest()->getRequestURI())
       ->setUser($viewer);
 
     $edit = id(new PhabricatorActionView())
       ->setIcon('edit')
       ->setName(pht('Edit Actions'))
       ->setHref(
         $this->getRepositoryControllerURI($repository, 'edit/actions/'));
     $view->addAction($edit);
 
     return $view;
   }
 
   private function buildActionsProperties(
     PhabricatorRepository $repository,
     PhabricatorActionListView $actions) {
 
     $viewer = $this->getRequest()->getUser();
 
     $view = id(new PHUIPropertyListView())
       ->setUser($viewer)
       ->setActionList($actions)
       ->addSectionHeader(pht('Actions'));
 
     $notify = $repository->getDetail('herald-disabled')
       ? pht('Off')
       : pht('On');
     $notify = phutil_tag('em', array(), $notify);
     $view->addProperty(pht('Publish/Notify'), $notify);
 
     $autoclose = $repository->getDetail('disable-autoclose')
       ? pht('Off')
       : pht('On');
     $autoclose = phutil_tag('em', array(), $autoclose);
     $view->addProperty(pht('Autoclose'), $autoclose);
 
     return $view;
   }
 
   private function buildRemoteActions(PhabricatorRepository $repository) {
     $viewer = $this->getRequest()->getUser();
 
     $view = id(new PhabricatorActionListView())
       ->setObjectURI($this->getRequest()->getRequestURI())
       ->setUser($viewer);
 
     $edit = id(new PhabricatorActionView())
       ->setIcon('edit')
       ->setName(pht('Edit Remote'))
       ->setHref(
         $this->getRepositoryControllerURI($repository, 'edit/remote/'));
     $view->addAction($edit);
 
     return $view;
   }
 
   private function buildRemoteProperties(
     PhabricatorRepository $repository,
     PhabricatorActionListView $actions) {
 
     $viewer = $this->getRequest()->getUser();
 
     $view = id(new PHUIPropertyListView())
       ->setUser($viewer)
       ->setActionList($actions)
       ->addSectionHeader(pht('Remote'));
 
     $view->addProperty(
       pht('Remote URI'),
       $repository->getHumanReadableDetail('remote-uri'));
 
     return $view;
   }
 
   private function buildLocalActions(PhabricatorRepository $repository) {
     $viewer = $this->getRequest()->getUser();
 
     $view = id(new PhabricatorActionListView())
       ->setObjectURI($this->getRequest()->getRequestURI())
       ->setUser($viewer);
 
     $edit = id(new PhabricatorActionView())
       ->setIcon('edit')
       ->setName(pht('Edit Local'))
       ->setHref(
         $this->getRepositoryControllerURI($repository, 'edit/local/'));
     $view->addAction($edit);
 
     return $view;
   }
 
   private function buildLocalProperties(
     PhabricatorRepository $repository,
     PhabricatorActionListView $actions) {
 
     $viewer = $this->getRequest()->getUser();
 
     $view = id(new PHUIPropertyListView())
       ->setUser($viewer)
       ->setActionList($actions)
       ->addSectionHeader(pht('Local'));
 
     $view->addProperty(
       pht('Local Path'),
       $repository->getHumanReadableDetail('local-path'));
 
     return $view;
   }
 
   private function buildHostingActions(PhabricatorRepository $repository) {
     $user = $this->getRequest()->getUser();
 
     $view = id(new PhabricatorActionListView())
       ->setObjectURI($this->getRequest()->getRequestURI())
       ->setUser($user);
 
     $edit = id(new PhabricatorActionView())
       ->setIcon('edit')
       ->setName(pht('Edit Hosting'))
       ->setHref(
         $this->getRepositoryControllerURI($repository, 'edit/hosting/'));
     $view->addAction($edit);
 
     return $view;
   }
 
   private function buildHostingProperties(
     PhabricatorRepository $repository,
     PhabricatorActionListView $actions) {
 
     $user = $this->getRequest()->getUser();
 
     $view = id(new PHUIPropertyListView())
       ->setUser($user)
       ->setActionList($actions)
       ->addSectionHeader(pht('Hosting'));
 
     $hosting = $repository->isHosted()
       ? pht('Hosted on Phabricator')
       : pht('Hosted Elsewhere');
     $view->addProperty(pht('Hosting'), phutil_tag('em', array(), $hosting));
 
     $view->addProperty(
       pht('Serve over HTTP'),
       phutil_tag(
         'em',
         array(),
         PhabricatorRepository::getProtocolAvailabilityName(
           $repository->getServeOverHTTP())));
 
     $view->addProperty(
       pht('Serve over SSH'),
       phutil_tag(
         'em',
         array(),
         PhabricatorRepository::getProtocolAvailabilityName(
           $repository->getServeOverSSH())));
 
     return $view;
   }
 
+  private function buildRepositoryStatus(
+    PhabricatorRepository $repository) {
+
+    $view = new PHUIStatusListView();
+
+    if ($repository->isTracked()) {
+      $view->addItem(
+        id(new PHUIStatusItemView())
+          ->setIcon('accept-green')
+          ->setTarget(pht('Repository Active')));
+    } else {
+      $view->addItem(
+        id(new PHUIStatusItemView())
+          ->setIcon('warning')
+          ->setTarget(pht('Repository Inactive'))
+          ->setNote(
+            pht('Activate this repository to begin or resume import.')));
+      return $view;
+    }
+
+    $doc_href = PhabricatorEnv::getDocLink(
+      'article/Managing_Daemons_with_phd.html');
+    $daemon_instructions = pht(
+      'Use %s to start daemons. See %s.',
+      phutil_tag('tt', array(), 'bin/phd start'),
+      phutil_tag(
+        'a',
+        array(
+          'href' => $doc_href,
+        ),
+        pht('Managing Daemons with phd')));
+
+
+    $pull_daemon = id(new PhabricatorDaemonLogQuery())
+      ->setViewer(PhabricatorUser::getOmnipotentUser())
+      ->withStatus(PhabricatorDaemonLogQuery::STATUS_ALIVE)
+      ->withDaemonClasses(array('PhabricatorRepositoryPullLocalDaemon'))
+      ->setLimit(1)
+      ->execute();
+
+    if ($pull_daemon) {
+      $view->addItem(
+        id(new PHUIStatusItemView())
+          ->setIcon('accept-green')
+          ->setTarget(pht('Pull Daemon Running')));
+    } else {
+      $view->addItem(
+        id(new PHUIStatusItemView())
+          ->setIcon('warning-red')
+          ->setTarget(pht('Pull Daemon Not Running'))
+          ->setNote($daemon_instructions));
+    }
+
+
+    $task_daemon = id(new PhabricatorDaemonLogQuery())
+      ->setViewer(PhabricatorUser::getOmnipotentUser())
+      ->withStatus(PhabricatorDaemonLogQuery::STATUS_ALIVE)
+      ->withDaemonClasses(array('PhabricatorTaskmasterDaemon'))
+      ->setLimit(1)
+      ->execute();
+    if ($task_daemon) {
+      $view->addItem(
+        id(new PHUIStatusItemView())
+          ->setIcon('accept-green')
+          ->setTarget(pht('Task Daemon Running')));
+    } else {
+      $view->addItem(
+        id(new PHUIStatusItemView())
+          ->setIcon('warning-red')
+          ->setTarget(pht('Task Daemon Not Running'))
+          ->setNote($daemon_instructions));
+    }
+
+    $local_parent = dirname($repository->getLocalPath());
+    if (Filesystem::pathExists($local_parent)) {
+      $view->addItem(
+        id(new PHUIStatusItemView())
+          ->setIcon('accept-green')
+          ->setTarget(pht('Storage Directory OK'))
+          ->setNote(phutil_tag('tt', array(), $local_parent)));
+    } else {
+      $view->addItem(
+        id(new PHUIStatusItemView())
+          ->setIcon('warning-red')
+          ->setTarget(pht('No Storage Directory'))
+          ->setNote(
+            pht(
+              'Storage directory %s does not exist, or is not readable by '.
+              'the webserver. Create this directory or make it readable.',
+              phutil_tag('tt', array(), $local_parent))));
+      return $view;
+    }
+
+    if ($repository->usesLocalWorkingCopy()) {
+      $local_path = $repository->getLocalPath();
+      if (Filesystem::pathExists($local_path)) {
+        $view->addItem(
+          id(new PHUIStatusItemView())
+            ->setIcon('accept-green')
+            ->setTarget(pht('Working Copy OK'))
+            ->setNote(phutil_tag('tt', array(), $local_path)));
+      } else {
+        $view->addItem(
+          id(new PHUIStatusItemView())
+            ->setIcon('time-orange')
+            ->setTarget(pht('No Working Copy Yet'))
+            ->setNote(
+              pht('Waiting for daemons to build a working copy.')));
+        return $view;
+      }
+    }
+
+    return $view;
+  }
+
 }
diff --git a/src/applications/repository/storage/PhabricatorRepository.php b/src/applications/repository/storage/PhabricatorRepository.php
index 2ac8e9cc89..6bd26aa9d1 100644
--- a/src/applications/repository/storage/PhabricatorRepository.php
+++ b/src/applications/repository/storage/PhabricatorRepository.php
@@ -1,874 +1,884 @@
 <?php
 
 /**
  * @task uri Repository URI Management
  */
 final class PhabricatorRepository extends PhabricatorRepositoryDAO
   implements
     PhabricatorPolicyInterface,
     PhabricatorFlaggableInterface,
     PhabricatorMarkupInterface {
 
   /**
    * Shortest hash we'll recognize in raw "a829f32" form.
    */
   const MINIMUM_UNQUALIFIED_HASH = 7;
 
   /**
    * Shortest hash we'll recognize in qualified "rXab7ef2f8" form.
    */
   const MINIMUM_QUALIFIED_HASH = 5;
 
   const TABLE_PATH = 'repository_path';
   const TABLE_PATHCHANGE = 'repository_pathchange';
   const TABLE_FILESYSTEM = 'repository_filesystem';
   const TABLE_SUMMARY = 'repository_summary';
   const TABLE_BADCOMMIT = 'repository_badcommit';
   const TABLE_LINTMESSAGE = 'repository_lintmessage';
 
   const SERVE_OFF = 'off';
   const SERVE_READONLY = 'readonly';
   const SERVE_READWRITE = 'readwrite';
 
   protected $name;
   protected $callsign;
   protected $uuid;
   protected $viewPolicy;
   protected $editPolicy;
   protected $pushPolicy;
 
   protected $versionControlSystem;
   protected $details = array();
 
   private $sshKeyfile;
 
   private $commitCount = self::ATTACHABLE;
   private $mostRecentCommit = self::ATTACHABLE;
 
   public static function initializeNewRepository(PhabricatorUser $actor) {
     $app = id(new PhabricatorApplicationQuery())
       ->setViewer($actor)
       ->withClasses(array('PhabricatorApplicationDiffusion'))
       ->executeOne();
 
     $view_policy = $app->getPolicy(DiffusionCapabilityDefaultView::CAPABILITY);
     $edit_policy = $app->getPolicy(DiffusionCapabilityDefaultEdit::CAPABILITY);
     $push_policy = $app->getPolicy(DiffusionCapabilityDefaultPush::CAPABILITY);
 
     return id(new PhabricatorRepository())
       ->setViewPolicy($view_policy)
       ->setEditPolicy($edit_policy)
       ->setPushPolicy($push_policy);
   }
 
   public function getConfiguration() {
     return array(
       self::CONFIG_AUX_PHID => true,
       self::CONFIG_SERIALIZATION => array(
         'details' => self::SERIALIZATION_JSON,
       ),
     ) + parent::getConfiguration();
   }
 
   public function generatePHID() {
     return PhabricatorPHID::generateNewPHID(
       PhabricatorRepositoryPHIDTypeRepository::TYPECONST);
   }
 
   public function toDictionary() {
     return array(
       'name'        => $this->getName(),
       'phid'        => $this->getPHID(),
       'callsign'    => $this->getCallsign(),
       'vcs'         => $this->getVersionControlSystem(),
       'uri'         => PhabricatorEnv::getProductionURI($this->getURI()),
       'remoteURI'   => (string)$this->getPublicRemoteURI(),
       'tracking'    => $this->getDetail('tracking-enabled'),
       'description' => $this->getDetail('description'),
     );
   }
 
   public function getDetail($key, $default = null) {
     return idx($this->details, $key, $default);
   }
 
   public function getHumanReadableDetail($key, $default = null) {
     $value = $this->getDetail($key, $default);
 
     switch ($key) {
       case 'branch-filter':
       case 'close-commits-filter':
         $value = array_keys($value);
         $value = implode(', ', $value);
         break;
     }
 
     return $value;
   }
 
   public function setDetail($key, $value) {
     $this->details[$key] = $value;
     return $this;
   }
 
   public function attachCommitCount($count) {
     $this->commitCount = $count;
     return $this;
   }
 
   public function getCommitCount() {
     return $this->assertAttached($this->commitCount);
   }
 
   public function attachMostRecentCommit(
     PhabricatorRepositoryCommit $commit = null) {
     $this->mostRecentCommit = $commit;
     return $this;
   }
 
   public function getMostRecentCommit() {
     return $this->assertAttached($this->mostRecentCommit);
   }
 
   public function getDiffusionBrowseURIForPath(
     PhabricatorUser $user,
     $path,
     $line = null,
     $branch = null) {
 
     $drequest = DiffusionRequest::newFromDictionary(
       array(
         'user' => $user,
         'repository' => $this,
         'path' => $path,
         'branch' => $branch,
       ));
 
     return $drequest->generateURI(
       array(
         'action' => 'browse',
         'line'   => $line,
       ));
   }
 
   public function getLocalPath() {
     return $this->getDetail('local-path');
   }
 
   public function getSubversionBaseURI() {
     $vcs = $this->getVersionControlSystem();
     if ($vcs != PhabricatorRepositoryType::REPOSITORY_TYPE_SVN) {
       throw new Exception("Not a subversion repository!");
     }
 
     $uri = $this->getDetail('remote-uri');
     $subpath = $this->getDetail('svn-subpath');
 
     return $uri.$subpath;
   }
 
   public function execRemoteCommand($pattern /* , $arg, ... */) {
     $args = func_get_args();
     $args = $this->formatRemoteCommand($args);
     return call_user_func_array('exec_manual', $args);
   }
 
   public function execxRemoteCommand($pattern /* , $arg, ... */) {
     $args = func_get_args();
     $args = $this->formatRemoteCommand($args);
     return call_user_func_array('execx', $args);
   }
 
   public function getRemoteCommandFuture($pattern /* , $arg, ... */) {
     $args = func_get_args();
     $args = $this->formatRemoteCommand($args);
     return newv('ExecFuture', $args);
   }
 
   public function passthruRemoteCommand($pattern /* , $arg, ... */) {
     $args = func_get_args();
     $args = $this->formatRemoteCommand($args);
     return call_user_func_array('phutil_passthru', $args);
   }
 
   public function execLocalCommand($pattern /* , $arg, ... */) {
     $this->assertLocalExists();
 
     $args = func_get_args();
     $args = $this->formatLocalCommand($args);
     return call_user_func_array('exec_manual', $args);
   }
 
   public function execxLocalCommand($pattern /* , $arg, ... */) {
     $this->assertLocalExists();
 
     $args = func_get_args();
     $args = $this->formatLocalCommand($args);
     return call_user_func_array('execx', $args);
   }
 
   public function getLocalCommandFuture($pattern /* , $arg, ... */) {
     $this->assertLocalExists();
 
     $args = func_get_args();
     $args = $this->formatLocalCommand($args);
     return newv('ExecFuture', $args);
   }
 
   public function passthruLocalCommand($pattern /* , $arg, ... */) {
     $this->assertLocalExists();
 
     $args = func_get_args();
     $args = $this->formatLocalCommand($args);
     return call_user_func_array('phutil_passthru', $args);
   }
 
 
   private function formatRemoteCommand(array $args) {
     $pattern = $args[0];
     $args = array_slice($args, 1);
 
     $empty = $this->getEmptyReadableDirectoryPath();
 
     if ($this->shouldUseSSH()) {
       switch ($this->getVersionControlSystem()) {
         case PhabricatorRepositoryType::REPOSITORY_TYPE_SVN:
           $pattern = "SVN_SSH=%s svn --non-interactive {$pattern}";
           array_unshift(
             $args,
             csprintf(
               'ssh -l %P -i %P',
               new PhutilOpaqueEnvelope($this->getSSHLogin()),
               new PhutilOpaqueEnvelope($this->getSSHKeyfile())));
           break;
         case PhabricatorRepositoryType::REPOSITORY_TYPE_GIT:
           $command = call_user_func_array(
             'csprintf',
             array_merge(
               array(
                 "(ssh-add %P && HOME=%s git {$pattern})",
                 new PhutilOpaqueEnvelope($this->getSSHKeyfile()),
                 $empty,
               ),
               $args));
           $pattern = "ssh-agent sh -c %s";
           $args = array($command);
           break;
         case PhabricatorRepositoryType::REPOSITORY_TYPE_MERCURIAL:
           $pattern = "hg --config ui.ssh=%s {$pattern}";
           array_unshift(
             $args,
             csprintf(
               'ssh -l %P -i %P',
               new PhutilOpaqueEnvelope($this->getSSHLogin()),
               new PhutilOpaqueEnvelope($this->getSSHKeyfile())));
           break;
         default:
           throw new Exception("Unrecognized version control system.");
       }
     } else if ($this->shouldUseHTTP()) {
       switch ($this->getVersionControlSystem()) {
         case PhabricatorRepositoryType::REPOSITORY_TYPE_SVN:
           $pattern =
             "svn ".
             "--non-interactive ".
             "--no-auth-cache ".
             "--trust-server-cert ".
             "--username %P ".
             "--password %P ".
             $pattern;
           array_unshift(
             $args,
             new PhutilOpaqueEnvelope($this->getDetail('http-login')),
             new PhutilOpaqueEnvelope($this->getDetail('http-pass')));
           break;
         default:
           throw new Exception(
             "No support for HTTP Basic Auth in this version control system.");
       }
     } else if ($this->shouldUseSVNProtocol()) {
       switch ($this->getVersionControlSystem()) {
         case PhabricatorRepositoryType::REPOSITORY_TYPE_SVN:
             $pattern =
               "svn ".
               "--non-interactive ".
               "--no-auth-cache ".
               "--username %P ".
               "--password %P ".
               $pattern;
             array_unshift(
               $args,
               new PhutilOpaqueEnvelope($this->getDetail('http-login')),
               new PhutilOpaqueEnvelope($this->getDetail('http-pass')));
             break;
         default:
           throw new Exception(
             "SVN protocol is SVN only.");
       }
     } else {
       switch ($this->getVersionControlSystem()) {
         case PhabricatorRepositoryType::REPOSITORY_TYPE_SVN:
           $pattern = "svn --non-interactive {$pattern}";
           break;
         case PhabricatorRepositoryType::REPOSITORY_TYPE_GIT:
           $pattern = "HOME=%s git {$pattern}";
           array_unshift($args, $empty);
           break;
         case PhabricatorRepositoryType::REPOSITORY_TYPE_MERCURIAL:
           $pattern = "hg {$pattern}";
           break;
         default:
           throw new Exception("Unrecognized version control system.");
       }
     }
 
     array_unshift($args, $pattern);
 
     return $args;
   }
 
   private function formatLocalCommand(array $args) {
     $pattern = $args[0];
     $args = array_slice($args, 1);
 
     $empty = $this->getEmptyReadableDirectoryPath();
 
     switch ($this->getVersionControlSystem()) {
       case PhabricatorRepositoryType::REPOSITORY_TYPE_SVN:
         $pattern = "(cd %s && svn --non-interactive {$pattern})";
         array_unshift($args, $this->getLocalPath());
         break;
       case PhabricatorRepositoryType::REPOSITORY_TYPE_GIT:
         $pattern = "(cd %s && HOME=%s git {$pattern})";
         array_unshift($args, $this->getLocalPath(), $empty);
         break;
       case PhabricatorRepositoryType::REPOSITORY_TYPE_MERCURIAL:
         $hgplain = (phutil_is_windows() ? "set HGPLAIN=1 &&" : "HGPLAIN=1");
         $pattern = "(cd %s && {$hgplain} hg {$pattern})";
         array_unshift($args, $this->getLocalPath());
         break;
       default:
         throw new Exception("Unrecognized version control system.");
     }
 
     array_unshift($args, $pattern);
 
     return $args;
   }
 
   private function getEmptyReadableDirectoryPath() {
     // See T2965. Some time after Git 1.7.5.4, Git started fataling if it can
     // not read $HOME. For many users, $HOME points at /root (this seems to be
     // a default result of Apache setup). Instead, explicitly point $HOME at a
     // readable, empty directory so that Git looks for the config file it's
     // after, fails to locate it, and moves on. This is really silly, but seems
     // like the least damaging approach to mitigating the issue.
     $root = dirname(phutil_get_library_root('phabricator'));
     return $root.'/support/empty/';
   }
 
   private function getSSHLogin() {
     return $this->getDetail('ssh-login');
   }
 
   private function getSSHKeyfile() {
     if ($this->sshKeyfile === null) {
       $key = $this->getDetail('ssh-key');
       $keyfile = $this->getDetail('ssh-keyfile');
       if ($keyfile) {
         // Make sure we can read the file, that it exists, etc.
         Filesystem::readFile($keyfile);
         $this->sshKeyfile = $keyfile;
       } else if ($key) {
         $keyfile = new TempFile('phabricator-repository-ssh-key');
         chmod($keyfile, 0600);
         Filesystem::writeFile($keyfile, $key);
         $this->sshKeyfile = $keyfile;
       } else {
         $this->sshKeyfile = '';
       }
     }
 
     return (string)$this->sshKeyfile;
   }
 
   public function getURI() {
     return '/diffusion/'.$this->getCallsign().'/';
   }
 
   public function isTracked() {
     return $this->getDetail('tracking-enabled', false);
   }
 
   public function getDefaultBranch() {
     $default = $this->getDetail('default-branch');
     if (strlen($default)) {
       return $default;
     }
 
     $default_branches = array(
       PhabricatorRepositoryType::REPOSITORY_TYPE_GIT        => 'master',
       PhabricatorRepositoryType::REPOSITORY_TYPE_MERCURIAL  => 'default',
     );
 
     return idx($default_branches, $this->getVersionControlSystem());
   }
 
   public function getDefaultArcanistBranch() {
     return coalesce($this->getDefaultBranch(), 'svn');
   }
 
   private function isBranchInFilter($branch, $filter_key) {
     $vcs = $this->getVersionControlSystem();
 
     $is_git = ($vcs == PhabricatorRepositoryType::REPOSITORY_TYPE_GIT);
 
     $use_filter = ($is_git);
 
     if ($use_filter) {
       $filter = $this->getDetail($filter_key, array());
       if ($filter && empty($filter[$branch])) {
         return false;
       }
     }
 
     // By default, all branches pass.
     return true;
   }
 
   public function shouldTrackBranch($branch) {
     return $this->isBranchInFilter($branch, 'branch-filter');
   }
 
   public function shouldAutocloseBranch($branch) {
     if ($this->isImporting()) {
       return false;
     }
 
     if ($this->getDetail('disable-autoclose', false)) {
       return false;
     }
 
     return $this->isBranchInFilter($branch, 'close-commits-filter');
   }
 
   public function shouldAutocloseCommit(
     PhabricatorRepositoryCommit $commit,
     PhabricatorRepositoryCommitData $data) {
 
     if ($this->getDetail('disable-autoclose', false)) {
       return false;
     }
 
     switch ($this->getVersionControlSystem()) {
       case PhabricatorRepositoryType::REPOSITORY_TYPE_SVN:
         return true;
       case PhabricatorRepositoryType::REPOSITORY_TYPE_GIT:
         break;
       case PhabricatorRepositoryType::REPOSITORY_TYPE_MERCURIAL:
         return true;
       default:
         throw new Exception("Unrecognized version control system.");
     }
 
     $branches = $data->getCommitDetail('seenOnBranches', array());
     foreach ($branches as $branch) {
       if ($this->shouldAutocloseBranch($branch)) {
         return true;
       }
     }
 
     return false;
   }
 
   public function formatCommitName($commit_identifier) {
     $vcs = $this->getVersionControlSystem();
 
     $type_git = PhabricatorRepositoryType::REPOSITORY_TYPE_GIT;
     $type_hg = PhabricatorRepositoryType::REPOSITORY_TYPE_MERCURIAL;
 
     $is_git = ($vcs == $type_git);
     $is_hg = ($vcs == $type_hg);
     if ($is_git || $is_hg) {
       $short_identifier = substr($commit_identifier, 0, 12);
     } else {
       $short_identifier = $commit_identifier;
     }
 
     return 'r'.$this->getCallsign().$short_identifier;
   }
 
   public function isImporting() {
     return (bool)$this->getDetail('importing', false);
   }
 
 /* -(  Repository URI Management  )------------------------------------------ */
 
 
   /**
    * Get the remote URI for this repository.
    *
    * @return string
    * @task uri
    */
   public function getRemoteURI() {
     return (string)$this->getRemoteURIObject();
   }
 
 
   /**
    * Get the remote URI for this repository, without authentication information.
    *
    * @return string Repository URI.
    * @task uri
    */
   public function getPublicRemoteURI() {
     $uri = $this->getRemoteURIObject();
 
     // Make sure we don't leak anything if this repo is using HTTP Basic Auth
     // with the credentials in the URI or something zany like that.
 
     if ($uri instanceof PhutilGitURI) {
       if (!$this->getDetail('show-user', false)) {
         $uri->setUser(null);
       }
     } else {
       if (!$this->getDetail('show-user', false)) {
         $uri->setUser(null);
       }
       $uri->setPass(null);
     }
 
     return (string)$uri;
   }
 
 
   /**
    * Get the protocol for the repository's remote.
    *
    * @return string Protocol, like "ssh" or "git".
    * @task uri
    */
   public function getRemoteProtocol() {
     $uri = $this->getRemoteURIObject();
 
     if ($uri instanceof PhutilGitURI) {
       return 'ssh';
     } else {
       return $uri->getProtocol();
     }
   }
 
 
   /**
    * Get a parsed object representation of the repository's remote URI. This
    * may be a normal URI (returned as a @{class@libphutil:PhutilURI}) or a git
    * URI (returned as a @{class@libphutil:PhutilGitURI}).
    *
    * @return wild A @{class@libphutil:PhutilURI} or
    *              @{class@libphutil:PhutilGitURI}.
    * @task uri
    */
   private function getRemoteURIObject() {
     $raw_uri = $this->getDetail('remote-uri');
     if (!$raw_uri) {
       return new PhutilURI('');
     }
 
     if (!strncmp($raw_uri, '/', 1)) {
       return new PhutilURI('file://'.$raw_uri);
     }
 
     $uri = new PhutilURI($raw_uri);
     if ($uri->getProtocol()) {
       if ($this->isSSHProtocol($uri->getProtocol())) {
         if ($this->getSSHLogin()) {
           $uri->setUser($this->getSSHLogin());
         }
       }
       return $uri;
     }
 
     $uri = new PhutilGitURI($raw_uri);
     if ($uri->getDomain()) {
       if ($this->getSSHLogin()) {
         $uri->setUser($this->getSSHLogin());
       }
       return $uri;
     }
 
     throw new Exception("Remote URI '{$raw_uri}' could not be parsed!");
   }
 
 
   /**
    * Determine if we should connect to the remote using SSH flags and
    * credentials.
    *
    * @return bool True to use the SSH protocol.
    * @task uri
    */
   private function shouldUseSSH() {
     $protocol = $this->getRemoteProtocol();
     if ($this->isSSHProtocol($protocol)) {
       return (bool)$this->getSSHKeyfile();
     } else {
       return false;
     }
   }
 
 
   /**
    * Determine if we should connect to the remote using HTTP flags and
    * credentials.
    *
    * @return bool True to use the HTTP protocol.
    * @task uri
    */
   private function shouldUseHTTP() {
     $protocol = $this->getRemoteProtocol();
     if ($protocol == 'http' || $protocol == 'https') {
       return (bool)$this->getDetail('http-login');
     } else {
       return false;
     }
   }
 
 
   /**
    * Determine if we should connect to the remote using SVN flags and
    * credentials.
    *
    * @return bool True to use the SVN protocol.
    * @task uri
    */
   private function shouldUseSVNProtocol() {
     $protocol = $this->getRemoteProtocol();
     if ($protocol == 'svn') {
       return (bool)$this->getDetail('http-login');
     } else {
       return false;
     }
   }
 
 
   /**
    * Determine if a protocol is SSH or SSH-like.
    *
    * @param string A protocol string, like "http" or "ssh".
    * @return bool True if the protocol is SSH-like.
    * @task uri
    */
   private function isSSHProtocol($protocol) {
     return ($protocol == 'ssh' || $protocol == 'svn+ssh');
   }
 
   public function delete() {
     $this->openTransaction();
 
       $paths = id(new PhabricatorOwnersPath())
         ->loadAllWhere('repositoryPHID = %s', $this->getPHID());
       foreach ($paths as $path) {
         $path->delete();
       }
 
       $projects = id(new PhabricatorRepositoryArcanistProject())
         ->loadAllWhere('repositoryID = %d', $this->getID());
       foreach ($projects as $project) {
         // note each project deletes its PhabricatorRepositorySymbols
         $project->delete();
       }
 
       $commits = id(new PhabricatorRepositoryCommit())
         ->loadAllWhere('repositoryID = %d', $this->getID());
       foreach ($commits as $commit) {
         // note PhabricatorRepositoryAuditRequests and
         // PhabricatorRepositoryCommitData are deleted here too.
         $commit->delete();
       }
 
       $conn_w = $this->establishConnection('w');
 
       queryfx(
         $conn_w,
         'DELETE FROM %T WHERE repositoryID = %d',
         self::TABLE_FILESYSTEM,
         $this->getID());
 
       queryfx(
         $conn_w,
         'DELETE FROM %T WHERE repositoryID = %d',
         self::TABLE_PATHCHANGE,
         $this->getID());
 
       queryfx(
         $conn_w,
         'DELETE FROM %T WHERE repositoryID = %d',
         self::TABLE_SUMMARY,
         $this->getID());
 
       $result = parent::delete();
 
     $this->saveTransaction();
     return $result;
   }
 
   public function isGit() {
     $vcs = $this->getVersionControlSystem();
     return ($vcs == PhabricatorRepositoryType::REPOSITORY_TYPE_GIT);
   }
 
   public function isSVN() {
     $vcs = $this->getVersionControlSystem();
     return ($vcs == PhabricatorRepositoryType::REPOSITORY_TYPE_SVN);
   }
 
   public function isHg() {
     $vcs = $this->getVersionControlSystem();
     return ($vcs == PhabricatorRepositoryType::REPOSITORY_TYPE_MERCURIAL);
   }
 
   public function isHosted() {
     return (bool)$this->getDetail('hosting-enabled', false);
   }
 
   public function setHosted($enabled) {
     return $this->setDetail('hosting-enabled', $enabled);
   }
 
   public function getServeOverHTTP() {
     return $this->getDetail('serve-over-http', self::SERVE_OFF);
   }
 
   public function setServeOverHTTP($mode) {
     return $this->setDetail('serve-over-http', $mode);
   }
 
   public function getServeOverSSH() {
     return $this->getDetail('serve-over-ssh', self::SERVE_OFF);
   }
 
   public function setServeOverSSH($mode) {
     return $this->setDetail('serve-over-ssh', $mode);
   }
 
   public static function getProtocolAvailabilityName($constant) {
     switch ($constant) {
       case self::SERVE_OFF:
         return pht('Off');
       case self::SERVE_READONLY:
         return pht('Read Only');
       case self::SERVE_READWRITE:
         return pht('Read/Write');
       default:
         return pht('Unknown');
     }
   }
 
 
   /**
    * Raise more useful errors when there are basic filesystem problems.
    */
   private function assertLocalExists() {
     switch ($this->getVersionControlSystem()) {
       case PhabricatorRepositoryType::REPOSITORY_TYPE_SVN:
         if (!$this->isHosted()) {
           // For non-hosted SVN repositories, we don't expect a local directory
           // to exist.
           return;
         }
         break;
     }
 
     $local = $this->getLocalPath();
     Filesystem::assertExists($local);
     Filesystem::assertIsDirectory($local);
     Filesystem::assertReadable($local);
   }
 
   /**
    * Determine if the working copy is bare or not. In Git, this corresponds
    * to `--bare`. In Mercurial, `--noupdate`.
    */
   public function isWorkingCopyBare() {
     switch ($this->getVersionControlSystem()) {
       case PhabricatorRepositoryType::REPOSITORY_TYPE_SVN:
       case PhabricatorRepositoryType::REPOSITORY_TYPE_MERCURIAL:
         return false;
       case PhabricatorRepositoryType::REPOSITORY_TYPE_GIT:
         $local = $this->getLocalPath();
         if (Filesystem::pathExists($local.'/.git')) {
           return false;
         } else {
           return true;
         }
     }
   }
 
+  public function usesLocalWorkingCopy() {
+    switch ($this->getVersionControlSystem()) {
+      case PhabricatorRepositoryType::REPOSITORY_TYPE_SVN:
+        return $this->isHosted();
+      case PhabricatorRepositoryType::REPOSITORY_TYPE_GIT:
+      case PhabricatorRepositoryType::REPOSITORY_TYPE_MERCURIAL:
+        return true;
+    }
+  }
+
 
 /* -(  PhabricatorPolicyInterface  )----------------------------------------- */
 
 
   public function getCapabilities() {
     return array(
       PhabricatorPolicyCapability::CAN_VIEW,
       PhabricatorPolicyCapability::CAN_EDIT,
       DiffusionCapabilityPush::CAPABILITY,
     );
   }
 
   public function getPolicy($capability) {
     switch ($capability) {
       case PhabricatorPolicyCapability::CAN_VIEW:
         return $this->getViewPolicy();
       case PhabricatorPolicyCapability::CAN_EDIT:
         return $this->getEditPolicy();
       case DiffusionCapabilityPush::CAPABILITY:
         return $this->getPushPolicy();
     }
   }
 
   public function hasAutomaticCapability($capability, PhabricatorUser $user) {
     return false;
   }
 
   public function describeAutomaticCapability($capability) {
     return null;
   }
 
 
 
 /* -(  PhabricatorMarkupInterface  )----------------------------------------- */
 
 
   public function getMarkupFieldKey($field) {
     $hash = PhabricatorHash::digestForIndex($this->getMarkupText($field));
     return "repo:{$hash}";
   }
 
   public function newMarkupEngine($field) {
     return PhabricatorMarkupEngine::newMarkupEngine(array());
   }
 
   public function getMarkupText($field) {
     return $this->getDetail('description');
   }
 
   public function didMarkupText(
     $field,
     $output,
     PhutilMarkupEngine $engine) {
     require_celerity_resource('phabricator-remarkup-css');
     return phutil_tag(
       'div',
       array(
         'class' => 'phabricator-remarkup',
       ),
       $output);
   }
 
   public function shouldUseMarkupCache($field) {
     return true;
   }
 
 }