diff --git a/git-review/branch.go b/git-review/branch.go
index 4cc8a0e..ad82a46 100644
--- a/git-review/branch.go
+++ b/git-review/branch.go
@@ -81,6 +81,18 @@
 	return b.commitHash
 }
 
+// Branchpoint returns an identifier for the latest revision
+// common to both this branch and its upstream branch.
+// If this branch has not split from upstream,
+// Branchpoint returns "HEAD".
+func (b *Branch) Branchpoint() string {
+	b.loadPending()
+	if b.parentHash == "" {
+		return "HEAD"
+	}
+	return b.parentHash
+}
+
 func (b *Branch) loadPending() {
 	if b.loadedPending {
 		return
@@ -99,17 +111,20 @@
 		parent := fields[i+2]
 		subject := fields[i+3]
 		msg := fields[i+4]
-		if i == 0 {
-			b.commitHash = hash
-			b.shortCommitHash = shortHash
-			b.parentHash = parent
-			b.subject = subject
-			b.message = msg
-			for _, line := range strings.Split(msg, "\n") {
-				if strings.HasPrefix(line, "Change-Id: ") {
-					b.changeID = line[len("Change-Id: "):]
-					break
-				}
+
+		// Overwrite each time through the loop.
+		// We want to save the info about the *first* commit
+		// after the branch point, and the log is ordered
+		// starting at the most recent and working backward.
+		b.commitHash = hash
+		b.shortCommitHash = shortHash
+		b.parentHash = parent
+		b.subject = subject
+		b.message = msg
+		for _, line := range strings.Split(msg, "\n") {
+			if strings.HasPrefix(line, "Change-Id: ") {
+				b.changeID = line[len("Change-Id: "):]
+				break
 			}
 		}
 		b.commitsAhead++
diff --git a/git-review/gofmt.go b/git-review/gofmt.go
new file mode 100644
index 0000000..4cde005
--- /dev/null
+++ b/git-review/gofmt.go
@@ -0,0 +1,315 @@
+// Copyright 2014 The Go Authors.  All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package main
+
+import (
+	"bytes"
+	"flag"
+	"fmt"
+	"io"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"sort"
+	"strings"
+)
+
+var gofmtList bool
+
+func gofmt(args []string) {
+	flags.BoolVar(&gofmtList, "l", false, "list files that need to be formatted")
+	flags.Parse(args)
+	if len(flag.Args()) > 0 {
+		fmt.Fprintf(os.Stderr, "Usage: %s gofmt %s [-l]\n", globalFlags, os.Args[0])
+		os.Exit(2)
+	}
+
+	f := gofmtCommand
+	if !gofmtList {
+		f |= gofmtWrite
+	}
+
+	files, stderr := runGofmt(f)
+	if gofmtList {
+		var out io.Writer = os.Stdout
+		if stdoutTrap != nil {
+			out = stdoutTrap
+		}
+		for _, file := range files {
+			fmt.Fprintf(out, "%s\n", file)
+		}
+	}
+	if stderr != "" {
+		dief("gofmt reported errors:\n\t%s", strings.Replace(strings.TrimSpace(stderr), "\n", "\n\t", -1))
+	}
+}
+
+const (
+	gofmtPreCommit = 1 << iota
+	gofmtCommand
+	gofmtWrite
+)
+
+// runGofmt runs the external gofmt command over modified files.
+//
+// The definition of "modified files" depends on the bit flags.
+// If gofmtPreCommit is set, then runGofmt considers *.go files that
+// differ between the index (staging area) and the branchpoint
+// (the latest commit before the branch diverged from upstream).
+// If gofmtCommand is set, then runGofmt considers all those files
+// in addition to files with unstaged modifications.
+// It never considers untracked files.
+//
+// As a special case for the main repo (but applied everywhere)
+// *.go files under a top-level test directory are excluded from the
+// formatting requirement, except those in test/bench/.
+//
+// If gofmtWrite is set (only with gofmtCommand, meaning this is 'git gofmt'),
+// runGofmt replaces the original files with their formatted equivalents.
+// Git makes this difficult. In general the file in the working tree
+// (the local file system) can have unstaged changes that make it different
+// from the equivalent file in the index. To help pass the precommit hook,
+// 'git gofmt'  must make it easy to update the files in the index.
+// One option is to run gofmt on all the files of the same name in the
+// working tree and leave it to the user to sort out what should be staged
+// back into the index. Another is to refuse to reformat files for which
+// different versions exist in the index vs the working tree. Both of these
+// options are unsatisfying: they foist busy work onto the user,
+// and it's exactly the kind of busy work that a program is best for.
+// Instead, when runGofmt finds files in the index that need
+// reformatting, it reformats them there, bypassing the working tree.
+// It also reformats files in the working tree that need reformatting.
+// For both, only files modified since the branchpoint are considered.
+// The result should be that both index and working tree get formatted
+// correctly and diffs between the two remain meaningful (free of
+// formatting distractions). Modifying files in the index directly may
+// surprise Git users, but it seems the best of a set of bad choices, and
+// of course those users can choose not to use 'git gofmt'.
+// This is a bit more work than the other git commands do, which is
+// a little worrying, but the choice being made has the nice property
+// that if 'git gofmt' is interrupted, a second 'git gofmt' will put things into
+// the same state the first would have.
+//
+// runGofmt returns a list of files that need (or needed) reformatting.
+// If gofmtPreCommit is set, the names always refer to files in the index.
+// If gofmtCommand is set, then a name without a suffix (see below)
+// refers to both the copy in the index and the copy in the working tree
+// and implies that the two copies are identical. Otherwise, in the case
+// that the index and working tree differ, the file name will have an explicit
+// " (staged)" or " (unstaged)" suffix saying which is meant.
+//
+// runGofmt also returns any standard error output from gofmt,
+// usually indicating syntax errors in the Go source files.
+// If gofmtCommand is set, syntax errors in index files that do not match
+// the working tree show a " (staged)" suffix after the file name.
+// The errors never use the " (unstaged)" suffix, in order to keep
+// references to the local file system in the standard file:line form.
+func runGofmt(flags int) (files []string, stderrText string) {
+	pwd, err := os.Getwd()
+	if err != nil {
+		dief("%v", err)
+	}
+	pwd = filepath.Clean(pwd) // convert to host \ syntax
+	if !strings.HasSuffix(pwd, string(filepath.Separator)) {
+		pwd += string(filepath.Separator)
+	}
+
+	b := CurrentBranch()
+	repo := repoRoot()
+	if !strings.HasSuffix(repo, string(filepath.Separator)) {
+		repo += string(filepath.Separator)
+	}
+
+	// Find files modified in the index compared to the branchpoint.
+	indexFiles := addRoot(repo, filter(gofmtRequired, getLines("git", "diff", "--name-only", "--diff-filter=ACM", "--cached", b.Branchpoint())))
+	localFiles := addRoot(repo, filter(gofmtRequired, getLines("git", "diff", "--name-only", "--diff-filter=ACM")))
+	localFilesMap := stringMap(localFiles)
+	isUnstaged := func(file string) bool {
+		return localFilesMap[file]
+	}
+
+	if len(indexFiles) == 0 && ((flags&gofmtCommand) == 0 || len(localFiles) == 0) {
+		return
+	}
+
+	// Determine which files have unstaged changes and are therefore
+	// different from their index versions. For those, the index version must
+	// be copied into a temporary file in the local file system.
+	needTemp := filter(isUnstaged, indexFiles)
+
+	// Map between temporary file name and place in file tree where
+	// file would be checked out (if not for the unstaged changes).
+	tempToFile := map[string]string{}
+	fileToTemp := map[string]string{}
+	cleanup := func() {} // call before dying (defer won't run)
+	if len(needTemp) > 0 {
+		// Ask Git to copy the index versions into temporary files.
+		// Git stores the temporary files, named .merge_*, in the repo root.
+		// Unlike the Git commands above, the non-temp file names printed
+		// here are relative to the current directory, not the repo root.
+		args := []string{"checkout-index", "--temp", "--"}
+		args = append(args, needTemp...)
+		for _, line := range getLines("git", args...) {
+			i := strings.Index(line, "\t")
+			if i < 0 {
+				continue
+			}
+			temp, file := line[:i], line[i+1:]
+			temp = filepath.Join(repo, temp)
+			file = filepath.Join(pwd, file)
+			tempToFile[temp] = file
+			fileToTemp[file] = temp
+		}
+		cleanup = func() {
+			for temp := range tempToFile {
+				os.Remove(temp)
+			}
+			tempToFile = nil
+		}
+		defer cleanup()
+	}
+	dief := func(format string, args ...interface{}) {
+		cleanup()
+		dief(format, args...) // calling top-level dief function
+	}
+
+	// Run gofmt to find out which files need reformatting;
+	// if gofmtWrite is set, reformat them in place.
+	// For references to local files, remove leading pwd if present
+	// to make relative to current directory.
+	// Temp files and local-only files stay as absolute paths for easy matching in output.
+	args := []string{"-l"}
+	if flags&gofmtWrite != 0 {
+		args = append(args, "-w")
+	}
+	for _, file := range indexFiles {
+		if isUnstaged(file) {
+			args = append(args, fileToTemp[file])
+		} else {
+			args = append(args, strings.TrimPrefix(file, pwd))
+		}
+	}
+	if flags&gofmtCommand != 0 {
+		for _, file := range localFiles {
+			args = append(args, file)
+		}
+	}
+
+	cmd := exec.Command("gofmt", args...)
+	var stdout, stderr bytes.Buffer
+	cmd.Stdout = &stdout
+	cmd.Stderr = &stderr
+	err = cmd.Run()
+
+	if stderr.Len() == 0 && err != nil {
+		// Error but no stderr: usually can't find gofmt.
+		dief("invoking gofmt: %v", err)
+	}
+
+	// Build file list.
+	files = strings.Split(stdout.String(), "\n")
+	if len(files) > 0 && files[len(files)-1] == "" {
+		files = files[:len(files)-1]
+	}
+
+	// Restage files that need to be restaged.
+	if flags&gofmtWrite != 0 {
+		add := []string{"add"}
+		write := []string{"hash-object", "-w", "--"}
+		updateIndex := []string{}
+		for _, file := range files {
+			if real := tempToFile[file]; real != "" {
+				write = append(write, file)
+				updateIndex = append(updateIndex, strings.TrimPrefix(real, repo))
+			} else if !isUnstaged(file) {
+				add = append(add, file)
+			}
+		}
+		if len(add) > 1 {
+			run("git", add...)
+		}
+		if len(updateIndex) > 0 {
+			hashes := getLines("git", write...)
+			if len(hashes) != len(write)-3 {
+				dief("git hash-object -w did not write expected number of objects")
+			}
+			var buf bytes.Buffer
+			for i, name := range updateIndex {
+				fmt.Fprintf(&buf, "100644 %s\t%s\n", hashes[i], name)
+			}
+			cmd := exec.Command("git", "update-index", "--index-info")
+			cmd.Stdin = &buf
+			out, err := cmd.CombinedOutput()
+			if err != nil {
+				dief("git update-index: %v\n%s", err, out)
+			}
+		}
+	}
+
+	// Remap temp files back to original names for caller.
+	for i, file := range files {
+		if real := tempToFile[file]; real != "" {
+			if flags&gofmtCommand != 0 {
+				real += " (staged)"
+			}
+			files[i] = strings.TrimPrefix(real, pwd)
+		} else if isUnstaged(file) {
+			files[i] = strings.TrimPrefix(file+" (unstaged)", pwd)
+		}
+	}
+
+	// Rewrite temp names in stderr, and shorten local file names.
+	// No suffix added for local file names (see comment above).
+	text := "\n" + stderr.String()
+	for temp, file := range tempToFile {
+		if flags&gofmtCommand != 0 {
+			file += " (staged)"
+		}
+		text = strings.Replace(text, "\n"+temp+":", "\n"+strings.TrimPrefix(file, pwd)+":", -1)
+	}
+	for _, file := range localFiles {
+		text = strings.Replace(text, "\n"+file+":", "\n"+strings.TrimPrefix(file, pwd)+":", -1)
+	}
+	text = text[1:]
+
+	sort.Strings(files)
+	return files, text
+}
+
+// gofmtRequired reports whether the specified file should be checked
+// for gofmt'dness by the pre-commit hook.
+// The file name is relative to the repo root.
+func gofmtRequired(file string) bool {
+	return strings.HasSuffix(file, ".go") &&
+		!(strings.HasPrefix(file, "test/") && !strings.HasPrefix(file, "test/bench/"))
+}
+
+// stringMap returns a map m such that m[s] == true if s was in the original list.
+func stringMap(list []string) map[string]bool {
+	m := map[string]bool{}
+	for _, x := range list {
+		m[x] = true
+	}
+	return m
+}
+
+// filter returns the elements in list satisfying f.
+func filter(f func(string) bool, list []string) []string {
+	var out []string
+	for _, x := range list {
+		if f(x) {
+			out = append(out, x)
+		}
+	}
+	return out
+}
+
+func addRoot(root string, list []string) []string {
+	var out []string
+	for _, x := range list {
+		out = append(out, filepath.Join(root, x))
+	}
+	return out
+}
diff --git a/git-review/gofmt_test.go b/git-review/gofmt_test.go
new file mode 100644
index 0000000..a4b884c
--- /dev/null
+++ b/git-review/gofmt_test.go
@@ -0,0 +1,171 @@
+// Copyright 2014 The Go Authors.  All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package main
+
+import (
+	"fmt"
+	"io/ioutil"
+	"os"
+	"strings"
+	"testing"
+)
+
+const (
+	goodGo      = "package good\n"
+	badGo       = " package bad1 "
+	badGoFixed  = "package bad1\n"
+	bad2Go      = " package bad2 "
+	bad2GoFixed = "package bad2\n"
+	brokenGo    = "package B R O K E N"
+)
+
+func TestGofmt(t *testing.T) {
+	// Test of basic operations.
+	gt := newGitTest(t)
+	defer gt.done()
+
+	gt.work(t)
+
+	if err := os.MkdirAll(gt.client+"/test/bench", 0755); err != nil {
+		t.Fatal(err)
+	}
+	write(t, gt.client+"/bad.go", badGo)
+	write(t, gt.client+"/good.go", goodGo)
+	write(t, gt.client+"/test/bad.go", badGo)
+	write(t, gt.client+"/test/good.go", goodGo)
+	write(t, gt.client+"/test/bench/bad.go", badGo)
+	write(t, gt.client+"/test/bench/good.go", goodGo)
+	trun(t, gt.client, "git", "add", ".") // make files tracked
+
+	testMain(t, "gofmt", "-l")
+	testPrintedStdout(t, "bad.go\n", "!good.go", "!test/bad", "test/bench/bad.go")
+
+	testMain(t, "gofmt", "-l")
+	testPrintedStdout(t, "bad.go\n", "!good.go", "!test/bad", "test/bench/bad.go")
+
+	testMain(t, "gofmt")
+	testPrintedStdout(t, "!.go") // no output
+
+	testMain(t, "gofmt", "-l")
+	testPrintedStdout(t, "!.go") // no output
+
+	write(t, gt.client+"/bad.go", badGo)
+	write(t, gt.client+"/broken.go", brokenGo)
+	trun(t, gt.client, "git", "add", ".")
+	testMainDied(t, "gofmt", "-l")
+	testPrintedStdout(t, "bad.go")
+	testPrintedStderr(t, "gofmt reported errors", "broken.go")
+}
+
+func TestGofmtUnstaged(t *testing.T) {
+	// Test when unstaged files are different from staged ones.
+	// See TestHookPreCommitUnstaged for an explanation.
+	// In this test we use two different kinds of bad files, so that
+	// we can test having a bad file in the index and a different
+	// bad file in the working directory.
+
+	gt := newGitTest(t)
+	defer gt.done()
+	gt.work(t)
+
+	name := []string{"good", "bad", "bad2", "broken"}
+	orig := []string{goodGo, badGo, bad2Go, brokenGo}
+	fixed := []string{goodGo, badGoFixed, bad2GoFixed, brokenGo}
+	const N = 4
+
+	var allFiles, wantOut, wantErr []string
+	writeFiles := func(n int) {
+		allFiles = nil
+		wantOut = nil
+		wantErr = nil
+		for i := 0; i < N*N*N; i++ {
+			// determine n'th digit of 3-digit base-N value i
+			j := i
+			for k := 0; k < (3 - 1 - n); k++ {
+				j /= N
+			}
+			text := orig[j%N]
+			file := fmt.Sprintf("%s-%s-%s.go", name[i/N/N], name[(i/N)%N], name[i%N])
+			allFiles = append(allFiles, file)
+			write(t, gt.client+"/"+file, text)
+
+			if (i/N)%N != i%N {
+				staged := file + " (staged)"
+				switch {
+				case strings.Contains(file, "-bad-"), strings.Contains(file, "-bad2-"):
+					wantOut = append(wantOut, staged)
+					wantErr = append(wantErr, "!"+staged)
+				case strings.Contains(file, "-broken-"):
+					wantOut = append(wantOut, "!"+staged)
+					wantErr = append(wantErr, staged)
+				default:
+					wantOut = append(wantOut, "!"+staged)
+					wantErr = append(wantErr, "!"+staged)
+				}
+			}
+			switch {
+			case strings.Contains(file, "-bad.go"), strings.Contains(file, "-bad2.go"):
+				if (i/N)%N != i%N {
+					file += " (unstaged)"
+				}
+				wantOut = append(wantOut, file+"\n")
+				wantErr = append(wantErr, "!"+file+":", "!"+file+" (unstaged)")
+			case strings.Contains(file, "-broken.go"):
+				wantOut = append(wantOut, "!"+file+"\n", "!"+file+" (unstaged)")
+				wantErr = append(wantErr, file+":")
+			default:
+				wantOut = append(wantOut, "!"+file+"\n", "!"+file+":", "!"+file+" (unstaged)")
+				wantErr = append(wantErr, "!"+file+"\n", "!"+file+":", "!"+file+" (unstaged)")
+			}
+		}
+	}
+
+	// committed files
+	writeFiles(0)
+	trun(t, gt.client, "git", "add", ".")
+	trun(t, gt.client, "git", "commit", "-m", "msg")
+
+	// staged files
+	writeFiles(1)
+	trun(t, gt.client, "git", "add", ".")
+
+	// unstaged files
+	writeFiles(2)
+
+	// Check that gofmt -l shows the right output and errors.
+	testMainDied(t, "gofmt", "-l")
+	testPrintedStdout(t, wantOut...)
+	testPrintedStderr(t, wantErr...)
+
+	// Again (last command should not have written anything).
+	testMainDied(t, "gofmt", "-l")
+	testPrintedStdout(t, wantOut...)
+	testPrintedStderr(t, wantErr...)
+
+	// Reformat in place.
+	testMainDied(t, "gofmt")
+	testPrintedStdout(t, "!.go")
+	testPrintedStderr(t, wantErr...)
+
+	// Read files to make sure unstaged did not bleed into staged.
+	for i, file := range allFiles {
+		if data, err := ioutil.ReadFile(gt.client + "/" + file); err != nil {
+			t.Errorf("%v", err)
+		} else if want := fixed[i%N]; string(data) != want {
+			t.Errorf("%s: working tree = %q, want %q", file, string(data), want)
+		}
+		if data, want := trun(t, gt.client, "git", "show", ":"+file), fixed[i/N%N]; data != want {
+			t.Errorf("%s: index = %q, want %q", file, data, want)
+		}
+		if data, want := trun(t, gt.client, "git", "show", "HEAD:"+file), orig[i/N/N]; data != want {
+			t.Errorf("%s: commit = %q, want %q", file, data, want)
+		}
+	}
+
+	// Check that gofmt -l still shows the errors.
+	testMainDied(t, "gofmt", "-l")
+	testPrintedStdout(t, "!.go")
+	testPrintedStderr(t, wantErr...)
+}
diff --git a/git-review/hook.go b/git-review/hook.go
index f79d78d..fd8a9ef 100644
--- a/git-review/hook.go
+++ b/git-review/hook.go
@@ -151,41 +151,26 @@
 		dief("cannot commit on %s branch", b.Name)
 	}
 
-	root := repoRoot()
+	hookGofmt()
+}
 
-	// Run the gofmt check over the pending commit, if any.
-	rev := "HEAD"
-	if b.HasPendingCommit() {
-		rev = "HEAD^" // branch point, hopefully
-	}
-	// This command prints file names relative to the repo root.
-	files := getLines("git", "diff", "--cached", "--name-only", "--diff-filter=ACM", rev)
-	var goFiles []string // absolute paths of files that need gofmting
-	for _, file := range files {
-		if gofmtRequired(file) {
-			goFiles = append(goFiles, filepath.Join(root, file))
+func hookGofmt() {
+	files, stderr := runGofmt(gofmtPreCommit)
+
+	if stderr != "" {
+		msgf := printf
+		if len(files) == 0 {
+			msgf = dief
 		}
-	}
-	if len(goFiles) == 0 {
-		return
+		msgf("gofmt reported errors:\n\t%s", strings.Replace(strings.TrimSpace(stderr), "\n", "\n\t", -1))
 	}
 
-	// Check gofmt.
-	unfmted := getLines("gofmt", append([]string{"-l"}, goFiles...)...)
-	if len(unfmted) == 0 {
+	if len(files) == 0 {
 		return
 	}
 
 	dief("gofmt needs to format these files (run 'git gofmt'):\n\t%s",
-		strings.Join(unfmted, "\n\t"))
-}
-
-// gofmtRequired reports whether the specified file should be checked
-// for gofmt'dness by the pre-commit hook.
-// The file name is relative to the repo root.
-func gofmtRequired(file string) bool {
-	return strings.HasSuffix(file, ".go") &&
-		!(strings.HasPrefix(file, "test/") && !strings.HasPrefix(file, "test/bench/"))
+		strings.Join(files, "\n\t"))
 }
 
 // This is NOT USED ANYMORE.
diff --git a/git-review/hook_test.go b/git-review/hook_test.go
index 2ccc7c4..20b4b68 100644
--- a/git-review/hook_test.go
+++ b/git-review/hook_test.go
@@ -6,6 +6,7 @@
 
 import (
 	"bytes"
+	"fmt"
 	"io/ioutil"
 	"os"
 	"path/filepath"
@@ -51,21 +52,15 @@
 	gt := newGitTest(t)
 	defer gt.done()
 
-	gt.removeStubHooks()
-	testMain(t, "hooks") // install hooks
-
 	// Write out a non-Go file.
 	testMain(t, "change", "mybranch")
 	write(t, gt.client+"/msg.txt", "A test message.")
 	trun(t, gt.client, "git", "add", "msg.txt")
 	testMain(t, "hook-invoke", "pre-commit") // should be no-op
 
-	// Write out a badly formatted Go files.
 	if err := os.MkdirAll(gt.client+"/test/bench", 0755); err != nil {
 		t.Fatal(err)
 	}
-	const badGo = "package main\nfunc main(){}"
-	const goodGo = "package main\n\nfunc main() {\n}\n"
 	write(t, gt.client+"/bad.go", badGo)
 	write(t, gt.client+"/good.go", goodGo)
 	write(t, gt.client+"/test/bad.go", badGo)
@@ -77,6 +72,79 @@
 	testMainDied(t, "hook-invoke", "pre-commit")
 	testPrintedStderr(t, "gofmt needs to format these files (run 'git gofmt'):",
 		"bad.go", "!good.go", "!test/bad", "test/bench/bad.go")
+
+	write(t, gt.client+"/broken.go", brokenGo)
+	trun(t, gt.client, "git", "add", "broken.go")
+	testMainDied(t, "hook-invoke", "pre-commit")
+	testPrintedStderr(t, "gofmt needs to format these files (run 'git gofmt'):",
+		"bad.go", "!good.go", "!test/bad", "test/bench/bad.go",
+		"gofmt reported errors:", "broken.go")
+}
+
+func TestHookPreCommitUnstaged(t *testing.T) {
+	gt := newGitTest(t)
+	defer gt.done()
+	gt.work(t)
+
+	write(t, gt.client+"/bad.go", badGo)
+	write(t, gt.client+"/good.go", goodGo)
+
+	// The pre-commit hook is being asked about files in the index.
+	// Make sure it is not looking at files in the working tree (current directory) instead.
+	// There are three possible kinds of file: good, bad (misformatted), and broken (syntax error).
+	// There are also three possible places files live: the most recent commit, the index,
+	// and the working tree. We write a sequence of files that cover all possible
+	// combination of kinds of file in the various places. For example,
+	// good-bad-broken.go is a good file in the most recent commit,
+	// a bad file in the index, and a broken file in the working tree.
+	// After creating these files, we check that the gofmt hook reports
+	// about the index only.
+
+	const N = 3
+	name := []string{"good", "bad", "broken"}
+	content := []string{goodGo, badGo, brokenGo}
+	var wantErr []string
+	var allFiles []string
+	writeFiles := func(n int) {
+		allFiles = nil
+		wantErr = nil
+		for i := 0; i < N*N*N; i++ {
+			// determine n'th digit of 3-digit base-N value i
+			j := i
+			for k := 0; k < (3 - 1 - n); k++ {
+				j /= N
+			}
+			file := fmt.Sprintf("%s-%s-%s.go", name[i/N/N], name[(i/N)%N], name[i%N])
+			allFiles = append(allFiles, file)
+			write(t, gt.client+"/"+file, content[j%N])
+
+			switch {
+			case strings.Contains(file, "-bad-"):
+				wantErr = append(wantErr, "\t"+file+"\n")
+			case strings.Contains(file, "-broken-"):
+				wantErr = append(wantErr, "\t"+file+":")
+			default:
+				wantErr = append(wantErr, "!"+file)
+			}
+		}
+	}
+
+	// committed files
+	writeFiles(0)
+	trun(t, gt.client, "git", "add", ".")
+	trun(t, gt.client, "git", "commit", "-m", "msg")
+
+	// staged files
+	writeFiles(1)
+	trun(t, gt.client, "git", "add", ".")
+
+	// unstaged files
+	writeFiles(2)
+
+	wantErr = append(wantErr, "gofmt reported errors", "gofmt needs to format these files")
+
+	testMainDied(t, "hook-invoke", "pre-commit")
+	testPrintedStderr(t, wantErr...)
 }
 
 func TestHooks(t *testing.T) {
diff --git a/git-review/mail.go b/git-review/mail.go
index 99821e3..01dd4b8 100644
--- a/git-review/mail.go
+++ b/git-review/mail.go
@@ -36,7 +36,7 @@
 	}
 
 	if *diff {
-		run("git", "diff", "HEAD^..HEAD")
+		run("git", "diff", b.Branchpoint()+"..HEAD")
 		return
 	}
 
diff --git a/git-review/review.go b/git-review/review.go
index fa049a3..7097e8e 100644
--- a/git-review/review.go
+++ b/git-review/review.go
@@ -53,10 +53,12 @@
 		Create a change commit, or amend an existing change commit,
 		with the staged changes. If a branch name is provided, check
 		out that branch (creating it if it does not exist).
-		(Does not amend the existing commit when switching branches.)
+		Does not amend the existing commit when switching branches.
 
-	gofmt
-		TBD
+	gofmt [-l]
+		Run gofmt on all tracked files in the staging area and the working tree.
+		If -l is specified, list files that need formatting.
+		Otherwise, reformat files in place.
 
 	help
 		Show this help text.
@@ -111,7 +113,7 @@
 	case "change":
 		change(args)
 	case "gofmt":
-		dief("gofmt not implemented")
+		gofmt(args)
 	case "hook-invoke":
 		hookInvoke(args)
 	case "hooks":
@@ -148,9 +150,13 @@
 	}
 }
 
+func runErr(command string, args ...string) error {
+	return runDirErr("", command, args...)
+}
+
 var runLogTrap []string
 
-func runErr(command string, args ...string) error {
+func runDirErr(dir, command string, args ...string) error {
 	if *verbose > 0 || *noRun {
 		fmt.Fprintln(os.Stderr, commandString(command, args))
 	}
diff --git a/git-review/sync.go b/git-review/sync.go
index d96ba77..8df3427 100644
--- a/git-review/sync.go
+++ b/git-review/sync.go
@@ -31,7 +31,7 @@
 	// Pull should have done this for us, but check just in case.
 	b.loadedPending = false
 	if b.Submitted(id) && b.HasPendingCommit() {
-		run("git", "reset", "HEAD^")
+		run("git", "reset", b.Branchpoint())
 	}
 }
 
diff --git a/git-review/util_test.go b/git-review/util_test.go
index c2406dc..b095a5f 100644
--- a/git-review/util_test.go
+++ b/git-review/util_test.go
@@ -147,6 +147,9 @@
 }
 
 func testMain(t *testing.T, args ...string) {
+	*noRun = false
+	*verbose = 0
+
 	t.Logf("git-review %s", strings.Join(args, " "))
 
 	canDie := mainCanDie