diff --git a/runutil/sequence.go b/runutil/sequence.go
index 257c3fd..47fbf64 100644
--- a/runutil/sequence.go
+++ b/runutil/sequence.go
@@ -12,6 +12,7 @@
 	"os"
 	"path/filepath"
 	"runtime"
+	"sync"
 	"time"
 )
 
@@ -67,6 +68,7 @@
 	defaultStdin                 io.Reader
 	defaultStdout, defaultStderr io.Writer
 	dirs                         []string
+	verbosity                    *bool
 	timeout                      time.Duration
 }
 
@@ -117,6 +119,17 @@
 	return s
 }
 
+// Verbosity arranges for the next call to Run, Call or Last to use the specified
+// verbosity. This will be cleared and not used for any calls
+// to Run, Call or Last beyond the next one.
+func (s *Sequence) Verbose(verbosity bool) *Sequence {
+	if s.err != nil {
+		return s
+	}
+	s.verbosity = &verbosity
+	return s
+}
+
 // internal getOpts that doesn't override stdin, stdout, stderr
 func (s *Sequence) getOpts() Opts {
 	var opts Opts
@@ -143,16 +156,49 @@
 	s.opts = &opts
 }
 
+type wrappedError struct {
+	oe, we error
+}
+
+func (ie *wrappedError) Error() string {
+	return ie.we.Error()
+}
+
+// Error returns the error, if any, stored in the Sequence.
 func (s *Sequence) Error() error {
 	if s.err != nil && len(s.caller) > 0 {
-		// TODO(toddw): Wrapping the error here is bad, since some callers require
-		// the original error to be returned.  E.g. it's common to call os.Stat()
-		// and check against os.IsNotExist, which breaks with wrapped errors.
-		return fmt.Errorf("%s: %v", s.caller, s.err)
+		return &wrappedError{oe: s.err, we: fmt.Errorf("%s: %v", s.caller, s.err)}
 	}
 	return s.err
 }
 
+// IsExist returns a boolean indicating whether the error is known
+// to report that a file or directory already exists.
+func IsExist(err error) bool {
+	if we, ok := err.(*wrappedError); ok {
+		return os.IsExist(we.oe)
+	}
+	return os.IsExist(err)
+}
+
+// IsNotExist returns a boolean indicating whether the error is known
+// to report that a file or directory does not exist.
+func IsNotExist(err error) bool {
+	if we, ok := err.(*wrappedError); ok {
+		return os.IsNotExist(we.oe)
+	}
+	return os.IsNotExist(err)
+}
+
+// IsPermission returns a boolean indicating whether the error is known
+// to report that permission is denied.
+func IsPermission(err error) bool {
+	if we, ok := err.(*wrappedError); ok {
+		return os.IsPermission(we.oe)
+	}
+	return os.IsPermission(err)
+}
+
 func fmtError(depth int, err error, detail string) string {
 	_, file, line, _ := runtime.Caller(depth + 1)
 	return fmt.Sprintf("%s:%d: %s", filepath.Base(file), line, detail)
@@ -167,7 +213,8 @@
 }
 
 func (s *Sequence) reset() {
-	s.stdin, s.stdout, s.stderr, s.env, s.opts = nil, nil, nil, nil, nil
+	s.stdin, s.stdout, s.stderr, s.env = nil, nil, nil, nil
+	s.opts, s.verbosity = nil, nil
 	s.reading = false
 	s.timeout = 0
 }
@@ -206,6 +253,17 @@
 	}
 }
 
+type lockedWriter struct {
+	sync.Mutex
+	f io.Writer
+}
+
+func (lw *lockedWriter) Write(d []byte) (int, error) {
+	lw.Lock()
+	defer lw.Unlock()
+	return lw.f.Write(d)
+}
+
 func (s *Sequence) initAndDefer() func() {
 	if s.stdout == nil && s.stderr == nil {
 		fout, err := ioutil.TempFile("", "seq")
@@ -219,6 +277,9 @@
 		if s.reading {
 			opts.Stdin = s.stdin
 		}
+		if s.verbosity != nil {
+			opts.Verbose = *s.verbosity
+		}
 		s.setOpts(opts)
 		return func() {
 			filename := fout.Name()
@@ -233,30 +294,39 @@
 		}
 	}
 	opts := s.getOpts()
-	rStdin, wStdin := io.Pipe()
+	rStdout, wStdout := io.Pipe()
 	rStderr, wStderr := io.Pipe()
-	opts.Stdout = wStdin
+	opts.Stdout = wStdout
 	opts.Stderr = wStderr
 	opts.Env = s.env
 	if s.reading {
 		opts.Stdin = s.stdin
 	}
 	var stdinCh, stderrCh chan error
-	if s.stdout != nil {
+	stdout := s.stdout
+	stderr := s.stderr
+	if stdout != nil {
+		if stdout == stderr {
+			stdout = &lockedWriter{f: stdout}
+			stderr = &lockedWriter{f: stderr}
+		}
 		stdinCh = make(chan error)
-		go copy(s.stdout, rStdin, stdinCh)
+		go copy(stdout, rStdout, stdinCh)
 	} else {
 		opts.Stdout = s.defaultStdout
 	}
-	if s.stderr != nil {
+	if stderr != nil {
 		stderrCh = make(chan error)
-		go copy(s.stderr, rStderr, stderrCh)
+		go copy(stderr, rStderr, stderrCh)
 	} else {
 		opts.Stderr = s.defaultStderr
 	}
+	if s.verbosity != nil {
+		opts.Verbose = *s.verbosity
+	}
 	s.setOpts(opts)
 	return func() {
-		if err := s.done(wStdin, wStderr, stdinCh, stderrCh); err != nil && s.err == nil {
+		if err := s.done(wStdout, wStderr, stdinCh, stderrCh); err != nil && s.err == nil {
 			s.err = err
 		}
 	}
@@ -435,6 +505,15 @@
 	return s
 }
 
+// Fprintf calls fmt.Fprintf.
+func (s *Sequence) Fprintf(f io.Writer, format string, args ...interface{}) *Sequence {
+	if s.err != nil {
+		return s
+	}
+	fmt.Fprintf(f, format, args...)
+	return s
+}
+
 // Done returns the error stored in the Sequence and pops back to the first
 // entry in the directory stack if Pushd has been called. Done is a terminating
 // function. There is no need to ensure that Done is called before returning