diff --git a/gosh/.api b/gosh/.api
index 687f358..d8cead2 100644
--- a/gosh/.api
+++ b/gosh/.api
@@ -1,11 +1,9 @@
-pkg gosh, func Call(string, ...interface{}) error
 pkg gosh, func InitChildMain()
 pkg gosh, func InitMain()
 pkg gosh, func NewBufferedPipe() io.ReadWriteCloser
 pkg gosh, func NewShell(Opts) *Shell
 pkg gosh, func NopWriteCloser(io.Writer) io.WriteCloser
-pkg gosh, func Register(string, interface{}) *Fn
-pkg gosh, func Run(func() int) int
+pkg gosh, func RegisterFunc(string, interface{}) *Func
 pkg gosh, func SendReady()
 pkg gosh, func SendVars(map[string]string)
 pkg gosh, method (*Cmd) AddStderrWriter(io.WriteCloser)
@@ -14,10 +12,8 @@
 pkg gosh, method (*Cmd) AwaitVars(...string) map[string]string
 pkg gosh, method (*Cmd) Clone() *Cmd
 pkg gosh, method (*Cmd) CombinedOutput() string
-pkg gosh, method (*Cmd) Kill()
 pkg gosh, method (*Cmd) Pid() int
 pkg gosh, method (*Cmd) Run()
-pkg gosh, method (*Cmd) Shutdown(os.Signal)
 pkg gosh, method (*Cmd) Signal(os.Signal)
 pkg gosh, method (*Cmd) Start()
 pkg gosh, method (*Cmd) StderrPipe() io.Reader
@@ -25,15 +21,14 @@
 pkg gosh, method (*Cmd) Stdout() string
 pkg gosh, method (*Cmd) StdoutPipe() io.Reader
 pkg gosh, method (*Cmd) StdoutStderr() (string, string)
+pkg gosh, method (*Cmd) Terminate(os.Signal)
 pkg gosh, method (*Cmd) Wait()
-pkg gosh, method (*Fn) Call(...interface{}) error
 pkg gosh, method (*Shell) AddToCleanup(func())
 pkg gosh, method (*Shell) BuildGoPkg(string, ...string) string
 pkg gosh, method (*Shell) Cleanup()
 pkg gosh, method (*Shell) Cmd(string, ...string) *Cmd
-pkg gosh, method (*Shell) Fn(*Fn, ...interface{}) *Cmd
+pkg gosh, method (*Shell) FuncCmd(*Func, ...interface{}) *Cmd
 pkg gosh, method (*Shell) HandleError(error)
-pkg gosh, method (*Shell) Main(*Fn, ...string) *Cmd
 pkg gosh, method (*Shell) MakeTempDir() string
 pkg gosh, method (*Shell) MakeTempFile() *os.File
 pkg gosh, method (*Shell) Ok()
@@ -52,7 +47,7 @@
 pkg gosh, type Cmd struct, PropagateOutput bool
 pkg gosh, type Cmd struct, Stdin string
 pkg gosh, type Cmd struct, Vars map[string]string
-pkg gosh, type Fn struct
+pkg gosh, type Func struct
 pkg gosh, type Opts struct
 pkg gosh, type Opts struct, BinDir string
 pkg gosh, type Opts struct, ChildOutputDir string
diff --git a/gosh/cmd.go b/gosh/cmd.go
index 6ed9682..9fa6d1f 100644
--- a/gosh/cmd.go
+++ b/gosh/cmd.go
@@ -43,11 +43,11 @@
 	Args []string
 	// IgnoreParentExit, if true, makes it so the child process does not exit when
 	// its parent exits. Only takes effect if the child process was spawned via
-	// Shell.Fn or Shell.Main, or explicitly calls InitChildMain.
+	// Shell.FuncCmd or explicitly calls InitChildMain.
 	IgnoreParentExit bool
 	// ExitAfter, if non-zero, specifies that the child process should exit after
 	// the given duration has elapsed. Only takes effect if the child process was
-	// spawned via Shell.Fn or Shell.Main, or explicitly calls InitChildMain.
+	// spawned via Shell.FuncCmd or explicitly calls InitChildMain.
 	ExitAfter time.Duration
 	// PropagateOutput is inherited from Shell.Opts.PropagateChildOutput.
 	PropagateOutput bool
@@ -174,22 +174,18 @@
 	c.handleError(c.wait())
 }
 
-// Kill causes the process to exit immediately.
-func (c *Cmd) Kill() {
-	c.sh.Ok()
-	c.handleError(c.kill())
-}
-
 // Signal sends a signal to the process.
 func (c *Cmd) Signal(sig os.Signal) {
 	c.sh.Ok()
 	c.handleError(c.signal(sig))
 }
 
-// Shutdown sends a signal to the process, then waits for it to exit.
-func (c *Cmd) Shutdown(sig os.Signal) {
+// Terminate sends a signal to the process, then waits for it to exit. Terminate
+// is different from Signal followed by Wait: Terminate succeeds as long as the
+// process exits, whereas Wait fails if the exit code isn't 0.
+func (c *Cmd) Terminate(sig os.Signal) {
 	c.sh.Ok()
-	c.handleError(c.shutdown(sig))
+	c.handleError(c.terminate(sig))
 }
 
 // Run calls Start followed by Wait.
@@ -408,10 +404,9 @@
 }
 
 func (c *Cmd) clone() (*Cmd, error) {
-	vars := copyMap(c.Vars)
 	args := make([]string, len(c.Args))
 	copy(args, c.Args)
-	res, err := newCmdInternal(c.sh, vars, c.Path, args[1:])
+	res, err := newCmdInternal(c.sh, copyMap(c.Vars), c.Path, args[1:])
 	if err != nil {
 		return nil, err
 	}
@@ -617,22 +612,16 @@
 // https://golang.org/src/os/exec_windows.go
 const errFinished = "os: process already finished"
 
-func (c *Cmd) kill() error {
-	if !c.started {
-		return errDidNotCallStart
-	}
-	if !c.isRunning() {
-		return nil
-	}
-	if err := c.c.Process.Kill(); err != nil && err.Error() != errFinished {
-		return err
-	}
-	return nil
-}
-
+// NOTE(sadovsky): Technically speaking, Process.Signal(os.Kill) is different
+// from Process.Kill. Currently, gosh.Cmd does not provide a way to trigger
+// Process.Kill. If it proves necessary, we'll add a "gosh.Kill" implementation
+// of the os.Signal interface, and have the signal and terminate methods map
+// that to Process.Kill.
 func (c *Cmd) signal(sig os.Signal) error {
 	if !c.started {
 		return errDidNotCallStart
+	} else if c.calledWait {
+		return errAlreadyCalledWait
 	}
 	if !c.isRunning() {
 		return nil
@@ -643,11 +632,12 @@
 	return nil
 }
 
-func (c *Cmd) shutdown(sig os.Signal) error {
+func (c *Cmd) terminate(sig os.Signal) error {
 	if err := c.signal(sig); err != nil {
 		return err
 	}
 	if err := c.wait(); err != nil {
+		// Succeed as long as the process exited, regardless of the exit code.
 		if _, ok := err.(*exec.ExitError); !ok {
 			return err
 		}
diff --git a/gosh/internal/gosh_example/main.go b/gosh/internal/gosh_example/main.go
index d79d680..d3ecab2 100644
--- a/gosh/internal/gosh_example/main.go
+++ b/gosh/internal/gosh_example/main.go
@@ -11,7 +11,7 @@
 	"v.io/x/lib/gosh/internal/gosh_example_lib"
 )
 
-func ExampleCmds() {
+func ExampleCmd() {
 	sh := gosh.NewShell(gosh.Opts{})
 	defer sh.Cleanup()
 
@@ -30,37 +30,28 @@
 }
 
 var (
-	getFn   = gosh.Register("getFn", lib.Get)
-	serveFn = gosh.Register("serveFn", lib.Serve)
+	getFunc   = gosh.RegisterFunc("getFunc", lib.Get)
+	serveFunc = gosh.RegisterFunc("serveFunc", lib.Serve)
 )
 
-func ExampleFns() {
+func ExampleFuncCmd() {
 	sh := gosh.NewShell(gosh.Opts{})
 	defer sh.Cleanup()
 
 	// Start server.
-	c := sh.Fn(serveFn)
+	c := sh.FuncCmd(serveFunc)
 	c.Start()
 	c.AwaitReady()
 	addr := c.AwaitVars("Addr")["Addr"]
 	fmt.Println(addr)
 
 	// Run client.
-	c = sh.Fn(getFn, addr)
-	fmt.Print(c.Stdout())
-}
-
-func ExampleShellMain() {
-	sh := gosh.NewShell(gosh.Opts{})
-	defer sh.Cleanup()
-
-	c := sh.Main(lib.HelloWorldMain)
+	c = sh.FuncCmd(getFunc, addr)
 	fmt.Print(c.Stdout())
 }
 
 func main() {
 	gosh.InitMain()
-	ExampleCmds()
-	ExampleFns()
-	ExampleShellMain()
+	ExampleCmd()
+	ExampleFuncCmd()
 }
diff --git a/gosh/internal/gosh_example_lib/lib.go b/gosh/internal/gosh_example_lib/lib.go
index c2158d4..be51c33 100644
--- a/gosh/internal/gosh_example_lib/lib.go
+++ b/gosh/internal/gosh_example_lib/lib.go
@@ -15,13 +15,6 @@
 	"v.io/x/lib/gosh"
 )
 
-const helloWorld = "Hello, world!"
-
-// HelloWorldMain is used to demonstrate usage of Shell.Main.
-var HelloWorldMain = gosh.Register("HelloWorldMain", func() {
-	fmt.Println(helloWorld)
-})
-
 func Get(addr string) {
 	resp, err := http.Get("http://" + addr)
 	if err != nil {
@@ -49,7 +42,7 @@
 
 func Serve() {
 	http.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
-		fmt.Fprintln(w, helloWorld)
+		fmt.Fprintln(w, "Hello, world!")
 	})
 	// Note: With http.ListenAndServe() there's no easy way to tell which port
 	// number we were assigned, so instead we use net.Listen() followed by
diff --git a/gosh/registry.go b/gosh/registry.go
index 139a4f1..64453a8 100644
--- a/gosh/registry.go
+++ b/gosh/registry.go
@@ -13,29 +13,34 @@
 	"errors"
 	"fmt"
 	"reflect"
+	"runtime"
+	"sync"
 )
 
-// Fn is a registered, callable function.
-type Fn struct {
-	name  string
-	value reflect.Value
+// Func is a registered, callable function.
+type Func struct {
+	handle string
+	value  reflect.Value
 }
 
 var (
-	fns       = map[string]*Fn{}
 	errorType = reflect.TypeOf((*error)(nil)).Elem()
+	funcsMu   = sync.RWMutex{} // protects funcs
+	funcs     = map[string]*Func{}
 )
 
-// Register registers the given function with the given name. 'name' must be
-// unique across the dependency graph; 'fni' must be a function that accepts
-// gob-encodable arguments and returns an error or nothing.
-func Register(name string, fni interface{}) *Fn {
-	// TODO(sadovsky): Include len(fns) in registered name if it turns out that
-	// initialization order is deterministic.
-	if _, ok := fns[name]; ok {
-		panic(fmt.Errorf("gosh: %q is already registered", name))
+// RegisterFunc registers the given function with the given name. 'fi' must be a
+// function that accepts gob-encodable arguments and returns an error or
+// nothing.
+func RegisterFunc(name string, fi interface{}) *Func {
+	funcsMu.Lock()
+	defer funcsMu.Unlock()
+	_, file, line, _ := runtime.Caller(1)
+	handle := fmt.Sprintf("%s:%d:%s", file, line, name)
+	if _, ok := funcs[handle]; ok {
+		panic(fmt.Errorf("gosh: %q is already registered", handle))
 	}
-	v := reflect.ValueOf(fni)
+	v := reflect.ValueOf(fi)
 	t := v.Type()
 	if t.Kind() != reflect.Func {
 		panic(fmt.Errorf("gosh: %q is not a function: %v", name, t.Kind()))
@@ -43,7 +48,7 @@
 	if t.NumOut() > 1 || t.NumOut() == 1 && t.Out(0) != errorType {
 		panic(fmt.Errorf("gosh: %q must return an error or nothing: %v", name, t))
 	}
-	// Register the function's args with gob. Needed because Shell.Fn takes
+	// Register the function's args with gob. Needed because Shell.Func takes
 	// interface{} arguments.
 	for i := 0; i < t.NumIn(); i++ {
 		// Note: Clients are responsible for registering any concrete types stored
@@ -53,23 +58,34 @@
 		}
 		gob.Register(reflect.Zero(t.In(i)).Interface())
 	}
-	fn := &Fn{name: name, value: v}
-	fns[name] = fn
-	return fn
+	f := &Func{handle: handle, value: v}
+	funcs[handle] = f
+	return f
 }
 
-// Call calls the named function, which must have been registered.
-func Call(name string, args ...interface{}) error {
-	fn, err := getFn(name)
+// getFunc returns the referenced function.
+func getFunc(handle string) (*Func, error) {
+	funcsMu.RLock()
+	f, ok := funcs[handle]
+	funcsMu.RUnlock()
+	if !ok {
+		return nil, fmt.Errorf("gosh: unknown function %q", handle)
+	}
+	return f, nil
+}
+
+// callFunc calls the referenced function, which must have been registered.
+func callFunc(handle string, args ...interface{}) error {
+	f, err := getFunc(handle)
 	if err != nil {
 		return err
 	}
-	return fn.Call(args...)
+	return f.call(args...)
 }
 
-// Call calls the function fn with the input arguments args.
-func (fn *Fn) Call(args ...interface{}) error {
-	t := fn.value.Type()
+// call calls this Func with the given input arguments.
+func (f *Func) call(args ...interface{}) error {
+	t := f.value.Type()
 	in := []reflect.Value{}
 	for i, arg := range args {
 		var av reflect.Value
@@ -82,22 +98,13 @@
 		}
 		in = append(in, av)
 	}
-	out := fn.value.Call(in)
+	out := f.value.Call(in)
 	if t.NumOut() == 1 && !out[0].IsNil() {
 		return out[0].Interface().(error)
 	}
 	return nil
 }
 
-// getFn returns the named function.
-func getFn(name string) (*Fn, error) {
-	fn, ok := fns[name]
-	if !ok {
-		return nil, fmt.Errorf("gosh: unknown function %q", name)
-	}
-	return fn, nil
-}
-
 // argType returns the type of the nth argument to a function of type t.
 func argType(t reflect.Type, n int) reflect.Type {
 	if !t.IsVariadic() || n < t.NumIn()-1 {
@@ -106,14 +113,14 @@
 	return t.In(t.NumIn() - 1).Elem()
 }
 
-// checkCall checks that the named function exists and can be called with the
-// given arguments. Modeled after the implementation of reflect.Value.call.
-func checkCall(name string, args ...interface{}) error {
-	fn, err := getFn(name)
+// checkCall checks that the referenced function exists and can be called with
+// the given arguments. Modeled after the implementation of reflect.Value.call.
+func checkCall(handle string, args ...interface{}) error {
+	f, err := getFunc(handle)
 	if err != nil {
 		return err
 	}
-	t := fn.value.Type()
+	t := f.value.Type()
 	n := t.NumIn()
 	if t.IsVariadic() {
 		n--
@@ -139,16 +146,16 @@
 // invocation
 
 type invocation struct {
-	Name string
-	Args []interface{}
+	Handle string
+	Args   []interface{}
 }
 
-// encInvocation encodes an invocation.
-func encInvocation(name string, args ...interface{}) (string, error) {
-	if err := checkCall(name, args...); err != nil {
+// encodeInvocation encodes an invocation.
+func encodeInvocation(handle string, args ...interface{}) (string, error) {
+	if err := checkCall(handle, args...); err != nil {
 		return "", err
 	}
-	inv := invocation{Name: name, Args: args}
+	inv := invocation{Handle: handle, Args: args}
 	buf := &bytes.Buffer{}
 	if err := gob.NewEncoder(buf).Encode(inv); err != nil {
 		return "", fmt.Errorf("gosh: failed to encode invocation: %v", err)
@@ -158,8 +165,8 @@
 	return base64.StdEncoding.EncodeToString(buf.Bytes()), nil
 }
 
-// decInvocation decodes an invocation.
-func decInvocation(s string) (name string, args []interface{}, err error) {
+// decodeInvocation decodes an invocation.
+func decodeInvocation(s string) (handle string, args []interface{}, err error) {
 	var inv invocation
 	b, err := base64.StdEncoding.DecodeString(s)
 	if err == nil {
@@ -168,5 +175,5 @@
 	if err != nil {
 		return "", nil, fmt.Errorf("gosh: failed to decode invocation: %v", err)
 	}
-	return inv.Name, inv.Args, nil
+	return inv.Handle, inv.Args, nil
 }
diff --git a/gosh/shell.go b/gosh/shell.go
index 37d3174..59a3171 100644
--- a/gosh/shell.go
+++ b/gosh/shell.go
@@ -43,14 +43,6 @@
 	errDidNotCallNewShell   = errors.New("gosh: did not call gosh.NewShell")
 )
 
-// TODO(sadovsky):
-// - Eliminate Shell.Main, since it's easy enough to use Shell.Fn and set the
-//   returned Cmd's Args.
-// - Rename Shell.Fn to Shell.FuncCmd, Fn to Func, Register to RegisterFunc, and
-//   Call to CallFunc.
-// - Eliminate gosh.Run.
-// - Revisit whether to have Cmd.Shutdown.
-
 // Shell represents a shell. Not thread-safe.
 type Shell struct {
 	// Err is the most recent error from this Shell or any of its Cmds (may be
@@ -70,7 +62,7 @@
 	cmds           []*Cmd
 	tempFiles      []*os.File
 	tempDirs       []string
-	cleanupFns     []func()
+	cleanupFuncs   []func()
 }
 
 // Opts configures Shell.
@@ -109,7 +101,8 @@
 	}
 }
 
-// Cmd returns a Cmd for an invocation of the named program.
+// Cmd returns a Cmd for an invocation of the named program. The given arguments
+// are passed to the child as command-line arguments.
 func (sh *Shell) Cmd(name string, args ...string) *Cmd {
 	sh.Ok()
 	res, err := sh.cmd(nil, name, args...)
@@ -117,22 +110,13 @@
 	return res
 }
 
-// Fn returns a Cmd for an invocation of the given registered Fn.
-func (sh *Shell) Fn(fn *Fn, args ...interface{}) *Cmd {
+// FuncCmd returns a Cmd for an invocation of the given registered Func. The
+// given arguments are gob-encoded in the parent process, then gob-decoded in
+// the child and passed to the Func as parameters. To specify command-line
+// arguments for the child invocation, append to the returned Cmd's Args.
+func (sh *Shell) FuncCmd(f *Func, args ...interface{}) *Cmd {
 	sh.Ok()
-	res, err := sh.fn(fn, args...)
-	sh.HandleError(err)
-	return res
-}
-
-// Main returns a Cmd for an invocation of the given registered main() function.
-// Intended usage: Have your program's main() call RealMain, then write a parent
-// program that uses Shell.Main to run RealMain in a child process. With this
-// approach, RealMain can be compiled into the parent program's binary. Caveat:
-// potential flag collisions.
-func (sh *Shell) Main(fn *Fn, args ...string) *Cmd {
-	sh.Ok()
-	res, err := sh.main(fn, args...)
+	res, err := sh.funcCmd(f, args...)
 	sh.HandleError(err)
 	return res
 }
@@ -192,15 +176,16 @@
 }
 
 // AddToCleanup registers the given function to be called by Shell.Cleanup().
-func (sh *Shell) AddToCleanup(fn func()) {
+func (sh *Shell) AddToCleanup(f func()) {
 	sh.Ok()
-	sh.HandleError(sh.addToCleanup(fn))
+	sh.HandleError(sh.addToCleanup(f))
 }
 
 // Cleanup cleans up all resources (child processes, temporary files and
 // directories) associated with this Shell. It is safe (and recommended) to call
 // Cleanup after a Shell error. It is also safe to call Cleanup multiple times;
-// calls after the first return immediately with no effect.
+// calls after the first return immediately with no effect. Cleanup never calls
+// HandleError.
 func (sh *Shell) Cleanup() {
 	if !sh.calledNewShell {
 		panic(errDidNotCallNewShell)
@@ -234,17 +219,18 @@
 
 // onTerminationSignal starts a goroutine that listens for various termination
 // signals and calls the given function when such a signal is received.
-func onTerminationSignal(fn func(os.Signal)) {
+func onTerminationSignal(f func(os.Signal)) {
 	ch := make(chan os.Signal, 1)
 	signal.Notify(ch, syscall.SIGINT, syscall.SIGQUIT, syscall.SIGTERM)
 	go func() {
-		fn(<-ch)
+		f(<-ch)
 	}()
 }
 
 // Note: On error, newShell returns a *Shell with Opts.Fatalf initialized to
 // simplify things for the caller.
 func newShell(opts Opts) (*Shell, error) {
+	osVars := sliceToMap(os.Environ())
 	if opts.Fatalf == nil {
 		opts.Fatalf = func(format string, v ...interface{}) {
 			panic(fmt.Sprintf(format, v...))
@@ -256,15 +242,20 @@
 		}
 	}
 	if opts.ChildOutputDir == "" {
-		opts.ChildOutputDir = os.Getenv(envChildOutputDir)
+		opts.ChildOutputDir = osVars[envChildOutputDir]
+	}
+	// Filter out any gosh env vars coming from outside.
+	shVars := copyMap(osVars)
+	for _, key := range []string{envBinDir, envChildOutputDir, envExitAfter, envInvocation, envWatchParent} {
+		delete(shVars, key)
 	}
 	sh := &Shell{
 		Opts:           opts,
-		Vars:           map[string]string{},
+		Vars:           shVars,
 		calledNewShell: true,
 	}
 	if sh.Opts.BinDir == "" {
-		sh.Opts.BinDir = os.Getenv(envBinDir)
+		sh.Opts.BinDir = osVars[envBinDir]
 		if sh.Opts.BinDir == "" {
 			var err error
 			if sh.Opts.BinDir, err = sh.makeTempDir(); err != nil {
@@ -298,9 +289,7 @@
 	if vars == nil {
 		vars = make(map[string]string)
 	}
-	// TODO(sadovsky): Copy os.Environ() into sh.Vars in NewShell, and clear
-	// envWatchParent and envExitAfter if they're set.
-	c, err := newCmd(sh, mergeMaps(sliceToMap(os.Environ()), sh.Vars, vars), name, append(args, sh.Args...)...)
+	c, err := newCmd(sh, mergeMaps(sh.Vars, vars), name, append(args, sh.Args...)...)
 	if err != nil {
 		return nil, err
 	}
@@ -318,39 +307,20 @@
 	}
 }
 
-func (sh *Shell) fn(fn *Fn, args ...interface{}) (*Cmd, error) {
+func (sh *Shell) funcCmd(f *Func, args ...interface{}) (*Cmd, error) {
 	// Safeguard against the developer forgetting to call InitMain, which could
 	// lead to infinite recursion.
 	if !calledInitMain {
 		return nil, errDidNotCallInitMain
 	}
-	b, err := encInvocation(fn.name, args...)
+	buf, err := encodeInvocation(f.handle, args...)
 	if err != nil {
 		return nil, err
 	}
-	vars := map[string]string{envInvocation: string(b)}
+	vars := map[string]string{envInvocation: string(buf)}
 	return sh.cmd(vars, executablePath)
 }
 
-func (sh *Shell) main(fn *Fn, args ...string) (*Cmd, error) {
-	// Safeguard against the developer forgetting to call InitMain, which could
-	// lead to infinite recursion.
-	if !calledInitMain {
-		return nil, errDidNotCallInitMain
-	}
-	// Check that fn has the required signature.
-	t := fn.value.Type()
-	if t.NumIn() != 0 || t.NumOut() != 0 {
-		return nil, errors.New("gosh: main function must have no input or output parameters")
-	}
-	b, err := encInvocation(fn.name)
-	if err != nil {
-		return nil, err
-	}
-	vars := map[string]string{envInvocation: string(b)}
-	return sh.cmd(vars, executablePath, args...)
-}
-
 func (sh *Shell) wait() error {
 	// Note: It is illegal to call newCmd() concurrently with Shell.wait(), so we
 	// need not hold cleanupMu when accessing sh.cmds below.
@@ -463,24 +433,24 @@
 	return nil
 }
 
-func (sh *Shell) addToCleanup(fn func()) error {
+func (sh *Shell) addToCleanup(f func()) error {
 	sh.cleanupMu.Lock()
 	defer sh.cleanupMu.Unlock()
 	if sh.calledCleanup {
 		return errAlreadyCalledCleanup
 	}
-	sh.cleanupFns = append(sh.cleanupFns, fn)
+	sh.cleanupFuncs = append(sh.cleanupFuncs, f)
 	return nil
 }
 
-// forEachRunningCmd applies fn to each running child process.
-func (sh *Shell) forEachRunningCmd(fn func(*Cmd)) bool {
+// forEachRunningCmd applies f to each running child process.
+func (sh *Shell) forEachRunningCmd(f func(*Cmd)) bool {
 	anyRunning := false
 	for _, c := range sh.cmds {
 		if c.isRunning() {
 			anyRunning = true
-			if fn != nil {
-				fn(c)
+			if f != nil {
+				f(c)
 			}
 		}
 	}
@@ -489,10 +459,10 @@
 
 // Note: It is safe to run Shell.terminateRunningCmds concurrently with the
 // waiter goroutine and with Cmd.wait. In particular, Shell.terminateRunningCmds
-// only calls c.{isRunning,Pid,Signal,Kill}, all of which are thread-safe with
-// the waiter goroutine and with Cmd.wait.
+// only calls c.{isRunning,Pid,signal}, all of which are thread-safe with the
+// waiter goroutine and with Cmd.wait.
 func (sh *Shell) terminateRunningCmds() {
-	// Try Cmd.signal first; if that doesn't work, use Cmd.kill.
+	// Send os.Interrupt first; if that doesn't work, send os.Kill.
 	anyRunning := sh.forEachRunningCmd(func(c *Cmd) {
 		if err := c.signal(os.Interrupt); err != nil {
 			sh.logf("%d.Signal(os.Interrupt) failed: %v\n", c.Pid(), err)
@@ -505,13 +475,13 @@
 			sh.logf("%s (PID %d) did not die\n", c.Path, c.Pid())
 		})
 	}
-	// If any child is still running, wait for another second, then call Cmd.kill
-	// for all running children.
+	// If any child is still running, wait for another second, then send os.Kill
+	// to all running children.
 	if anyRunning {
 		time.Sleep(time.Second)
 		sh.forEachRunningCmd(func(c *Cmd) {
-			if err := c.kill(); err != nil {
-				sh.logf("%d.Kill() failed: %v\n", c.Pid(), err)
+			if err := c.signal(os.Kill); err != nil {
+				sh.logf("%d.Signal(os.Kill) failed: %v\n", c.Pid(), err)
 			}
 		})
 		sh.logf("Killed all remaining child processes\n")
@@ -546,8 +516,8 @@
 		}
 	}
 	// Call any registered cleanup functions in LIFO order.
-	for i := len(sh.cleanupFns) - 1; i >= 0; i-- {
-		sh.cleanupFns[i]()
+	for i := len(sh.cleanupFuncs) - 1; i >= 0; i-- {
+		sh.cleanupFuncs[i]()
 	}
 }
 
@@ -558,7 +528,7 @@
 
 // InitMain must be called early on in main(), before flags are parsed. In the
 // parent process, it returns immediately with no effect. In a child process for
-// a Shell.Fn or Shell.Main command, it runs the specified function, then exits.
+// a Shell.FuncCmd command, it runs the specified function, then exits.
 func InitMain() {
 	calledInitMain = true
 	s := os.Getenv(envInvocation)
@@ -567,23 +537,16 @@
 	}
 	os.Unsetenv(envInvocation)
 	InitChildMain()
-	name, args, err := decInvocation(s)
+	name, args, err := decodeInvocation(s)
 	if err != nil {
 		log.Fatal(err)
 	}
-	if err := Call(name, args...); err != nil {
+	if err := callFunc(name, args...); err != nil {
 		log.Fatal(err)
 	}
 	os.Exit(0)
 }
 
-// Run calls InitMain, then returns run(). Exported so that TestMain functions
-// can simply call os.Exit(gosh.Run(m.Run)).
-func Run(run func() int) int {
-	InitMain()
-	return run()
-}
-
 // NopWriteCloser returns a WriteCloser with a no-op Close method wrapping the
 // provided Writer.
 func NopWriteCloser(w io.Writer) io.WriteCloser {
diff --git a/gosh/shell_test.go b/gosh/shell_test.go
index 73e5da0..f8e1840 100644
--- a/gosh/shell_test.go
+++ b/gosh/shell_test.go
@@ -6,10 +6,10 @@
 
 // TODO(sadovsky): Add more tests:
 // - effects of Shell.Cleanup
-// - Cmd.Clone
 // - Shell.{Vars,Args,Rename,MakeTempFile,MakeTempDir}
-// - Opts (including defaulting behavior)
-// - {,Maybe}WatchParent
+// - Shell.Opts.{PropagateChildOutput,ChildOutputDir,BinDir}
+// - Cmd.Clone
+// - Cmd.Opts.{IgnoreParentExit,ExitAfter,PropagateOutput}
 
 import (
 	"bufio"
@@ -19,6 +19,7 @@
 	"io"
 	"io/ioutil"
 	"os"
+	"os/signal"
 	"path/filepath"
 	"reflect"
 	"runtime/debug"
@@ -78,35 +79,52 @@
 	}
 }
 
+func setsErr(t *testing.T, sh *gosh.Shell, f func()) {
+	calledFatalf := false
+	sh.Opts.Fatalf = func(string, ...interface{}) { calledFatalf = true }
+	f()
+	nok(t, sh.Err)
+	eq(t, calledFatalf, true)
+	sh.Err = nil
+	sh.Opts.Fatalf = makeFatalf(t)
+}
+
 ////////////////////////////////////////
 // Simple functions
 
 // Simplified versions of various Unix commands.
 var (
-	catFn = gosh.Register("catFn", func() {
+	catFunc = gosh.RegisterFunc("catFunc", func() {
 		io.Copy(os.Stdout, os.Stdin)
 	})
-	echoFn = gosh.Register("echoFn", func() {
+	echoFunc = gosh.RegisterFunc("echoFunc", func() {
 		fmt.Println(os.Args[1])
 	})
-	readFn = gosh.Register("readFn", func() {
+	readFunc = gosh.RegisterFunc("readFunc", func() {
 		bufio.NewReader(os.Stdin).ReadString('\n')
 	})
 )
 
 // Functions with parameters.
 var (
-	exitFn = gosh.Register("exitFn", func(code int) {
+	exitFunc = gosh.RegisterFunc("exitFunc", func(code int) {
 		os.Exit(code)
 	})
-	sleepFn = gosh.Register("sleepFn", func(d time.Duration, code int) {
+	sleepFunc = gosh.RegisterFunc("sleepFunc", func(d time.Duration, code int) {
+		// For TestSignal and TestTerminate.
+		ch := make(chan os.Signal, 1)
+		signal.Notify(ch, os.Interrupt)
+		go func() {
+			<-ch
+			os.Exit(0)
+		}()
 		time.Sleep(d)
 		os.Exit(code)
 	})
-	printFn = gosh.Register("printFn", func(v ...interface{}) {
+	printFunc = gosh.RegisterFunc("printFunc", func(v ...interface{}) {
 		fmt.Print(v...)
 	})
-	printfFn = gosh.Register("printfFn", func(format string, v ...interface{}) {
+	printfFunc = gosh.RegisterFunc("printfFunc", func(format string, v ...interface{}) {
 		fmt.Printf(format, v...)
 	})
 )
@@ -151,9 +169,7 @@
 	ok(t, err)
 	eq(t, cwd, startDir)
 	// The next sh.Popd() will fail.
-	sh.Opts.Fatalf = nil
-	sh.Popd()
-	nok(t, sh.Err)
+	setsErr(t, sh, func() { sh.Popd() })
 }
 
 func evalSymlinks(t *testing.T, dir string) string {
@@ -182,7 +198,7 @@
 	eq(t, getwdEvalSymlinks(t), startDir)
 }
 
-func TestCmds(t *testing.T) {
+func TestCmd(t *testing.T) {
 	sh := gosh.NewShell(gosh.Opts{Fatalf: makeFatalf(t), Logf: t.Logf})
 	defer sh.Cleanup()
 
@@ -201,44 +217,36 @@
 }
 
 var (
-	getFn   = gosh.Register("getFn", lib.Get)
-	serveFn = gosh.Register("serveFn", lib.Serve)
+	getFunc   = gosh.RegisterFunc("getFunc", lib.Get)
+	serveFunc = gosh.RegisterFunc("serveFunc", lib.Serve)
 )
 
-func TestFns(t *testing.T) {
+func TestFuncCmd(t *testing.T) {
 	sh := gosh.NewShell(gosh.Opts{Fatalf: makeFatalf(t), Logf: t.Logf})
 	defer sh.Cleanup()
 
 	// Start server.
-	c := sh.Fn(serveFn)
+	c := sh.FuncCmd(serveFunc)
 	c.Start()
 	c.AwaitReady()
 	addr := c.AwaitVars("Addr")["Addr"]
 	neq(t, addr, "")
 
 	// Run client.
-	c = sh.Fn(getFn, addr)
-	eq(t, c.Stdout(), "Hello, world!\n")
-}
-
-func TestShellMain(t *testing.T) {
-	sh := gosh.NewShell(gosh.Opts{Fatalf: makeFatalf(t), Logf: t.Logf})
-	defer sh.Cleanup()
-
-	c := sh.Main(lib.HelloWorldMain)
+	c = sh.FuncCmd(getFunc, addr)
 	eq(t, c.Stdout(), "Hello, world!\n")
 }
 
 // Functions designed for TestRegistry.
 var (
-	printIntsFn = gosh.Register("printIntsFn", func(v ...int) {
+	printIntsFunc = gosh.RegisterFunc("printIntsFunc", func(v ...int) {
 		var vi []interface{}
 		for _, x := range v {
 			vi = append(vi, x)
 		}
 		fmt.Print(vi...)
 	})
-	printfIntsFn = gosh.Register("printfIntsFn", func(format string, v ...int) {
+	printfIntsFunc = gosh.RegisterFunc("printfIntsFunc", func(format string, v ...int) {
 		var vi []interface{}
 		for _, x := range v {
 			vi = append(vi, x)
@@ -252,21 +260,13 @@
 	sh := gosh.NewShell(gosh.Opts{Fatalf: makeFatalf(t), Logf: t.Logf})
 	defer sh.Cleanup()
 
-	c := sh.Fn(exitFn, 0)
+	c := sh.FuncCmd(exitFunc, 0)
 	c.Start()
-	sh.Opts.Fatalf = nil
-	c.AwaitReady()
-	nok(t, sh.Err)
-	sh.Err = nil
-	sh.Opts.Fatalf = makeFatalf(t)
+	setsErr(t, sh, func() { c.AwaitReady() })
 
-	c = sh.Fn(exitFn, 0)
+	c = sh.FuncCmd(exitFunc, 0)
 	c.Start()
-	sh.Opts.Fatalf = nil
-	c.AwaitVars("foo")
-	nok(t, sh.Err)
-	sh.Err = nil
-	sh.Opts.Fatalf = makeFatalf(t)
+	setsErr(t, sh, func() { c.AwaitVars("foo") })
 }
 
 // Tests function signature-checking and execution.
@@ -276,105 +276,81 @@
 
 	// Variadic functions. Non-variadic functions are sufficiently covered in
 	// other tests.
-	eq(t, sh.Fn(printFn).Stdout(), "")
-	eq(t, sh.Fn(printFn, 0).Stdout(), "0")
-	eq(t, sh.Fn(printFn, 0, "foo").Stdout(), "0foo")
-	eq(t, sh.Fn(printfFn, "").Stdout(), "")
-	eq(t, sh.Fn(printfFn, "%v", 0).Stdout(), "0")
-	eq(t, sh.Fn(printfFn, "%v%v", 0, "foo").Stdout(), "0foo")
-	eq(t, sh.Fn(printIntsFn, 1, 2).Stdout(), "1 2")
-	eq(t, sh.Fn(printfIntsFn, "%v %v", 1, 2).Stdout(), "1 2")
-
-	// Error cases.
-	sh.Opts.Fatalf = nil
-	reset := func() {
-		nok(t, sh.Err)
-		sh.Err = nil
-	}
+	eq(t, sh.FuncCmd(printFunc).Stdout(), "")
+	eq(t, sh.FuncCmd(printFunc, 0).Stdout(), "0")
+	eq(t, sh.FuncCmd(printFunc, 0, "foo").Stdout(), "0foo")
+	eq(t, sh.FuncCmd(printfFunc, "").Stdout(), "")
+	eq(t, sh.FuncCmd(printfFunc, "%v", 0).Stdout(), "0")
+	eq(t, sh.FuncCmd(printfFunc, "%v%v", 0, "foo").Stdout(), "0foo")
+	eq(t, sh.FuncCmd(printIntsFunc, 1, 2).Stdout(), "1 2")
+	eq(t, sh.FuncCmd(printfIntsFunc, "%v %v", 1, 2).Stdout(), "1 2")
 
 	// Too few arguments.
-	sh.Fn(exitFn)
-	reset()
-	sh.Fn(sleepFn, time.Second)
-	reset()
-	sh.Fn(printfFn)
-	reset()
+	setsErr(t, sh, func() { sh.FuncCmd(exitFunc) })
+	setsErr(t, sh, func() { sh.FuncCmd(sleepFunc, time.Second) })
+	setsErr(t, sh, func() { sh.FuncCmd(printfFunc) })
 
 	// Too many arguments.
-	sh.Fn(exitFn, 0, 0)
-	reset()
-	sh.Fn(sleepFn, time.Second, 0, 0)
-	reset()
+	setsErr(t, sh, func() { sh.FuncCmd(exitFunc, 0, 0) })
+	setsErr(t, sh, func() { sh.FuncCmd(sleepFunc, time.Second, 0, 0) })
 
 	// Wrong argument types.
-	sh.Fn(exitFn, "foo")
-	reset()
-	sh.Fn(sleepFn, 0, 0)
-	reset()
-	sh.Fn(printfFn, 0)
-	reset()
-	sh.Fn(printfFn, 0, 0)
-	reset()
+	setsErr(t, sh, func() { sh.FuncCmd(exitFunc, "foo") })
+	setsErr(t, sh, func() { sh.FuncCmd(sleepFunc, 0, 0) })
+	setsErr(t, sh, func() { sh.FuncCmd(printfFunc, 0) })
+	setsErr(t, sh, func() { sh.FuncCmd(printfFunc, 0, 0) })
 
 	// Wrong variadic argument types.
-	sh.Fn(printIntsFn, 0.5)
-	reset()
-	sh.Fn(printIntsFn, 0, 0.5)
-	reset()
-	sh.Fn(printfIntsFn, "%v", 0.5)
-	reset()
-	sh.Fn(printfIntsFn, "%v", 0, 0.5)
-	reset()
+	setsErr(t, sh, func() { sh.FuncCmd(printIntsFunc, 0.5) })
+	setsErr(t, sh, func() { sh.FuncCmd(printIntsFunc, 0, 0.5) })
+	setsErr(t, sh, func() { sh.FuncCmd(printfIntsFunc, "%v", 0.5) })
+	setsErr(t, sh, func() { sh.FuncCmd(printfIntsFunc, "%v", 0, 0.5) })
 
 	// Unsupported argument types.
 	var p *int
-	sh.Fn(printFn, p)
-	reset()
-	sh.Fn(printfFn, "%v", p)
-	reset()
+	setsErr(t, sh, func() { sh.FuncCmd(printFunc, p) })
+	setsErr(t, sh, func() { sh.FuncCmd(printfFunc, "%v", p) })
 }
 
 func TestStdin(t *testing.T) {
 	sh := gosh.NewShell(gosh.Opts{Fatalf: makeFatalf(t), Logf: t.Logf})
 	defer sh.Cleanup()
 
-	c := sh.Main(catFn)
+	c := sh.FuncCmd(catFunc)
 	c.Stdin = "foo\n"
 	// We set c.Stdin and did not call c.StdinPipe(), so stdin should close and
 	// cat should exit immediately.
 	eq(t, c.Stdout(), "foo\n")
 
-	c = sh.Main(catFn)
+	c = sh.FuncCmd(catFunc)
 	c.StdinPipe().Write([]byte("foo\n"))
 	// The "cat" command only exits when stdin is closed, so we must explicitly
 	// close the stdin pipe. Note, it's safe to call c.StdinPipe multiple times.
 	c.StdinPipe().Close()
 	eq(t, c.Stdout(), "foo\n")
 
-	c = sh.Main(readFn)
+	c = sh.FuncCmd(readFunc)
 	c.StdinPipe().Write([]byte("foo\n"))
 	// The "read" command exits when it sees a newline, so Cmd.Wait (and thus
 	// Cmd.Run) should return immediately; it should not be necessary to close the
 	// stdin pipe.
 	c.Run()
 
-	c = sh.Main(catFn)
+	c = sh.FuncCmd(catFunc)
 	// No stdin, so cat should exit immediately.
 	eq(t, c.Stdout(), "")
 
 	// It's an error (detected at command start time) to both set c.Stdin and call
 	// c.StdinPipe. Note, this indirectly tests that Shell.Cleanup works even if
 	// some Cmd.Start failed.
-	c = sh.Main(catFn)
+	c = sh.FuncCmd(catFunc)
 	c.Stdin = "foo"
 	c.StdinPipe().Write([]byte("bar"))
 	c.StdinPipe().Close()
-	sh.Opts.Fatalf = nil
-	c.Start()
-	nok(t, sh.Err)
+	setsErr(t, sh, func() { c.Start() })
 }
 
-var writeFn = gosh.Register("writeFn", func(stdout, stderr bool) error {
+var writeFunc = gosh.RegisterFunc("writeFunc", func(stdout, stderr bool) error {
 	if stdout {
 		if _, err := os.Stdout.Write([]byte("A")); err != nil {
 			return err
@@ -403,7 +379,7 @@
 	defer sh.Cleanup()
 
 	// Write to stdout only.
-	c := sh.Fn(writeFn, true, false)
+	c := sh.FuncCmd(writeFunc, true, false)
 	stdoutPipe, stderrPipe := c.StdoutPipe(), c.StderrPipe()
 	stdout, stderr := c.StdoutStderr()
 	eq(t, stdout, "AA")
@@ -412,7 +388,7 @@
 	eq(t, toString(t, stderrPipe), "")
 
 	// Write to stderr only.
-	c = sh.Fn(writeFn, false, true)
+	c = sh.FuncCmd(writeFunc, false, true)
 	stdoutPipe, stderrPipe = c.StdoutPipe(), c.StderrPipe()
 	stdout, stderr = c.StdoutStderr()
 	eq(t, stdout, "")
@@ -421,7 +397,7 @@
 	eq(t, toString(t, stderrPipe), "BB")
 
 	// Write to both stdout and stderr.
-	c = sh.Fn(writeFn, true, true)
+	c = sh.FuncCmd(writeFunc, true, true)
 	stdoutPipe, stderrPipe = c.StdoutPipe(), c.StderrPipe()
 	stdout, stderr = c.StdoutStderr()
 	eq(t, stdout, "AA")
@@ -430,11 +406,11 @@
 	eq(t, toString(t, stderrPipe), "BB")
 }
 
-var writeMoreFn = gosh.Register("writeMoreFn", func() {
+var writeMoreFunc = gosh.RegisterFunc("writeMoreFunc", func() {
 	sh := gosh.NewShell(gosh.Opts{})
 	defer sh.Cleanup()
 
-	c := sh.Fn(writeFn, true, true)
+	c := sh.FuncCmd(writeFunc, true, true)
 	c.AddStdoutWriter(gosh.NopWriteCloser(os.Stdout))
 	c.AddStderrWriter(gosh.NopWriteCloser(os.Stderr))
 	c.Run()
@@ -448,7 +424,7 @@
 	sh := gosh.NewShell(gosh.Opts{Fatalf: makeFatalf(t), Logf: t.Logf})
 	defer sh.Cleanup()
 
-	stdout, stderr := sh.Fn(writeMoreFn).StdoutStderr()
+	stdout, stderr := sh.FuncCmd(writeMoreFunc).StdoutStderr()
 	eq(t, stdout, "AA stdout done")
 	eq(t, stderr, "BB stderr done")
 }
@@ -458,27 +434,18 @@
 	sh := gosh.NewShell(gosh.Opts{Fatalf: makeFatalf(t), Logf: t.Logf})
 	defer sh.Cleanup()
 
-	c := sh.Fn(writeMoreFn)
-	sh.Opts.Fatalf = nil
-	c.AddStdoutWriter(os.Stdout)
-	nok(t, sh.Err)
-	sh.Err = nil
-	c.AddStdoutWriter(os.Stderr)
-	nok(t, sh.Err)
-	sh.Err = nil
-	c.AddStderrWriter(os.Stdout)
-	nok(t, sh.Err)
-	sh.Err = nil
-	c.AddStderrWriter(os.Stderr)
-	nok(t, sh.Err)
-	sh.Err = nil
+	c := sh.FuncCmd(writeMoreFunc)
+	setsErr(t, sh, func() { c.AddStdoutWriter(os.Stdout) })
+	setsErr(t, sh, func() { c.AddStdoutWriter(os.Stderr) })
+	setsErr(t, sh, func() { c.AddStderrWriter(os.Stdout) })
+	setsErr(t, sh, func() { c.AddStderrWriter(os.Stderr) })
 }
 
 func TestCombinedOutput(t *testing.T) {
 	sh := gosh.NewShell(gosh.Opts{Fatalf: makeFatalf(t), Logf: t.Logf})
 	defer sh.Cleanup()
 
-	c := sh.Fn(writeFn, true, true)
+	c := sh.FuncCmd(writeFunc, true, true)
 	buf := &bytes.Buffer{}
 	c.AddStdoutWriter(gosh.NopWriteCloser(buf))
 	c.AddStderrWriter(gosh.NopWriteCloser(buf))
@@ -496,7 +463,7 @@
 	defer sh.Cleanup()
 
 	dir := sh.MakeTempDir()
-	c := sh.Fn(writeFn, true, true)
+	c := sh.FuncCmd(writeFunc, true, true)
 	c.OutputDir = dir
 	c.Run()
 
@@ -531,7 +498,7 @@
 	sh := gosh.NewShell(gosh.Opts{Fatalf: makeFatalf(t), Logf: t.Logf})
 	defer sh.Cleanup()
 
-	c := sh.Fn(writeFn, true, true)
+	c := sh.FuncCmd(writeFunc, true, true)
 	buf := &bytes.Buffer{}
 	wc := &countingWriteCloser{Writer: buf}
 	c.AddStdoutWriter(wc)
@@ -551,15 +518,16 @@
 	sh := gosh.NewShell(gosh.Opts{Fatalf: makeFatalf(t), Logf: t.Logf})
 	defer sh.Cleanup()
 
-	echo := sh.Main(echoFn, "foo")
-	cat := sh.Main(catFn)
+	echo := sh.FuncCmd(echoFunc)
+	echo.Args = append(echo.Args, "foo")
+	cat := sh.FuncCmd(catFunc)
 	echo.AddStdoutWriter(cat.StdinPipe())
 	echo.Start()
 	eq(t, cat.Stdout(), "foo\n")
 
 	// This time, pipe both stdout and stderr to cat's stdin.
-	c := sh.Fn(writeFn, true, true)
-	cat = sh.Main(catFn)
+	c := sh.FuncCmd(writeFunc, true, true)
+	cat = sh.FuncCmd(catFunc)
 	c.AddStdoutWriter(cat.StdinPipe())
 	c.AddStderrWriter(cat.StdinPipe())
 	c.Start()
@@ -568,21 +536,57 @@
 	eq(t, len(cat.Stdout()), 4)
 }
 
-func TestShutdown(t *testing.T) {
+func TestSignal(t *testing.T) {
 	sh := gosh.NewShell(gosh.Opts{Fatalf: makeFatalf(t), Logf: t.Logf})
 	defer sh.Cleanup()
 
 	for _, d := range []time.Duration{0, time.Second} {
 		for _, s := range []os.Signal{os.Interrupt, os.Kill} {
 			fmt.Println(d, s)
-			c := sh.Fn(sleepFn, d, 0)
+			c := sh.FuncCmd(sleepFunc, d, 0)
 			c.Start()
-			// Wait for a bit to allow the zero-sleep commands to exit, to test that
-			// Shutdown succeeds for an exited process.
+			// Wait for a bit to allow the zero-sleep commands to exit.
 			time.Sleep(100 * time.Millisecond)
-			c.Shutdown(s)
+			c.Signal(s)
+			// Wait should succeed as long as the exit code was 0, regardless of
+			// whether the signal arrived or the process had already exited.
+			if s == os.Interrupt {
+				// Note: We don't call Wait in the {d: 0, s: os.Kill} case because doing
+				// so makes the test flaky on slow systems.
+				c.Wait()
+			} else if d == time.Second {
+				setsErr(t, sh, func() { c.Wait() })
+			}
 		}
 	}
+
+	// Signal should fail if Wait has been called.
+	c := sh.FuncCmd(sleepFunc, time.Duration(0), 0)
+	c.Run()
+	setsErr(t, sh, func() { c.Signal(os.Interrupt) })
+}
+
+func TestTerminate(t *testing.T) {
+	sh := gosh.NewShell(gosh.Opts{Fatalf: makeFatalf(t), Logf: t.Logf})
+	defer sh.Cleanup()
+
+	for _, d := range []time.Duration{0, time.Second} {
+		for _, s := range []os.Signal{os.Interrupt, os.Kill} {
+			fmt.Println(d, s)
+			c := sh.FuncCmd(sleepFunc, d, 0)
+			c.Start()
+			// Wait for a bit to allow the zero-sleep commands to exit.
+			time.Sleep(100 * time.Millisecond)
+			// Terminate should succeed regardless of the exit code, and regardless of
+			// whether the signal arrived or the process had already exited.
+			c.Terminate(s)
+		}
+	}
+
+	// Terminate should fail if Wait has been called.
+	c := sh.FuncCmd(sleepFunc, time.Duration(0), 0)
+	c.Run()
+	setsErr(t, sh, func() { c.Terminate(os.Interrupt) })
 }
 
 func TestShellWait(t *testing.T) {
@@ -592,14 +596,14 @@
 	d0 := time.Duration(0)
 	d200 := 200 * time.Millisecond
 
-	c0 := sh.Fn(sleepFn, d0, 0)   // not started
-	c1 := sh.Fn(sleepFn, d0, 0)   // failed to start
-	c2 := sh.Fn(sleepFn, d200, 0) // running and will succeed
-	c3 := sh.Fn(sleepFn, d200, 1) // running and will fail
-	c4 := sh.Fn(sleepFn, d0, 0)   // succeeded
-	c5 := sh.Fn(sleepFn, d0, 0)   // succeeded, called wait
-	c6 := sh.Fn(sleepFn, d0, 1)   // failed
-	c7 := sh.Fn(sleepFn, d0, 1)   // failed, called wait
+	c0 := sh.FuncCmd(sleepFunc, d0, 0)   // not started
+	c1 := sh.FuncCmd(sleepFunc, d0, 0)   // failed to start
+	c2 := sh.FuncCmd(sleepFunc, d200, 0) // running and will succeed
+	c3 := sh.FuncCmd(sleepFunc, d200, 1) // running and will fail
+	c4 := sh.FuncCmd(sleepFunc, d0, 0)   // succeeded
+	c5 := sh.FuncCmd(sleepFunc, d0, 0)   // succeeded, called wait
+	c6 := sh.FuncCmd(sleepFunc, d0, 1)   // failed
+	c7 := sh.FuncCmd(sleepFunc, d0, 1)   // failed, called wait
 
 	c3.ExitErrorIsOk = true
 	c6.ExitErrorIsOk = true
@@ -608,11 +612,7 @@
 	// Configure the "failed to start" command.
 	c1.StdinPipe()
 	c1.Stdin = "foo"
-	sh.Opts.Fatalf = nil
-	c1.Start()
-	nok(t, sh.Err)
-	sh.Err = nil
-	sh.Opts.Fatalf = makeFatalf(t)
+	setsErr(t, sh, func() { c1.Start() })
 
 	// Start commands, then wait for them to exit.
 	for _, c := range []*gosh.Cmd{c2, c3, c4, c5, c6, c7} {
@@ -627,8 +627,8 @@
 	// It should be possible to run existing unstarted commands, and to create and
 	// run new commands, after calling Shell.Wait.
 	c0.Run()
-	sh.Fn(sleepFn, d0, 0).Run()
-	sh.Fn(sleepFn, d0, 0).Start()
+	sh.FuncCmd(sleepFunc, d0, 0).Run()
+	sh.FuncCmd(sleepFunc, d0, 0).Start()
 
 	// Call Shell.Wait again.
 	sh.Wait()
@@ -639,24 +639,22 @@
 	defer sh.Cleanup()
 
 	// Exit code 0 is not an error.
-	c := sh.Fn(exitFn, 0)
+	c := sh.FuncCmd(exitFunc, 0)
 	c.Run()
 	ok(t, c.Err)
 	ok(t, sh.Err)
 
 	// Exit code 1 is an error.
-	c = sh.Fn(exitFn, 1)
+	c = sh.FuncCmd(exitFunc, 1)
 	c.ExitErrorIsOk = true
 	c.Run()
 	nok(t, c.Err)
 	ok(t, sh.Err)
 
 	// If ExitErrorIsOk is false, exit code 1 triggers sh.HandleError.
-	c = sh.Fn(exitFn, 1)
-	sh.Opts.Fatalf = nil
-	c.Run()
+	c = sh.FuncCmd(exitFunc, 1)
+	setsErr(t, sh, func() { c.Run() })
 	nok(t, c.Err)
-	nok(t, sh.Err)
 }
 
 // Tests that sh.Ok panics under various conditions.
@@ -727,5 +725,6 @@
 }
 
 func TestMain(m *testing.M) {
-	os.Exit(gosh.Run(m.Run))
+	gosh.InitMain()
+	os.Exit(m.Run())
 }
diff --git a/vlog/flags_test.go b/vlog/flags_test.go
index f241165..f22ed59 100644
--- a/vlog/flags_test.go
+++ b/vlog/flags_test.go
@@ -15,7 +15,7 @@
 	"v.io/x/lib/vlog"
 )
 
-var child = gosh.Register("child", func() error {
+var child = gosh.RegisterFunc("child", func() error {
 	tmp := filepath.Join(os.TempDir(), "foo")
 	flag.Set("log_dir", tmp)
 	flag.Set("vmodule", "foo=2")
@@ -44,9 +44,10 @@
 func TestFlags(t *testing.T) {
 	sh := gosh.NewShell(gosh.Opts{Fatalf: t.Fatalf, Logf: t.Logf})
 	defer sh.Cleanup()
-	sh.Fn(child).Run()
+	sh.FuncCmd(child).Run()
 }
 
 func TestMain(m *testing.M) {
-	os.Exit(gosh.Run(m.Run))
+	gosh.InitMain()
+	os.Exit(m.Run())
 }