diff --git a/doc.go b/doc.go
index c74bb6b..2c3b843 100644
--- a/doc.go
+++ b/doc.go
@@ -214,31 +214,21 @@
 doesn't already exist, otherwise additional imports are added to the existing
 file.
 
-<manifest> specifies the manifest file to use.
+An <import> element is added to the manifest representing a remote manifest
+import.  The manifest file path is relative to the root directory of the remote
+import repository.
 
-[remote] optionally specifies the remote manifest repository.
-
-If [remote] is not specified, a <fileimport> element is added to the manifest,
-representing a local file import.  The manifest file may be an absolute path, or
-relative to the current working directory.  The resulting path must be a
-subdirectory of $JIRI_ROOT.
-
-If [remote] is specified, an <import> element is added to the manifest,
-representing a remote manifest import.  The remote manifest repository is
-treated similar to regular projects; "jiri update" will update all remote
-manifest repository projects before updating regular projects.  The manifest
-file path is relative to the root directory of the remote import repository.
-
-Example of a local file import:
-  $ jiri import $JIRI_ROOT/path/to/manifest/file
-
-Example of a remote manifest import:
+Example:
   $ jiri import myfile https://foo.com/bar.git
 
 Run "jiri help manifest" for details on manifests.
 
 Usage:
-   jiri import [flags] <manifest> [remote]
+   jiri import [flags] <manifest> <remote>
+
+<manifest> specifies the manifest file to use.
+
+<remote> specifies the remote manifest repository.
 
 The jiri import flags are:
  -name=
@@ -251,15 +241,11 @@
    Write a new .jiri_manifest file with the given specification.  If it already
    exists, the existing content will be ignored and the file will be
    overwritten.
- -path=
-   Path to store the manifest project locally.  Uses "manifest" if unspecified.
  -protocol=git
    The version control protocol used by the remote manifest project.
  -remote-branch=master
    The branch of the remote manifest project to track, without the leading
    "origin/".
- -revision=HEAD
-   The revision of the remote manifest project to reset to during "jiri update".
  -root=
    Root to store the manifest project locally.
 
diff --git a/import.go b/import.go
index fc9ce35..7636f13 100644
--- a/import.go
+++ b/import.go
@@ -5,10 +5,7 @@
 package main
 
 import (
-	"fmt"
 	"os"
-	"path/filepath"
-	"strings"
 
 	"v.io/jiri/jiri"
 	"v.io/jiri/project"
@@ -18,7 +15,7 @@
 
 var (
 	// Flags for configuring project attributes for remote imports.
-	flagImportName, flagImportPath, flagImportProtocol, flagImportRemoteBranch, flagImportRevision, flagImportRoot string
+	flagImportName, flagImportProtocol, flagImportRemoteBranch, flagImportRoot string
 	// Flags for controlling the behavior of the command.
 	flagImportOverwrite bool
 	flagImportOut       string
@@ -26,10 +23,8 @@
 
 func init() {
 	cmdImport.Flags.StringVar(&flagImportName, "name", "", `The name of the remote manifest project, used to disambiguate manifest projects with the same remote.  Typically empty.`)
-	cmdImport.Flags.StringVar(&flagImportPath, "path", "", `Path to store the manifest project locally.  Uses "manifest" if unspecified.`)
 	cmdImport.Flags.StringVar(&flagImportProtocol, "protocol", "git", `The version control protocol used by the remote manifest project.`)
 	cmdImport.Flags.StringVar(&flagImportRemoteBranch, "remote-branch", "master", `The branch of the remote manifest project to track, without the leading "origin/".`)
-	cmdImport.Flags.StringVar(&flagImportRevision, "revision", "HEAD", `The revision of the remote manifest project to reset to during "jiri update".`)
 	cmdImport.Flags.StringVar(&flagImportRoot, "root", "", `Root to store the manifest project locally.`)
 
 	cmdImport.Flags.BoolVar(&flagImportOverwrite, "overwrite", false, `Write a new .jiri_manifest file with the given specification.  If it already exists, the existing content will be ignored and the file will be overwritten.`)
@@ -46,34 +41,25 @@
 doesn't already exist, otherwise additional imports are added to the existing
 file.
 
-<manifest> specifies the manifest file to use.
+An <import> element is added to the manifest representing a remote manifest
+import.  The manifest file path is relative to the root directory of the remote
+import repository.
 
-[remote] optionally specifies the remote manifest repository.
-
-If [remote] is not specified, a <fileimport> element is added to the manifest,
-representing a local file import.  The manifest file may be an absolute path, or
-relative to the current working directory.  The resulting path must be a
-subdirectory of $JIRI_ROOT.
-
-If [remote] is specified, an <import> element is added to the manifest,
-representing a remote manifest import.  The remote manifest repository is
-treated similar to regular projects; "jiri update" will update all remote
-manifest repository projects before updating regular projects.  The manifest
-file path is relative to the root directory of the remote import repository.
-
-Example of a local file import:
-  $ jiri import $JIRI_ROOT/path/to/manifest/file
-
-Example of a remote manifest import:
+Example:
   $ jiri import myfile https://foo.com/bar.git
 
 Run "jiri help manifest" for details on manifests.
 `,
-	ArgsName: "<manifest> [remote]",
+	ArgsName: "<manifest> <remote>",
+	ArgsLong: `
+<manifest> specifies the manifest file to use.
+
+<remote> specifies the remote manifest repository.
+`,
 }
 
 func runImport(jirix *jiri.X, args []string) error {
-	if len(args) == 0 || len(args) > 2 {
+	if len(args) != 2 {
 		return jirix.UsageErrorf("wrong number of arguments")
 	}
 	// Initialize manifest.
@@ -88,44 +74,16 @@
 	if manifest == nil {
 		manifest = &project.Manifest{}
 	}
-	// Add the local or remote import.
-	if len(args) == 1 {
-		// FileImport.File is relative to the directory containing the manifest
-		// file; since the .jiri_manifest file is in JIRI_ROOT, that's what it
-		// should be relative to.
-		if _, err := os.Stat(args[0]); err != nil {
-			return err
-		}
-		abs, err := filepath.Abs(args[0])
-		if err != nil {
-			return err
-		}
-		rel, err := filepath.Rel(jirix.Root, abs)
-		if err != nil {
-			return err
-		}
-		if strings.HasPrefix(rel, "..") {
-			return fmt.Errorf("%s is not a subdirectory of JIRI_ROOT %s", abs, jirix.Root)
-		}
-		manifest.FileImports = append(manifest.FileImports, project.FileImport{
-			File: rel,
-		})
-	} else {
-		// There's not much error checking when writing the .jiri_manifest file;
-		// errors will be reported when "jiri update" is run.
-		manifest.Imports = append(manifest.Imports, project.Import{
-			Manifest: args[0],
-			Root:     flagImportRoot,
-			Project: project.Project{
-				Name:         flagImportName,
-				Path:         flagImportPath,
-				Protocol:     flagImportProtocol,
-				Remote:       args[1],
-				RemoteBranch: flagImportRemoteBranch,
-				Revision:     flagImportRevision,
-			},
-		})
-	}
+	// There's not much error checking when writing the .jiri_manifest file;
+	// errors will be reported when "jiri update" is run.
+	manifest.Imports = append(manifest.Imports, project.Import{
+		Manifest:     args[0],
+		Name:         flagImportName,
+		Protocol:     flagImportProtocol,
+		Remote:       args[1],
+		RemoteBranch: flagImportRemoteBranch,
+		Root:         flagImportRoot,
+	})
 	// Write output to stdout or file.
 	outFile := flagImportOut
 	if outFile == "" {
diff --git a/import_test.go b/import_test.go
index d1ae209..7b13b97 100644
--- a/import_test.go
+++ b/import_test.go
@@ -29,58 +29,19 @@
 			Stderr: `wrong number of arguments`,
 		},
 		{
+			Args:   []string{"a"},
+			Stderr: `wrong number of arguments`,
+		},
+		{
 			Args:   []string{"a", "b", "c"},
 			Stderr: `wrong number of arguments`,
 		},
-		// Local file imports, default append behavior
-		{
-			Args: []string{"manfile"},
-			Want: `<manifest>
-  <imports>
-    <fileimport file="manfile"/>
-  </imports>
-</manifest>
-`,
-		},
-		{
-			Args: []string{"./manfile"},
-			Want: `<manifest>
-  <imports>
-    <fileimport file="manfile"/>
-  </imports>
-</manifest>
-`,
-		},
-		{
-			Args: []string{"manfile"},
-			Exist: `<manifest>
-  <imports>
-    <import manifest="bar" remote="https://github.com/orig.git"/>
-  </imports>
-</manifest>
-`,
-			Want: `<manifest>
-  <imports>
-    <import manifest="bar" remote="https://github.com/orig.git"/>
-    <fileimport file="manfile"/>
-  </imports>
-</manifest>
-`,
-		},
-		{
-			Args:   []string{"../manfile"},
-			Stderr: `not a subdirectory of JIRI_ROOT`,
-		},
-		{
-			Args:   []string{"noexist"},
-			Stderr: `no such file`,
-		},
 		// Remote imports, default append behavior
 		{
-			Args: []string{"-name=name", "-path=path", "-remote-branch=remotebranch", "-revision=revision", "-root=root", "foo", "https://github.com/new.git"},
+			Args: []string{"-name=name", "-remote-branch=remotebranch", "-root=root", "foo", "https://github.com/new.git"},
 			Want: `<manifest>
   <imports>
-    <import manifest="foo" root="root" name="name" path="path" remote="https://github.com/new.git" remotebranch="remotebranch" revision="revision"/>
+    <import manifest="foo" name="name" remote="https://github.com/new.git" remotebranch="remotebranch" root="root"/>
   </imports>
 </manifest>
 `,
@@ -129,48 +90,6 @@
 </manifest>
 `,
 		},
-		// Local file imports, explicit overwrite behavior
-		{
-			Args: []string{"-overwrite", "manfile"},
-			Want: `<manifest>
-  <imports>
-    <fileimport file="manfile"/>
-  </imports>
-</manifest>
-`,
-		},
-		{
-			Args: []string{"-overwrite", "./manfile"},
-			Want: `<manifest>
-  <imports>
-    <fileimport file="manfile"/>
-  </imports>
-</manifest>
-`,
-		},
-		{
-			Args: []string{"-overwrite", "manfile"},
-			Exist: `<manifest>
-  <imports>
-    <import manifest="bar" remote="https://github.com/orig.git"/>
-  </imports>
-</manifest>
-`,
-			Want: `<manifest>
-  <imports>
-    <fileimport file="manfile"/>
-  </imports>
-</manifest>
-`,
-		},
-		{
-			Args:   []string{"-overwrite", "../manfile"},
-			Stderr: `not a subdirectory of JIRI_ROOT`,
-		},
-		{
-			Args:   []string{"-overwrite", "noexist"},
-			Stderr: `no such file`,
-		},
 		// Remote imports, explicit overwrite behavior
 		{
 			Args: []string{"-overwrite", "foo", "https://github.com/new.git"},
diff --git a/jiri/x.go b/jiri/x.go
index 6a574b3..c67a452 100644
--- a/jiri/x.go
+++ b/jiri/x.go
@@ -144,6 +144,9 @@
 
 // ResolveManifestPath resolves the given manifest name to an absolute path in
 // the local filesystem.
+//
+// TODO(toddw): Remove this once the transition to new manifests is done.  In
+// the new world, we always start with the JiriManifestFile.
 func (x *X) ResolveManifestPath(name string) (string, error) {
 	if x.UsingOldManifests() {
 		return x.resolveManifestPathDeprecated(name)
diff --git a/profiles/profilesreader/reader.go b/profiles/profilesreader/reader.go
index eff4533..09bea9c 100644
--- a/profiles/profilesreader/reader.go
+++ b/profiles/profilesreader/reader.go
@@ -104,7 +104,6 @@
 	jirix        *jiri.X
 	config       *util.Config
 	projects     project.Projects
-	tools        project.Tools
 	pdb          *profiles.DB
 }
 
@@ -117,7 +116,7 @@
 	if err != nil {
 		return nil, err
 	}
-	projects, tools, err := project.ReadJiriManifest(jirix)
+	projects, _, err := project.LoadManifest(jirix)
 	if err != nil {
 		return nil, err
 	}
@@ -131,7 +130,6 @@
 		jirix:        jirix,
 		config:       config,
 		projects:     projects,
-		tools:        tools,
 		profilesMode: bool(profilesMode),
 		pdb:          pdb,
 	}
diff --git a/project/.api b/project/.api
index f475c27..7f0d015 100644
--- a/project/.api
+++ b/project/.api
@@ -9,6 +9,7 @@
 pkg project, func DataDirPath(*jiri.X, string) (string, error)
 pkg project, func GetProjectStates(*jiri.X, bool) (map[ProjectKey]*ProjectState, error)
 pkg project, func InstallTools(*jiri.X, string) error
+pkg project, func LoadManifest(*jiri.X) (Projects, Tools, error)
 pkg project, func LocalProjects(*jiri.X, ScanMode) (Projects, error)
 pkg project, func MakeProjectKey(string, string) ProjectKey
 pkg project, func ManifestFromBytes([]byte) (*Manifest, error)
@@ -17,13 +18,11 @@
 pkg project, func PollProjects(*jiri.X, map[string]struct{}) (Update, error)
 pkg project, func ProjectAtPath(*jiri.X, string) (Project, error)
 pkg project, func ProjectFromFile(*jiri.X, string) (*Project, error)
-pkg project, func ReadJiriManifest(*jiri.X) (Projects, Tools, error)
 pkg project, func TransitionBinDir(*jiri.X) error
 pkg project, func UpdateUniverse(*jiri.X, bool) error
+pkg project, method (*Import) ProjectKey() ProjectKey
 pkg project, method (*Manifest) ToBytes() ([]byte, error)
 pkg project, method (*Manifest) ToFile(*jiri.X, string) error
-pkg project, method (Import) Key() ProjectKey
-pkg project, method (Import) ToFile(*jiri.X, string) error
 pkg project, method (Project) Key() ProjectKey
 pkg project, method (Project) ToFile(*jiri.X, string) error
 pkg project, method (ProjectKeys) Len() int
@@ -39,18 +38,21 @@
 pkg project, type CL struct, Author string
 pkg project, type CL struct, Description string
 pkg project, type CL struct, Email string
-pkg project, type FileImport struct
-pkg project, type FileImport struct, File string
-pkg project, type FileImport struct, XMLName struct{}
 pkg project, type Import struct
 pkg project, type Import struct, Manifest string
+pkg project, type Import struct, Name string
+pkg project, type Import struct, Protocol string
+pkg project, type Import struct, Remote string
+pkg project, type Import struct, RemoteBranch string
 pkg project, type Import struct, Root string
 pkg project, type Import struct, XMLName struct{}
-pkg project, type Import struct, embedded Project
+pkg project, type LocalImport struct
+pkg project, type LocalImport struct, File string
+pkg project, type LocalImport struct, XMLName struct{}
 pkg project, type Manifest struct
-pkg project, type Manifest struct, FileImports []FileImport
 pkg project, type Manifest struct, Imports []Import
 pkg project, type Manifest struct, Label string
+pkg project, type Manifest struct, LocalImports []LocalImport
 pkg project, type Manifest struct, Projects []Project
 pkg project, type Manifest struct, Tools []Tool
 pkg project, type Manifest struct, XMLName struct{}
diff --git a/project/paths.go b/project/paths.go
index d34c41f..e21e9bc 100644
--- a/project/paths.go
+++ b/project/paths.go
@@ -18,7 +18,7 @@
 // breaks.  We should revisit the whole data directory thing, and in particular
 // see if we can get rid of tools having to know their own names.
 func DataDirPath(jirix *jiri.X, toolName string) (string, error) {
-	projects, tools, err := ReadJiriManifest(jirix)
+	projects, tools, err := LoadManifest(jirix)
 	if err != nil {
 		return "", err
 	}
diff --git a/project/project.go b/project/project.go
index 7b81ad4..3d52109 100644
--- a/project/project.go
+++ b/project/project.go
@@ -8,6 +8,7 @@
 	"bytes"
 	"encoding/xml"
 	"fmt"
+	"hash/fnv"
 	"io/ioutil"
 	"net/url"
 	"os"
@@ -40,12 +41,12 @@
 
 // Manifest represents a setting used for updating the universe.
 type Manifest struct {
-	Imports     []Import     `xml:"imports>import"`
-	FileImports []FileImport `xml:"imports>fileimport"`
-	Label       string       `xml:"label,attr,omitempty"`
-	Projects    []Project    `xml:"projects>project"`
-	Tools       []Tool       `xml:"tools>tool"`
-	XMLName     struct{}     `xml:"manifest"`
+	Imports      []Import      `xml:"imports>import"`
+	LocalImports []LocalImport `xml:"imports>localimport"`
+	Label        string        `xml:"label,attr,omitempty"`
+	Projects     []Project     `xml:"projects>project"`
+	Tools        []Tool        `xml:"tools>tool"`
+	XMLName      struct{}      `xml:"manifest"`
 }
 
 // ManifestFromBytes returns a manifest parsed from data, with defaults filled
@@ -81,11 +82,11 @@
 	emptyProjectsBytes = []byte("\n  <projects></projects>\n")
 	emptyToolsBytes    = []byte("\n  <tools></tools>\n")
 
-	endElemBytes       = []byte("/>\n")
-	endImportBytes     = []byte("></import>\n")
-	endFileImportBytes = []byte("></fileimport>\n")
-	endProjectBytes    = []byte("></project>\n")
-	endToolBytes       = []byte("></tool>\n")
+	endElemBytes        = []byte("/>\n")
+	endImportBytes      = []byte("></import>\n")
+	endLocalImportBytes = []byte("></localimport>\n")
+	endProjectBytes     = []byte("></project>\n")
+	endToolBytes        = []byte("></tool>\n")
 
 	endImportSoloBytes  = []byte("></import>")
 	endProjectSoloBytes = []byte("></project>")
@@ -97,7 +98,7 @@
 	x := new(Manifest)
 	x.Label = m.Label
 	x.Imports = append([]Import(nil), m.Imports...)
-	x.FileImports = append([]FileImport(nil), m.FileImports...)
+	x.LocalImports = append([]LocalImport(nil), m.LocalImports...)
 	x.Projects = append([]Project(nil), m.Projects...)
 	x.Tools = append([]Tool(nil), m.Tools...)
 	return x
@@ -119,7 +120,7 @@
 	data = bytes.Replace(data, emptyProjectsBytes, newlineBytes, -1)
 	data = bytes.Replace(data, emptyToolsBytes, newlineBytes, -1)
 	data = bytes.Replace(data, endImportBytes, endElemBytes, -1)
-	data = bytes.Replace(data, endFileImportBytes, endElemBytes, -1)
+	data = bytes.Replace(data, endLocalImportBytes, endElemBytes, -1)
 	data = bytes.Replace(data, endProjectBytes, endElemBytes, -1)
 	data = bytes.Replace(data, endToolBytes, endElemBytes, -1)
 	if !bytes.HasSuffix(data, newlineBytes) {
@@ -153,8 +154,8 @@
 			return err
 		}
 	}
-	for index := range m.FileImports {
-		if err := m.FileImports[index].validate(); err != nil {
+	for index := range m.LocalImports {
+		if err := m.LocalImports[index].validate(); err != nil {
 			return err
 		}
 	}
@@ -177,8 +178,8 @@
 			return err
 		}
 	}
-	for index := range m.FileImports {
-		if err := m.FileImports[index].validate(); err != nil {
+	for index := range m.LocalImports {
+		if err := m.LocalImports[index].validate(); err != nil {
 			return err
 		}
 	}
@@ -199,36 +200,37 @@
 type Import struct {
 	// Manifest file to use from the remote manifest project.
 	Manifest string `xml:"manifest,attr,omitempty"`
-	// Root path, prepended to the manifest project path, as well as all projects
-	// specified in the manifest file.
-	Root string `xml:"root,attr,omitempty"`
-	// Project description of the manifest repository.
-	Project
+	// Name is the name of the remote manifest project, used to determine the
+	// project key.
+	//
+	// If Remote and Manifest are empty, it is the old-style name of the manifest
+	// to import, similar to localimport. This is deprecated behavior, and will be
+	// removed.
+	//
+	// TODO(toddw): Remove the old behavior when the transition to new-style
+	// manifests is complete.
+	Name string `xml:"name,attr,omitempty"`
+	// Protocol is the version control protocol used by the remote manifest
+	// project. If not set, "git" is used as the default.
+	Protocol string `xml:"protocol,attr,omitempty"`
+	// Remote is the remote manifest project to import.
+	Remote string `xml:"remote,attr,omitempty"`
+	// RemoteBranch is the name of the remote branch to track. It doesn't affect
+	// the name of the local branch that jiri maintains, which is always
+	// "master". If not set, "master" is used as the default.
+	RemoteBranch string `xml:"remotebranch,attr,omitempty"`
+	// Root path, prepended to all project paths specified in the manifest file.
+	Root    string   `xml:"root,attr,omitempty"`
 	XMLName struct{} `xml:"import"`
 }
 
-// ToFile writes the import i to a file with the given filename, with defaults
-// unfilled.
-func (i Import) ToFile(jirix *jiri.X, filename string) error {
-	if err := i.unfillDefaults(); err != nil {
-		return err
-	}
-	data, err := xml.Marshal(i)
-	if err != nil {
-		return fmt.Errorf("import xml.Marshal failed: %v", err)
-	}
-	// Same logic as Manifest.ToBytes, to make the output more compact.
-	data = bytes.Replace(data, endImportSoloBytes, endElemSoloBytes, -1)
-	return safeWriteFile(jirix, filename, data)
-}
-
 func (i *Import) fillDefaults() error {
 	if i.Remote != "" {
-		if i.Path == "" {
-			i.Path = "manifest"
+		if i.Protocol == "" {
+			i.Protocol = "git"
 		}
-		if err := i.Project.fillDefaults(); err != nil {
-			return err
+		if i.RemoteBranch == "" {
+			i.RemoteBranch = "master"
 		}
 	}
 	return i.validate()
@@ -236,11 +238,11 @@
 
 func (i *Import) unfillDefaults() error {
 	if i.Remote != "" {
-		if i.Path == "manifest" {
-			i.Path = ""
+		if i.Protocol == "git" {
+			i.Protocol = ""
 		}
-		if err := i.Project.unfillDefaults(); err != nil {
-			return err
+		if i.RemoteBranch == "master" {
+			i.RemoteBranch = ""
 		}
 	}
 	return i.validate()
@@ -268,31 +270,56 @@
 	return nil
 }
 
-// remoteKey returns a key based on the remote and manifest, used for
+func (i *Import) toProject(path string) (Project, error) {
+	p := Project{
+		Name:         i.Name,
+		Path:         path,
+		Protocol:     i.Protocol,
+		Remote:       i.Remote,
+		RemoteBranch: i.RemoteBranch,
+	}
+	err := p.fillDefaults()
+	return p, err
+}
+
+// ProjectKey returns the unique ProjectKey for the imported project.
+func (i *Import) ProjectKey() ProjectKey {
+	return MakeProjectKey(i.Name, i.Remote)
+}
+
+// projectKeyFileName returns a file name based on the ProjectKey.
+func (i *Import) projectKeyFileName() string {
+	// TODO(toddw): Disallow weird characters from project names.
+	hash := fnv.New64a()
+	hash.Write([]byte(i.ProjectKey()))
+	return fmt.Sprintf("%s_%x", i.Name, hash.Sum64())
+}
+
+// cycleKey returns a key based on the remote and manifest, used for
 // cycle-detection.  It's only valid for new-style remote imports; it's empty
 // for the old-style local imports.
-func (i *Import) remoteKey() string {
+func (i *Import) cycleKey() string {
 	if i.Remote == "" {
 		return ""
 	}
-	// We don't join the remote and manifest with a slash, since that might not be
-	// unique.  E.g.
+	// We don't join the remote and manifest with a slash or any other url-safe
+	// character, since that might not be unique.  E.g.
 	//   remote:   https://foo.com/a/b    remote:   https://foo.com/a
 	//   manifest: c                      manifest: b/c
 	// In both cases, the key would be https://foo.com/a/b/c.
 	return i.Remote + " + " + i.Manifest
 }
 
-// FileImport represents a file-based import.
-type FileImport struct {
+// LocalImport represents a local manifest import.
+type LocalImport struct {
 	// Manifest file to import from.
 	File    string   `xml:"file,attr,omitempty"`
-	XMLName struct{} `xml:"fileimport"`
+	XMLName struct{} `xml:"localimport"`
 }
 
-func (i *FileImport) validate() error {
+func (i *LocalImport) validate() error {
 	if i.File == "" {
-		return fmt.Errorf("bad fileimport: must specify file: %+v", *i)
+		return fmt.Errorf("bad localimport: must specify file: %+v", *i)
 	}
 	return nil
 }
@@ -398,10 +425,13 @@
 	}
 	// Same logic as Manifest.ToBytes, to make the output more compact.
 	data = bytes.Replace(data, endProjectSoloBytes, endElemSoloBytes, -1)
+	if !bytes.HasSuffix(data, newlineBytes) {
+		data = append(data, '\n')
+	}
 	return safeWriteFile(jirix, filename, data)
 }
 
-// Key returns a unique ProjectKey for the project.
+// Key returns the unique ProjectKey for the project.
 func (p Project) Key() ProjectKey {
 	return MakeProjectKey(p.Name, p.Remote)
 }
@@ -563,7 +593,7 @@
 	}
 
 	// Add all tools from the current manifest to the snapshot manifest.
-	_, tools, err := ReadJiriManifest(jirix)
+	_, tools, err := LoadManifest(jirix)
 	if err != nil {
 		return err
 	}
@@ -642,25 +672,29 @@
 	jirix.TimerPush("local projects")
 	defer jirix.TimerPop()
 
-	latestUpdateSnapshot := jirix.UpdateHistoryLatestLink()
-	latestUpdateSnapshotExists, err := jirix.NewSeq().IsFile(latestUpdateSnapshot)
+	latestSnapshot := jirix.UpdateHistoryLatestLink()
+	latestSnapshotExists, err := jirix.NewSeq().IsFile(latestSnapshot)
 	if err != nil {
 		return nil, err
 	}
-	if scanMode == FastScan && latestUpdateSnapshotExists {
-		// Fast path:  Full scan was not requested, and we have a snapshot
-		// containing the latest update.  Check that the projects listed in the
-		// snapshot exist locally.  If not, then fall back on the slow path.
-		manifestProjects, _, err := readManifestFile(jirix, latestUpdateSnapshot)
+	if scanMode == FastScan && latestSnapshotExists {
+		// Fast path: Full scan was not requested, and we have a snapshot containing
+		// the latest update.  Check that the projects listed in the snapshot exist
+		// locally.  If not, then fall back on the slow path.
+		//
+		// An error will be returned if the snapshot contains remote imports, since
+		// that would cause an infinite loop; we'd need local projects, in order to
+		// load the snapshot, in order to determine the local projects.
+		snapshotProjects, _, err := loadManifestFile(jirix, latestSnapshot, nil)
 		if err != nil {
 			return nil, err
 		}
-		projectsExist, err := projectsExistLocally(jirix, manifestProjects)
+		projectsExist, err := projectsExistLocally(jirix, snapshotProjects)
 		if err != nil {
 			return nil, err
 		}
 		if projectsExist {
-			return setProjectRevisions(jirix, manifestProjects)
+			return setProjectRevisions(jirix, snapshotProjects)
 		}
 	}
 
@@ -715,7 +749,7 @@
 	if err != nil {
 		return nil, err
 	}
-	remoteProjects, _, err := ReadJiriManifest(jirix)
+	remoteProjects, _, err := LoadManifest(jirix)
 	if err != nil {
 		return nil, err
 	}
@@ -776,25 +810,43 @@
 	return update, nil
 }
 
-// ReadJiriManifest reads and parses the .jiri_manifest file.
-func ReadJiriManifest(jirix *jiri.X) (Projects, Tools, error) {
-	file, err := jirix.ResolveManifestPath(jirix.Manifest())
+// LoadManifest loads the manifest, starting with the .jiri_manifest file,
+// resolving remote and local imports.  Returns the projects and tools specified
+// by the manifest.
+//
+// If the user is still using old-style manifests, it uses the old
+// ResolveManifestPath logic to determine the initial manifest file, since the
+// .jiri_manifest doesn't exist.
+func LoadManifest(jirix *jiri.X) (Projects, Tools, error) {
+	jirix.TimerPush("load manifest")
+	defer jirix.TimerPop()
+	var (
+		file          string
+		localProjects Projects
+		err           error
+	)
+	// TODO(toddw): Remove old manifest logic when the transition is complete.
+	if jirix.UsingOldManifests() {
+		file, err = jirix.ResolveManifestPath(jirix.Manifest())
+	} else {
+		file = jirix.JiriManifestFile()
+		localProjects, err = LocalProjects(jirix, FastScan)
+	}
 	if err != nil {
 		return nil, nil, err
 	}
-	return readManifestFile(jirix, file)
+	return loadManifestFile(jirix, file, localProjects)
 }
 
-// readManifestFile reads and parses the manifest with the given filename.
-func readManifestFile(jirix *jiri.X, file string) (Projects, Tools, error) {
-	jirix.TimerPush("read manifest")
-	defer jirix.TimerPop()
-	var imp importer
-	projects, tools := Projects{}, Tools{}
-	if err := imp.Load(jirix, jirix.Root, file, "", projects, tools); err != nil {
+// loadManifestFile loads the manifest starting with the given file, resolving
+// remote and local imports.  Local projects are used to resolve remote imports;
+// if nil, encountering any remote import will result in an error.
+func loadManifestFile(jirix *jiri.X, file string, localProjects Projects) (Projects, Tools, error) {
+	ld := newManifestLoader(localProjects, false)
+	if err := ld.Load(jirix, "", file, ""); err != nil {
 		return nil, nil, err
 	}
-	return projects, tools, nil
+	return ld.Projects, ld.Tools, nil
 }
 
 // getManifestRemote returns the remote url of the origin from the manifest
@@ -811,76 +863,84 @@
 		}, "get manifest origin").Done()
 }
 
-func updateManifestProjects(jirix *jiri.X) error {
-	jirix.TimerPush("update manifest")
+func loadUpdatedManifest(jirix *jiri.X, localProjects Projects) (Projects, Tools, string, error) {
+	jirix.TimerPush("load updated manifest")
 	defer jirix.TimerPop()
 	if jirix.UsingOldManifests() {
-		return updateManifestProjectsDeprecated(jirix)
+		projects, tools, err := loadUpdatedManifestDeprecated(jirix)
+		return projects, tools, "", err
 	}
-	// Update the repositories corresponding to all remote imports.
-	//
-	// TODO(toddw): Cache local projects in jirix, so that we don't need to
-	// perform multiple full scans.
-	localProjects, err := LocalProjects(jirix, FullScan)
-	if err != nil {
-		return err
+	ld := newManifestLoader(localProjects, true)
+	if err := ld.Load(jirix, "", jirix.JiriManifestFile(), ""); err != nil {
+		return nil, nil, ld.TmpDir, err
 	}
-	file, err := jirix.ResolveManifestPath(jirix.Manifest())
-	if err != nil {
-		return err
-	}
-	var imp importer
-	return imp.Update(jirix, jirix.Root, file, "", localProjects)
+	return ld.Projects, ld.Tools, ld.TmpDir, nil
 }
 
-func updateManifestProjectsDeprecated(jirix *jiri.X) error {
+// TODO(toddw): Remove this logic when the transition to new manifests is done.
+func loadUpdatedManifestDeprecated(jirix *jiri.X) (Projects, Tools, error) {
 	manifestPath := filepath.Join(jirix.Root, ".manifest")
 	manifestRemote, err := getManifestRemote(jirix, manifestPath)
 	if err != nil {
-		return err
+		return nil, nil, err
 	}
 	project := Project{
-		Path:         manifestPath,
-		Protocol:     "git",
-		Remote:       manifestRemote,
-		Revision:     "HEAD",
-		RemoteBranch: "master",
+		Path:   manifestPath,
+		Remote: manifestRemote,
 	}
-	return resetProject(jirix, project)
+	if err := project.fillDefaults(); err != nil {
+		return nil, nil, err
+	}
+	if err := syncProjectMaster(jirix, project); err != nil {
+		return nil, nil, err
+	}
+	file, err := jirix.ResolveManifestPath(jirix.Manifest())
+	if err != nil {
+		return nil, nil, err
+	}
+	return loadManifestFile(jirix, file, nil)
 }
 
-// UpdateUniverse updates all local projects and tools to match the
-// remote counterparts identified by the given manifest. Optionally,
-// the 'gc' flag can be used to indicate that local projects that no
-// longer exist remotely should be removed.
+// UpdateUniverse updates all local projects and tools to match the remote
+// counterparts identified in the manifest. Optionally, the 'gc' flag can be
+// used to indicate that local projects that no longer exist remotely should be
+// removed.
 func UpdateUniverse(jirix *jiri.X, gc bool) (e error) {
 	jirix.TimerPush("update universe")
 	defer jirix.TimerPop()
-	// 0. Update all manifest projects to match their remote counterparts, and
-	// read the manifest file.
-	if err := updateManifestProjects(jirix); err != nil {
-		return err
+	// 0. Load the manifest, updating all manifest projects to match their remote
+	// counterparts.
+	scanMode := FastScan
+	if gc {
+		scanMode = FullScan
 	}
-	remoteProjects, remoteTools, err := ReadJiriManifest(jirix)
+	localProjects, err := LocalProjects(jirix, scanMode)
 	if err != nil {
 		return err
 	}
 	s := jirix.NewSeq()
+	remoteProjects, remoteTools, tmpLoadDir, err := loadUpdatedManifest(jirix, localProjects)
+	if tmpLoadDir != "" {
+		defer collect.Error(func() error { return s.RemoveAll(tmpLoadDir).Done() }, &e)
+	}
+	if err != nil {
+		return err
+	}
 	// 1. Update all local projects to match their remote counterparts.
-	if err := updateProjects(jirix, remoteProjects, gc); err != nil {
+	if err := updateProjects(jirix, localProjects, remoteProjects, gc); err != nil {
 		return err
 	}
 	// 2. Build all tools in a temporary directory.
-	tmpDir, err := s.TempDir("", "tmp-jiri-tools-build")
+	tmpToolsDir, err := s.TempDir("", "tmp-jiri-tools-build")
 	if err != nil {
 		return fmt.Errorf("TempDir() failed: %v", err)
 	}
-	defer collect.Error(func() error { return s.RemoveAll(tmpDir).Done() }, &e)
-	if err := buildToolsFromMaster(jirix, remoteTools, tmpDir); err != nil {
+	defer collect.Error(func() error { return s.RemoveAll(tmpToolsDir).Done() }, &e)
+	if err := buildToolsFromMaster(jirix, remoteProjects, remoteTools, tmpToolsDir); err != nil {
 		return err
 	}
 	// 3. Install the tools into $JIRI_ROOT/.jiri_root/bin.
-	return InstallTools(jirix, tmpDir)
+	return InstallTools(jirix, tmpToolsDir)
 }
 
 // ApplyToLocalMaster applies an operation expressed as the given function to
@@ -1003,13 +1063,8 @@
 // available in the local master branch of the tools repository. Notably, this
 // function does not perform any version control operation on the master
 // branch.
-func buildToolsFromMaster(jirix *jiri.X, tools Tools, outputDir string) error {
-	localProjects, err := LocalProjects(jirix, FastScan)
-	if err != nil {
-		return err
-	}
+func buildToolsFromMaster(jirix *jiri.X, projects Projects, tools Tools, outputDir string) error {
 	failed := false
-
 	toolsToBuild, toolProjects := Tools{}, Projects{}
 	toolNames := []string{} // Used for logging purposes.
 	for _, tool := range tools {
@@ -1020,7 +1075,7 @@
 		if tool.Package == "" {
 			continue
 		}
-		project, err := localProjects.FindUnique(tool.Project)
+		project, err := projects.FindUnique(tool.Project)
 		if err != nil {
 			return err
 		}
@@ -1263,213 +1318,263 @@
 	return nil
 }
 
-// resetProject advances the local master branch of the given
-// project, which is expected to exist locally at project.Path.
-func resetProject(jirix *jiri.X, project Project) error {
-	fn := func() error {
-		switch project.Protocol {
-		case "git":
-			if project.Remote == "" {
-				return fmt.Errorf("project %v does not have a remote", project.Name)
-			}
-			if err := gitutil.New(jirix.NewSeq()).SetRemoteUrl("origin", project.Remote); err != nil {
-				return err
-			}
-			if err := gitutil.New(jirix.NewSeq()).Fetch("origin"); err != nil {
-				return err
-			}
-
-			// Having a specific revision trumps everything else - once fetched,
-			// always reset to that revision.
-			if project.Revision != "" && project.Revision != "HEAD" {
-				return gitutil.New(jirix.NewSeq()).Reset(project.Revision)
-			}
-
-			// If no revision, reset to the configured remote branch, or master
-			// if no remote branch.
-			remoteBranch := project.RemoteBranch
-			if remoteBranch == "" {
-				remoteBranch = "master"
-			}
-			return gitutil.New(jirix.NewSeq()).Reset("origin/" + remoteBranch)
-		default:
-			return UnsupportedProtocolErr(project.Protocol)
+// fetchProject fetches from the project remote.
+func fetchProject(jirix *jiri.X, project Project) error {
+	switch project.Protocol {
+	case "git":
+		if project.Remote == "" {
+			return fmt.Errorf("project %q does not have a remote", project.Name)
 		}
+		if err := gitutil.New(jirix.NewSeq()).SetRemoteUrl("origin", project.Remote); err != nil {
+			return err
+		}
+		return gitutil.New(jirix.NewSeq()).Fetch("origin")
+	default:
+		return UnsupportedProtocolErr(project.Protocol)
 	}
-	return ApplyToLocalMaster(jirix, Projects{project.Key(): project}, fn)
 }
 
-// importer handles importing manifest files.  There are two uses: Load reads
-// full manifests into memory, while Update updates remote manifest projects.
-type importer struct {
-	cycleStack []cycleInfo
+// resetProjectCurrentBranch resets the current branch to the revision and
+// branch specified on the project.
+func resetProjectCurrentBranch(jirix *jiri.X, project Project) error {
+	if err := project.fillDefaults(); err != nil {
+		return err
+	}
+	switch project.Protocol {
+	case "git":
+		// Having a specific revision trumps everything else.
+		if project.Revision != "HEAD" {
+			return gitutil.New(jirix.NewSeq()).Reset(project.Revision)
+		}
+		// If no revision, reset to the configured remote branch, or master
+		// if no remote branch.
+		return gitutil.New(jirix.NewSeq()).Reset("origin/" + project.RemoteBranch)
+	default:
+		return UnsupportedProtocolErr(project.Protocol)
+	}
+}
+
+// syncProjectMaster fetches from the project remote and resets the local master
+// branch to the revision and branch specified on the project.
+func syncProjectMaster(jirix *jiri.X, project Project) error {
+	return ApplyToLocalMaster(jirix, Projects{project.Key(): project}, func() error {
+		if err := fetchProject(jirix, project); err != nil {
+			return err
+		}
+		return resetProjectCurrentBranch(jirix, project)
+	})
+}
+
+// newManifestLoader returns a new manifest loader.  The localProjects are used
+// to resolve remote imports; if nil, encountering any remote import will result
+// in an error.  If update is true, remote manifest import projects that don't
+// exist locally are cloned under TmpDir, and inserted into localProjects.
+//
+// If update is true, remote changes to manifest projects will be fetched, and
+// manifest projects that don't exist locally will be created in temporary
+// directories, and added to localProjects.
+func newManifestLoader(localProjects Projects, update bool) *loader {
+	return &loader{
+		Projects:      make(Projects),
+		Tools:         make(Tools),
+		localProjects: localProjects,
+		update:        update,
+	}
+}
+
+type loader struct {
+	Projects      Projects
+	Tools         Tools
+	TmpDir        string
+	localProjects Projects
+	update        bool
+	cycleStack    []cycleInfo
 }
 
 type cycleInfo struct {
 	file, key string
 }
 
-// importNoCycles checks for cycles in imports.  There are two types of cycles:
+// loadNoCycles checks for cycles in imports.  There are two types of cycles:
 //   file - Cycle in the paths of manifest files in the local filesystem.
 //   key  - Cycle in the remote manifests specified by remote imports.
 //
 // Example of file cycles.  File A imports file B, and vice versa.
 //     file=manifest/A              file=manifest/B
 //     <manifest>                   <manifest>
-//       <fileimport file="B"/>       <fileimport file="A"/>
+//       <localimport file="B"/>      <localimport file="A"/>
 //     </manifest>                  </manifest>
 //
 // Example of key cycles.  The key consists of "remote/manifest", e.g.
 //   https://vanadium.googlesource.com/manifest/v2/default
 // In the example, key x/A imports y/B, and vice versa.
-//     key=x/A                                 key=y/B
-//     <manifest>                              <manifest>
-//       <import remote="y" manifest="B"/>       <import remote="x" manifest="A"/>
-//     </manifest>                             </manifest>
+//     key=x/A                               key=y/B
+//     <manifest>                            <manifest>
+//       <import remote="y" manifest="B"/>     <import remote="x" manifest="A"/>
+//     </manifest>                           </manifest>
 //
 // The above examples are simple, but the general strategy is demonstrated.  We
 // keep a single stack for both files and keys, and push onto each stack before
-// running the recursive load or update function, and pop the stack when the
+// running the recursive read or update function, and pop the stack when the
 // function is done.  If we see a duplicate on the stack at any point, we know
-// there's a cycle.  Note that we know the file for both local fileimports as
-// well as remote imports, but we only know the key for remote imports; the key
-// for local fileimports is empty.
+// there's a cycle.  Note that we know the file for both local and remote
+// imports, but we only know the key for remote imports; the key for local
+// imports is empty.
 //
-// A more complex case would involve a combination of local fileimports and
-// remote imports, using the "root" attribute to change paths on the local
-// filesystem.  In this case the key will eventually expose the cycle.
-func (imp *importer) importNoCycles(file, key string, fn func() error) error {
-	info := cycleInfo{file, key}
-	for _, c := range imp.cycleStack {
-		if file == c.file {
-			return fmt.Errorf("import cycle detected in local manifest files: %q", append(imp.cycleStack, info))
-		}
-		if key != "" && key == c.key {
-			return fmt.Errorf("import cycle detected in remote manifest imports: %q", append(imp.cycleStack, info))
+// A more complex case would involve a combination of local and remote imports,
+// using the "root" attribute to change paths on the local filesystem.  In this
+// case the key will eventually expose the cycle.
+func (ld *loader) loadNoCycles(jirix *jiri.X, root, file, cycleKey string) error {
+	info := cycleInfo{file, cycleKey}
+	for _, c := range ld.cycleStack {
+		switch {
+		case file == c.file:
+			return fmt.Errorf("import cycle detected in local manifest files: %q", append(ld.cycleStack, info))
+		case cycleKey == c.key && cycleKey != "":
+			return fmt.Errorf("import cycle detected in remote manifest imports: %q", append(ld.cycleStack, info))
 		}
 	}
-	imp.cycleStack = append(imp.cycleStack, info)
-	if err := fn(); err != nil {
+	ld.cycleStack = append(ld.cycleStack, info)
+	if err := ld.load(jirix, root, file); err != nil {
 		return err
 	}
-	imp.cycleStack = imp.cycleStack[:len(imp.cycleStack)-1]
+	ld.cycleStack = ld.cycleStack[:len(ld.cycleStack)-1]
 	return nil
 }
 
-func (imp *importer) Load(jirix *jiri.X, root, file, key string, projects Projects, tools Tools) error {
-	return imp.importNoCycles(file, key, func() error {
-		return imp.load(jirix, root, file, projects, tools)
-	})
+// shortFileName returns the relative path if file is relative to root,
+// otherwise returns the file name unchanged.
+func shortFileName(root, file string) string {
+	if p := root + string(filepath.Separator); strings.HasPrefix(file, p) {
+		return file[len(p):]
+	}
+	return file
 }
 
-func (imp *importer) load(jirix *jiri.X, root, file string, projects Projects, tools Tools) error {
+func (ld *loader) Load(jirix *jiri.X, root, file, cycleKey string) error {
+	jirix.TimerPush("load " + shortFileName(jirix.Root, file))
+	defer jirix.TimerPop()
+	return ld.loadNoCycles(jirix, root, file, cycleKey)
+}
+
+func (ld *loader) load(jirix *jiri.X, root, file string) error {
 	m, err := ManifestFromFile(jirix, file)
 	if err != nil {
 		return err
 	}
-	// Process all imports.
-	for _, _import := range m.Imports {
-		newRoot, newFile := root, ""
-		if _import.Remote != "" {
-			// New-style remote import
-			newRoot = filepath.Join(root, _import.Root)
-			newFile = filepath.Join(newRoot, _import.Path, _import.Manifest)
-		} else {
-			// Old-style name-based local import.
-			//
-			// TODO(toddw): Remove this logic when the manifest transition is done.
-			if newFile, err = jirix.ResolveManifestPath(_import.Name); err != nil {
-				return err
-			}
-		}
-		if err := imp.Load(jirix, newRoot, newFile, _import.remoteKey(), projects, tools); err != nil {
-			return err
-		}
-	}
-	// Process all file imports.
-	for _, fileImport := range m.FileImports {
-		newFile := filepath.Join(filepath.Dir(file), fileImport.File)
-		if err := imp.Load(jirix, root, newFile, "", projects, tools); err != nil {
-			return err
-		}
-	}
-	// Process all projects.
-	for _, project := range m.Projects {
-		project.Path = filepath.Join(root, project.Path)
-		projects[project.Key()] = project
-	}
-	// Process all tools.
-	for _, tool := range m.Tools {
-		tools[tool.Name] = tool
-	}
-	return nil
-}
-
-func (imp *importer) Update(jirix *jiri.X, root, file, key string, localProjects Projects) error {
-	return imp.importNoCycles(file, key, func() error {
-		return imp.update(jirix, root, file, localProjects)
-	})
-}
-
-func (imp *importer) update(jirix *jiri.X, root, file string, localProjects Projects) error {
-	m, err := ManifestFromFile(jirix, file)
-	if err != nil {
-		return err
-	}
-	// Process all remote imports.  This logic treats the remote import as a
-	// regular project, and runs our regular create/move/update logic on it.  We
-	// never handle deletes here; those are handled in updateProjects.
+	// Process remote imports.
 	for _, remote := range m.Imports {
 		if remote.Remote == "" {
-			// Old-style local imports handled in loop below.
+			// Old-style named imports handled in loop below.
 			continue
 		}
-		newRoot := filepath.Join(root, remote.Root)
-		remote.Path = filepath.Join(newRoot, remote.Path)
-		newFile := filepath.Join(remote.Path, remote.Manifest)
-		var localProject *Project
-		if p, ok := localProjects[remote.Project.Key()]; ok {
-			localProject = &p
+		nextRoot, nextFile := filepath.Join(root, remote.Root), ""
+		key := remote.ProjectKey()
+		p, ok := ld.localProjects[key]
+		if !ok {
+			if !ld.update {
+				return fmt.Errorf("can't resolve remote import: project %q not found locally", key)
+			}
+			// The remote manifest project doesn't exist locally.  Clone it into a
+			// temp directory, and add it to ld.localProjects.
+			if ld.TmpDir == "" {
+				if ld.TmpDir, err = jirix.NewSeq().TempDir("", "jiri-load"); err != nil {
+					return fmt.Errorf("TempDir() failed: %v", err)
+				}
+			}
+			path := filepath.Join(ld.TmpDir, remote.projectKeyFileName())
+			if p, err = remote.toProject(path); err != nil {
+				return err
+			}
+			if err := jirix.NewSeq().MkdirAll(path, 0755).Done(); err != nil {
+				return err
+			}
+			if err := gitutil.New(jirix.NewSeq()).Clone(p.Remote, path); err != nil {
+				return err
+			}
+			ld.localProjects[key] = p
 		}
-		// Since &remote.Project is never nil, we'll never produce a delete op.
-		op := computeOp(localProject, &remote.Project, false, newRoot)
-		if err := op.Test(jirix, newFsUpdates()); err != nil {
-			return err
+		// Reset the project to its specified branch and load the next file.  Note
+		// that we call load() recursively, so multiple files may be loaded by
+		// resetAndLoad.
+		if strings.HasPrefix(p.Path, ld.TmpDir) {
+			nextFile = filepath.Join(p.Path, remote.Manifest)
+		} else {
+			nextFile = filepath.Join(jirix.Root, nextRoot, p.Path, remote.Manifest)
 		}
-		updateFn := func() error { return op.Run(jirix, nil) }
-		if err := jirix.NewSeq().Verbose(true).Call(updateFn, "%v", op).Done(); err != nil {
-			fmt.Fprintf(jirix.Stderr(), "%v\n", err)
-			return err
-		}
-		localProjects[remote.Project.Key()] = remote.Project
-		if err := imp.Update(jirix, newRoot, newFile, remote.remoteKey(), localProjects); err != nil {
+		if err := ld.resetAndLoad(jirix, nextRoot, nextFile, remote.cycleKey(), p); err != nil {
 			return err
 		}
 	}
-	// Process all old-style local imports.
-	for _, local := range m.Imports {
-		if local.Remote != "" {
+	// Process old-style named imports.
+	//
+	// TODO(toddw): Remove this logic when the manifest transition is done.
+	for _, named := range m.Imports {
+		if named.Remote != "" {
 			// New-style remote imports handled in loop above.
 			continue
 		}
-		newFile, err := jirix.ResolveManifestPath(local.Name)
+		nextFile, err := jirix.ResolveManifestPath(named.Name)
 		if err != nil {
 			return err
 		}
-		if err := imp.Update(jirix, root, newFile, "", localProjects); err != nil {
+		if err := ld.Load(jirix, root, nextFile, ""); err != nil {
 			return err
 		}
 	}
-	// Process all file imports.
-	for _, fileImport := range m.FileImports {
-		newFile := filepath.Join(filepath.Dir(file), fileImport.File)
-		if err := imp.Update(jirix, root, newFile, "", localProjects); err != nil {
+	// Process local imports.
+	for _, local := range m.LocalImports {
+		// TODO(toddw): Add our invariant check that the file is in the same
+		// repository as the current remote import repository.
+		nextFile := filepath.Join(filepath.Dir(file), local.File)
+		if err := ld.Load(jirix, root, nextFile, ""); err != nil {
 			return err
 		}
 	}
+	// Collect projects.
+	for _, project := range m.Projects {
+		project.Path = filepath.Join(jirix.Root, root, project.Path)
+		key := project.Key()
+		if dup, ok := ld.Projects[key]; ok && dup != project {
+			// TODO(toddw): Tell the user the other conflicting file.
+			return fmt.Errorf("duplicate project %q found in %v", key, shortFileName(jirix.Root, file))
+		}
+		ld.Projects[key] = project
+	}
+	// Collect tools.
+	for _, tool := range m.Tools {
+		name := tool.Name
+		if dup, ok := ld.Tools[name]; ok && dup != tool {
+			// TODO(toddw): Tell the user the other conflicting file.
+			return fmt.Errorf("duplicate tool %q found in %v", name, shortFileName(jirix.Root, file))
+		}
+		ld.Tools[name] = tool
+	}
 	return nil
 }
 
+func (ld *loader) resetAndLoad(jirix *jiri.X, root, file, cycleKey string, project Project) (e error) {
+	// Change to the project.Path directory, and revert when done.
+	pushd := jirix.NewSeq().Pushd(project.Path)
+	defer collect.Error(pushd.Done, &e)
+	// Reset the local master branch to what's specified on the project.  We only
+	// fetch on updates; non-updates just perform the reset.
+	//
+	// TODO(toddw): Support "jiri update -local=p1,p2" by simply calling ld.Load
+	// for the given projects, rather than ApplyToLocalMaster(fetch+reset+load).
+	return ApplyToLocalMaster(jirix, Projects{project.Key(): project}, func() error {
+		if ld.update {
+			if err := fetchProject(jirix, project); err != nil {
+				return err
+			}
+		}
+		if err := resetProjectCurrentBranch(jirix, project); err != nil {
+			return err
+		}
+		return ld.Load(jirix, root, file, cycleKey)
+	})
+}
+
 // reportNonMaster checks if the given project is on master branch and
 // if not, reports this fact along with information on how to update it.
 func reportNonMaster(jirix *jiri.X, project Project) (e error) {
@@ -1559,18 +1664,10 @@
 	}
 }
 
-func updateProjects(jirix *jiri.X, remoteProjects Projects, gc bool) error {
+func updateProjects(jirix *jiri.X, localProjects, remoteProjects Projects, gc bool) error {
 	jirix.TimerPush("update projects")
 	defer jirix.TimerPop()
 
-	scanMode := FastScan
-	if gc {
-		scanMode = FullScan
-	}
-	localProjects, err := LocalProjects(jirix, scanMode)
-	if err != nil {
-		return err
-	}
 	getRemoteHeadRevisions(jirix, remoteProjects)
 	ops := computeOperations(localProjects, remoteProjects, gc, "")
 	updates := newFsUpdates()
@@ -1595,15 +1692,15 @@
 		return cmdline.ErrExitCode(2)
 	}
 
-	// Run all RunHook scripts.
+	// Run all RunHook scripts, apply githooks, and write the current manifest.
+	// TODO(toddw): What's the significance of exit code 2?
 	if !runHooks(jirix, ops) {
 		return cmdline.ErrExitCode(2)
 	}
-
-	if err := writeCurrentManifest(jirix, manifest); err != nil {
-		return err
+	if err := applyGitHooks(jirix, ops); err != nil {
+		return cmdline.ErrExitCode(2)
 	}
-	return nil
+	return writeCurrentManifest(jirix, manifest)
 }
 
 // runHooks runs all hooks for the given operations.  It returns true iff all
@@ -1616,7 +1713,7 @@
 		if op.Project().RunHook == "" {
 			continue
 		}
-		if op.Kind() != "create" && op.Kind() != "update" && op.Kind() != "move" {
+		if op.Kind() != "create" && op.Kind() != "move" && op.Kind() != "update" {
 			continue
 		}
 		s := jirix.NewSeq()
@@ -1633,6 +1730,63 @@
 	return ok
 }
 
+func applyGitHooks(jirix *jiri.X, ops []operation) error {
+	jirix.TimerPush("apply githooks")
+	defer jirix.TimerPop()
+	s := jirix.NewSeq()
+	for _, op := range ops {
+		if op.Kind() == "create" || op.Kind() == "move" {
+			// Apply exclusion for /.jiri/. Ideally we'd only write this file on
+			// create, but the remote manifest import is move from the temp directory
+			// into the final spot, so we need this to apply to both.
+			//
+			// TODO(toddw): Find a better way to do this.
+			excludeDir := filepath.Join(op.Project().Path, ".git", "info")
+			excludeFile := filepath.Join(excludeDir, "exclude")
+			excludeString := "/.jiri/\n"
+			if err := s.MkdirAll(excludeDir, 0755).WriteFile(excludeFile, []byte(excludeString), 0644).Done(); err != nil {
+				return err
+			}
+		}
+		if op.Project().GitHooks == "" {
+			continue
+		}
+		if op.Kind() != "create" && op.Kind() != "move" && op.Kind() != "update" {
+			continue
+		}
+		// Apply git hooks, overwriting any existing hooks.  Jiri is in control of
+		// writing all hooks.
+		gitHooksDstDir := filepath.Join(op.Project().Path, ".git", "hooks")
+		gitHooksSrcDir := filepath.Join(jirix.Root, op.Root(), op.Project().GitHooks)
+		// Copy the specified GitHooks directory into the project's git
+		// hook directory.  We walk the file system, creating directories
+		// and copying files as we encounter them.
+		copyFn := func(path string, info os.FileInfo, err error) error {
+			if err != nil {
+				return err
+			}
+			relPath, err := filepath.Rel(gitHooksSrcDir, path)
+			if err != nil {
+				return err
+			}
+			dst := filepath.Join(gitHooksDstDir, relPath)
+			if info.IsDir() {
+				return s.MkdirAll(dst, 0755).Done()
+			}
+			src, err := s.ReadFile(path)
+			if err != nil {
+				return err
+			}
+			// The file *must* be executable to be picked up by git.
+			return s.WriteFile(dst, src, 0755).Done()
+		}
+		if err := filepath.Walk(gitHooksSrcDir, copyFn); err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
 // writeMetadata stores the given project metadata in the directory
 // identified by the given path.
 func writeMetadata(jirix *jiri.X, project Project, dir string) (e error) {
@@ -1783,50 +1937,6 @@
 		if err := gitutil.New(jirix.NewSeq()).Clone(op.project.Remote, tmpDir); err != nil {
 			return err
 		}
-
-		// Apply git hooks.  We're creating this repo, so there's no danger of
-		// overriding existing hooks.  Customizing your git hooks with jiri is a bad
-		// idea anyway, since jiri won't know to not delete the project when you
-		// switch between manifests or do a cleanup.
-		gitHooksDstDir := filepath.Join(tmpDir, ".git", "hooks")
-		if op.project.GitHooks != "" {
-			gitHooksSrcDir := filepath.Join(jirix.Root, op.root, op.project.GitHooks)
-			// Copy the specified GitHooks directory into the project's git
-			// hook directory.  We walk the file system, creating directories
-			// and copying files as we encounter them.
-			copyFn := func(path string, info os.FileInfo, err error) error {
-				if err != nil {
-					return err
-				}
-				relPath, err := filepath.Rel(gitHooksSrcDir, path)
-				if err != nil {
-					return err
-				}
-				dst := filepath.Join(gitHooksDstDir, relPath)
-				if info.IsDir() {
-					return s.MkdirAll(dst, perm).Done()
-				}
-				src, err := s.ReadFile(path)
-				if err != nil {
-					return err
-				}
-				return s.WriteFile(dst, src, perm).Done()
-			}
-			if err := filepath.Walk(gitHooksSrcDir, copyFn); err != nil {
-				return err
-			}
-		}
-
-		// Apply exclusion for /.jiri/. We're creating the repo so we can safely
-		// write to .git/info/exclude
-		excludeString := "/.jiri/\n"
-		excludeDir := filepath.Join(tmpDir, ".git", "info")
-		excludeFile := filepath.Join(excludeDir, "exclude")
-		if err := s.MkdirAll(excludeDir, os.FileMode(0750)).
-			WriteFile(excludeFile, []byte(excludeString), perm).Done(); err != nil {
-			return err
-		}
-
 		cwd, err := os.Getwd()
 		if err != nil {
 			return err
@@ -1835,6 +1945,7 @@
 		if err := s.Chdir(tmpDir).Done(); err != nil {
 			return err
 		}
+		// TODO(toddw): Why call Reset here, when resetProject is called just below?
 		if err := gitutil.New(jirix.NewSeq()).Reset(op.project.Revision); err != nil {
 			return err
 		}
@@ -1848,7 +1959,7 @@
 		Rename(tmpDir, op.destination).Done(); err != nil {
 		return err
 	}
-	if err := resetProject(jirix, op.project); err != nil {
+	if err := syncProjectMaster(jirix, op.project); err != nil {
 		return err
 	}
 	return addProjectToManifest(jirix, manifest, op.project)
@@ -1952,7 +2063,7 @@
 	if err := reportNonMaster(jirix, op.project); err != nil {
 		return err
 	}
-	if err := resetProject(jirix, op.project); err != nil {
+	if err := syncProjectMaster(jirix, op.project); err != nil {
 		return err
 	}
 	if err := writeMetadata(jirix, op.project, op.project.Path); err != nil {
@@ -1996,7 +2107,7 @@
 	if err := reportNonMaster(jirix, op.project); err != nil {
 		return err
 	}
-	if err := resetProject(jirix, op.project); err != nil {
+	if err := syncProjectMaster(jirix, op.project); err != nil {
 		return err
 	}
 	if err := writeMetadata(jirix, op.project, op.project.Path); err != nil {
@@ -2112,29 +2223,11 @@
 
 func computeOp(local, remote *Project, gc bool, root string) operation {
 	switch {
-	case local != nil && remote != nil:
-		if local.Path != remote.Path {
-			// moveOperation also does an update, so we don't need to check the
-			// revision here.
-			return moveOperation{commonOperation{
-				destination: remote.Path,
-				project:     *remote,
-				source:      local.Path,
-				root:        root,
-			}}
-		}
-		if local.Revision != remote.Revision {
-			return updateOperation{commonOperation{
-				destination: remote.Path,
-				project:     *remote,
-				source:      local.Path,
-				root:        root,
-			}}
-		}
-		return nullOperation{commonOperation{
+	case local == nil && remote != nil:
+		return createOperation{commonOperation{
 			destination: remote.Path,
 			project:     *remote,
-			source:      local.Path,
+			source:      "",
 			root:        root,
 		}}
 	case local != nil && remote == nil:
@@ -2144,13 +2237,32 @@
 			source:      local.Path,
 			root:        root,
 		}, gc}
-	case local == nil && remote != nil:
-		return createOperation{commonOperation{
-			destination: remote.Path,
-			project:     *remote,
-			source:      "",
-			root:        root,
-		}}
+	case local != nil && remote != nil:
+		switch {
+		case local.Path != remote.Path:
+			// moveOperation also does an update, so we don't need to check the
+			// revision here.
+			return moveOperation{commonOperation{
+				destination: remote.Path,
+				project:     *remote,
+				source:      local.Path,
+				root:        root,
+			}}
+		case local.Revision != remote.Revision:
+			return updateOperation{commonOperation{
+				destination: remote.Path,
+				project:     *remote,
+				source:      local.Path,
+				root:        root,
+			}}
+		default:
+			return nullOperation{commonOperation{
+				destination: remote.Path,
+				project:     *remote,
+				source:      local.Path,
+				root:        root,
+			}}
+		}
 	default:
 		panic("jiri: computeOp called with nil local and remote")
 	}
@@ -2159,7 +2271,7 @@
 // ParseNames identifies the set of projects that a jiri command should
 // be applied to.
 func ParseNames(jirix *jiri.X, args []string, defaultProjects map[string]struct{}) (Projects, error) {
-	manifestProjects, _, err := ReadJiriManifest(jirix)
+	manifestProjects, _, err := LoadManifest(jirix)
 	if err != nil {
 		return nil, err
 	}
diff --git a/project/project_test.go b/project/project_test.go
index 8db3887..f19cc97 100644
--- a/project/project_test.go
+++ b/project/project_test.go
@@ -579,17 +579,17 @@
 
 	// Set up the cycle .jiri_manifest -> A -> B -> A
 	jiriManifest := project.Manifest{
-		FileImports: []project.FileImport{
+		LocalImports: []project.LocalImport{
 			{File: "A"},
 		},
 	}
 	manifestA := project.Manifest{
-		FileImports: []project.FileImport{
+		LocalImports: []project.LocalImport{
 			{File: "B"},
 		},
 	}
 	manifestB := project.Manifest{
-		FileImports: []project.FileImport{
+		LocalImports: []project.LocalImport{
 			{File: "A"},
 		},
 	}
@@ -623,23 +623,17 @@
 	// Set up the cycle .jiri_manifest -> remote1+A -> remote2+B -> remote1+A
 	jiriManifest := project.Manifest{
 		Imports: []project.Import{
-			{Manifest: "A", Project: project.Project{
-				Name: "n1", Path: "p1", Remote: remote1,
-			}},
+			{Manifest: "A", Name: "n1", Remote: remote1},
 		},
 	}
 	manifestA := project.Manifest{
 		Imports: []project.Import{
-			{Manifest: "B", Project: project.Project{
-				Name: "n2", Path: "p2", Remote: remote2,
-			}},
+			{Manifest: "B", Name: "n2", Remote: remote2},
 		},
 	}
 	manifestB := project.Manifest{
 		Imports: []project.Import{
-			{Manifest: "A", Project: project.Project{
-				Name: "n3", Path: "p3", Remote: remote1,
-			}},
+			{Manifest: "A", Name: "n3", Remote: remote1},
 		},
 	}
 	if err := jiriManifest.ToFile(jirix, jirix.JiriManifestFile()); err != nil {
@@ -675,32 +669,26 @@
 	// Set up the cycle .jiri_manifest -> remote1+A -> remote2+B -> C -> remote1+D -> A
 	jiriManifest := project.Manifest{
 		Imports: []project.Import{
-			{Manifest: "A", Root: "r1", Project: project.Project{
-				Name: "n1", Path: "p1", Remote: remote1,
-			}},
+			{Manifest: "A", Root: "r1", Name: "n1", Remote: remote1},
 		},
 	}
 	manifestA := project.Manifest{
 		Imports: []project.Import{
-			{Manifest: "B", Root: "r2", Project: project.Project{
-				Name: "n2", Path: "p2", Remote: remote2,
-			}},
+			{Manifest: "B", Root: "r2", Name: "n2", Remote: remote2},
 		},
 	}
 	manifestB := project.Manifest{
-		FileImports: []project.FileImport{
+		LocalImports: []project.LocalImport{
 			{File: "C"},
 		},
 	}
 	manifestC := project.Manifest{
 		Imports: []project.Import{
-			{Manifest: "D", Root: "r3", Project: project.Project{
-				Name: "n3", Path: "p3", Remote: remote1,
-			}},
+			{Manifest: "D", Root: "r3", Name: "n3", Remote: remote1},
 		},
 	}
 	manifestD := project.Manifest{
-		FileImports: []project.FileImport{
+		LocalImports: []project.LocalImport{
 			{File: "A"},
 		},
 	}
@@ -928,31 +916,45 @@
 				Label: "label",
 				Imports: []project.Import{
 					{
-						Manifest: "manifest",
-						Project: project.Project{
-							Path:         "manifest",
-							Protocol:     "git",
-							Remote:       "remote",
-							RemoteBranch: "master",
-							Revision:     "HEAD",
-						},
+						Manifest:     "manifest1",
+						Name:         "remoteimport1",
+						Protocol:     "git",
+						Remote:       "remote1",
+						RemoteBranch: "master",
 					},
-					{Project: project.Project{Name: "localimport"}},
+					{
+						Manifest:     "manifest2",
+						Name:         "remoteimport2",
+						Protocol:     "git",
+						Remote:       "remote2",
+						RemoteBranch: "branch2",
+					},
+					{
+						Name: "oldimport",
+					},
 				},
-				FileImports: []project.FileImport{
+				LocalImports: []project.LocalImport{
 					{File: "fileimport"},
 				},
 				Projects: []project.Project{
 					{
+						Name:         "project1",
+						Path:         "path1",
+						Protocol:     "git",
+						Remote:       "remote1",
+						RemoteBranch: "master",
+						Revision:     "HEAD",
 						GerritHost:   "https://test-review.googlesource.com",
 						GitHooks:     "path/to/githooks",
 						RunHook:      "path/to/hook",
-						Name:         "project",
-						Path:         "path",
+					},
+					{
+						Name:         "project2",
+						Path:         "path2",
 						Protocol:     "git",
-						Remote:       "remote",
-						RemoteBranch: "otherbranch",
-						Revision:     "rev",
+						Remote:       "remote2",
+						RemoteBranch: "branch2",
+						Revision:     "rev2",
 					},
 				},
 				Tools: []project.Tool{
@@ -965,12 +967,14 @@
 			},
 			`<manifest label="label">
   <imports>
-    <import manifest="manifest" remote="remote"/>
-    <import name="localimport"/>
-    <fileimport file="fileimport"/>
+    <import manifest="manifest1" name="remoteimport1" remote="remote1"/>
+    <import manifest="manifest2" name="remoteimport2" remote="remote2" remotebranch="branch2"/>
+    <import name="oldimport"/>
+    <localimport file="fileimport"/>
   </imports>
   <projects>
-    <project name="project" path="path" remote="remote" remotebranch="otherbranch" revision="rev" gerrithost="https://test-review.googlesource.com" githooks="path/to/githooks" runhook="path/to/hook"/>
+    <project name="project1" path="path1" remote="remote1" gerrithost="https://test-review.googlesource.com" githooks="path/to/githooks" runhook="path/to/hook"/>
+    <project name="project2" path="path2" remote="remote2" remotebranch="branch2" revision="rev2"/>
   </projects>
   <tools>
     <tool data="tooldata" name="tool" project="toolproject"/>
@@ -1008,25 +1012,27 @@
 		{
 			// Default fields are dropped when marshaled, and added when unmarshaled.
 			project.Project{
-				Name:         "project",
-				Path:         "path",
+				Name:         "project1",
+				Path:         "path1",
 				Protocol:     "git",
-				Remote:       "remote",
+				Remote:       "remote1",
 				RemoteBranch: "master",
 				Revision:     "HEAD",
 			},
-			`<project name="project" path="path" remote="remote"/>`,
+			`<project name="project1" path="path1" remote="remote1"/>
+`,
 		},
 		{
 			project.Project{
-				Name:         "project",
-				Path:         "path",
+				Name:         "project2",
+				Path:         "path2",
 				Protocol:     "git",
-				Remote:       "remote",
-				RemoteBranch: "otherbranch",
-				Revision:     "rev",
+				Remote:       "remote2",
+				RemoteBranch: "branch2",
+				Revision:     "rev2",
 			},
-			`<project name="project" path="path" remote="remote" remotebranch="otherbranch" revision="rev"/>`,
+			`<project name="project2" path="path2" remote="remote2" remotebranch="branch2" revision="rev2"/>
+`,
 		},
 	}
 	for index, test := range tests {
@@ -1059,6 +1065,7 @@
 		XML     string
 		Project project.Project
 	}{
+		// Make sure <Project> opening tag is accepted.
 		{
 			`<Project name="project" path="path" remote="remote"/>`,
 			project.Project{
@@ -1070,6 +1077,7 @@
 				Revision:     "HEAD",
 			},
 		},
+		// Make sure <Project> opening and closing tags are accepted.
 		{
 			`<Project name="project" path="path" remote="remote"></Project>`,
 			project.Project{
@@ -1081,14 +1089,15 @@
 				Revision:     "HEAD",
 			},
 		},
+		// Make sure "this_attribute_should_be_ignored" is silently ignored.
 		{
-			`<Project this_attribute_should_be_ignored="junk" name="project" path="path" remote="remote" remotebranch="otherbranch" revision="rev"></Project>`,
+			`<Project this_attribute_should_be_ignored="junk" name="project" path="path" remote="remote" remotebranch="branch" revision="rev"></Project>`,
 			project.Project{
 				Name:         "project",
 				Path:         "path",
 				Protocol:     "git",
 				Remote:       "remote",
-				RemoteBranch: "otherbranch",
+				RemoteBranch: "branch",
 				Revision:     "rev",
 			},
 		},
@@ -1107,64 +1116,3 @@
 		}
 	}
 }
-
-func TestImportToFile(t *testing.T) {
-	jirix, cleanup := jiritest.NewX(t)
-	defer cleanup()
-
-	tests := []struct {
-		Import project.Import
-		XML    string
-	}{
-		{
-			project.Import{
-				Project: project.Project{
-					Name: "import",
-				},
-			},
-			`<import name="import"/>`,
-		},
-		{
-			// Default fields are dropped when marshaled, and added when unmarshaled.
-			project.Import{
-				Manifest: "manifest",
-				Project: project.Project{
-					Name:         "import",
-					Path:         "manifest",
-					Protocol:     "git",
-					Remote:       "remote",
-					RemoteBranch: "master",
-					Revision:     "HEAD",
-				},
-			},
-			`<import manifest="manifest" name="import" remote="remote"/>`,
-		},
-		{
-			project.Import{
-				Manifest: "manifest",
-				Project: project.Project{
-					Name:         "import",
-					Path:         "path",
-					Protocol:     "git",
-					Remote:       "remote",
-					RemoteBranch: "otherbranch",
-					Revision:     "rev",
-				},
-			},
-			`<import manifest="manifest" name="import" path="path" remote="remote" remotebranch="otherbranch" revision="rev"/>`,
-		},
-	}
-	for index, test := range tests {
-		filename := filepath.Join(jirix.Root, fmt.Sprintf("test-%d", index))
-		if err := test.Import.ToFile(jirix, filename); err != nil {
-			t.Errorf("%+v ToFile failed: %v", test.Import, err)
-		}
-		gotBytes, err := jirix.NewSeq().ReadFile(filename)
-		if err != nil {
-			t.Errorf("%+v ReadFile failed: %v", test.Import, err)
-		}
-		if got, want := string(gotBytes), test.XML; got != want {
-			t.Errorf("%+v ToFile GOT\n%v\nWANT\n%v", test.Import, got, want)
-		}
-	}
-}
diff --git a/rebuild.go b/rebuild.go
index 3f68b9a..984ee35 100644
--- a/rebuild.go
+++ b/rebuild.go
@@ -29,7 +29,7 @@
 }
 
 func runRebuild(jirix *jiri.X, args []string) (e error) {
-	_, tools, err := project.ReadJiriManifest(jirix)
+	_, tools, err := project.LoadManifest(jirix)
 	if err != nil {
 		return err
 	}
diff --git a/snapshot.go b/snapshot.go
index 168598f..b0e6262 100644
--- a/snapshot.go
+++ b/snapshot.go
@@ -116,9 +116,10 @@
 
 	// Execute the above function in the snapshot directory on a clean master branch.
 	p := project.Project{
-		Path:     snapshotDir,
-		Protocol: "git",
-		Revision: "HEAD",
+		Path:         snapshotDir,
+		Protocol:     "git",
+		RemoteBranch: "master",
+		Revision:     "HEAD",
 	}
 	return project.ApplyToLocalMaster(jirix, project.Projects{p.Key(): p}, createFn)
 }
diff --git a/upgrade.go b/upgrade.go
index 1209c4f..382e18e 100644
--- a/upgrade.go
+++ b/upgrade.go
@@ -82,65 +82,56 @@
 		return jirix.UsageErrorf("must specify upgrade kind")
 	}
 	kind := args[0]
-	var argRemote, argRoot, argPath, argManifest string
+	var argRemote, argName, argManifest string
 	switch kind {
 	case "v23":
 		argRemote = "https://vanadium.googlesource.com/manifest"
-		argRoot, argPath, argManifest = "", "manifest", "public"
+		argName, argManifest = "manifest", "public"
 	case "fuchsia":
-		// TODO(toddw): Confirm these choices.
 		argRemote = "https://github.com/effenel/fnl-start.git"
-		argRoot, argPath, argManifest = "", "manifest", "default"
+		argName, argManifest = "fnl-start", "manifest/fuchsia"
 	default:
 		return jirix.UsageErrorf("unknown upgrade kind %q", kind)
 	}
 	// Initialize manifest from .local_manifest.
-	hasLocalFile := false
+	hasLocalFile := true
 	manifest, err := project.ManifestFromFile(jirix, localFile)
-	switch {
-	case err != nil && !runutil.IsNotExist(err):
-		return err
-	case err == nil:
-		hasLocalFile = true
-		seenOldImport := false
-		var newImports []project.Import
-		for _, oldImport := range manifest.Imports {
-			if oldImport.Remote != "" {
-				// This is a new-style remote import, carry it over directly.
-				newImports = append(newImports, oldImport)
-				continue
-			}
-			// This is an old-style file import, convert it to the new style.
-			oldName := oldImport.Name
-			if kind == "v23" && oldName == "default" {
-				oldName = "public" // default no longer exists, now it's just public.
-			}
-			if !seenOldImport {
-				// This is the first old import, update the manifest name for the remote
-				// import we'll be adding later.
-				argManifest = oldName
-				seenOldImport = true
-			} else {
-				// Convert import from name="foo" to file="manifest/foo"
-				manifest.FileImports = append(manifest.FileImports, project.FileImport{
-					File: filepath.Join(argRoot, argPath, oldName),
-				})
-			}
+	if err != nil {
+		if !runutil.IsNotExist(err) {
+			return err
 		}
-		manifest.Imports = newImports
-	}
-	if manifest == nil {
+		hasLocalFile = false
 		manifest = &project.Manifest{}
 	}
-	// Add remote import.
-	manifest.Imports = append(manifest.Imports, project.Import{
-		Manifest: argManifest,
-		Root:     argRoot,
-		Project: project.Project{
-			Path:   argPath,
-			Remote: argRemote,
-		},
-	})
+	oldImports := manifest.Imports
+	manifest.Imports = nil
+	for _, oldImport := range oldImports {
+		if oldImport.Remote != "" {
+			// This is a new-style remote import, carry it over directly.
+			manifest.Imports = append(manifest.Imports, oldImport)
+			continue
+		}
+		// This is an old-style import, convert it to the new style.
+		oldName := oldImport.Name
+		switch {
+		case kind == "v23" && oldName == "default":
+			oldName = "public"
+		case kind == "fuchsia" && oldName == "default":
+			oldName = "manifest/fuchsia"
+		}
+		manifest.Imports = append(manifest.Imports, project.Import{
+			Manifest: oldName,
+			Name:     argName,
+			Remote:   argRemote,
+		})
+	}
+	if len(manifest.Imports) == 0 {
+		manifest.Imports = append(manifest.Imports, project.Import{
+			Manifest: argManifest,
+			Name:     argName,
+			Remote:   argRemote,
+		})
+	}
 	// Write output to .jiri_manifest file.
 	outFile := jirix.JiriManifestFile()
 	if _, err := os.Stat(outFile); err == nil {
diff --git a/upgrade_test.go b/upgrade_test.go
index f9e5733..4361c1b 100644
--- a/upgrade_test.go
+++ b/upgrade_test.go
@@ -41,7 +41,7 @@
 			Args: []string{"v23"},
 			Want: `<manifest>
   <imports>
-    <import manifest="public" remote="https://vanadium.googlesource.com/manifest"/>
+    <import manifest="public" name="manifest" remote="https://vanadium.googlesource.com/manifest"/>
   </imports>
 </manifest>
 `,
@@ -56,7 +56,7 @@
 `,
 			Want: `<manifest>
   <imports>
-    <import manifest="public" remote="https://vanadium.googlesource.com/manifest"/>
+    <import manifest="public" name="manifest" remote="https://vanadium.googlesource.com/manifest"/>
   </imports>
 </manifest>
 `,
@@ -71,7 +71,7 @@
 `,
 			Want: `<manifest>
   <imports>
-    <import manifest="private" remote="https://vanadium.googlesource.com/manifest"/>
+    <import manifest="private" name="manifest" remote="https://vanadium.googlesource.com/manifest"/>
   </imports>
 </manifest>
 `,
@@ -88,9 +88,9 @@
 `,
 			Want: `<manifest>
   <imports>
-    <import manifest="private" remote="https://vanadium.googlesource.com/manifest"/>
-    <fileimport file="manifest/infrastructure"/>
-    <fileimport file="manifest/public"/>
+    <import manifest="private" name="manifest" remote="https://vanadium.googlesource.com/manifest"/>
+    <import manifest="infrastructure" name="manifest" remote="https://vanadium.googlesource.com/manifest"/>
+    <import manifest="public" name="manifest" remote="https://vanadium.googlesource.com/manifest"/>
   </imports>
 </manifest>
 `,
@@ -107,9 +107,9 @@
 `,
 			Want: `<manifest>
   <imports>
-    <import manifest="public" remote="https://vanadium.googlesource.com/manifest"/>
-    <fileimport file="manifest/infrastructure"/>
-    <fileimport file="manifest/private"/>
+    <import manifest="public" name="manifest" remote="https://vanadium.googlesource.com/manifest"/>
+    <import manifest="infrastructure" name="manifest" remote="https://vanadium.googlesource.com/manifest"/>
+    <import manifest="private" name="manifest" remote="https://vanadium.googlesource.com/manifest"/>
   </imports>
 </manifest>
 `,
@@ -124,7 +124,7 @@
 			Args: []string{"fuchsia"},
 			Want: `<manifest>
   <imports>
-    <import manifest="default" remote="https://github.com/effenel/fnl-start.git"/>
+    <import manifest="manifest/fuchsia" name="fnl-start" remote="https://github.com/effenel/fnl-start.git"/>
   </imports>
 </manifest>
 `,
@@ -139,7 +139,7 @@
 `,
 			Want: `<manifest>
   <imports>
-    <import manifest="default" remote="https://github.com/effenel/fnl-start.git"/>
+    <import manifest="manifest/fuchsia" name="fnl-start" remote="https://github.com/effenel/fnl-start.git"/>
   </imports>
 </manifest>
 `,
@@ -154,7 +154,7 @@
 `,
 			Want: `<manifest>
   <imports>
-    <import manifest="private" remote="https://github.com/effenel/fnl-start.git"/>
+    <import manifest="private" name="fnl-start" remote="https://github.com/effenel/fnl-start.git"/>
   </imports>
 </manifest>
 `,
@@ -171,9 +171,9 @@
 `,
 			Want: `<manifest>
   <imports>
-    <import manifest="private" remote="https://github.com/effenel/fnl-start.git"/>
-    <fileimport file="manifest/infrastructure"/>
-    <fileimport file="manifest/default"/>
+    <import manifest="private" name="fnl-start" remote="https://github.com/effenel/fnl-start.git"/>
+    <import manifest="infrastructure" name="fnl-start" remote="https://github.com/effenel/fnl-start.git"/>
+    <import manifest="manifest/fuchsia" name="fnl-start" remote="https://github.com/effenel/fnl-start.git"/>
   </imports>
 </manifest>
 `,
@@ -190,9 +190,9 @@
 `,
 			Want: `<manifest>
   <imports>
-    <import manifest="default" remote="https://github.com/effenel/fnl-start.git"/>
-    <fileimport file="manifest/infrastructure"/>
-    <fileimport file="manifest/private"/>
+    <import manifest="manifest/fuchsia" name="fnl-start" remote="https://github.com/effenel/fnl-start.git"/>
+    <import manifest="infrastructure" name="fnl-start" remote="https://github.com/effenel/fnl-start.git"/>
+    <import manifest="private" name="fnl-start" remote="https://github.com/effenel/fnl-start.git"/>
   </imports>
 </manifest>
 `,
@@ -210,6 +210,7 @@
 }
 
 func testUpgrade(opts gosh.Opts, jiriTool string, test upgradeTestCase) error {
+	opts.PropagateChildOutput = true
 	sh := gosh.NewShell(opts)
 	defer sh.Cleanup()
 	jiriRoot := sh.MakeTempDir()
@@ -267,7 +268,7 @@
 	localData := `<manifest/>`
 	jiriData := `<manifest>
   <imports>
-    <import manifest="public" remote="https://vanadium.googlesource.com/manifest"/>
+    <import manifest="public" name="manifest" remote="https://vanadium.googlesource.com/manifest"/>
   </imports>
 </manifest>
 `