diff --git a/project/project.go b/project/project.go
index f6f2d5f..9a59667 100644
--- a/project/project.go
+++ b/project/project.go
@@ -266,19 +266,13 @@
 		manifest.Hooks = append(manifest.Hooks, hook)
 	}
 
-	perm := os.FileMode(0755)
-	if err := jirix.Run().MkdirAll(filepath.Dir(path), perm); err != nil {
-		return err
-	}
+	s := jirix.NewSeq()
 	data, err := xml.MarshalIndent(manifest, "", "  ")
 	if err != nil {
 		return fmt.Errorf("MarshalIndent(%v) failed: %v", manifest, err)
 	}
-	perm = os.FileMode(0644)
-	if err := jirix.Run().WriteFile(path, data, perm); err != nil {
-		return err
-	}
-	return nil
+	return s.MkdirAll(filepath.Dir(path), os.FileMode(0755)).
+		WriteFile(path, data, os.FileMode(0644)).Done()
 }
 
 const currentManifestFileName = ".current_manifest"
@@ -287,9 +281,9 @@
 // the most recent "jiri update" invocation.
 func CurrentManifest(jirix *jiri.X) (*Manifest, error) {
 	currentManifestPath := toAbs(jirix, currentManifestFileName)
-	bytes, err := jirix.Run().ReadFile(currentManifestPath)
+	bytes, err := jirix.NewSeq().ReadFile(currentManifestPath)
 	if err != nil {
-		if os.IsNotExist(err) {
+		if runutil.IsNotExist(err) {
 			fmt.Fprintf(jirix.Stderr(), `WARNING: Could not find %s.
 The contents of this file are stored as metadata in binaries the jiri
 tool builds. To fix this problem, please run "jiri update".
@@ -313,10 +307,7 @@
 	if err != nil {
 		return fmt.Errorf("MarshalIndent(%v) failed: %v", manifest, err)
 	}
-	if err := jirix.Run().WriteFile(currentManifestPath, bytes, os.FileMode(0644)); err != nil {
-		return err
-	}
-	return nil
+	return jirix.NewSeq().WriteFile(currentManifestPath, bytes, os.FileMode(0644)).Done()
 }
 
 // CurrentProjectKey gets the key of the current project from the current
@@ -327,10 +318,11 @@
 	if err != nil {
 		return "", nil
 	}
+	s := jirix.NewSeq()
 	metadataDir := filepath.Join(topLevel, jiri.ProjectMetaDir)
-	if _, err := jirix.Run().Stat(metadataDir); err == nil {
+	if _, err := s.Stat(metadataDir); err == nil {
 		metadataFile := filepath.Join(metadataDir, jiri.ProjectMetaFile)
-		bytes, err := jirix.Run().ReadFile(metadataFile)
+		bytes, err := s.ReadFile(metadataFile)
 		if err != nil {
 			return "", err
 		}
@@ -350,12 +342,13 @@
 	if err != nil {
 		return nil, err
 	}
-	defer collect.Error(func() error { return jirix.Run().Chdir(cwd) }, &e)
+	defer collect.Error(func() error { return jirix.NewSeq().Chdir(cwd).Done() }, &e)
 
+	s := jirix.NewSeq()
 	for name, project := range projects {
 		switch project.Protocol {
 		case "git":
-			if err := jirix.Run().Chdir(project.Path); err != nil {
+			if err := s.Chdir(project.Path).Done(); err != nil {
 				return nil, err
 			}
 			revision, err := jirix.Git().CurrentRevisionOfBranch("master")
@@ -441,7 +434,7 @@
 	if err != nil {
 		return nil, err
 	}
-	defer collect.Error(func() error { return jirix.Run().Chdir(cwd) }, &e)
+	defer collect.Error(func() error { return jirix.NewSeq().Chdir(cwd).Done() }, &e)
 
 	// Gather local & remote project data.
 	localProjects, err := LocalProjects(jirix, FastScan)
@@ -460,6 +453,7 @@
 		return nil, err
 	}
 
+	s := jirix.NewSeq()
 	for _, op := range ops {
 		name := op.Project().Name
 
@@ -477,7 +471,7 @@
 			case "git":
 
 				// Enter project directory - this assumes absolute paths.
-				if err := jirix.Run().Chdir(updateOp.destination); err != nil {
+				if err := s.Chdir(updateOp.destination).Done(); err != nil {
 					return nil, err
 				}
 
@@ -578,16 +572,17 @@
 	if err != nil {
 		return err
 	}
+	s := jirix.NewSeq()
 	// 1. Update all local projects to match their remote counterparts.
 	if err := updateProjects(jirix, remoteProjects, gc); err != nil {
 		return err
 	}
 	// 2. Build all tools in a temporary directory.
-	tmpDir, err := jirix.Run().TempDir("", "tmp-jiri-tools-build")
+	tmpDir, err := s.TempDir("", "tmp-jiri-tools-build")
 	if err != nil {
 		return fmt.Errorf("TempDir() failed: %v", err)
 	}
-	defer collect.Error(func() error { return jirix.Run().RemoveAll(tmpDir) }, &e)
+	defer collect.Error(func() error { return s.RemoveAll(tmpDir).Done() }, &e)
 	if err := buildToolsFromMaster(jirix, remoteTools, tmpDir); err != nil {
 		return err
 	}
@@ -606,13 +601,15 @@
 	if err != nil {
 		return err
 	}
-	defer collect.Error(func() error { return jirix.Run().Chdir(cwd) }, &e)
+	defer collect.Error(func() error { return jirix.NewSeq().Chdir(cwd).Done() }, &e)
+
+	s := jirix.NewSeq()
 
 	// Loop through all projects, checking out master and stashing any unstaged
 	// changes.
 	for _, project := range projects {
 		p := project
-		if err := jirix.Run().Chdir(p.Path); err != nil {
+		if err := s.Chdir(p.Path).Done(); err != nil {
 			return err
 		}
 		switch p.Protocol {
@@ -631,7 +628,7 @@
 			// After running the function, return to this project's directory,
 			// checkout the original branch, and stash pop if necessary.
 			defer collect.Error(func() error {
-				if err := jirix.Run().Chdir(p.Path); err != nil {
+				if err := s.Chdir(p.Path).Done(); err != nil {
 					return err
 				}
 				if err := jirix.Git().CheckoutBranch(branch); err != nil {
@@ -694,21 +691,20 @@
 	if envGoPath := os.Getenv("GOPATH"); envGoPath != "" {
 		workspaces = append(workspaces, strings.Split(envGoPath, string(filepath.ListSeparator))...)
 	}
+	s := jirix.NewSeq()
 	var stderr bytes.Buffer
-	opts := jirix.Run().Opts()
+
 	// We unset GOARCH and GOOS because jiri update should always build for the
 	// native architecture and OS.  Also, as of go1.5, setting GOBIN is not
 	// compatible with GOARCH or GOOS.
-	opts.Env = map[string]string{
+	env := map[string]string{
 		"GOARCH": "",
 		"GOOS":   "",
 		"GOBIN":  outputDir,
 		"GOPATH": strings.Join(workspaces, string(filepath.ListSeparator)),
 	}
-	opts.Stdout = ioutil.Discard
-	opts.Stderr = &stderr
 	args := append([]string{"install"}, toolPkgs...)
-	if err := jirix.Run().CommandWithOpts(opts, "go", args...); err != nil {
+	if err := s.Env(env).Capture(ioutil.Discard, &stderr).Last("go", args...); err != nil {
 		return fmt.Errorf("tool build failed\n%v", stderr.String())
 	}
 	return nil
@@ -752,8 +748,7 @@
 
 	// Always log the output of updateFn, irrespective of
 	// the value of the verbose flag.
-	opts := runutil.Opts{Verbose: true}
-	if err := jirix.Run().FunctionWithOpts(opts, updateFn, "build tools: %v", strings.Join(toolNames, " ")); err != nil {
+	if err := jirix.NewSeq().Verbose(true).Call(updateFn, "build tools: %v", strings.Join(toolNames, " ")).Done(); err != nil {
 		fmt.Fprintf(jirix.Stderr(), "%v\n", err)
 		failed = true
 	}
@@ -771,10 +766,11 @@
 	if err != nil {
 		return fmt.Errorf("Getwd() failed: %v", err)
 	}
-	defer collect.Error(func() error { return jirix.Run().Chdir(wd) }, &e)
+	defer collect.Error(func() error { return jirix.NewSeq().Chdir(wd).Done() }, &e)
+	s := jirix.NewSeq()
 	for _, project := range projects {
 		localProjectDir := project.Path
-		if err := jirix.Run().Chdir(localProjectDir); err != nil {
+		if err := s.Chdir(localProjectDir).Done(); err != nil {
 			return err
 		}
 		if err := resetLocalProject(jirix, cleanupBranches, project.RemoteBranch); err != nil {
@@ -834,8 +830,8 @@
 	// Existence of a metadata directory is how we know we've found a
 	// Jiri-maintained project.
 	metadataDir := filepath.Join(absPath, jiri.ProjectMetaDir)
-	if _, err := jirix.Run().Stat(metadataDir); err != nil {
-		if os.IsNotExist(err) {
+	if _, err := jirix.NewSeq().Stat(metadataDir); err != nil {
+		if runutil.IsNotExist(err) {
 			return false, nil
 		}
 		return false, err
@@ -849,7 +845,7 @@
 	var project Project
 	absPath := toAbs(jirix, path)
 	metadataFile := filepath.Join(absPath, jiri.ProjectMetaDir, jiri.ProjectMetaFile)
-	bytes, err := jirix.Run().ReadFile(metadataFile)
+	bytes, err := jirix.NewSeq().ReadFile(metadataFile)
 	if err != nil {
 		return project, err
 	}
@@ -883,7 +879,7 @@
 	}
 
 	// Recurse into all the sub directories.
-	fileInfos, err := jirix.Run().ReadDir(path)
+	fileInfos, err := jirix.NewSeq().ReadDir(path)
 	if err != nil {
 		return err
 	}
@@ -915,14 +911,14 @@
 		return fmt.Errorf("MkdirAll(%v) failed: %v", binDir, err)
 	}
 	failed := false
+	s := jirix.NewSeq()
 	for _, fi := range fis {
 		installFn := func() error {
 			src := filepath.Join(dir, fi.Name())
 			dst := filepath.Join(binDir, fi.Name())
-			return jirix.Run().Rename(src, dst)
+			return jirix.NewSeq().Rename(src, dst).Done()
 		}
-		opts := runutil.Opts{Verbose: true}
-		if err := jirix.Run().FunctionWithOpts(opts, installFn, "install tool %q", fi.Name()); err != nil {
+		if err := s.Verbose(true).Call(installFn, "install tool %q", fi.Name()).Done(); err != nil {
 			fmt.Fprintf(jirix.Stderr(), "%v\n", err)
 			failed = true
 		}
@@ -945,14 +941,15 @@
 //
 // TODO(toddw): Remove this logic after the transition to .jiri_root is done.
 func TransitionBinDir(jirix *jiri.X) error {
+	s := jirix.NewSeq()
 	oldDir, newDir := filepath.Join(jirix.Root, "devtools", "bin"), jirix.BinDir()
-	switch info, err := jirix.Run().Lstat(oldDir); {
-	case os.IsNotExist(err):
+	switch info, err := s.Lstat(oldDir); {
+	case runutil.IsNotExist(err):
 		// Drop down to create the symlink below.
 	case err != nil:
 		return fmt.Errorf("Failed to stat old bin dir: %v", err)
 	case info.Mode()&os.ModeSymlink != 0:
-		link, err := jirix.NewSeq().Readlink(oldDir)
+		link, err := s.Readlink(oldDir)
 		if err != nil {
 			return fmt.Errorf("Failed to read link from old bin dir: %v", err)
 		}
@@ -965,9 +962,9 @@
 		// The old dir exists, and either it's not a symlink, or it's a symlink that
 		// doesn't point to the new dir.  Move the old dir to the backup location.
 		backupDir := newDir + ".BACKUP"
-		switch _, err := jirix.Run().Stat(backupDir); {
-		case os.IsNotExist(err):
-			if err := jirix.NewSeq().Rename(oldDir, backupDir).Done(); err != nil {
+		switch _, err := s.Stat(backupDir); {
+		case runutil.IsNotExist(err):
+			if err := s.Rename(oldDir, backupDir).Done(); err != nil {
 				return fmt.Errorf("Failed to backup old bin dir %v to %v: %v", oldDir, backupDir, err)
 			}
 			// Drop down to create the symlink below.
@@ -978,7 +975,7 @@
 		}
 	}
 	// Create the symlink.
-	if err := jirix.NewSeq().MkdirAll(filepath.Dir(oldDir), 0755).Symlink(newDir, oldDir).Done(); err != nil {
+	if err := s.MkdirAll(filepath.Dir(oldDir), 0755).Symlink(newDir, oldDir).Done(); err != nil {
 		return fmt.Errorf("Failed to symlink to new bin dir %v from %v: %v", newDir, oldDir, err)
 	}
 	return nil
@@ -988,6 +985,7 @@
 func runHooks(jirix *jiri.X, hooks Hooks) error {
 	jirix.TimerPush("run hooks")
 	defer jirix.TimerPop()
+	s := jirix.NewSeq()
 	for _, hook := range hooks {
 		command := hook.Path
 		args := []string{}
@@ -998,7 +996,7 @@
 		for _, arg := range hook.Args {
 			args = append(args, arg.Arg)
 		}
-		if err := jirix.Run().Command(command, args...); err != nil {
+		if err := s.Last(command, args...); err != nil {
 			return fmt.Errorf("Hook %v failed: %v command: %v args: %v", hook.Name, err, command, args)
 		}
 	}
@@ -1044,7 +1042,7 @@
 // loadManifest loads the given manifest, processing all of its
 // imports, projects and tools settings.
 func loadManifest(jirix *jiri.X, path string, hosts Hosts, projects Projects, tools Tools, hooks Hooks, stack map[string]struct{}) error {
-	data, err := jirix.Run().ReadFile(path)
+	data, err := jirix.NewSeq().ReadFile(path)
 	if err != nil {
 		return err
 	}
@@ -1156,8 +1154,9 @@
 	if err != nil {
 		return err
 	}
-	defer collect.Error(func() error { return jirix.Run().Chdir(cwd) }, &e)
-	if err := jirix.Run().Chdir(project.Path); err != nil {
+	defer collect.Error(func() error { return jirix.NewSeq().Chdir(cwd).Done() }, &e)
+	s := jirix.NewSeq()
+	if err := s.Chdir(project.Path).Done(); err != nil {
 		return err
 	}
 	switch project.Protocol {
@@ -1169,8 +1168,7 @@
 		if current != "master" {
 			line1 := fmt.Sprintf(`NOTE: "jiri update" only updates the "master" branch and the current branch is %q`, current)
 			line2 := fmt.Sprintf(`to update the %q branch once the master branch is updated, run "git merge master"`, current)
-			opts := runutil.Opts{Verbose: true}
-			jirix.Run().OutputWithOpts(opts, []string{line1, line2})
+			s.Verbose(true).Output([]string{line1, line2})
 		}
 		return nil
 	default:
@@ -1244,12 +1242,12 @@
 	}
 	failed := false
 	manifest := &Manifest{Label: jirix.Manifest()}
+	s := jirix.NewSeq()
 	for _, op := range ops {
 		updateFn := func() error { return op.Run(jirix, manifest) }
 		// Always log the output of updateFn, irrespective of
 		// the value of the verbose flag.
-		opts := runutil.Opts{Verbose: true}
-		if err := jirix.Run().FunctionWithOpts(opts, updateFn, "%v", op); err != nil {
+		if err := s.Verbose(true).Call(updateFn, "%v", op).Done(); err != nil {
 			fmt.Fprintf(jirix.Stderr(), "%v\n", err)
 			failed = true
 		}
@@ -1271,13 +1269,14 @@
 	if err != nil {
 		return err
 	}
-	defer collect.Error(func() error { return jirix.Run().Chdir(cwd) }, &e)
-	if err := jirix.Run().MkdirAll(metadataDir, os.FileMode(0755)); err != nil {
+	defer collect.Error(func() error { return jirix.NewSeq().Chdir(cwd).Done() }, &e)
+
+	s := jirix.NewSeq()
+	if err := s.MkdirAll(metadataDir, os.FileMode(0755)).
+		Chdir(metadataDir).Done(); err != nil {
 		return err
 	}
-	if err := jirix.Run().Chdir(metadataDir); err != nil {
-		return err
-	}
+
 	// Replace absolute project paths with relative paths to make it
 	// possible to move the $JIRI_ROOT directory locally.
 	relPath, err := toRel(jirix, project.Path)
@@ -1291,10 +1290,8 @@
 	}
 	metadataFile := filepath.Join(metadataDir, jiri.ProjectMetaFile)
 	tmpMetadataFile := metadataFile + ".tmp"
-	if err := jirix.Run().WriteFile(tmpMetadataFile, bytes, os.FileMode(0644)); err != nil {
-		return err
-	}
-	if err := jirix.Run().Rename(tmpMetadataFile, metadataFile); err != nil {
+	if err := s.WriteFile(tmpMetadataFile, bytes, os.FileMode(0644)).
+		Rename(tmpMetadataFile, metadataFile).Done(); err != nil {
 		return err
 	}
 	return nil
@@ -1392,20 +1389,19 @@
 	if err != nil {
 		return err
 	}
+	s := jirix.NewSeq()
 
 	path, perm := filepath.Dir(op.destination), os.FileMode(0755)
-	if err := jirix.Run().MkdirAll(path, perm); err != nil {
-		return err
-	}
+	tmpDirPrefix := strings.Replace(op.Project().Name, "/", ".", -1) + "-"
+
 	// Create a temporary directory for the initial setup of the
 	// project to prevent an untimely termination from leaving the
 	// $JIRI_ROOT directory in an inconsistent state.
-	tmpDirPrefix := strings.Replace(op.Project().Name, "/", ".", -1) + "-"
-	tmpDir, err := jirix.Run().TempDir(path, tmpDirPrefix)
+	tmpDir, err := s.MkdirAll(path, perm).TempDir(path, tmpDirPrefix)
 	if err != nil {
 		return err
 	}
-	defer collect.Error(func() error { return jirix.Run().RemoveAll(tmpDir) }, &e)
+	defer collect.Error(func() error { return jirix.NewSeq().RemoveAll(tmpDir).Done() }, &e)
 	switch op.project.Protocol {
 	case "git":
 		if err := jirix.Git().Clone(op.project.Remote, tmpDir); err != nil {
@@ -1421,12 +1417,12 @@
 			gitHookDir := filepath.Join(tmpDir, ".git", "hooks")
 			for _, githook := range host.GitHooks {
 				mdir := jirix.ManifestDir()
-				src, err := jirix.Run().ReadFile(filepath.Join(mdir, githook.Path))
+				src, err := s.ReadFile(filepath.Join(mdir, githook.Path))
 				if err != nil {
 					return err
 				}
 				dst := filepath.Join(gitHookDir, githook.Name)
-				if err := jirix.Run().WriteFile(dst, src, perm); err != nil {
+				if err := s.WriteFile(dst, src, perm).Done(); err != nil {
 					return err
 				}
 			}
@@ -1436,11 +1432,9 @@
 		// write to .git/info/exclude
 		excludeString := "/.jiri/\n"
 		excludeDir := filepath.Join(tmpDir, ".git", "info")
-		if err := jirix.Run().MkdirAll(excludeDir, os.FileMode(0750)); err != nil {
-			return err
-		}
 		excludeFile := filepath.Join(excludeDir, "exclude")
-		if err := jirix.Run().WriteFile(excludeFile, []byte(excludeString), perm); err != nil {
+		if err := s.MkdirAll(excludeDir, os.FileMode(0750)).
+			WriteFile(excludeFile, []byte(excludeString), perm).Done(); err != nil {
 			return err
 		}
 
@@ -1448,8 +1442,8 @@
 		if err != nil {
 			return err
 		}
-		defer collect.Error(func() error { return jirix.Run().Chdir(cwd) }, &e)
-		if err := jirix.Run().Chdir(tmpDir); err != nil {
+		defer collect.Error(func() error { return jirix.NewSeq().Chdir(cwd).Done() }, &e)
+		if err := s.Chdir(tmpDir).Done(); err != nil {
 			return err
 		}
 		if err := jirix.Git().Reset(op.project.Revision); err != nil {
@@ -1461,10 +1455,8 @@
 	if err := writeMetadata(jirix, op.project, tmpDir); err != nil {
 		return err
 	}
-	if err := jirix.Run().Chmod(tmpDir, os.FileMode(0755)); err != nil {
-		return err
-	}
-	if err := jirix.Run().Rename(tmpDir, op.destination); err != nil {
+	if err := s.Chmod(tmpDir, os.FileMode(0755)).
+		Rename(tmpDir, op.destination).Done(); err != nil {
 		return err
 	}
 	if err := resetProject(jirix, op.project); err != nil {
@@ -1479,8 +1471,8 @@
 
 func (op createOperation) Test(jirix *jiri.X, updates *fsUpdates) error {
 	// Check the local file system.
-	if _, err := jirix.Run().Stat(op.destination); err != nil {
-		if !os.IsNotExist(err) {
+	if _, err := jirix.NewSeq().Stat(op.destination); err != nil {
+		if !runutil.IsNotExist(err) {
 			return err
 		}
 	} else if !updates.isDeleted(op.destination) {
@@ -1498,6 +1490,7 @@
 }
 
 func (op deleteOperation) Run(jirix *jiri.X, _ *Manifest) error {
+	s := jirix.NewSeq()
 	if op.gc {
 		// Never delete the <JiriProject>.
 		if op.project.Name == JiriProject {
@@ -1506,8 +1499,7 @@
 				"however this project is required for correct operation of the jiri",
 				"development tools and will thus not be deleted",
 			}
-			opts := runutil.Opts{Verbose: true}
-			jirix.Run().OutputWithOpts(opts, lines)
+			s.Verbose(true).Output(lines)
 			return nil
 		}
 		// Never delete projects with non-master branches, uncommitted
@@ -1531,11 +1523,10 @@
 				"however this project either contains non-master branches, uncommitted",
 				"work, or untracked files and will thus not be deleted",
 			}
-			opts := runutil.Opts{Verbose: true}
-			jirix.Run().OutputWithOpts(opts, lines)
+			s.Verbose(true).Output(lines)
 			return nil
 		}
-		return jirix.Run().RemoveAll(op.source)
+		return s.RemoveAll(op.source).Done()
 	}
 	lines := []string{
 		fmt.Sprintf("NOTE: project %v was not found in the project manifest", op.project.Name),
@@ -1543,8 +1534,7 @@
 		fmt.Sprintf(`if you no longer need it, invoke "rm -rf %v"`, op.source),
 		`or invoke "jiri update -gc" to remove all such local projects`,
 	}
-	opts := runutil.Opts{Verbose: true}
-	jirix.Run().OutputWithOpts(opts, lines)
+	s.Verbose(true).Output(lines)
 	return nil
 }
 
@@ -1553,8 +1543,8 @@
 }
 
 func (op deleteOperation) Test(jirix *jiri.X, updates *fsUpdates) error {
-	if _, err := jirix.Run().Stat(op.source); err != nil {
-		if os.IsNotExist(err) {
+	if _, err := jirix.NewSeq().Stat(op.source); err != nil {
+		if runutil.IsNotExist(err) {
 			return fmt.Errorf("cannot delete %q as it does not exist", op.source)
 		}
 		return err
@@ -1569,11 +1559,10 @@
 }
 
 func (op moveOperation) Run(jirix *jiri.X, manifest *Manifest) error {
+	s := jirix.NewSeq()
 	path, perm := filepath.Dir(op.destination), os.FileMode(0755)
-	if err := jirix.Run().MkdirAll(path, perm); err != nil {
-		return err
-	}
-	if err := jirix.Run().Rename(op.source, op.destination); err != nil {
+	if err := s.MkdirAll(path, perm).
+		Rename(op.source, op.destination).Done(); err != nil {
 		return err
 	}
 	if err := reportNonMaster(jirix, op.project); err != nil {
@@ -1593,14 +1582,15 @@
 }
 
 func (op moveOperation) Test(jirix *jiri.X, updates *fsUpdates) error {
-	if _, err := jirix.Run().Stat(op.source); err != nil {
-		if os.IsNotExist(err) {
+	s := jirix.NewSeq()
+	if _, err := s.Stat(op.source); err != nil {
+		if runutil.IsNotExist(err) {
 			return fmt.Errorf("cannot move %q to %q as the source does not exist", op.source, op.destination)
 		}
 		return err
 	}
-	if _, err := jirix.Run().Stat(op.destination); err != nil {
-		if !os.IsNotExist(err) {
+	if _, err := s.Stat(op.destination); err != nil {
+		if !runutil.IsNotExist(err) {
 			return err
 		}
 	} else {
diff --git a/project/project_test.go b/project/project_test.go
index 37d4046..03eb785 100644
--- a/project/project_test.go
+++ b/project/project_test.go
@@ -19,6 +19,7 @@
 	"v.io/jiri/jiri"
 	"v.io/jiri/jiritest"
 	"v.io/jiri/project"
+	"v.io/jiri/runutil"
 )
 
 func addRemote(t *testing.T, jirix *jiri.X, localProject, name, remoteProject string) {
@@ -26,8 +27,8 @@
 	if err != nil {
 		t.Fatalf("%v", err)
 	}
-	defer jirix.Run().Chdir(cwd)
-	if err := jirix.Run().Chdir(localProject); err != nil {
+	defer jirix.NewSeq().Chdir(cwd)
+	if err := jirix.NewSeq().Chdir(localProject).Done(); err != nil {
 		t.Fatalf("%v", err)
 	}
 	if err := jirix.Git().AddRemote(name, remoteProject); err != nil {
@@ -36,7 +37,7 @@
 }
 
 func checkReadme(t *testing.T, jirix *jiri.X, project, message string) {
-	if _, err := jirix.Run().Stat(project); err != nil {
+	if _, err := jirix.NewSeq().Stat(project); err != nil {
 		t.Fatalf("%v", err)
 	}
 	readmeFile := filepath.Join(project, "README")
@@ -51,7 +52,7 @@
 
 // Checks that /.jiri/ is ignored in a local project checkout
 func checkGitIgnore(t *testing.T, jirix *jiri.X, project string) {
-	if _, err := jirix.Run().Stat(project); err != nil {
+	if _, err := jirix.NewSeq().Stat(project); err != nil {
 		t.Fatalf("%v", err)
 	}
 	gitInfoExcludeFile := filepath.Join(project, ".git", "info", "exclude")
@@ -106,7 +107,7 @@
 
 func createRemoteManifest(t *testing.T, jirix *jiri.X, dir string, remotes []string) {
 	manifestDir, perm := filepath.Join(dir, "v2"), os.FileMode(0755)
-	if err := jirix.Run().MkdirAll(manifestDir, perm); err != nil {
+	if err := jirix.NewSeq().MkdirAll(manifestDir, perm).Done(); err != nil {
 		t.Fatalf("%v", err)
 	}
 	manifest := project.Manifest{}
@@ -145,8 +146,8 @@
 	if err != nil {
 		t.Fatalf("%v", err)
 	}
-	defer jirix.Run().Chdir(cwd)
-	if err := jirix.Run().Chdir(manifestDir); err != nil {
+	defer jirix.NewSeq().Chdir(cwd)
+	if err := jirix.NewSeq().Chdir(manifestDir).Done(); err != nil {
 		t.Fatalf("%v", err)
 	}
 	if err := jirix.Git().CommitFile(manifestFile, "creating manifest"); err != nil {
@@ -188,8 +189,8 @@
 	if err != nil {
 		t.Fatalf("%v", err)
 	}
-	defer jirix.Run().Chdir(cwd)
-	if err := jirix.Run().Chdir(name); err != nil {
+	defer jirix.NewSeq().Chdir(cwd)
+	if err := jirix.NewSeq().Chdir(name).Done(); err != nil {
 		t.Fatalf("%v", err)
 	}
 	revision, err := jirix.Git().CurrentRevision()
@@ -265,15 +266,16 @@
 
 func setupNewProject(t *testing.T, jirix *jiri.X, dir, name string, ignore bool) string {
 	projectDir, perm := filepath.Join(dir, name), os.FileMode(0755)
-	if err := jirix.Run().MkdirAll(projectDir, perm); err != nil {
+	s := jirix.NewSeq()
+	if err := s.MkdirAll(projectDir, perm).Done(); err != nil {
 		t.Fatalf("%v", err)
 	}
 	cwd, err := os.Getwd()
 	if err != nil {
 		t.Fatalf("%v", err)
 	}
-	defer jirix.Run().Chdir(cwd)
-	if err := jirix.Run().Chdir(projectDir); err != nil {
+	defer jirix.NewSeq().Chdir(cwd)
+	if err := s.Chdir(projectDir).Done(); err != nil {
 		t.Fatalf("%v", err)
 	}
 	if err := jirix.Git().Init(projectDir); err != nil {
@@ -281,7 +283,7 @@
 	}
 	if ignore {
 		ignoreFile := filepath.Join(projectDir, ".gitignore")
-		if err := jirix.Run().WriteFile(ignoreFile, []byte(jiri.ProjectMetaDir), os.FileMode(0644)); err != nil {
+		if err := s.WriteFile(ignoreFile, []byte(jiri.ProjectMetaDir), os.FileMode(0644)).Done(); err != nil {
 			t.Fatalf("%v", err)
 		}
 		if err := jirix.Git().Add(ignoreFile); err != nil {
@@ -295,11 +297,12 @@
 }
 
 func writeEmptyMetadata(t *testing.T, jirix *jiri.X, projectDir string) {
-	if err := jirix.Run().Chdir(projectDir); err != nil {
+	s := jirix.NewSeq()
+	if err := s.Chdir(projectDir).Done(); err != nil {
 		t.Fatalf("%v", err)
 	}
 	metadataDir := filepath.Join(projectDir, jiri.ProjectMetaDir)
-	if err := jirix.Run().MkdirAll(metadataDir, os.FileMode(0755)); err != nil {
+	if err := s.MkdirAll(metadataDir, os.FileMode(0755)).Done(); err != nil {
 		t.Fatalf("%v", err)
 	}
 	bytes, err := xml.Marshal(project.Project{})
@@ -307,7 +310,7 @@
 		t.Fatalf("Marshal() failed: %v", err)
 	}
 	metadataFile := filepath.Join(metadataDir, jiri.ProjectMetaFile)
-	if err := jirix.Run().WriteFile(metadataFile, bytes, os.FileMode(0644)); err != nil {
+	if err := s.WriteFile(metadataFile, bytes, os.FileMode(0644)).Done(); err != nil {
 		t.Fatalf("%v", err)
 	}
 }
@@ -321,8 +324,8 @@
 	if err != nil {
 		t.Fatalf("%v", err)
 	}
-	defer jirix.Run().Chdir(cwd)
-	if err := jirix.Run().Chdir(projectDir); err != nil {
+	defer jirix.NewSeq().Chdir(cwd)
+	if err := jirix.NewSeq().Chdir(projectDir).Done(); err != nil {
 		t.Fatalf("%v", err)
 	}
 	if err := jirix.Git().CommitFile(path, "creating README"); err != nil {
@@ -335,8 +338,8 @@
 	if err != nil {
 		t.Fatalf("%v", err)
 	}
-	defer jirix.Run().Chdir(cwd)
-	if err := jirix.Run().Chdir(projectDir); err != nil {
+	defer jirix.NewSeq().Chdir(cwd)
+	if err := jirix.NewSeq().Chdir(projectDir).Done(); err != nil {
 		t.Fatalf("%v", err)
 	}
 	if err := jirix.Git().CreateAndCheckoutBranch(branch); err != nil {
@@ -349,8 +352,8 @@
 	if err != nil {
 		t.Fatalf("%v", err)
 	}
-	defer jirix.Run().Chdir(cwd)
-	if err := jirix.Run().Chdir(projectDir); err != nil {
+	defer jirix.NewSeq().Chdir(cwd)
+	if err := jirix.NewSeq().Chdir(projectDir).Done(); err != nil {
 		t.Fatalf("%v", err)
 	}
 	if err := jirix.Git().Reset("origin/master"); err != nil {
@@ -414,7 +417,7 @@
 
 	// Check that deleting a project forces LocalProjects to run a full scan,
 	// even if FastScan is specified.
-	if err := jirix.Run().RemoveAll(projectPaths[0]); err != nil {
+	if err := jirix.NewSeq().RemoveAll(projectPaths[0]).Done(); err != nil {
 		t.Fatalf("RemoveAll(%v) failed: %v", projectPaths[0])
 	}
 	foundProjects, err = project.LocalProjects(jirix, project.FastScan)
@@ -543,10 +546,10 @@
 	checkDeleteFn := func(i int, revision string) {
 		if i == 3 {
 			localProject := filepath.Join(localDir, localProjectName(i))
-			if _, err := jirix.Run().Stat(localProject); err == nil {
+			if _, err := jirix.NewSeq().Stat(localProject); err == nil {
 				t.Fatalf("project %v has not been deleted", localProject)
 			} else {
-				if !os.IsNotExist(err) {
+				if !runutil.IsNotExist(err) {
 					t.Fatalf("%v", err)
 				}
 			}
diff --git a/project/state.go b/project/state.go
index 98c92d4..49c350d 100644
--- a/project/state.go
+++ b/project/state.go
@@ -5,10 +5,10 @@
 package project
 
 import (
-	"os"
 	"path/filepath"
 
 	"v.io/jiri/jiri"
+	"v.io/jiri/runutil"
 	"v.io/jiri/tool"
 )
 
@@ -39,8 +39,8 @@
 		for _, branch := range branches {
 			file := filepath.Join(state.Project.Path, jiri.ProjectMetaDir, branch, ".gerrit_commit_message")
 			hasFile := true
-			if _, err := jirix.Run().Stat(file); err != nil {
-				if !os.IsNotExist(err) {
+			if _, err := jirix.NewSeq().Stat(file); err != nil {
+				if !runutil.IsNotExist(err) {
 					ch <- err
 					return
 				}
diff --git a/runutil/sequence.go b/runutil/sequence.go
index ec35908..1dc1412 100644
--- a/runutil/sequence.go
+++ b/runutil/sequence.go
@@ -556,7 +556,11 @@
 	if s.err != nil {
 		return s
 	}
-	s.r.OutputWithOpts(s.getOpts(), output)
+	opts := s.getOpts()
+	if s.verbosity != nil {
+		opts.Verbose = *s.verbosity
+	}
+	s.r.OutputWithOpts(opts, output)
 	return s
 }