diff --git a/glide.lock b/glide.lock
index 0482f9d..04611c5 100644
--- a/glide.lock
+++ b/glide.lock
@@ -1,18 +1,24 @@
-hash: 7b0d46d2b21d5d8ff24023a402285f87b14b9f554ae52913cc7ea08bfd17453d
-updated: 2016-07-13T23:09:11.03428654-04:00
+hash: e12d18f87508f2f53e2981b52a02ed23d135f59ab90f3afca813727c0685eec0
+updated: 2016-09-15T09:56:26.054743146-04:00
 imports:
 - name: github.com/armon/go-radix
-  version: 4239b77079c7b5d1243b7b4736304ce8ddb6f0f2
+  branch: master
+  revision: 4239b77079c7b5d1243b7b4736304ce8ddb6f0f2
 - name: github.com/codegangsta/cli
-  version: 71f57d300dd6a780ac1856c005c4b518cfd498ec
+  version: v1.14.0
+  revision: 71f57d300dd6a780ac1856c005c4b518cfd498ec
 - name: github.com/Masterminds/semver
-  version: b3ef6b1808e9889dfb8767ce7068db923a3d07de
+  branch: 2.x
+  revision: b3ef6b1808e9889dfb8767ce7068db923a3d07de
 - name: github.com/Masterminds/vcs
-  version: fbe9fb6ad5b5f35b3e82a7c21123cfc526cbf895
+  version: v1.8.0
+  revision: fbe9fb6ad5b5f35b3e82a7c21123cfc526cbf895
 - name: github.com/sdboyer/gps
-  version: 6e8a101af5e735feedcdae1f716bebc338b74525
+  branch: master
+  revision: 166f36103aedbb9d835b9b6dcc7762a6bd900a98
 - name: github.com/termie/go-shutil
-  version: bcacb06fecaeec8dc42af03c87c6949f4a05c74c
+  revision: bcacb06fecaeec8dc42af03c87c6949f4a05c74c
 - name: gopkg.in/yaml.v2
-  version: a83829b6f1293c91addabc89d0571c246397bbf4
+  branch: v2
+  revision: 31c299268d302dd0aa9a0dcf765a3d58971ac83f
 testImports: []
diff --git a/vendor/github.com/sdboyer/gps/README.md b/vendor/github.com/sdboyer/gps/README.md
index 2cd2d99..381c2a8 100644
--- a/vendor/github.com/sdboyer/gps/README.md
+++ b/vendor/github.com/sdboyer/gps/README.md
@@ -3,7 +3,7 @@
     src="header.png"
     width="800" height="255" border="0" alt="gps">
 <br>
-<a href="https://circleci.com/gh/sdboyer/gps"><img src="https://circleci.com/gh/sdboyer/gps.svg?style=svg" alt="Build Status"></a>
+<a href="https://circleci.com/gh/sdboyer/gps"><img src="https://circleci.com/gh/sdboyer/gps.svg?style=shield" alt="Build Status"></a>
 <a href="https://ci.appveyor.com/project/sdboyer/gps"><img src="https://ci.appveyor.com/api/projects/status/github/sdboyer/gps?svg=true&branch=master&passingText=Windows%20-%20OK&failingText=Windows%20-%20failed&pendingText=Windows%20-%20pending" alt="Windows Build Status"></a>
 <a href="https://goreportcard.com/report/github.com/sdboyer/gps"><img src="https://goreportcard.com/badge/github.com/sdboyer/gps" alt="Build Status"></a>
 <a href="https://codecov.io/gh/sdboyer/gps"><img src="https://codecov.io/gh/sdboyer/gps/branch/master/graph/badge.svg" alt="Codecov" /></a>
diff --git a/vendor/github.com/sdboyer/gps/analysis.go b/vendor/github.com/sdboyer/gps/analysis.go
index 7fcb5bf..d410eb3 100644
--- a/vendor/github.com/sdboyer/gps/analysis.go
+++ b/vendor/github.com/sdboyer/gps/analysis.go
@@ -69,7 +69,7 @@
 // A PackageTree is returned, which contains the ImportRoot and map of import path
 // to PackageOrErr - each path under the root that exists will have either a
 // Package, or an error describing why the directory is not a valid package.
-func listPackages(fileRoot, importRoot string) (PackageTree, error) {
+func ListPackages(fileRoot, importRoot string) (PackageTree, error) {
 	// Set up a build.ctx for parsing
 	ctx := build.Default
 	ctx.GOROOT = ""
@@ -148,9 +148,6 @@
 		// We do skip dot-dirs, though, because it's such a ubiquitous standard
 		// that they not be visited by normal commands, and because things get
 		// really weird if we don't.
-		//
-		// TODO(sdboyer) does this entail that we should chuck dot-led import
-		// paths later on?
 		if strings.HasPrefix(fi.Name(), ".") {
 			return filepath.SkipDir
 		}
@@ -297,19 +294,279 @@
 	return fmt.Sprintf("import path %s had problematic local imports", e.Dir)
 }
 
+func readFileBuildTags(fp string) ([]string, error) {
+	co, err := readGoContents(fp)
+	if err != nil {
+		return []string{}, err
+	}
+
+	var tags []string
+	// Only look at places where we had a code comment.
+	if len(co) > 0 {
+		t := findTags(co)
+		for _, tg := range t {
+			found := false
+			for _, tt := range tags {
+				if tt == tg {
+					found = true
+				}
+			}
+			if !found {
+				tags = append(tags, tg)
+			}
+		}
+	}
+
+	return tags, nil
+}
+
+// Read contents of a Go file up to the package declaration. This can be used
+// to find the the build tags.
+func readGoContents(fp string) ([]byte, error) {
+	f, err := os.Open(fp)
+	defer f.Close()
+	if err != nil {
+		return []byte{}, err
+	}
+
+	var s scanner.Scanner
+	s.Init(f)
+	var tok rune
+	var pos scanner.Position
+	for tok != scanner.EOF {
+		tok = s.Scan()
+
+		// Getting the token text will skip comments by default.
+		tt := s.TokenText()
+		// build tags will not be after the package declaration.
+		if tt == "package" {
+			pos = s.Position
+			break
+		}
+	}
+
+	var buf bytes.Buffer
+	f.Seek(0, 0)
+	_, err = io.CopyN(&buf, f, int64(pos.Offset))
+	if err != nil {
+		return []byte{}, err
+	}
+
+	return buf.Bytes(), nil
+}
+
+// From a byte slice of a Go file find the tags.
+func findTags(co []byte) []string {
+	p := co
+	var tgs []string
+	for len(p) > 0 {
+		line := p
+		if i := bytes.IndexByte(line, '\n'); i >= 0 {
+			line, p = line[:i], p[i+1:]
+		} else {
+			p = p[len(p):]
+		}
+		line = bytes.TrimSpace(line)
+		// Only look at comment lines that are well formed in the Go style
+		if bytes.HasPrefix(line, []byte("//")) {
+			line = bytes.TrimSpace(line[len([]byte("//")):])
+			if len(line) > 0 && line[0] == '+' {
+				f := strings.Fields(string(line))
+
+				// We've found a +build tag line.
+				if f[0] == "+build" {
+					for _, tg := range f[1:] {
+						tgs = append(tgs, tg)
+					}
+				}
+			}
+		}
+	}
+
+	return tgs
+}
+
+// A PackageTree represents the results of recursively parsing a tree of
+// packages, starting at the ImportRoot. The results of parsing the files in the
+// directory identified by each import path - a Package or an error - are stored
+// in the Packages map, keyed by that import path.
+type PackageTree struct {
+	ImportRoot string
+	Packages   map[string]PackageOrErr
+}
+
+// dup copies the PackageTree.
+//
+// This is really only useful as a defensive measure to prevent external state
+// mutations.
+func (t PackageTree) dup() PackageTree {
+	t2 := PackageTree{
+		ImportRoot: t.ImportRoot,
+		Packages:   map[string]PackageOrErr{},
+	}
+
+	for path, poe := range t.Packages {
+		poe2 := PackageOrErr{
+			Err: poe.Err,
+			P:   poe.P,
+		}
+		if len(poe.P.Imports) > 0 {
+			poe2.P.Imports = make([]string, len(poe.P.Imports))
+			copy(poe2.P.Imports, poe.P.Imports)
+		}
+		if len(poe.P.TestImports) > 0 {
+			poe2.P.TestImports = make([]string, len(poe.P.TestImports))
+			copy(poe2.P.TestImports, poe.P.TestImports)
+		}
+
+		t2.Packages[path] = poe2
+	}
+
+	return t2
+}
+
 type wm struct {
 	err error
 	ex  map[string]bool
 	in  map[string]bool
 }
 
-// wmToReach takes an externalReach()-style workmap and transitively walks all
-// internal imports until they reach an external path or terminate, then
+// PackageOrErr stores the results of attempting to parse a single directory for
+// Go source code.
+type PackageOrErr struct {
+	P   Package
+	Err error
+}
+
+// ReachMap maps a set of import paths (keys) to the set of external packages
+// transitively reachable from the packages at those import paths.
+//
+// See PackageTree.ExternalReach() for more information.
+type ReachMap map[string][]string
+
+// ExternalReach looks through a PackageTree and computes the list of external
+// import statements (that is, import statements pointing to packages that are
+// not logical children of PackageTree.ImportRoot) that are transitively
+// imported by the internal packages in the tree.
+//
+// main indicates whether (true) or not (false) to include main packages in the
+// analysis. When utilized by gps' solver, main packages are generally excluded
+// from analyzing anything other than the root project, as they necessarily can't
+// be imported.
+//
+// tests indicates whether (true) or not (false) to include imports from test
+// files in packages when computing the reach map.
+//
+// ignore is a map of import paths that, if encountered, should be excluded from
+// analysis. This exclusion applies to both internal and external packages. If
+// an external import path is ignored, it is simply omitted from the results.
+//
+// If an internal path is ignored, then not only does it not appear in the final
+// map, but it is also excluded from the transitive calculations of other
+// internal packages.  That is, if you ignore A/foo, then the external package
+// list for all internal packages that import A/foo will not include external
+// packages that are only reachable through A/foo.
+//
+// Visually, this means that, given a PackageTree with root A and packages at A,
+// A/foo, and A/bar, and the following import chain:
+//
+//  A -> A/foo -> A/bar -> B/baz
+//
+// In this configuration, all of A's packages transitively import B/baz, so the
+// returned map would be:
+//
+//  map[string][]string{
+// 	"A": []string{"B/baz"},
+// 	"A/foo": []string{"B/baz"}
+// 	"A/bar": []string{"B/baz"},
+//  }
+//
+// However, if you ignore A/foo, then A's path to B/baz is broken, and A/foo is
+// omitted entirely. Thus, the returned map would be:
+//
+//  map[string][]string{
+// 	"A": []string{},
+// 	"A/bar": []string{"B/baz"},
+//  }
+//
+// If there are no packages to ignore, it is safe to pass a nil map.
+func (t PackageTree) ExternalReach(main, tests bool, ignore map[string]bool) ReachMap {
+	if ignore == nil {
+		ignore = make(map[string]bool)
+	}
+
+	// world's simplest adjacency list
+	workmap := make(map[string]wm)
+
+	var imps []string
+	for ip, perr := range t.Packages {
+		if perr.Err != nil {
+			workmap[ip] = wm{
+				err: perr.Err,
+			}
+			continue
+		}
+		p := perr.P
+
+		// Skip main packages, unless param says otherwise
+		if p.Name == "main" && !main {
+			continue
+		}
+		// Skip ignored packages
+		if ignore[ip] {
+			continue
+		}
+
+		imps = imps[:0]
+		imps = p.Imports
+		if tests {
+			imps = dedupeStrings(imps, p.TestImports)
+		}
+
+		w := wm{
+			ex: make(map[string]bool),
+			in: make(map[string]bool),
+		}
+
+		for _, imp := range imps {
+			// Skip ignored imports
+			if ignore[imp] {
+				continue
+			}
+
+			if !checkPrefixSlash(filepath.Clean(imp), t.ImportRoot) {
+				w.ex[imp] = true
+			} else {
+				if w2, seen := workmap[imp]; seen {
+					for i := range w2.ex {
+						w.ex[i] = true
+					}
+					for i := range w2.in {
+						w.in[i] = true
+					}
+				} else {
+					w.in[imp] = true
+				}
+			}
+		}
+
+		workmap[ip] = w
+	}
+
+	//return wmToReach(workmap, t.ImportRoot)
+	return wmToReach(workmap, "") // TODO(sdboyer) this passes tests, but doesn't seem right
+}
+
+// wmToReach takes an internal "workmap" constructed by
+// PackageTree.ExternalReach(), transitively walks (via depth-first traversal)
+// all internal imports until they reach an external path or terminate, then
 // translates the results into a slice of external imports for each internal
 // pkg.
 //
 // The basedir string, with a trailing slash ensured, will be stripped from the
 // keys of the returned map.
+//
+// This is mostly separated out for testing purposes.
 func wmToReach(workmap map[string]wm, basedir string) map[string][]string {
 	// Uses depth-first exploration to compute reachability into external
 	// packages, dropping any internal packages on "poisoned paths" - a path
@@ -502,351 +759,9 @@
 	return rm
 }
 
-func readBuildTags(p string) ([]string, error) {
-	_, err := os.Stat(p)
-	if err != nil {
-		return []string{}, err
-	}
-
-	d, err := os.Open(p)
-	if err != nil {
-		return []string{}, err
-	}
-
-	objects, err := d.Readdir(-1)
-	if err != nil {
-		return []string{}, err
-	}
-
-	var tags []string
-	for _, obj := range objects {
-
-		// only process Go files
-		if strings.HasSuffix(obj.Name(), ".go") {
-			fp := filepath.Join(p, obj.Name())
-
-			co, err := readGoContents(fp)
-			if err != nil {
-				return []string{}, err
-			}
-
-			// Only look at places where we had a code comment.
-			if len(co) > 0 {
-				t := findTags(co)
-				for _, tg := range t {
-					found := false
-					for _, tt := range tags {
-						if tt == tg {
-							found = true
-						}
-					}
-					if !found {
-						tags = append(tags, tg)
-					}
-				}
-			}
-		}
-	}
-
-	return tags, nil
-}
-
-func readFileBuildTags(fp string) ([]string, error) {
-	co, err := readGoContents(fp)
-	if err != nil {
-		return []string{}, err
-	}
-
-	var tags []string
-	// Only look at places where we had a code comment.
-	if len(co) > 0 {
-		t := findTags(co)
-		for _, tg := range t {
-			found := false
-			for _, tt := range tags {
-				if tt == tg {
-					found = true
-				}
-			}
-			if !found {
-				tags = append(tags, tg)
-			}
-		}
-	}
-
-	return tags, nil
-}
-
-// Read contents of a Go file up to the package declaration. This can be used
-// to find the the build tags.
-func readGoContents(fp string) ([]byte, error) {
-	f, err := os.Open(fp)
-	defer f.Close()
-	if err != nil {
-		return []byte{}, err
-	}
-
-	var s scanner.Scanner
-	s.Init(f)
-	var tok rune
-	var pos scanner.Position
-	for tok != scanner.EOF {
-		tok = s.Scan()
-
-		// Getting the token text will skip comments by default.
-		tt := s.TokenText()
-		// build tags will not be after the package declaration.
-		if tt == "package" {
-			pos = s.Position
-			break
-		}
-	}
-
-	var buf bytes.Buffer
-	f.Seek(0, 0)
-	_, err = io.CopyN(&buf, f, int64(pos.Offset))
-	if err != nil {
-		return []byte{}, err
-	}
-
-	return buf.Bytes(), nil
-}
-
-// From a byte slice of a Go file find the tags.
-func findTags(co []byte) []string {
-	p := co
-	var tgs []string
-	for len(p) > 0 {
-		line := p
-		if i := bytes.IndexByte(line, '\n'); i >= 0 {
-			line, p = line[:i], p[i+1:]
-		} else {
-			p = p[len(p):]
-		}
-		line = bytes.TrimSpace(line)
-		// Only look at comment lines that are well formed in the Go style
-		if bytes.HasPrefix(line, []byte("//")) {
-			line = bytes.TrimSpace(line[len([]byte("//")):])
-			if len(line) > 0 && line[0] == '+' {
-				f := strings.Fields(string(line))
-
-				// We've found a +build tag line.
-				if f[0] == "+build" {
-					for _, tg := range f[1:] {
-						tgs = append(tgs, tg)
-					}
-				}
-			}
-		}
-	}
-
-	return tgs
-}
-
-// Get an OS value that's not the one passed in.
-func getOsValue(n string) string {
-	for _, o := range osList {
-		if o != n {
-			return o
-		}
-	}
-
-	return n
-}
-
-func isSupportedOs(n string) bool {
-	for _, o := range osList {
-		if o == n {
-			return true
-		}
-	}
-
-	return false
-}
-
-// Get an Arch value that's not the one passed in.
-func getArchValue(n string) string {
-	for _, o := range archList {
-		if o != n {
-			return o
-		}
-	}
-
-	return n
-}
-
-func isSupportedArch(n string) bool {
-	for _, o := range archList {
-		if o == n {
-			return true
-		}
-	}
-
-	return false
-}
-
-func ensureTrailingSlash(s string) string {
-	return strings.TrimSuffix(s, string(os.PathSeparator)) + string(os.PathSeparator)
-}
-
-// helper func to merge, dedupe, and sort strings
-func dedupeStrings(s1, s2 []string) (r []string) {
-	dedupe := make(map[string]bool)
-
-	if len(s1) > 0 && len(s2) > 0 {
-		for _, i := range s1 {
-			dedupe[i] = true
-		}
-		for _, i := range s2 {
-			dedupe[i] = true
-		}
-
-		for i := range dedupe {
-			r = append(r, i)
-		}
-		// And then re-sort them
-		sort.Strings(r)
-	} else if len(s1) > 0 {
-		r = s1
-	} else if len(s2) > 0 {
-		r = s2
-	}
-
-	return
-}
-
-// A PackageTree represents the results of recursively parsing a tree of
-// packages, starting at the ImportRoot. The results of parsing the files in the
-// directory identified by each import path - a Package or an error - are stored
-// in the Packages map, keyed by that import path.
-type PackageTree struct {
-	ImportRoot string
-	Packages   map[string]PackageOrErr
-}
-
-// PackageOrErr stores the results of attempting to parse a single directory for
-// Go source code.
-type PackageOrErr struct {
-	P   Package
-	Err error
-}
-
-// ExternalReach looks through a PackageTree and computes the list of external
-// import statements (that is, import statements pointing to packages that are
-// not logical children of PackageTree.ImportRoot) that are transitively
-// imported by the internal packages in the tree.
-//
-// main indicates whether (true) or not (false) to include main packages in the
-// analysis. When utilized by gps' solver, main packages are generally excluded
-// from analyzing anything other than the root project, as they necessarily can't
-// be imported.
-//
-// tests indicates whether (true) or not (false) to include imports from test
-// files in packages when computing the reach map.
-//
-// ignore is a map of import paths that, if encountered, should be excluded from
-// analysis. This exclusion applies to both internal and external packages. If
-// an external import path is ignored, it is simply omitted from the results.
-//
-// If an internal path is ignored, then not only does it not appear in the final
-// map, but it is also excluded from the transitive calculations of other
-// internal packages.  That is, if you ignore A/foo, then the external package
-// list for all internal packages that import A/foo will not include external
-// packages that are only reachable through A/foo.
-//
-// Visually, this means that, given a PackageTree with root A and packages at A,
-// A/foo, and A/bar, and the following import chain:
-//
-//  A -> A/foo -> A/bar -> B/baz
-//
-// In this configuration, all of A's packages transitively import B/baz, so the
-// returned map would be:
-//
-//  map[string][]string{
-// 	"A": []string{"B/baz"},
-// 	"A/foo": []string{"B/baz"}
-// 	"A/bar": []string{"B/baz"},
-//  }
-//
-// However, if you ignore A/foo, then A's path to B/baz is broken, and A/foo is
-// omitted entirely. Thus, the returned map would be:
-//
-//  map[string][]string{
-// 	"A": []string{},
-// 	"A/bar": []string{"B/baz"},
-//  }
-//
-// If there are no packages to ignore, it is safe to pass a nil map.
-func (t PackageTree) ExternalReach(main, tests bool, ignore map[string]bool) map[string][]string {
-	if ignore == nil {
-		ignore = make(map[string]bool)
-	}
-
-	// world's simplest adjacency list
-	workmap := make(map[string]wm)
-
-	var imps []string
-	for ip, perr := range t.Packages {
-		if perr.Err != nil {
-			workmap[ip] = wm{
-				err: perr.Err,
-			}
-			continue
-		}
-		p := perr.P
-
-		// Skip main packages, unless param says otherwise
-		if p.Name == "main" && !main {
-			continue
-		}
-		// Skip ignored packages
-		if ignore[ip] {
-			continue
-		}
-
-		imps = imps[:0]
-		imps = p.Imports
-		if tests {
-			imps = dedupeStrings(imps, p.TestImports)
-		}
-
-		w := wm{
-			ex: make(map[string]bool),
-			in: make(map[string]bool),
-		}
-
-		for _, imp := range imps {
-			// Skip ignored imports
-			if ignore[imp] {
-				continue
-			}
-
-			if !checkPrefixSlash(filepath.Clean(imp), t.ImportRoot) {
-				w.ex[imp] = true
-			} else {
-				if w2, seen := workmap[imp]; seen {
-					for i := range w2.ex {
-						w.ex[i] = true
-					}
-					for i := range w2.in {
-						w.in[i] = true
-					}
-				} else {
-					w.in[imp] = true
-				}
-			}
-		}
-
-		workmap[ip] = w
-	}
-
-	//return wmToReach(workmap, t.ImportRoot)
-	return wmToReach(workmap, "") // TODO(sdboyer) this passes tests, but doesn't seem right
-}
-
 // ListExternalImports computes a sorted, deduplicated list of all the external
-// packages that are reachable through imports from all valid packages in the
-// PackageTree.
+// packages that are reachable through imports from all valid packages in a
+// ReachMap, as computed by PackageTree.ExternalReach().
 //
 // main and tests determine whether main packages and test imports should be
 // included in the calculation. "External" is defined as anything not prefixed,
@@ -910,10 +825,7 @@
 //    -> A/.bar -> B/baz
 //
 // A is legal, and it imports A/.bar, so the results will include B/baz.
-func (t PackageTree) ListExternalImports(main, tests bool, ignore map[string]bool) []string {
-	// First, we need a reachmap
-	rm := t.ExternalReach(main, tests, ignore)
-
+func (rm ReachMap) ListExternalImports() []string {
 	exm := make(map[string]struct{})
 	for pkg, reach := range rm {
 		// Eliminate import paths with any elements having leading dots, leading
@@ -962,3 +874,33 @@
 	}
 	return s == prefix || strings.HasPrefix(s, ensureTrailingSlash(prefix))
 }
+
+func ensureTrailingSlash(s string) string {
+	return strings.TrimSuffix(s, string(os.PathSeparator)) + string(os.PathSeparator)
+}
+
+// helper func to merge, dedupe, and sort strings
+func dedupeStrings(s1, s2 []string) (r []string) {
+	dedupe := make(map[string]bool)
+
+	if len(s1) > 0 && len(s2) > 0 {
+		for _, i := range s1 {
+			dedupe[i] = true
+		}
+		for _, i := range s2 {
+			dedupe[i] = true
+		}
+
+		for i := range dedupe {
+			r = append(r, i)
+		}
+		// And then re-sort them
+		sort.Strings(r)
+	} else if len(s1) > 0 {
+		r = s1
+	} else if len(s2) > 0 {
+		r = s2
+	}
+
+	return
+}
diff --git a/vendor/github.com/sdboyer/gps/analysis_test.go b/vendor/github.com/sdboyer/gps/analysis_test.go
index 210d036..c21f53b 100644
--- a/vendor/github.com/sdboyer/gps/analysis_test.go
+++ b/vendor/github.com/sdboyer/gps/analysis_test.go
@@ -836,7 +836,7 @@
 			continue
 		}
 
-		out, err := listPackages(fix.fileRoot, fix.importRoot)
+		out, err := ListPackages(fix.fileRoot, fix.importRoot)
 
 		if err != nil && fix.err == nil {
 			t.Errorf("listPackages(%q): Received error but none expected: %s", name, err)
@@ -889,7 +889,7 @@
 
 func TestListExternalImports(t *testing.T) {
 	// There's enough in the 'varied' test case to test most of what matters
-	vptree, err := listPackages(filepath.Join(getwd(t), "_testdata", "src", "varied"), "varied")
+	vptree, err := ListPackages(filepath.Join(getwd(t), "_testdata", "src", "varied"), "varied")
 	if err != nil {
 		t.Fatalf("listPackages failed on varied test case: %s", err)
 	}
@@ -900,7 +900,7 @@
 	var main, tests bool
 
 	validate := func() {
-		result := vptree.ListExternalImports(main, tests, ignore)
+		result := vptree.ExternalReach(main, tests, ignore).ListExternalImports()
 		if !reflect.DeepEqual(expect, result) {
 			t.Errorf("Wrong imports in %q case:\n\t(GOT): %s\n\t(WNT): %s", name, result, expect)
 		}
@@ -1034,12 +1034,12 @@
 	validate()
 
 	// The only thing varied *doesn't* cover is disallowed path patterns
-	ptree, err := listPackages(filepath.Join(getwd(t), "_testdata", "src", "disallow"), "disallow")
+	ptree, err := ListPackages(filepath.Join(getwd(t), "_testdata", "src", "disallow"), "disallow")
 	if err != nil {
 		t.Fatalf("listPackages failed on disallow test case: %s", err)
 	}
 
-	result := ptree.ListExternalImports(false, false, nil)
+	result := ptree.ExternalReach(false, false, nil).ListExternalImports()
 	expect = []string{"github.com/sdboyer/gps", "hash", "sort"}
 	if !reflect.DeepEqual(expect, result) {
 		t.Errorf("Wrong imports in %q case:\n\t(GOT): %s\n\t(WNT): %s", name, result, expect)
@@ -1048,7 +1048,7 @@
 
 func TestExternalReach(t *testing.T) {
 	// There's enough in the 'varied' test case to test most of what matters
-	vptree, err := listPackages(filepath.Join(getwd(t), "_testdata", "src", "varied"), "varied")
+	vptree, err := ListPackages(filepath.Join(getwd(t), "_testdata", "src", "varied"), "varied")
 	if err != nil {
 		t.Fatalf("listPackages failed on varied test case: %s", err)
 	}
diff --git a/vendor/github.com/sdboyer/gps/bridge.go b/vendor/github.com/sdboyer/gps/bridge.go
index a7368e3..379cd4b 100644
--- a/vendor/github.com/sdboyer/gps/bridge.go
+++ b/vendor/github.com/sdboyer/gps/bridge.go
@@ -14,7 +14,6 @@
 type sourceBridge interface {
 	SourceManager // composes SourceManager
 	verifyRootDir(path string) error
-	computeRootReach() ([]string, error)
 	pairRevision(id ProjectIdentifier, r Revision) []Version
 	pairVersion(id ProjectIdentifier, v UnpairedVersion) PairedVersion
 	vendorCodeExists(id ProjectIdentifier) (bool, error)
@@ -68,7 +67,7 @@
 }
 
 func (b *bridge) GetManifestAndLock(id ProjectIdentifier, v Version) (Manifest, Lock, error) {
-	if id.ProjectRoot == b.s.params.ImportRoot {
+	if id.ProjectRoot == ProjectRoot(b.s.rpt.ImportRoot) {
 		return b.s.rm, b.s.rl, nil
 	}
 	return b.sm.GetManifestAndLock(id, v)
@@ -339,57 +338,14 @@
 	return nil
 }
 
-// computeRootReach is a specialized, less stringent version of listExternal
-// that allows for a bit of fuzziness in the source inputs.
-//
-// Specifically, we need to:
-//  - Analyze test-type files as well as typical source files
-//  - Make a best-effort attempt even if the code doesn't compile
-//  - Include main packages in the analysis
-//
-// Perhaps most important is that we don't want to have the results of this
-// analysis be in any permanent cache, and we want to read directly from our
-// potentially messy root project source location on disk. Together, this means
-// that we can't ask the real SourceManager to do it.
-func (b *bridge) computeRootReach() ([]string, error) {
-	// TODO(sdboyer) i now cannot remember the reasons why i thought being less stringent
-	// in the analysis was OK. so, for now, we just compute a bog-standard list
-	// of externally-touched packages, including mains and test.
-	ptree, err := b.listRootPackages()
-	if err != nil {
-		return nil, err
-	}
-
-	return ptree.ListExternalImports(true, true, b.s.ig), nil
-}
-
-func (b *bridge) listRootPackages() (PackageTree, error) {
-	if b.crp == nil {
-		ptree, err := listPackages(b.s.params.RootDir, string(b.s.params.ImportRoot))
-
-		b.crp = &struct {
-			ptree PackageTree
-			err   error
-		}{
-			ptree: ptree,
-			err:   err,
-		}
-	}
-	if b.crp.err != nil {
-		return PackageTree{}, b.crp.err
-	}
-
-	return b.crp.ptree, nil
-}
-
 // listPackages lists all the packages contained within the given project at a
 // particular version.
 //
 // The root project is handled separately, as the source manager isn't
 // responsible for that code.
 func (b *bridge) ListPackages(id ProjectIdentifier, v Version) (PackageTree, error) {
-	if id.ProjectRoot == b.s.params.ImportRoot {
-		return b.listRootPackages()
+	if id.ProjectRoot == ProjectRoot(b.s.rpt.ImportRoot) {
+		panic("should never call ListPackages on root project")
 	}
 
 	return b.sm.ListPackages(id, v)
diff --git a/vendor/github.com/sdboyer/gps/example.go b/vendor/github.com/sdboyer/gps/example.go
index 2bbbe2c..c3a827a 100644
--- a/vendor/github.com/sdboyer/gps/example.go
+++ b/vendor/github.com/sdboyer/gps/example.go
@@ -32,10 +32,10 @@
 	// Set up params, including tracing
 	params := gps.SolveParameters{
 		RootDir:     root,
-		ImportRoot:  gps.ProjectRoot(importroot),
 		Trace:       true,
 		TraceLogger: log.New(os.Stdout, "", 0),
 	}
+	params.RootPackageTree, _ = gps.ListPackages(root, importroot)
 
 	// Set up a SourceManager with the NaiveAnalyzer
 	sourcemgr, _ := gps.NewSourceManager(NaiveAnalyzer{}, ".repocache", false)
diff --git a/vendor/github.com/sdboyer/gps/hash.go b/vendor/github.com/sdboyer/gps/hash.go
index 893c34e..ca9c9a2 100644
--- a/vendor/github.com/sdboyer/gps/hash.go
+++ b/vendor/github.com/sdboyer/gps/hash.go
@@ -20,7 +20,7 @@
 	// Do these checks up front before any other work is needed, as they're the
 	// only things that can cause errors
 	// Pass in magic root values, and the bridge will analyze the right thing
-	ptree, err := s.b.ListPackages(ProjectIdentifier{ProjectRoot: s.params.ImportRoot}, nil)
+	ptree, err := s.b.ListPackages(ProjectIdentifier{ProjectRoot: ProjectRoot(s.params.RootPackageTree.ImportRoot)}, nil)
 	if err != nil {
 		return nil, badOptsFailure(fmt.Sprintf("Error while parsing packages under %s: %s", s.params.RootDir, err.Error()))
 	}
diff --git a/vendor/github.com/sdboyer/gps/hash_test.go b/vendor/github.com/sdboyer/gps/hash_test.go
index f356ced..51732ca 100644
--- a/vendor/github.com/sdboyer/gps/hash_test.go
+++ b/vendor/github.com/sdboyer/gps/hash_test.go
@@ -10,9 +10,9 @@
 	fix := basicFixtures["shared dependency with overlapping constraints"]
 
 	params := SolveParameters{
-		RootDir:    string(fix.ds[0].n),
-		ImportRoot: fix.ds[0].n,
-		Manifest:   fix.rootmanifest(),
+		RootDir:         string(fix.ds[0].n),
+		RootPackageTree: fix.rootTree(),
+		Manifest:        fix.rootmanifest(),
 	}
 
 	s, err := Prepare(params, newdepspecSM(fix.ds, nil))
@@ -51,15 +51,16 @@
 func TestHashInputsIgnores(t *testing.T) {
 	fix := basicFixtures["shared dependency with overlapping constraints"]
 
-	rm := fix.rootmanifest().(simpleRootManifest)
+	rm := fix.rootmanifest().(simpleRootManifest).dup()
 	rm.ig = map[string]bool{
 		"foo": true,
 		"bar": true,
 	}
+
 	params := SolveParameters{
-		RootDir:    string(fix.ds[0].n),
-		ImportRoot: fix.ds[0].n,
-		Manifest:   rm,
+		RootDir:         string(fix.ds[0].n),
+		RootPackageTree: fix.rootTree(),
+		Manifest:        rm,
 	}
 
 	s, err := Prepare(params, newdepspecSM(fix.ds, nil))
@@ -101,7 +102,7 @@
 func TestHashInputsOverrides(t *testing.T) {
 	fix := basicFixtures["shared dependency with overlapping constraints"]
 
-	rm := fix.rootmanifest().(simpleRootManifest)
+	rm := fix.rootmanifest().(simpleRootManifest).dup()
 	// First case - override something not in the root, just with network name
 	rm.ovr = map[ProjectRoot]ProjectProperties{
 		"c": ProjectProperties{
@@ -109,9 +110,9 @@
 		},
 	}
 	params := SolveParameters{
-		RootDir:    string(fix.ds[0].n),
-		ImportRoot: fix.ds[0].n,
-		Manifest:   rm,
+		RootDir:         string(fix.ds[0].n),
+		RootPackageTree: fix.rootTree(),
+		Manifest:        rm,
 	}
 
 	s, err := Prepare(params, newdepspecSM(fix.ds, nil))
diff --git a/vendor/github.com/sdboyer/gps/manifest.go b/vendor/github.com/sdboyer/gps/manifest.go
index 94513d0..ff23ec0 100644
--- a/vendor/github.com/sdboyer/gps/manifest.go
+++ b/vendor/github.com/sdboyer/gps/manifest.go
@@ -90,6 +90,26 @@
 func (m simpleRootManifest) IgnorePackages() map[string]bool {
 	return m.ig
 }
+func (m simpleRootManifest) dup() simpleRootManifest {
+	m2 := simpleRootManifest{
+		c:   make([]ProjectConstraint, len(m.c)),
+		tc:  make([]ProjectConstraint, len(m.tc)),
+		ovr: ProjectConstraints{},
+		ig:  map[string]bool{},
+	}
+
+	copy(m2.c, m.c)
+	copy(m2.tc, m.tc)
+
+	for k, v := range m.ovr {
+		m2.ovr[k] = v
+	}
+	for k, v := range m.ig {
+		m2.ig[k] = v
+	}
+
+	return m2
+}
 
 // prepManifest ensures a manifest is prepared and safe for use by the solver.
 // This is mostly about ensuring that no outside routine can modify the manifest
diff --git a/vendor/github.com/sdboyer/gps/solve_basic_test.go b/vendor/github.com/sdboyer/gps/solve_basic_test.go
index c0ca587..9fe9780 100644
--- a/vendor/github.com/sdboyer/gps/solve_basic_test.go
+++ b/vendor/github.com/sdboyer/gps/solve_basic_test.go
@@ -348,6 +348,7 @@
 type specfix interface {
 	name() string
 	rootmanifest() RootManifest
+	rootTree() PackageTree
 	specs() []depspec
 	maxTries() int
 	solution() map[ProjectIdentifier]Version
@@ -413,6 +414,33 @@
 	}
 }
 
+func (f basicFixture) rootTree() PackageTree {
+	var imp, timp []string
+	for _, dep := range f.ds[0].deps {
+		imp = append(imp, string(dep.Ident.ProjectRoot))
+	}
+	for _, dep := range f.ds[0].devdeps {
+		timp = append(timp, string(dep.Ident.ProjectRoot))
+	}
+
+	n := string(f.ds[0].n)
+	pt := PackageTree{
+		ImportRoot: n,
+		Packages: map[string]PackageOrErr{
+			string(n): {
+				P: Package{
+					ImportPath:  n,
+					Name:        n,
+					Imports:     imp,
+					TestImports: timp,
+				},
+			},
+		},
+	}
+
+	return pt
+}
+
 func (f basicFixture) failure() error {
 	return f.fail
 }
@@ -667,6 +695,10 @@
 			"bar 1.0.1",
 		),
 	},
+	// This fixture describes a situation that should be impossible with a
+	// real-world VCS (contents of dep at same rev are different, as indicated
+	// by different constraints on bar). But, that's not the SUT here, so it's
+	// OK.
 	"pairs bare revs in lock with all versions": {
 		ds: []depspec{
 			mkDepspec("root 0.0.0", "foo ~1.0.1"),
@@ -682,7 +714,7 @@
 		),
 		r: mksolution(
 			"foo 1.0.2 foorev",
-			"bar 1.0.1",
+			"bar 1.0.2",
 		),
 	},
 	"does not pair bare revs in manifest with unpaired lock version": {
@@ -703,6 +735,35 @@
 			"bar 1.0.1",
 		),
 	},
+	"lock to branch on old rev keeps old rev": {
+		ds: []depspec{
+			mkDepspec("root 0.0.0", "foo bmaster"),
+			mkDepspec("foo bmaster newrev"),
+		},
+		l: mklock(
+			"foo bmaster oldrev",
+		),
+		r: mksolution(
+			"foo bmaster oldrev",
+		),
+	},
+	// Whereas this is a normal situation for a branch, when it occurs for a
+	// tag, it means someone's been naughty upstream. Still, though, the outcome
+	// is the same.
+	//
+	// TODO(sdboyer) this needs to generate a warning, once we start doing that
+	"lock to now-moved tag on old rev keeps old rev": {
+		ds: []depspec{
+			mkDepspec("root 0.0.0", "foo ptaggerino"),
+			mkDepspec("foo ptaggerino newrev"),
+		},
+		l: mklock(
+			"foo ptaggerino oldrev",
+		),
+		r: mksolution(
+			"foo ptaggerino oldrev",
+		),
+	},
 	"includes root package's dev dependencies": {
 		ds: []depspec{
 			mkDepspec("root 1.0.0", "(dev) foo 1.0.0", "(dev) bar 1.0.0"),
@@ -1175,6 +1236,16 @@
 }
 
 func (sm *depspecSourceManager) GetManifestAndLock(id ProjectIdentifier, v Version) (Manifest, Lock, error) {
+	// If the input version is a PairedVersion, look only at its top version,
+	// not the underlying. This is generally consistent with the idea that, for
+	// this class of lookup, the rev probably DOES exist, but upstream changed
+	// it (typically a branch). For the purposes of tests, then, that's an OK
+	// scenario, because otherwise we'd have to enumerate all the revs in the
+	// fixture declarations, which would screw up other things.
+	if pv, ok := v.(PairedVersion); ok {
+		v = pv.Unpair()
+	}
+
 	for _, ds := range sm.specs {
 		if id.netName() == string(ds.n) && v.Matches(ds.v) {
 			return ds, dummyLock{}, nil
@@ -1210,7 +1281,7 @@
 	pid := pident{n: ProjectRoot(id.netName()), v: v}
 
 	if r, exists := sm.rm[pid]; exists {
-		ptree := PackageTree{
+		return PackageTree{
 			ImportRoot: string(pid.n),
 			Packages: map[string]PackageOrErr{
 				string(pid.n): {
@@ -1221,8 +1292,29 @@
 					},
 				},
 			},
+		}, nil
+	}
+
+	// if incoming version was paired, walk the map and search for a match on
+	// top-only version
+	if pv, ok := v.(PairedVersion); ok {
+		uv := pv.Unpair()
+		for pid, r := range sm.rm {
+			if uv.Matches(pid.v) {
+				return PackageTree{
+					ImportRoot: string(pid.n),
+					Packages: map[string]PackageOrErr{
+						string(pid.n): {
+							P: Package{
+								ImportPath: string(pid.n),
+								Name:       string(pid.n),
+								Imports:    r[string(pid.n)],
+							},
+						},
+					},
+				}, nil
+			}
 		}
-		return ptree, nil
 	}
 
 	return PackageTree{}, fmt.Errorf("Project %s at version %s could not be found", pid.n, v)
@@ -1272,10 +1364,6 @@
 	return nil
 }
 
-func (sm *depspecSourceManager) VendorCodeExists(id ProjectIdentifier) (bool, error) {
-	return false, nil
-}
-
 func (sm *depspecSourceManager) Release() {}
 
 func (sm *depspecSourceManager) ExportProject(id ProjectIdentifier, v Version, to string) error {
@@ -1308,26 +1396,11 @@
 	*bridge
 }
 
-// override computeRootReach() on bridge to read directly out of the depspecs
-func (b *depspecBridge) computeRootReach() ([]string, error) {
-	// This only gets called for the root project, so grab that one off the test
-	// source manager
-	dsm := b.sm.(fixSM)
-	root := dsm.rootSpec()
-
-	ptree, err := dsm.ListPackages(mkPI(string(root.n)), nil)
-	if err != nil {
-		return nil, err
-	}
-
-	return ptree.ListExternalImports(true, true, dsm.ignore()), nil
-}
-
 // override verifyRoot() on bridge to prevent any filesystem interaction
 func (b *depspecBridge) verifyRootDir(path string) error {
 	root := b.sm.(fixSM).rootSpec()
 	if string(root.n) != path {
-		return fmt.Errorf("Expected only root project %q to computeRootReach(), got %q", root.n, path)
+		return fmt.Errorf("Expected only root project %q to verifyRootDir(), got %q", root.n, path)
 	}
 
 	return nil
@@ -1337,6 +1410,10 @@
 	return b.sm.(fixSM).ListPackages(id, v)
 }
 
+func (sm *depspecBridge) vendorCodeExists(id ProjectIdentifier) (bool, error) {
+	return false, nil
+}
+
 // enforce interfaces
 var _ Manifest = depspec{}
 var _ Lock = dummyLock{}
diff --git a/vendor/github.com/sdboyer/gps/solve_bimodal_test.go b/vendor/github.com/sdboyer/gps/solve_bimodal_test.go
index 9ebe483..f430ad9 100644
--- a/vendor/github.com/sdboyer/gps/solve_bimodal_test.go
+++ b/vendor/github.com/sdboyer/gps/solve_bimodal_test.go
@@ -3,6 +3,7 @@
 import (
 	"fmt"
 	"path/filepath"
+	"strings"
 )
 
 // dsp - "depspec with packages"
@@ -791,6 +792,28 @@
 	return m
 }
 
+func (f bimodalFixture) rootTree() PackageTree {
+	pt := PackageTree{
+		ImportRoot: string(f.ds[0].n),
+		Packages:   map[string]PackageOrErr{},
+	}
+
+	for _, pkg := range f.ds[0].pkgs {
+		elems := strings.Split(pkg.path, "/")
+		pt.Packages[pkg.path] = PackageOrErr{
+			P: Package{
+				ImportPath: pkg.path,
+				Name:       elems[len(elems)-1],
+				// TODO(sdboyer) ugh, tpkg type has no space for supporting test
+				// imports...
+				Imports: pkg.imports,
+			},
+		}
+	}
+
+	return pt
+}
+
 func (f bimodalFixture) failure() error {
 	return f.fail
 }
diff --git a/vendor/github.com/sdboyer/gps/solve_test.go b/vendor/github.com/sdboyer/gps/solve_test.go
index 53bcdcd..425dd50 100644
--- a/vendor/github.com/sdboyer/gps/solve_test.go
+++ b/vendor/github.com/sdboyer/gps/solve_test.go
@@ -19,7 +19,7 @@
 
 // TODO(sdboyer) regression test ensuring that locks with only revs for projects don't cause errors
 func init() {
-	flag.StringVar(&fixtorun, "gps.fix", "", "A single fixture to run in TestBasicSolves")
+	flag.StringVar(&fixtorun, "gps.fix", "", "A single fixture to run in TestBasicSolves or TestBimodalSolves")
 	overrideMkBridge()
 }
 
@@ -87,12 +87,12 @@
 	sm := newdepspecSM(fix.ds, nil)
 
 	params := SolveParameters{
-		RootDir:    string(fix.ds[0].n),
-		ImportRoot: ProjectRoot(fix.ds[0].n),
-		Manifest:   fix.rootmanifest(),
-		Lock:       dummyLock{},
-		Downgrade:  fix.downgrade,
-		ChangeAll:  fix.changeall,
+		RootDir:         string(fix.ds[0].n),
+		RootPackageTree: fix.rootTree(),
+		Manifest:        fix.rootmanifest(),
+		Lock:            dummyLock{},
+		Downgrade:       fix.downgrade,
+		ChangeAll:       fix.changeall,
 	}
 
 	if fix.l != nil {
@@ -137,12 +137,12 @@
 	sm := newbmSM(fix)
 
 	params := SolveParameters{
-		RootDir:    string(fix.ds[0].n),
-		ImportRoot: ProjectRoot(fix.ds[0].n),
-		Manifest:   fix.rootmanifest(),
-		Lock:       dummyLock{},
-		Downgrade:  fix.downgrade,
-		ChangeAll:  fix.changeall,
+		RootDir:         string(fix.ds[0].n),
+		RootPackageTree: fix.rootTree(),
+		Manifest:        fix.rootmanifest(),
+		Lock:            dummyLock{},
+		Downgrade:       fix.downgrade,
+		ChangeAll:       fix.changeall,
 	}
 
 	if fix.l != nil {
@@ -163,6 +163,13 @@
 		return fmt.Sprintf("%s (from %s)", id.ProjectRoot, id.NetworkName)
 	}
 
+	pv := func(v Version) string {
+		if pv, ok := v.(PairedVersion); ok {
+			return fmt.Sprintf("%s (%s)", pv.Unpair(), pv.Underlying())
+		}
+		return v.String()
+	}
+
 	fixfail := fix.failure()
 	if err != nil {
 		if fixfail == nil {
@@ -207,7 +214,7 @@
 				// delete result from map so we skip it on the reverse pass
 				delete(rp, p)
 				if v != av {
-					t.Errorf("(fixture: %q) Expected version %q of project %q, but actual version was %q", fix.name(), v, ppi(p), av)
+					t.Errorf("(fixture: %q) Expected version %q of project %q, but actual version was %q", fix.name(), pv(v), ppi(p), pv(av))
 				}
 			}
 		}
@@ -217,7 +224,7 @@
 			if fv, exists := fix.solution()[p]; !exists {
 				t.Errorf("(fixture: %q) Unexpected project %q present in results", fix.name(), ppi(p))
 			} else if v != fv {
-				t.Errorf("(fixture: %q) Got version %q of project %q, but expected version was %q", fix.name(), v, ppi(p), fv)
+				t.Errorf("(fixture: %q) Got version %q of project %q, but expected version was %q", fix.name(), pv(v), ppi(p), pv(fv))
 			}
 		}
 	}
@@ -232,7 +239,7 @@
 // produce weird side effects.
 func TestRootLockNoVersionPairMatching(t *testing.T) {
 	fix := basicFixture{
-		n: "does not pair bare revs in manifest with unpaired lock version",
+		n: "does not match unpaired lock versions with paired real versions",
 		ds: []depspec{
 			mkDepspec("root 0.0.0", "foo *"), // foo's constraint rewritten below to foorev
 			mkDepspec("foo 1.0.0", "bar 1.0.0"),
@@ -247,7 +254,7 @@
 		),
 		r: mksolution(
 			"foo 1.0.2 foorev",
-			"bar 1.0.1",
+			"bar 1.0.2",
 		),
 	}
 
@@ -262,10 +269,10 @@
 	l2[0].v = nil
 
 	params := SolveParameters{
-		RootDir:    string(fix.ds[0].n),
-		ImportRoot: ProjectRoot(fix.ds[0].n),
-		Manifest:   fix.rootmanifest(),
-		Lock:       l2,
+		RootDir:         string(fix.ds[0].n),
+		RootPackageTree: fix.rootTree(),
+		Manifest:        fix.rootmanifest(),
+		Lock:            l2,
 	}
 
 	res, err := fixSolve(params, sm)
@@ -303,7 +310,27 @@
 		t.Error("Prepare should have given error on empty import root, but gave:", err)
 	}
 
-	params.ImportRoot = ProjectRoot(pn)
+	params.RootPackageTree = PackageTree{
+		ImportRoot: pn,
+	}
+	_, err = Prepare(params, sm)
+	if err == nil {
+		t.Errorf("Prepare should have errored on empty name")
+	} else if !strings.Contains(err.Error(), "at least one package") {
+		t.Error("Prepare should have given error on empty import root, but gave:", err)
+	}
+
+	params.RootPackageTree = PackageTree{
+		ImportRoot: pn,
+		Packages: map[string]PackageOrErr{
+			pn: {
+				P: Package{
+					ImportPath: pn,
+					Name:       pn,
+				},
+			},
+		},
+	}
 	params.Trace = true
 	_, err = Prepare(params, sm)
 	if err == nil {
diff --git a/vendor/github.com/sdboyer/gps/solver.go b/vendor/github.com/sdboyer/gps/solver.go
index f7d9a24..8993b78 100644
--- a/vendor/github.com/sdboyer/gps/solver.go
+++ b/vendor/github.com/sdboyer/gps/solver.go
@@ -31,16 +31,15 @@
 	// A real path to a readable directory is required.
 	RootDir string
 
-	// The import path at the base of all import paths covered by the project.
-	// For example, the appropriate value for gps itself here is:
+	// The tree of packages that comprise the root project, as well as the
+	// import path that should identify the root of that tree.
 	//
-	//  github.com/sdboyer/gps
+	// In most situations, tools should simply pass the result of ListPackages()
+	// directly through here.
 	//
-	// In most cases, this should match the latter portion of RootDir. However,
-	// that is not (currently) required.
-	//
-	// A non-empty string is required.
-	ImportRoot ProjectRoot
+	// The ImportRoot property must be a non-empty string, and at least one
+	// element must be present in the Packages map.
+	RootPackageTree PackageTree
 
 	// The root manifest. This contains all the dependency constraints
 	// associated with normal Manifests, as well as the particular controls
@@ -157,6 +156,9 @@
 
 	// A defensively-copied instance of the root lock.
 	rl Lock
+
+	// A defensively-copied instance of params.RootPackageTree
+	rpt PackageTree
 }
 
 // A Solver is the main workhorse of gps: given a set of project inputs, it
@@ -192,9 +194,12 @@
 	if params.RootDir == "" {
 		return nil, badOptsFailure("params must specify a non-empty root directory")
 	}
-	if params.ImportRoot == "" {
+	if params.RootPackageTree.ImportRoot == "" {
 		return nil, badOptsFailure("params must include a non-empty import root")
 	}
+	if len(params.RootPackageTree.Packages) == 0 {
+		return nil, badOptsFailure("at least one package must be present in the PackageTree")
+	}
 	if params.Trace && params.TraceLogger == nil {
 		return nil, badOptsFailure("trace requested, but no logger provided")
 	}
@@ -208,6 +213,7 @@
 		ig:     params.Manifest.IgnorePackages(),
 		ovr:    params.Manifest.Overrides(),
 		tl:     params.TraceLogger,
+		rpt:    params.RootPackageTree.dup(),
 	}
 
 	// Ensure the ignore and overrides maps are at least initialized
@@ -316,7 +322,7 @@
 	return soln, err
 }
 
-// solve is the top-level loop for the SAT solving process.
+// solve is the top-level loop for the solving process.
 func (s *solver) solve() (map[atom]map[string]struct{}, error) {
 	// Main solving loop
 	for {
@@ -331,9 +337,9 @@
 		// satisfiability and selection paths depending on whether we've already
 		// selected the base project/repo that came off the unselected queue.
 		//
-		// (If we already have selected the project, other parts of the
-		// algorithm guarantee the bmi will contain at least one package from
-		// this project that has yet to be selected.)
+		// (If we've already selected the project, other parts of the algorithm
+		// guarantee the bmi will contain at least one package from this project
+		// that has yet to be selected.)
 		if awp, is := s.sel.selected(bmi.id); !is {
 			// Analysis path for when we haven't selected the project yet - need
 			// to create a version queue.
@@ -425,7 +431,7 @@
 func (s *solver) selectRoot() error {
 	pa := atom{
 		id: ProjectIdentifier{
-			ProjectRoot: s.params.ImportRoot,
+			ProjectRoot: ProjectRoot(s.rpt.ImportRoot),
 		},
 		// This is a hack so that the root project doesn't have a nil version.
 		// It's sort of OK because the root never makes it out into the results.
@@ -462,7 +468,7 @@
 
 	// Err is not possible at this point, as it could only come from
 	// listPackages(), which if we're here already succeeded for root
-	reach, _ := s.b.computeRootReach()
+	reach := s.rpt.ExternalReach(true, true, s.ig).ListExternalImports()
 
 	deps, err := s.intersectConstraintsWithImports(mdeps, reach)
 	if err != nil {
@@ -472,8 +478,8 @@
 
 	for _, dep := range deps {
 		// If we have no lock, or if this dep isn't in the lock, then prefetch
-		// it. See explanation longer comment in selectRoot() for how we benefit
-		// from parallelism here.
+		// it. See longer explanation in selectRoot() for how we benefit from
+		// parallelism here.
 		if _, has := s.rlm[dep.Ident.ProjectRoot]; !has {
 			go s.b.SyncSourceFor(dep.Ident)
 		}
@@ -490,7 +496,7 @@
 func (s *solver) getImportsAndConstraintsOf(a atomWithPackages) ([]completeDep, error) {
 	var err error
 
-	if s.params.ImportRoot == a.a.id.ProjectRoot {
+	if ProjectRoot(s.rpt.ImportRoot) == a.a.id.ProjectRoot {
 		panic("Should never need to recheck imports/constraints from root during solve")
 	}
 
@@ -625,7 +631,7 @@
 func (s *solver) createVersionQueue(bmi bimodalIdentifier) (*versionQueue, error) {
 	id := bmi.id
 	// If on the root package, there's no queue to make
-	if s.params.ImportRoot == id.ProjectRoot {
+	if ProjectRoot(s.rpt.ImportRoot) == id.ProjectRoot {
 		return newVersionQueue(id, nil, nil, s.b)
 	}
 
@@ -665,7 +671,7 @@
 		// TODO(sdboyer) nested loop; prime candidate for a cache somewhere
 		for _, dep := range s.sel.getDependenciesOn(bmi.id) {
 			// Skip the root, of course
-			if s.params.ImportRoot == dep.depender.id.ProjectRoot {
+			if ProjectRoot(s.rpt.ImportRoot) == dep.depender.id.ProjectRoot {
 				continue
 			}
 
@@ -1023,7 +1029,7 @@
 	// selection?
 
 	// skip if the root project
-	if s.params.ImportRoot != id.ProjectRoot {
+	if ProjectRoot(s.rpt.ImportRoot) != id.ProjectRoot {
 		// just look for the first (oldest) one; the backtracker will necessarily
 		// traverse through and pop off any earlier ones
 		for _, vq := range s.vqs {
diff --git a/vendor/github.com/sdboyer/gps/source.go b/vendor/github.com/sdboyer/gps/source.go
index 6256c51..75265d9 100644
--- a/vendor/github.com/sdboyer/gps/source.go
+++ b/vendor/github.com/sdboyer/gps/source.go
@@ -335,7 +335,7 @@
 		err = bs.crepo.r.UpdateVersion(v.String())
 	}
 
-	ptree, err = listPackages(bs.crepo.r.LocalPath(), string(pr))
+	ptree, err = ListPackages(bs.crepo.r.LocalPath(), string(pr))
 	bs.crepo.mut.Unlock()
 
 	// TODO(sdboyer) cache errs?
diff --git a/vendor/github.com/sdboyer/gps/trace.go b/vendor/github.com/sdboyer/gps/trace.go
index 4c20279..e08dcf7 100644
--- a/vendor/github.com/sdboyer/gps/trace.go
+++ b/vendor/github.com/sdboyer/gps/trace.go
@@ -109,7 +109,7 @@
 	// so who cares
 	rm := ptree.ExternalReach(true, true, s.ig)
 
-	s.tl.Printf("Root project is %q", s.params.ImportRoot)
+	s.tl.Printf("Root project is %q", s.rpt.ImportRoot)
 
 	var expkgs int
 	for _, cdep := range cdeps {
diff --git a/vendor/github.com/sdboyer/gps/vcs_source.go b/vendor/github.com/sdboyer/gps/vcs_source.go
index 277b1db..ecded0c 100644
--- a/vendor/github.com/sdboyer/gps/vcs_source.go
+++ b/vendor/github.com/sdboyer/gps/vcs_source.go
@@ -54,9 +54,10 @@
 	if rv, ok := v.(PairedVersion); ok {
 		vstr = rv.Underlying().String()
 	}
-	_, err = r.RunFromDir("git", "read-tree", vstr)
+
+	out, err := r.RunFromDir("git", "read-tree", vstr)
 	if err != nil {
-		return err
+		return fmt.Errorf("%s: %s", out, err)
 	}
 
 	// Ensure we have exactly one trailing slash
@@ -68,8 +69,11 @@
 	// the alternative is using plain checkout, though we have a bunch of
 	// housekeeping to do to set up, then tear down, the sparse checkout
 	// controls, as well as restore the original index and HEAD.
-	_, err = r.RunFromDir("git", "checkout-index", "-a", "--prefix="+to)
-	return err
+	out, err = r.RunFromDir("git", "checkout-index", "-a", "--prefix="+to)
+	if err != nil {
+		return fmt.Errorf("%s: %s", out, err)
+	}
+	return nil
 }
 
 func (s *gitSource) listVersions() (vlist []Version, err error) {
diff --git a/vendor/github.com/sdboyer/gps/version.go b/vendor/github.com/sdboyer/gps/version.go
index 1e15029..f288b2a 100644
--- a/vendor/github.com/sdboyer/gps/version.go
+++ b/vendor/github.com/sdboyer/gps/version.go
@@ -411,11 +411,7 @@
 	}
 
 	switch tv := v.v.(type) {
-	case plainVersion:
-		if tv.Matches(v2) {
-			return true
-		}
-	case branchVersion:
+	case plainVersion, branchVersion:
 		if tv.Matches(v2) {
 			return true
 		}
@@ -491,22 +487,23 @@
 		case branchVersion, plainVersion, semVersion:
 			return 1
 		}
-	case branchVersion:
-		switch r.(type) {
-		case Revision:
-			return -1
-		case branchVersion:
-			return 0
-		case plainVersion, semVersion:
-			return 1
-		}
 
 	case plainVersion:
 		switch r.(type) {
-		case Revision, branchVersion:
+		case Revision:
 			return -1
 		case plainVersion:
 			return 0
+		case branchVersion, semVersion:
+			return 1
+		}
+
+	case branchVersion:
+		switch r.(type) {
+		case Revision, plainVersion:
+			return -1
+		case branchVersion:
+			return 0
 		case semVersion:
 			return 1
 		}
@@ -531,9 +528,9 @@
 //  - Semver versions with a prerelease are after *all* non-prerelease semver.
 //  Against each other, they are sorted first by their numerical component, then
 //  lexicographically by their prerelease version.
+//  - All branches are next, and sort lexicographically against each other.
 //  - All non-semver versions (tags) are next, and sort lexicographically
 //  against each other.
-//  - All branches are next, and sort lexicographically against each other.
 //  - Revisions are last, and sort lexicographically against each other.
 //
 // So, given a slice of the following versions:
@@ -553,14 +550,15 @@
 // SortForDowngrade sorts a slice of []Version in roughly ascending order, so
 // that presumably older versions are visited first.
 //
-// This is *not* the reverse of the same as SortForUpgrade (or you could simply
-// sort.Reverse(). The type precedence is the same, including the
-// semver vs. semver-with-prerelease relation. Lexicographic comparisons within
-// non-semver tags, branches, and revisions remains the same as well; because
-// these domains have no implicit chronology, there is no reason to reverse
+// This is *not* the same as reversing SortForUpgrade (or you could simply
+// sort.Reverse()). The type precedence is the same, including the semver vs.
+// semver-with-prerelease relation. Lexicographic comparisons within non-semver
+// tags, branches, and revisions remains the same as well; because we treat
+// these domains as having no ordering relations (chronology), there can be no
+// real concept of "upgrade" vs "downgrade", so there is no reason to reverse
 // them.
 //
-// The only binary relation that is reversed for downgrade is within-type
+// Thus, the only binary relation that is reversed for downgrade is within-type
 // comparisons for semver (with and without prerelease).
 //
 // So, given a slice of the following versions:
diff --git a/vendor/github.com/sdboyer/gps/version_test.go b/vendor/github.com/sdboyer/gps/version_test.go
index 436dbe4..394bb27 100644
--- a/vendor/github.com/sdboyer/gps/version_test.go
+++ b/vendor/github.com/sdboyer/gps/version_test.go
@@ -32,15 +32,15 @@
 
 	edown := []Version{
 		v3, v4, v5, // semvers
-		v6, v8, // plain versions
 		v1, v2, v7, // floating/branches
+		v6, v8, // plain versions
 		rev, // revs
 	}
 
 	eup := []Version{
 		v5, v4, v3, // semvers
-		v6, v8, // plain versions
 		v1, v2, v7, // floating/branches
+		v6, v8, // plain versions
 		rev, // revs
 	}
 
diff --git a/vendor/gopkg.in/yaml.v2/LICENSE b/vendor/gopkg.in/yaml.v2/LICENSE
index a68e67f..866d74a 100644
--- a/vendor/gopkg.in/yaml.v2/LICENSE
+++ b/vendor/gopkg.in/yaml.v2/LICENSE
@@ -1,188 +1,13 @@
+Copyright 2011-2016 Canonical Ltd.
 
-Copyright (c) 2011-2014 - Canonical Inc.
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
 
-This software is licensed under the LGPLv3, included below.
+    http://www.apache.org/licenses/LICENSE-2.0
 
-As a special exception to the GNU Lesser General Public License version 3
-("LGPL3"), the copyright holders of this Library give you permission to
-convey to a third party a Combined Work that links statically or dynamically
-to this Library without providing any Minimal Corresponding Source or
-Minimal Application Code as set out in 4d or providing the installation
-information set out in section 4e, provided that you comply with the other
-provisions of LGPL3 and provided that you meet, for the Application the
-terms and conditions of the license(s) which apply to the Application.
-
-Except as stated in this special exception, the provisions of LGPL3 will
-continue to comply in full to this Library. If you modify this Library, you
-may apply this exception to your version of this Library, but you are not
-obliged to do so. If you do not wish to do so, delete this exception
-statement from your version. This exception does not (and cannot) modify any
-license terms which apply to the Application, with which you must still
-comply.
-
-
-                   GNU LESSER GENERAL PUBLIC LICENSE
-                       Version 3, 29 June 2007
-
- Copyright (C) 2007 Free Software Foundation, Inc. <http://fsf.org/>
- Everyone is permitted to copy and distribute verbatim copies
- of this license document, but changing it is not allowed.
-
-
-  This version of the GNU Lesser General Public License incorporates
-the terms and conditions of version 3 of the GNU General Public
-License, supplemented by the additional permissions listed below.
-
-  0. Additional Definitions.
-
-  As used herein, "this License" refers to version 3 of the GNU Lesser
-General Public License, and the "GNU GPL" refers to version 3 of the GNU
-General Public License.
-
-  "The Library" refers to a covered work governed by this License,
-other than an Application or a Combined Work as defined below.
-
-  An "Application" is any work that makes use of an interface provided
-by the Library, but which is not otherwise based on the Library.
-Defining a subclass of a class defined by the Library is deemed a mode
-of using an interface provided by the Library.
-
-  A "Combined Work" is a work produced by combining or linking an
-Application with the Library.  The particular version of the Library
-with which the Combined Work was made is also called the "Linked
-Version".
-
-  The "Minimal Corresponding Source" for a Combined Work means the
-Corresponding Source for the Combined Work, excluding any source code
-for portions of the Combined Work that, considered in isolation, are
-based on the Application, and not on the Linked Version.
-
-  The "Corresponding Application Code" for a Combined Work means the
-object code and/or source code for the Application, including any data
-and utility programs needed for reproducing the Combined Work from the
-Application, but excluding the System Libraries of the Combined Work.
-
-  1. Exception to Section 3 of the GNU GPL.
-
-  You may convey a covered work under sections 3 and 4 of this License
-without being bound by section 3 of the GNU GPL.
-
-  2. Conveying Modified Versions.
-
-  If you modify a copy of the Library, and, in your modifications, a
-facility refers to a function or data to be supplied by an Application
-that uses the facility (other than as an argument passed when the
-facility is invoked), then you may convey a copy of the modified
-version:
-
-   a) under this License, provided that you make a good faith effort to
-   ensure that, in the event an Application does not supply the
-   function or data, the facility still operates, and performs
-   whatever part of its purpose remains meaningful, or
-
-   b) under the GNU GPL, with none of the additional permissions of
-   this License applicable to that copy.
-
-  3. Object Code Incorporating Material from Library Header Files.
-
-  The object code form of an Application may incorporate material from
-a header file that is part of the Library.  You may convey such object
-code under terms of your choice, provided that, if the incorporated
-material is not limited to numerical parameters, data structure
-layouts and accessors, or small macros, inline functions and templates
-(ten or fewer lines in length), you do both of the following:
-
-   a) Give prominent notice with each copy of the object code that the
-   Library is used in it and that the Library and its use are
-   covered by this License.
-
-   b) Accompany the object code with a copy of the GNU GPL and this license
-   document.
-
-  4. Combined Works.
-
-  You may convey a Combined Work under terms of your choice that,
-taken together, effectively do not restrict modification of the
-portions of the Library contained in the Combined Work and reverse
-engineering for debugging such modifications, if you also do each of
-the following:
-
-   a) Give prominent notice with each copy of the Combined Work that
-   the Library is used in it and that the Library and its use are
-   covered by this License.
-
-   b) Accompany the Combined Work with a copy of the GNU GPL and this license
-   document.
-
-   c) For a Combined Work that displays copyright notices during
-   execution, include the copyright notice for the Library among
-   these notices, as well as a reference directing the user to the
-   copies of the GNU GPL and this license document.
-
-   d) Do one of the following:
-
-       0) Convey the Minimal Corresponding Source under the terms of this
-       License, and the Corresponding Application Code in a form
-       suitable for, and under terms that permit, the user to
-       recombine or relink the Application with a modified version of
-       the Linked Version to produce a modified Combined Work, in the
-       manner specified by section 6 of the GNU GPL for conveying
-       Corresponding Source.
-
-       1) Use a suitable shared library mechanism for linking with the
-       Library.  A suitable mechanism is one that (a) uses at run time
-       a copy of the Library already present on the user's computer
-       system, and (b) will operate properly with a modified version
-       of the Library that is interface-compatible with the Linked
-       Version.
-
-   e) Provide Installation Information, but only if you would otherwise
-   be required to provide such information under section 6 of the
-   GNU GPL, and only to the extent that such information is
-   necessary to install and execute a modified version of the
-   Combined Work produced by recombining or relinking the
-   Application with a modified version of the Linked Version. (If
-   you use option 4d0, the Installation Information must accompany
-   the Minimal Corresponding Source and Corresponding Application
-   Code. If you use option 4d1, you must provide the Installation
-   Information in the manner specified by section 6 of the GNU GPL
-   for conveying Corresponding Source.)
-
-  5. Combined Libraries.
-
-  You may place library facilities that are a work based on the
-Library side by side in a single library together with other library
-facilities that are not Applications and are not covered by this
-License, and convey such a combined library under terms of your
-choice, if you do both of the following:
-
-   a) Accompany the combined library with a copy of the same work based
-   on the Library, uncombined with any other library facilities,
-   conveyed under the terms of this License.
-
-   b) Give prominent notice with the combined library that part of it
-   is a work based on the Library, and explaining where to find the
-   accompanying uncombined form of the same work.
-
-  6. Revised Versions of the GNU Lesser General Public License.
-
-  The Free Software Foundation may publish revised and/or new versions
-of the GNU Lesser General Public License from time to time. Such new
-versions will be similar in spirit to the present version, but may
-differ in detail to address new problems or concerns.
-
-  Each version is given a distinguishing version number. If the
-Library as you received it specifies that a certain numbered version
-of the GNU Lesser General Public License "or any later version"
-applies to it, you have the option of following the terms and
-conditions either of that published version or of any later version
-published by the Free Software Foundation. If the Library as you
-received it does not specify a version number of the GNU Lesser
-General Public License, you may choose any version of the GNU Lesser
-General Public License ever published by the Free Software Foundation.
-
-  If the Library as you received it specifies that a proxy can decide
-whether future versions of the GNU Lesser General Public License shall
-apply, that proxy's public statement of acceptance of any version is
-permanent authorization for you to choose that version for the
-Library.
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
diff --git a/vendor/gopkg.in/yaml.v2/README.md b/vendor/gopkg.in/yaml.v2/README.md
index 7b8bd86..1884de6 100644
--- a/vendor/gopkg.in/yaml.v2/README.md
+++ b/vendor/gopkg.in/yaml.v2/README.md
@@ -42,7 +42,7 @@
 License
 -------
 
-The yaml package is licensed under the LGPL with an exception that allows it to be linked statically. Please see the LICENSE file for details.
+The yaml package is licensed under the Apache License 2.0. Please see the LICENSE file for details.
 
 
 Example