diff --git a/src/future/exec/ExecFuture.php b/src/future/exec/ExecFuture.php
index e56376dd..48911930 100644
--- a/src/future/exec/ExecFuture.php
+++ b/src/future/exec/ExecFuture.php
@@ -1,969 +1,984 @@
 <?php
 
 /**
  * Execute system commands in parallel using futures.
  *
  * ExecFuture is a future, which means it runs asynchronously and represents
  * a value which may not exist yet. See @{article:Using Futures} for an
  * explanation of futures. When an ExecFuture resolves, it returns the exit
  * code, stdout and stderr of the process it executed.
  *
  * ExecFuture is the core command execution implementation in libphutil, but is
  * exposed through a number of APIs. See @{article:Command Execution} for more
  * discussion about executing system commands.
  *
  * @task create   Creating ExecFutures
  * @task resolve  Resolving Execution
  * @task config   Configuring Execution
  * @task info     Command Information
  * @task interact Interacting With Commands
  * @task internal Internals
  */
 final class ExecFuture extends PhutilExecutableFuture {
 
   private $pipes        = array();
   private $proc         = null;
   private $start        = null;
   private $procStatus   = null;
 
   private $stdout       = null;
   private $stderr       = null;
   private $stdin        = null;
   private $closePipe    = true;
 
   private $stdoutPos    = 0;
   private $stderrPos    = 0;
 
   private $readBufferSize;
   private $stdoutSizeLimit = PHP_INT_MAX;
   private $stderrSizeLimit = PHP_INT_MAX;
 
   private $profilerCallID;
   private $killedByTimeout;
 
   private $windowsStdoutTempFile = null;
   private $windowsStderrTempFile = null;
 
   private $terminateTimeout;
   private $didTerminate;
   private $killTimeout;
 
   private static $descriptorSpec = array(
     0 => array('pipe', 'r'),  // stdin
     1 => array('pipe', 'w'),  // stdout
     2 => array('pipe', 'w'),  // stderr
   );
 
   protected function didConstruct() {
     $this->stdin = new PhutilRope();
   }
 
 /* -(  Command Information  )------------------------------------------------ */
 
 
   /**
    * Retrieve the byte limit for the stderr buffer.
    *
    * @return int Maximum buffer size, in bytes.
    * @task info
    */
   public function getStderrSizeLimit() {
     return $this->stderrSizeLimit;
   }
 
 
   /**
    * Retrieve the byte limit for the stdout buffer.
    *
    * @return int Maximum buffer size, in bytes.
    * @task info
    */
   public function getStdoutSizeLimit() {
     return $this->stdoutSizeLimit;
   }
 
 
   /**
    * Get the process's pid. This only works after execution is initiated, e.g.
    * by a call to start().
    *
    * @return int Process ID of the executing process.
    * @task info
    */
   public function getPID() {
     $status = $this->procGetStatus();
     return $status['pid'];
   }
 
 
 /* -(  Configuring Execution  )---------------------------------------------- */
 
 
   /**
    * Set a maximum size for the stdout read buffer. To limit stderr, see
    * @{method:setStderrSizeLimit}. The major use of these methods is to use less
    * memory if you are running a command which sometimes produces huge volumes
    * of output that you don't really care about.
    *
    * NOTE: Setting this to 0 means "no buffer", not "unlimited buffer".
    *
    * @param int Maximum size of the stdout read buffer.
    * @return this
    * @task config
    */
   public function setStdoutSizeLimit($limit) {
     $this->stdoutSizeLimit = $limit;
     return $this;
   }
 
 
   /**
    * Set a maximum size for the stderr read buffer.
    * See @{method:setStdoutSizeLimit} for discussion.
    *
    * @param int Maximum size of the stderr read buffer.
    * @return this
    * @task config
    */
   public function setStderrSizeLimit($limit) {
     $this->stderrSizeLimit = $limit;
     return $this;
   }
 
 
   /**
    * Set the maximum internal read buffer size this future. The future will
    * block reads once the internal stdout or stderr buffer exceeds this size.
    *
    * NOTE: If you @{method:resolve} a future with a read buffer limit, you may
    * block forever!
    *
    * TODO: We should probably release the read buffer limit during
    * @{method:resolve}, or otherwise detect this. For now, be careful.
    *
    * @param int|null Maximum buffer size, or `null` for unlimited.
    * @return this
    */
   public function setReadBufferSize($read_buffer_size) {
     $this->readBufferSize = $read_buffer_size;
     return $this;
   }
 
 
 /* -(  Interacting With Commands  )------------------------------------------ */
 
 
   /**
    * Read and return output from stdout and stderr, if any is available. This
    * method keeps a read cursor on each stream, but the entire streams are
    * still returned when the future resolves. You can call read() again after
    * resolving the future to retrieve only the parts of the streams you did not
    * previously read:
    *
    *   $future = new ExecFuture('...');
    *   // ...
    *   list($stdout) = $future->read(); // Returns output so far
    *   list($stdout) = $future->read(); // Returns new output since first call
    *   // ...
    *   list($stdout) = $future->resolvex(); // Returns ALL output
    *   list($stdout) = $future->read(); // Returns unread output
    *
    * NOTE: If you set a limit with @{method:setStdoutSizeLimit} or
    * @{method:setStderrSizeLimit}, this method will not be able to read data
    * past the limit.
    *
    * NOTE: If you call @{method:discardBuffers}, all the stdout/stderr data
    * will be thrown away and the cursors will be reset.
    *
    * @return pair <$stdout, $stderr> pair with new output since the last call
    *              to this method.
    * @task interact
    */
   public function read() {
     $stdout = $this->readStdout();
 
     $result = array(
       $stdout,
       (string)substr($this->stderr, $this->stderrPos),
     );
 
     $this->stderrPos = strlen($this->stderr);
 
     return $result;
   }
 
   public function readStdout() {
     if ($this->start) {
       $this->isReady(); // Sync
     }
 
     $result = (string)substr($this->stdout, $this->stdoutPos);
     $this->stdoutPos = strlen($this->stdout);
     return $result;
   }
 
 
   /**
    * Write data to stdin of the command.
    *
    * @param string Data to write.
    * @param bool If true, keep the pipe open for writing. By default, the pipe
    *             will be closed as soon as possible so that commands which
    *             listen for EOF will execute. If you want to keep the pipe open
    *             past the start of command execution, do an empty write with
    *             `$keep_pipe = true` first.
    * @return this
    * @task interact
    */
   public function write($data, $keep_pipe = false) {
     if (strlen($data)) {
       if (!$this->stdin) {
         throw new Exception(pht('Writing to a closed pipe!'));
       }
       $this->stdin->append($data);
     }
     $this->closePipe = !$keep_pipe;
 
     return $this;
   }
 
 
   /**
    * Permanently discard the stdout and stderr buffers and reset the read
    * cursors. This is basically useful only if you are streaming a large amount
    * of data from some process.
    *
    * Conceivably you might also need to do this if you're writing a client using
    * @{class:ExecFuture} and `netcat`, but you probably should not do that.
    *
    * NOTE: This completely discards the data. It won't be available when the
    * future resolves. This is almost certainly only useful if you need the
    * buffer memory for some reason.
    *
    * @return this
    * @task interact
    */
   public function discardBuffers() {
     $this->discardStdoutBuffer();
 
     $this->stderr = '';
     $this->stderrPos = 0;
 
     return $this;
   }
 
   public function discardStdoutBuffer() {
     $this->stdout = '';
     $this->stdoutPos = 0;
     return $this;
   }
 
 
   /**
    * Returns true if this future was killed by a timeout configured with
    * @{method:setTimeout}.
    *
    * @return bool True if the future was killed for exceeding its time limit.
    */
   public function getWasKilledByTimeout() {
     return $this->killedByTimeout;
   }
 
 
 /* -(  Configuring Execution  )---------------------------------------------- */
 
 
   /**
    * Set a hard limit on execution time. If the command runs longer, it will
    * be terminated and the future will resolve with an error code. You can test
    * if a future was killed by a timeout with @{method:getWasKilledByTimeout}.
    *
    * The subprocess will be sent a `TERM` signal, and then a `KILL` signal a
    * short while later if it fails to exit.
    *
    * @param int Maximum number of seconds this command may execute for before
    *  it is signaled.
    * @return this
    * @task config
    */
   public function setTimeout($seconds) {
     $this->terminateTimeout = $seconds;
     $this->killTimeout = $seconds + min($seconds, 60);
     return $this;
   }
 
 
 /* -(  Resolving Execution  )------------------------------------------------ */
 
 
   /**
    * Resolve a command you expect to exit with return code 0. Works like
    * @{method:resolve}, but throws if $err is nonempty. Returns only
    * $stdout and $stderr. See also @{function:execx}.
    *
    *   list($stdout, $stderr) = $future->resolvex();
    *
    * @param  float Optional timeout after which resolution will pause and
    *               execution will return to the caller.
    * @return pair  <$stdout, $stderr> pair.
    * @task resolve
    */
   public function resolvex() {
-    list($err, $stdout, $stderr) = $this->resolve();
-    if ($err) {
-      $cmd = $this->getCommand();
-
-      if ($this->getWasKilledByTimeout()) {
-        // NOTE: The timeout can be a float and PhutilNumber only handles
-        // integers, so just use "%s" to render it.
-        $message = pht(
-          'Command killed by timeout after running for more than %s seconds.',
-          $this->terminateTimeout);
-      } else {
-        $message = pht('Command failed with error #%d!', $err);
-      }
-
-      throw new CommandException(
-        $message,
-        $cmd,
-        $err,
-        $stdout,
-        $stderr);
-    }
-    return array($stdout, $stderr);
+    $result = $this->resolve();
+    return $this->raiseResultError($result);
   }
 
-
   /**
    * Resolve a command you expect to return valid JSON. Works like
    * @{method:resolvex}, but also throws if stderr is nonempty, or stdout is not
    * valid JSON. Returns a PHP array, decoded from the JSON command output.
    *
    * @param  float Optional timeout after which resolution will pause and
    *               execution will return to the caller.
    * @return array PHP array, decoded from JSON command output.
    * @task resolve
    */
   public function resolveJSON() {
     list($stdout, $stderr) = $this->resolvex();
     if (strlen($stderr)) {
       $cmd = $this->getCommand();
       throw new CommandException(
         pht(
           "JSON command '%s' emitted text to stderr when none was expected: %d",
           $cmd,
           $stderr),
         $cmd,
         0,
         $stdout,
         $stderr);
     }
     try {
       return phutil_json_decode($stdout);
     } catch (PhutilJSONParserException $ex) {
       $cmd = $this->getCommand();
       throw new CommandException(
         pht(
           "JSON command '%s' did not produce a valid JSON object on stdout: %s",
           $cmd,
           $stdout),
         $cmd,
         0,
         $stdout,
         $stderr);
     }
   }
 
   /**
    * Resolve the process by abruptly terminating it.
    *
    * @return list List of <err, stdout, stderr> results.
    * @task resolve
    */
   public function resolveKill() {
     if (!$this->hasResult()) {
       $signal = 9;
 
       if ($this->proc) {
         proc_terminate($this->proc, $signal);
       }
 
+      $this->closeProcess();
+
       $result = array(
         128 + $signal,
         $this->stdout,
         $this->stderr,
       );
 
-      $this->setResult($result);
-
-      $this->closeProcess();
+      $this->recordResult($result);
     }
 
     return $this->getResult();
   }
 
+  private function recordResult(array $result) {
+    $resolve_on_error = $this->getResolveOnError();
+    if (!$resolve_on_error) {
+      $result = $this->raiseResultError($result);
+    }
+
+    $this->setResult($result);
+  }
+
+  private function raiseResultError($result) {
+    list($err, $stdout, $stderr) = $result;
+
+    if ($err) {
+      $cmd = $this->getCommand();
+
+      if ($this->getWasKilledByTimeout()) {
+        // NOTE: The timeout can be a float and PhutilNumber only handles
+        // integers, so just use "%s" to render it.
+        $message = pht(
+          'Command killed by timeout after running for more than %s seconds.',
+          $this->terminateTimeout);
+      } else {
+        $message = pht('Command failed with error #%d!', $err);
+      }
+
+      throw new CommandException(
+        $message,
+        $cmd,
+        $err,
+        $stdout,
+        $stderr);
+    }
+
+    return array($stdout, $stderr);
+  }
+
 
 /* -(  Internals  )---------------------------------------------------------- */
 
 
   /**
    * Provides read sockets to the future core.
    *
    * @return list List of read sockets.
    * @task internal
    */
   public function getReadSockets() {
     list($stdin, $stdout, $stderr) = $this->pipes;
     $sockets = array();
     if (isset($stdout) && !feof($stdout)) {
       $sockets[] = $stdout;
     }
     if (isset($stderr) && !feof($stderr)) {
       $sockets[] = $stderr;
     }
     return $sockets;
   }
 
 
   /**
    * Provides write sockets to the future core.
    *
    * @return list List of write sockets.
    * @task internal
    */
   public function getWriteSockets() {
     list($stdin, $stdout, $stderr) = $this->pipes;
     $sockets = array();
     if (isset($stdin) && $this->stdin->getByteLength() && !feof($stdin)) {
       $sockets[] = $stdin;
     }
     return $sockets;
   }
 
 
   /**
    * Determine if the read buffer is empty.
    *
    * @return bool True if the read buffer is empty.
    * @task internal
    */
   public function isReadBufferEmpty() {
     return !strlen($this->stdout);
   }
 
 
   /**
    * Determine if the write buffer is empty.
    *
    * @return bool True if the write buffer is empty.
    * @task internal
    */
   public function isWriteBufferEmpty() {
     return !$this->getWriteBufferSize();
   }
 
 
   /**
    * Determine the number of bytes in the write buffer.
    *
    * @return int Number of bytes in the write buffer.
    * @task internal
    */
   public function getWriteBufferSize() {
     if (!$this->stdin) {
       return 0;
     }
     return $this->stdin->getByteLength();
   }
 
 
   /**
    * Reads some bytes from a stream, discarding output once a certain amount
    * has been accumulated.
    *
    * @param resource  Stream to read from.
    * @param int       Maximum number of bytes to return from $stream. If
    *                  additional bytes are available, they will be read and
    *                  discarded.
    * @param string    Human-readable description of stream, for exception
    *                  message.
    * @param int       Maximum number of bytes to read.
    * @return string   The data read from the stream.
    * @task internal
    */
   private function readAndDiscard($stream, $limit, $description, $length) {
     $output = '';
 
     if ($length <= 0) {
       return '';
     }
 
     do {
       $data = fread($stream, min($length, 64 * 1024));
       if (false === $data) {
         throw new Exception(pht('Failed to read from %s', $description));
       }
 
       $read_bytes = strlen($data);
 
       if ($read_bytes > 0 && $limit > 0) {
         if ($read_bytes > $limit) {
           $data = substr($data, 0, $limit);
         }
         $output .= $data;
         $limit -= strlen($data);
       }
 
       if (strlen($output) >= $length) {
         break;
       }
     } while ($read_bytes > 0);
 
     return $output;
   }
 
 
   /**
    * Begin or continue command execution.
    *
    * @return bool True if future has resolved.
    * @task internal
    */
   public function isReady() {
     // NOTE: We have a soft dependencies on PhutilErrorTrap here, to avoid
     // the need to build it into the Phage agent. Under normal circumstances,
     // this class are always available.
 
     if (!$this->pipes) {
       $is_windows = phutil_is_windows();
 
       if (!$this->start) {
         // We might already have started the timer via initiating resolution.
         $this->start = microtime(true);
       }
 
       $unmasked_command = $this->getCommand();
       $unmasked_command = $unmasked_command->getUnmaskedString();
 
       $pipes = array();
 
       if ($this->hasEnv()) {
         $env = $this->getEnv();
       } else {
         $env = null;
       }
 
       $cwd = $this->getCWD();
 
       // NOTE: See note above about Phage.
       if (class_exists('PhutilErrorTrap')) {
         $trap = new PhutilErrorTrap();
       } else {
         $trap = null;
       }
 
       $spec = self::$descriptorSpec;
       if ($is_windows) {
         $stdout_file = new TempFile();
         $stderr_file = new TempFile();
 
         $stdout_handle = fopen($stdout_file, 'wb');
         if (!$stdout_handle) {
           throw new Exception(
             pht(
               'Unable to open stdout temporary file ("%s") for writing.',
               $stdout_file));
         }
 
         $stderr_handle = fopen($stderr_file, 'wb');
         if (!$stderr_handle) {
           throw new Exception(
             pht(
               'Unable to open stderr temporary file ("%s") for writing.',
               $stderr_file));
         }
 
         $spec = array(
           0 => self::$descriptorSpec[0],
           1 => $stdout_handle,
           2 => $stderr_handle,
         );
       }
 
       $proc = @proc_open(
         $unmasked_command,
         $spec,
         $pipes,
         $cwd,
         $env,
         array(
           'bypass_shell' => true,
         ));
 
       if ($trap) {
         $err = $trap->getErrorsAsString();
         $trap->destroy();
       } else {
         $err = error_get_last();
         if ($err) {
           $err = $err['message'];
         }
       }
 
       if ($is_windows) {
         fclose($stdout_handle);
         fclose($stderr_handle);
       }
 
       if (!is_resource($proc)) {
         // When you run an invalid command on a Linux system, the "proc_open()"
         // works and then the process (really a "/bin/sh -c ...") exits after
         // it fails to resolve the command.
 
         // When you run an invalid command on a Windows system, we bypass the
         // shell and the "proc_open()" itself fails. See also T13504. Fail the
         // future immediately, acting as though it exited with an error code
         // for consistency with Linux.
 
         $result = array(
           1,
           '',
           pht(
             'Call to "proc_open()" to open a subprocess failed: %s',
             $err),
         );
 
-        $this->setResult($result);
+        $this->recordResult($result);
 
         return true;
       }
 
       if ($is_windows) {
         $stdout_handle = fopen($stdout_file, 'rb');
         if (!$stdout_handle) {
           throw new Exception(
             pht(
               'Unable to open stdout temporary file ("%s") for reading.',
               $stdout_file));
         }
 
         $stderr_handle = fopen($stderr_file, 'rb');
         if (!$stderr_handle) {
           throw new Exception(
             pht(
               'Unable to open stderr temporary file ("%s") for reading.',
               $stderr_file));
         }
 
         $pipes = array(
           0 => $pipes[0],
           1 => $stdout_handle,
           2 => $stderr_handle,
         );
 
         $this->windowsStdoutTempFile = $stdout_file;
         $this->windowsStderrTempFile = $stderr_file;
       }
 
       $this->pipes = $pipes;
       $this->proc  = $proc;
 
       list($stdin, $stdout, $stderr) = $pipes;
 
       if (!$is_windows) {
 
         // On Windows, we redirect process standard output and standard error
         // through temporary files. Files don't block, so we don't need to make
         // these streams nonblocking.
 
         if ((!stream_set_blocking($stdout, false)) ||
             (!stream_set_blocking($stderr, false)) ||
             (!stream_set_blocking($stdin,  false))) {
           $this->__destruct();
           throw new Exception(pht('Failed to set streams nonblocking.'));
         }
       }
 
       $this->tryToCloseStdin();
 
       return false;
     }
 
     if (!$this->proc) {
       return true;
     }
 
     list($stdin, $stdout, $stderr) = $this->pipes;
 
     while (isset($this->stdin) && $this->stdin->getByteLength()) {
       $write_segment = $this->stdin->getAnyPrefix();
 
       $bytes = fwrite($stdin, $write_segment);
       if ($bytes === false) {
         throw new Exception(pht('Unable to write to stdin!'));
       } else if ($bytes) {
         $this->stdin->removeBytesFromHead($bytes);
       } else {
         // Writes are blocked for now.
         break;
       }
     }
 
     $this->tryToCloseStdin();
 
     // Read status before reading pipes so that we can never miss data that
     // arrives between our last read and the process exiting.
     $status = $this->procGetStatus();
 
     $read_buffer_size = $this->readBufferSize;
 
     $max_stdout_read_bytes = PHP_INT_MAX;
     $max_stderr_read_bytes = PHP_INT_MAX;
     if ($read_buffer_size !== null) {
       $max_stdout_read_bytes = $read_buffer_size - strlen($this->stdout);
       $max_stderr_read_bytes = $read_buffer_size - strlen($this->stderr);
     }
 
     if ($max_stdout_read_bytes > 0) {
       $this->stdout .= $this->readAndDiscard(
         $stdout,
         $this->getStdoutSizeLimit() - strlen($this->stdout),
         'stdout',
         $max_stdout_read_bytes);
     }
 
     if ($max_stderr_read_bytes > 0) {
       $this->stderr .= $this->readAndDiscard(
         $stderr,
         $this->getStderrSizeLimit() - strlen($this->stderr),
         'stderr',
         $max_stderr_read_bytes);
     }
 
     $is_done = false;
     if (!$status['running']) {
       // We may still have unread bytes on stdout or stderr, particularly if
       // this future is being buffered and streamed. If we do, we don't want to
       // consider the subprocess to have exited until we've read everything.
       // See T9724 for context.
       if (feof($stdout) && feof($stderr)) {
         $is_done = true;
       }
     }
 
     if ($is_done) {
       $signal_info = null;
 
       // If the subprocess got nuked with `kill -9`, we get a -1 exitcode.
       // Upgrade this to a slightly more informative value by examining the
       // terminating signal code.
       $err = $status['exitcode'];
       if ($err == -1) {
         if ($status['signaled']) {
           $signo = $status['termsig'];
 
           $err = 128 + $signo;
 
           $signal_info = pht(
             "<Process was terminated by signal %s (%d).>\n\n",
             phutil_get_signal_name($signo),
             $signo);
         }
       }
 
       $result = array(
         $err,
         $this->stdout,
         $signal_info.$this->stderr,
       );
 
-      $this->setResult($result);
+      $this->recordResult($result);
 
       $this->closeProcess();
       return true;
     }
 
     $elapsed = (microtime(true) - $this->start);
 
     if ($this->terminateTimeout && ($elapsed >= $this->terminateTimeout)) {
       if (!$this->didTerminate) {
         $this->killedByTimeout = true;
         $this->sendTerminateSignal();
         return false;
       }
     }
 
     if ($this->killTimeout && ($elapsed >= $this->killTimeout)) {
       $this->killedByTimeout = true;
       $this->resolveKill();
       return true;
     }
 
   }
 
 
   /**
    * @return void
    * @task internal
    */
   public function __destruct() {
     if (!$this->proc) {
       return;
     }
 
     // NOTE: If we try to proc_close() an open process, we hang indefinitely. To
     // avoid this, kill the process explicitly if it's still running.
 
     $status = $this->procGetStatus();
     if ($status['running']) {
       $this->sendTerminateSignal();
       if (!$this->waitForExit(5)) {
         $this->resolveKill();
       }
     } else {
       $this->closeProcess();
     }
   }
 
 
   /**
    * Close and free resources if necessary.
    *
    * @return void
    * @task internal
    */
   private function closeProcess() {
     foreach ($this->pipes as $pipe) {
       if (isset($pipe)) {
         @fclose($pipe);
       }
     }
     $this->pipes = array(null, null, null);
     if ($this->proc) {
       @proc_close($this->proc);
       $this->proc = null;
     }
     $this->stdin = null;
 
     unset($this->windowsStdoutTempFile);
     unset($this->windowsStderrTempFile);
   }
 
 
   /**
    * Execute `proc_get_status()`, but avoid pitfalls.
    *
    * @return dict Process status.
    * @task internal
    */
   private function procGetStatus() {
     // After the process exits, we only get one chance to read proc_get_status()
     // before it starts returning garbage. Make sure we don't throw away the
     // last good read.
     if ($this->procStatus) {
       if (!$this->procStatus['running']) {
         return $this->procStatus;
       }
     }
     $this->procStatus = proc_get_status($this->proc);
 
     return $this->procStatus;
   }
 
   /**
    * Try to close stdin, if we're done using it. This keeps us from hanging if
    * the process on the other end of the pipe is waiting for EOF.
    *
    * @return void
    * @task internal
    */
   private function tryToCloseStdin() {
     if (!$this->closePipe) {
       // We've been told to keep the pipe open by a call to write(..., true).
       return;
     }
 
     if ($this->stdin->getByteLength()) {
       // We still have bytes to write.
       return;
     }
 
     list($stdin) = $this->pipes;
     if (!$stdin) {
       // We've already closed stdin.
       return;
     }
 
     // There's nothing stopping us from closing stdin, so close it.
 
     @fclose($stdin);
     $this->pipes[0] = null;
   }
 
   public function getDefaultWait() {
     $wait = parent::getDefaultWait();
 
     $next_timeout = $this->getNextTimeout();
     if ($next_timeout) {
       if (!$this->start) {
         $this->start = microtime(true);
       }
       $elapsed = (microtime(true) - $this->start);
       $wait = max(0, min($next_timeout - $elapsed, $wait));
     }
 
     return $wait;
   }
 
   private function getNextTimeout() {
     if ($this->didTerminate) {
       return $this->killTimeout;
     } else {
       return $this->terminateTimeout;
     }
   }
 
   private function sendTerminateSignal() {
     $this->didTerminate = true;
     proc_terminate($this->proc);
     return $this;
   }
 
   private function waitForExit($duration) {
     $start = microtime(true);
 
     while (true) {
       $status = $this->procGetStatus();
       if (!$status['running']) {
         return true;
       }
 
       $waited = (microtime(true) - $start);
       if ($waited > $duration) {
         return false;
       }
     }
   }
 
   protected function getServiceProfilerStartParameters() {
     return array(
       'type' => 'exec',
       'command' => phutil_string_cast($this->getCommand()),
     );
   }
 
   protected function getServiceProfilerResultParameters() {
     if ($this->hasResult()) {
       $result = $this->getResult();
       $err = idx($result, 0);
     } else {
       $err = null;
     }
 
     return array(
       'err' => $err,
     );
   }
 
 
 }
diff --git a/src/future/exec/PhutilExecutableFuture.php b/src/future/exec/PhutilExecutableFuture.php
index 3038032c..663ce567 100644
--- a/src/future/exec/PhutilExecutableFuture.php
+++ b/src/future/exec/PhutilExecutableFuture.php
@@ -1,221 +1,231 @@
 <?php
 
 /**
  * @task config Configuring the Command
  */
 abstract class PhutilExecutableFuture extends Future {
 
   private $command;
   private $env;
   private $cwd;
+  private $resolveOnError = true;
 
   final public function __construct($pattern /* , ... */) {
     $args = func_get_args();
 
     if ($pattern instanceof PhutilCommandString) {
       if (count($args) !== 1) {
         throw new Exception(
           pht(
             'Command (of class "%s") was constructed with a '.
             '"PhutilCommandString", but also passed arguments. '.
             'When using a preprebuilt command, you must not pass '.
             'arguments.',
             get_class($this)));
       }
       $this->command = $pattern;
     } else {
       $this->command = call_user_func_array('csprintf', $args);
     }
 
     $this->didConstruct();
   }
 
   protected function didConstruct() {
     return;
   }
 
+  final public function setResolveOnError($resolve_on_error) {
+    $this->resolveOnError = $resolve_on_error;
+    return $this;
+  }
+
+  final public function getResolveOnError() {
+    return $this->resolveOnError;
+  }
+
   final public function getCommand() {
     return $this->command;
   }
 
   /**
    * Set environmental variables for the command.
    *
    * By default, variables are added to the environment of this process. You
    * can optionally wipe the environment and pass only the specified values.
    *
    *   // Env will have "X" and current env ("PATH", etc.)
    *   $exec->setEnv(array('X' => 'y'));
    *
    *   // Env will have ONLY "X".
    *   $exec->setEnv(array('X' => 'y'), $wipe_process_env = true);
    *
    * @param map<string, string> Dictionary of environmental variables.
    * @param bool Optionally, pass `true` to replace the existing environment.
    * @return this
    *
    * @task config
    */
   final public function setEnv(array $env, $wipe_process_env = false) {
     // Force values to strings here. The underlying PHP commands get upset if
     // they are handed non-string values as environmental variables.
     foreach ($env as $key => $value) {
       $env[$key] = (string)$value;
     }
 
     if (!$wipe_process_env) {
       $env = $env + $this->getEnv();
     }
 
     $this->env = $env;
 
     return $this;
   }
 
 
   /**
    * Set the value of a specific environmental variable for this command.
    *
    * @param string Environmental variable name.
    * @param string|null New value, or null to remove this variable.
    * @return this
    * @task config
    */
   final public function updateEnv($key, $value) {
     $env = $this->getEnv();
 
     if ($value === null) {
       unset($env[$key]);
     } else {
       $env[$key] = (string)$value;
     }
 
     $this->env = $env;
 
     return $this;
   }
 
 
   /**
    * Returns `true` if this command has a configured environment.
    *
    * @return bool True if this command has an environment.
    * @task config
    */
   final public function hasEnv() {
     return ($this->env !== null);
   }
 
 
   /**
    * Get the configured environment.
    *
    * @return map<string, string> Effective environment for this command.
    * @task config
    */
   final public function getEnv() {
     if (!$this->hasEnv()) {
       $default_env = $_ENV;
 
       // If `variables_order` does not include "E", the $_ENV superglobal
       // does not build and there's no apparent reasonable way for us to
       // rebuild it (we could perhaps parse the output of `export`).
 
       // For now, explicitly populate variables which we rely on and which
       // we know may exist. After T12071, we should be able to rely on
       // $_ENV and no longer need to do this.
 
       $known_keys = array(
         'PHABRICATOR_ENV',
         'PHABRICATOR_INSTANCE',
       );
 
       foreach ($known_keys as $known_key) {
         $value = getenv($known_key);
         if (strlen($value)) {
           $default_env[$known_key] = $value;
         }
       }
 
       $this->setEnv($default_env, $wipe_process_env = true);
     }
 
     return $this->env;
   }
 
 
   /**
    * Set the current working directory for the subprocess (that is, set where
    * the subprocess will execute). If not set, the default value is the parent's
    * current working directory.
    *
    * @param string Directory to execute the subprocess in.
    * @return this
    * @task config
    */
   final public function setCWD($cwd) {
     $cwd = phutil_string_cast($cwd);
 
     try {
       Filesystem::assertExists($cwd);
     } catch (FilesystemException $ex) {
       throw new PhutilProxyException(
         pht(
           'Unable to run a command in directory "%s".',
           $cwd),
         $ex);
     }
 
     if (!is_dir($cwd)) {
       throw new Exception(
         pht(
           'Preparing to run a command in directory "%s", but that path is '.
           'not a directory.',
           $cwd));
     }
 
     // Although you don't technically need read permission to "chdir()" into
     // a directory, it is almost certainly a mistake to execute a subprocess
     // in a CWD we can't read. Refuse to do this. If callers have some
     // exceptionally clever scheme up their sleeves they can always have the
     // subprocess "cd" or "chdir()" explicitly.
 
     if (!is_readable($cwd)) {
       throw new Exception(
         pht(
           'Preparing to run a command in directory "%s", but that directory '.
           'is not readable (the current process does not have "+r" '.
           'permission).',
           $cwd));
     }
 
 
     if (phutil_is_windows()) {
       // Do nothing. On Windows, calling "is_executable(...)" on a directory
       // always appears to return "false". Skip this check under Windows.
     } else if (!is_executable($cwd)) {
       throw new Exception(
         pht(
           'Preparing to run a command in directory "%s", but that directory '.
           'is not executable (the current process does not have "+x" '.
           'permission).',
           $cwd));
     }
 
     $this->cwd = $cwd;
 
     return $this;
   }
 
 
   /**
    * Get the command's current working directory.
    *
    * @return string Working directory.
    * @task config
    */
   final public function getCWD() {
     return $this->cwd;
   }
 
 }
diff --git a/src/repository/api/ArcanistRepositoryAPI.php b/src/repository/api/ArcanistRepositoryAPI.php
index e1b47507..5ac9be43 100644
--- a/src/repository/api/ArcanistRepositoryAPI.php
+++ b/src/repository/api/ArcanistRepositoryAPI.php
@@ -1,676 +1,682 @@
 <?php
 
 /**
  * Interfaces with the VCS in the working copy.
  *
  * @task  status      Path Status
  */
 abstract class ArcanistRepositoryAPI extends Phobject {
 
   const FLAG_MODIFIED     = 1;
   const FLAG_ADDED        = 2;
   const FLAG_DELETED      = 4;
   const FLAG_UNTRACKED    = 8;
   const FLAG_CONFLICT     = 16;
   const FLAG_MISSING      = 32;
   const FLAG_UNSTAGED     = 64;
   const FLAG_UNCOMMITTED  = 128;
 
   // Occurs in SVN when you have uncommitted changes to a modified external,
   // or in Git when you have uncommitted or untracked changes in a submodule.
   const FLAG_EXTERNALS    = 256;
 
   // Occurs in SVN when you replace a file with a directory without telling
   // SVN about it.
   const FLAG_OBSTRUCTED   = 512;
 
   // Occurs in SVN when an update was interrupted or failed, e.g. you ^C'd it.
   const FLAG_INCOMPLETE   = 1024;
 
   protected $path;
   protected $diffLinesOfContext = 0x7FFF;
   private $baseCommitExplanation = '???';
   private $configurationManager;
   private $baseCommitArgumentRules;
 
   private $uncommittedStatusCache;
   private $commitRangeStatusCache;
 
   private $symbolicBaseCommit;
   private $resolvedBaseCommit;
 
   abstract public function getSourceControlSystemName();
 
   public function getDiffLinesOfContext() {
     return $this->diffLinesOfContext;
   }
 
   public function setDiffLinesOfContext($lines) {
     $this->diffLinesOfContext = $lines;
     return $this;
   }
 
   public function getWorkingCopyIdentity() {
     return $this->configurationManager->getWorkingCopyIdentity();
   }
 
   public function getConfigurationManager() {
     return $this->configurationManager;
   }
 
   public static function newAPIFromConfigurationManager(
     ArcanistConfigurationManager $configuration_manager) {
 
     $working_copy = $configuration_manager->getWorkingCopyIdentity();
 
     if (!$working_copy) {
       throw new Exception(
         pht(
           'Trying to create a %s without a working copy!',
           __CLASS__));
     }
 
     $root = $working_copy->getProjectRoot();
     switch ($working_copy->getVCSType()) {
       case 'svn':
         $api = new ArcanistSubversionAPI($root);
         break;
       case 'hg':
         $api = new ArcanistMercurialAPI($root);
         break;
       case 'git':
         $api = new ArcanistGitAPI($root);
         break;
       default:
         throw new Exception(
           pht(
             'The current working directory is not part of a working copy for '.
             'a supported version control system (Git, Subversion or '.
             'Mercurial).'));
     }
 
     $api->configurationManager = $configuration_manager;
     return $api;
   }
 
   public function __construct($path) {
     $this->path = $path;
   }
 
   public function getPath($to_file = null) {
     if ($to_file !== null) {
       return $this->path.DIRECTORY_SEPARATOR.
              ltrim($to_file, DIRECTORY_SEPARATOR);
     } else {
       return $this->path.DIRECTORY_SEPARATOR;
     }
   }
 
 
 /* -(  Path Status  )-------------------------------------------------------- */
 
 
   abstract protected function buildUncommittedStatus();
   abstract protected function buildCommitRangeStatus();
 
 
   /**
    * Get a list of uncommitted paths in the working copy that have been changed
    * or are affected by other status effects, like conflicts or untracked
    * files.
    *
    * Convenience methods @{method:getUntrackedChanges},
    * @{method:getUnstagedChanges}, @{method:getUncommittedChanges},
    * @{method:getMergeConflicts}, and @{method:getIncompleteChanges} allow
    * simpler selection of paths in a specific state.
    *
    * This method returns a map of paths to bitmasks with status, using
    * `FLAG_` constants. For example:
    *
    *   array(
    *     'some/uncommitted/file.txt' => ArcanistRepositoryAPI::FLAG_UNSTAGED,
    *   );
    *
    * A file may be in several states. Not all states are possible with all
    * version control systems.
    *
    * @return map<string, bitmask> Map of paths, see above.
    * @task status
    */
   final public function getUncommittedStatus() {
     if ($this->uncommittedStatusCache === null) {
       $status = $this->buildUncommittedStatus();
       ksort($status);
       $this->uncommittedStatusCache = $status;
     }
     return $this->uncommittedStatusCache;
   }
 
 
   /**
    * @task status
    */
   final public function getUntrackedChanges() {
     return $this->getUncommittedPathsWithMask(self::FLAG_UNTRACKED);
   }
 
 
   /**
    * @task status
    */
   final public function getUnstagedChanges() {
     return $this->getUncommittedPathsWithMask(self::FLAG_UNSTAGED);
   }
 
 
   /**
    * @task status
    */
   final public function getUncommittedChanges() {
     return $this->getUncommittedPathsWithMask(self::FLAG_UNCOMMITTED);
   }
 
 
   /**
    * @task status
    */
   final public function getMergeConflicts() {
     return $this->getUncommittedPathsWithMask(self::FLAG_CONFLICT);
   }
 
 
   /**
    * @task status
    */
   final public function getIncompleteChanges() {
     return $this->getUncommittedPathsWithMask(self::FLAG_INCOMPLETE);
   }
 
 
   /**
    * @task status
    */
   final public function getMissingChanges() {
     return $this->getUncommittedPathsWithMask(self::FLAG_MISSING);
   }
 
 
   /**
    * @task status
    */
   final public function getDirtyExternalChanges() {
     return $this->getUncommittedPathsWithMask(self::FLAG_EXTERNALS);
   }
 
 
   /**
    * @task status
    */
   private function getUncommittedPathsWithMask($mask) {
     $match = array();
     foreach ($this->getUncommittedStatus() as $path => $flags) {
       if ($flags & $mask) {
         $match[] = $path;
       }
     }
     return $match;
   }
 
 
   /**
    * Get a list of paths affected by the commits in the current commit range.
    *
    * See @{method:getUncommittedStatus} for a description of the return value.
    *
    * @return map<string, bitmask> Map from paths to status.
    * @task status
    */
   final public function getCommitRangeStatus() {
     if ($this->commitRangeStatusCache === null) {
       $status = $this->buildCommitRangeStatus();
       ksort($status);
       $this->commitRangeStatusCache = $status;
     }
     return $this->commitRangeStatusCache;
   }
 
 
   /**
    * Get a list of paths affected by commits in the current commit range, or
    * uncommitted changes in the working copy. See @{method:getUncommittedStatus}
    * or @{method:getCommitRangeStatus} to retrieve smaller parts of the status.
    *
    * See @{method:getUncommittedStatus} for a description of the return value.
    *
    * @return map<string, bitmask> Map from paths to status.
    * @task status
    */
   final public function getWorkingCopyStatus() {
     $range_status = $this->getCommitRangeStatus();
     $uncommitted_status = $this->getUncommittedStatus();
 
     $result = new PhutilArrayWithDefaultValue($range_status);
     foreach ($uncommitted_status as $path => $mask) {
       $result[$path] |= $mask;
     }
 
     $result = $result->toArray();
     ksort($result);
     return $result;
   }
 
 
   /**
    * Drops caches after changes to the working copy. By default, some queries
    * against the working copy are cached. They
    *
    * @return this
    * @task status
    */
   final public function reloadWorkingCopy() {
     $this->uncommittedStatusCache = null;
     $this->commitRangeStatusCache = null;
 
     $this->didReloadWorkingCopy();
     $this->reloadCommitRange();
 
     return $this;
   }
 
 
   /**
    * Hook for implementations to dirty working copy caches after the working
    * copy has been updated.
    *
    * @return void
    * @task status
    */
   protected function didReloadWorkingCopy() {
     return;
   }
 
 
   /**
    * Fetches the original file data for each path provided.
    *
    * @return map<string, string> Map from path to file data.
    */
   public function getBulkOriginalFileData($paths) {
     $filedata = array();
     foreach ($paths as $path) {
       $filedata[$path] = $this->getOriginalFileData($path);
     }
 
     return $filedata;
   }
 
   /**
    * Fetches the current file data for each path provided.
    *
    * @return map<string, string> Map from path to file data.
    */
   public function getBulkCurrentFileData($paths) {
     $filedata = array();
     foreach ($paths as $path) {
       $filedata[$path] = $this->getCurrentFileData($path);
     }
 
     return $filedata;
   }
 
   /**
    * @return Traversable
    */
   abstract public function getAllFiles();
 
   abstract public function getBlame($path);
 
   abstract public function getRawDiffText($path);
   abstract public function getOriginalFileData($path);
   abstract public function getCurrentFileData($path);
   abstract public function getLocalCommitInformation();
   abstract public function getSourceControlBaseRevision();
   abstract public function getCanonicalRevisionName($string);
   abstract public function getBranchName();
   abstract public function getSourceControlPath();
   abstract public function isHistoryDefaultImmutable();
   abstract public function supportsAmend();
   abstract public function getWorkingCopyRevision();
   abstract public function updateWorkingCopy();
   abstract public function getMetadataPath();
   abstract public function loadWorkingCopyDifferentialRevisions(
     ConduitClient $conduit,
     array $query);
   abstract public function getRemoteURI();
 
   public function getChangedFiles($since_commit) {
     throw new ArcanistCapabilityNotSupportedException($this);
   }
 
   public function getAuthor() {
     throw new ArcanistCapabilityNotSupportedException($this);
   }
 
   public function addToCommit(array $paths) {
     throw new ArcanistCapabilityNotSupportedException($this);
   }
 
   abstract public function supportsLocalCommits();
 
   public function doCommit($message) {
     throw new ArcanistCapabilityNotSupportedException($this);
   }
 
   public function amendCommit($message = null) {
     throw new ArcanistCapabilityNotSupportedException($this);
   }
 
   public function getAllBranches() {
     // TODO: Implement for Mercurial/SVN and make abstract.
     return array();
   }
 
   public function getAllBranchRefs() {
     throw new ArcanistCapabilityNotSupportedException($this);
   }
 
   public function getBaseCommitRef() {
     throw new ArcanistCapabilityNotSupportedException($this);
   }
 
   public function hasLocalCommit($commit) {
     throw new ArcanistCapabilityNotSupportedException($this);
   }
 
   public function getCommitMessage($commit) {
     throw new ArcanistCapabilityNotSupportedException($this);
   }
 
   public function getCommitSummary($commit) {
     throw new ArcanistCapabilityNotSupportedException($this);
   }
 
   public function getAllLocalChanges() {
     throw new ArcanistCapabilityNotSupportedException($this);
   }
 
   public function getFinalizedRevisionMessage() {
     throw new ArcanistCapabilityNotSupportedException($this);
   }
 
   public function execxLocal($pattern /* , ... */) {
     $args = func_get_args();
     return $this->buildLocalFuture($args)->resolvex();
   }
 
   public function execManualLocal($pattern /* , ... */) {
     $args = func_get_args();
     return $this->buildLocalFuture($args)->resolve();
   }
 
   public function execFutureLocal($pattern /* , ... */) {
     $args = func_get_args();
     return $this->buildLocalFuture($args);
   }
 
   abstract protected function buildLocalFuture(array $argv);
 
   public function canStashChanges() {
     return false;
   }
 
   public function stashChanges() {
     throw new ArcanistCapabilityNotSupportedException($this);
   }
 
   public function unstashChanges() {
     throw new ArcanistCapabilityNotSupportedException($this);
   }
 
 /* -(  Scratch Files  )------------------------------------------------------ */
 
 
   /**
    * Try to read a scratch file, if it exists and is readable.
    *
    * @param string Scratch file name.
    * @return mixed String for file contents, or false for failure.
    * @task scratch
    */
   public function readScratchFile($path) {
     $full_path = $this->getScratchFilePath($path);
     if (!$full_path) {
       return false;
     }
 
     if (!Filesystem::pathExists($full_path)) {
       return false;
     }
 
     try {
       $result = Filesystem::readFile($full_path);
     } catch (FilesystemException $ex) {
       return false;
     }
 
     return $result;
   }
 
 
   /**
    * Try to write a scratch file, if there's somewhere to put it and we can
    * write there.
    *
    * @param  string Scratch file name to write.
    * @param  string Data to write.
    * @return bool   True on success, false on failure.
    * @task scratch
    */
   public function writeScratchFile($path, $data) {
     $dir = $this->getScratchFilePath('');
     if (!$dir) {
       return false;
     }
 
     if (!Filesystem::pathExists($dir)) {
       try {
         Filesystem::createDirectory($dir);
       } catch (Exception $ex) {
         return false;
       }
     }
 
     try {
       Filesystem::writeFile($this->getScratchFilePath($path), $data);
     } catch (FilesystemException $ex) {
       return false;
     }
 
     return true;
   }
 
 
   /**
    * Try to remove a scratch file.
    *
    * @param   string  Scratch file name to remove.
    * @return  bool    True if the file was removed successfully.
    * @task scratch
    */
   public function removeScratchFile($path) {
     $full_path = $this->getScratchFilePath($path);
     if (!$full_path) {
       return false;
     }
 
     try {
       Filesystem::remove($full_path);
     } catch (FilesystemException $ex) {
       return false;
     }
 
     return true;
   }
 
 
   /**
    * Get a human-readable description of the scratch file location.
    *
    * @param string  Scratch file name.
    * @return mixed  String, or false on failure.
    * @task scratch
    */
   public function getReadableScratchFilePath($path) {
     $full_path = $this->getScratchFilePath($path);
     if ($full_path) {
       return Filesystem::readablePath(
         $full_path,
         $this->getPath());
     } else {
       return false;
     }
   }
 
 
   /**
    * Get the path to a scratch file, if possible.
    *
    * @param string  Scratch file name.
    * @return mixed  File path, or false on failure.
    * @task scratch
    */
   public function getScratchFilePath($path) {
     $new_scratch_path  = Filesystem::resolvePath(
       'arc',
       $this->getMetadataPath());
 
     static $checked = false;
     if (!$checked) {
       $checked = true;
       $old_scratch_path = $this->getPath('.arc');
       // we only want to do the migration once
       // unfortunately, people have checked in .arc directories which
       // means that the old one may get recreated after we delete it
       if (Filesystem::pathExists($old_scratch_path) &&
           !Filesystem::pathExists($new_scratch_path)) {
         Filesystem::createDirectory($new_scratch_path);
         $existing_files = Filesystem::listDirectory($old_scratch_path, true);
         foreach ($existing_files as $file) {
           $new_path = Filesystem::resolvePath($file, $new_scratch_path);
           $old_path = Filesystem::resolvePath($file, $old_scratch_path);
           Filesystem::writeFile(
             $new_path,
             Filesystem::readFile($old_path));
         }
         Filesystem::remove($old_scratch_path);
       }
     }
     return Filesystem::resolvePath($path, $new_scratch_path);
   }
 
 
 /* -(  Base Commits  )------------------------------------------------------- */
 
   abstract public function supportsCommitRanges();
 
   final public function setBaseCommit($symbolic_commit) {
     if (!$this->supportsCommitRanges()) {
       throw new ArcanistCapabilityNotSupportedException($this);
     }
 
     $this->symbolicBaseCommit = $symbolic_commit;
     $this->reloadCommitRange();
     return $this;
   }
 
   public function setHeadCommit($symbolic_commit) {
     throw new ArcanistCapabilityNotSupportedException($this);
   }
 
   final public function getBaseCommit() {
     if (!$this->supportsCommitRanges()) {
       throw new ArcanistCapabilityNotSupportedException($this);
     }
 
     if ($this->resolvedBaseCommit === null) {
       $commit = $this->buildBaseCommit($this->symbolicBaseCommit);
       $this->resolvedBaseCommit = $commit;
     }
 
     return $this->resolvedBaseCommit;
   }
 
   public function getHeadCommit() {
     throw new ArcanistCapabilityNotSupportedException($this);
   }
 
   final public function reloadCommitRange() {
     $this->resolvedBaseCommit = null;
     $this->baseCommitExplanation = null;
 
     $this->didReloadCommitRange();
 
     return $this;
   }
 
   protected function didReloadCommitRange() {
     return;
   }
 
   protected function buildBaseCommit($symbolic_commit) {
     throw new ArcanistCapabilityNotSupportedException($this);
   }
 
   public function getBaseCommitExplanation() {
     return $this->baseCommitExplanation;
   }
 
   public function setBaseCommitExplanation($explanation) {
     $this->baseCommitExplanation = $explanation;
     return $this;
   }
 
   public function resolveBaseCommitRule($rule, $source) {
     return null;
   }
 
   public function setBaseCommitArgumentRules($base_commit_argument_rules) {
     $this->baseCommitArgumentRules = $base_commit_argument_rules;
     return $this;
   }
 
   public function getBaseCommitArgumentRules() {
     return $this->baseCommitArgumentRules;
   }
 
   public function resolveBaseCommit() {
     $base_commit_rules = array(
       'runtime' => $this->getBaseCommitArgumentRules(),
       'local'   => '',
       'project' => '',
       'user'    => '',
       'system'  => '',
     );
     $all_sources = $this->configurationManager->getConfigFromAllSources('base');
 
     $base_commit_rules = $all_sources + $base_commit_rules;
 
     $parser = new ArcanistBaseCommitParser($this);
     $commit = $parser->resolveBaseCommit($base_commit_rules);
 
     return $commit;
   }
 
   public function getRepositoryUUID() {
     return null;
   }
 
   final public function newCommitRef() {
     return new ArcanistCommitRef();
   }
 
   final public function newBranchRef() {
     return new ArcanistBranchRef();
   }
 
+  final public function newFuture($pattern /* , ... */) {
+    $args = func_get_args();
+    return $this->buildLocalFuture($args)
+      ->setResolveOnError(false);
+  }
+
 }