diff --git a/action/get.go b/action/get.go
index 8a3a979..785dc28 100644
--- a/action/get.go
+++ b/action/get.go
@@ -37,12 +37,18 @@
 		msg.Die("Could not find the vendor dir: %s", err)
 	}
 
+	rd := filepath.Dir(glidefile)
+	rt, err := gps.ListPackages(rd, conf.Name)
+	if err != nil {
+		msg.Die("Error while scanning project: %s", err)
+	}
+
 	params := gps.SolveParameters{
-		RootDir:     filepath.Dir(glidefile),
-		ImportRoot:  gps.ProjectRoot(conf.Name),
-		Manifest:    conf,
-		Trace:       true,
-		TraceLogger: log.New(os.Stdout, "", 0),
+		RootDir:         rd,
+		RootPackageTree: rt,
+		Manifest:        conf,
+		Trace:           true,
+		TraceLogger:     log.New(os.Stdout, "", 0),
 	}
 
 	// We load the lock file early and bail out if there's a problem, because we
@@ -57,7 +63,7 @@
 	}
 
 	// Create the SourceManager for this run
-	sm, err := gps.NewSourceManager(dependency.Analyzer{}, filepath.Join(installer.Home, "cache"), false)
+	sm, err := gps.NewSourceManager(dependency.Analyzer{}, filepath.Join(installer.Home, "cache"))
 	defer sm.Release()
 	if err != nil {
 		msg.Err(err.Error())
diff --git a/action/install.go b/action/install.go
index a719cc0..0ce5797 100644
--- a/action/install.go
+++ b/action/install.go
@@ -31,19 +31,25 @@
 	}
 
 	// Create the SourceManager for this run
-	sm, err := gps.NewSourceManager(dependency.Analyzer{}, filepath.Join(installer.Home, "cache"), false)
+	sm, err := gps.NewSourceManager(dependency.Analyzer{}, filepath.Join(installer.Home, "cache"))
 	defer sm.Release()
 	if err != nil {
 		msg.Err(err.Error())
 		return
 	}
 
+	rd := filepath.Dir(vend)
+	rt, err := gps.ListPackages(rd, conf.Name)
+	if err != nil {
+		msg.Die("Error while scanning project: %s", err)
+	}
+
 	params := gps.SolveParameters{
-		RootDir:     filepath.Dir(vend),
-		ImportRoot:  gps.ProjectRoot(conf.Name),
-		Manifest:    conf,
-		Trace:       true,
-		TraceLogger: log.New(os.Stdout, "", 0),
+		RootDir:         rd,
+		RootPackageTree: rt,
+		Manifest:        conf,
+		Trace:           true,
+		TraceLogger:     log.New(os.Stdout, "", 0),
 	}
 
 	var s gps.Solver
@@ -63,7 +69,7 @@
 			msg.Err("Could not set up solver: %s", err)
 			return
 		}
-		digest, err := s.HashInputs()
+		digest := s.HashInputs()
 
 		// Check if digests match, and warn if they don't
 		if bytes.Equal(digest, params.Lock.InputHash()) {
diff --git a/action/update.go b/action/update.go
index 3221258..324b5a3 100644
--- a/action/update.go
+++ b/action/update.go
@@ -30,12 +30,18 @@
 		msg.Die("Could not find the vendor dir: %s", err)
 	}
 
+	rd := filepath.Dir(vend)
+	rt, err := gps.ListPackages(rd, conf.Name)
+	if err != nil {
+		msg.Die("Error while scanning project: %s", err)
+	}
+
 	params := gps.SolveParameters{
-		RootDir:     filepath.Dir(vend),
-		ImportRoot:  gps.ProjectRoot(conf.Name),
-		Manifest:    conf,
-		Trace:       true,
-		TraceLogger: log.New(os.Stdout, "", 0),
+		RootDir:         rd,
+		RootPackageTree: rt,
+		Manifest:        conf,
+		Trace:           true,
+		TraceLogger:     log.New(os.Stdout, "", 0),
 	}
 
 	if len(projs) == 0 {
@@ -59,7 +65,7 @@
 	}
 
 	// Create the SourceManager for this run
-	sm, err := gps.NewSourceManager(dependency.Analyzer{}, filepath.Join(installer.Home, "cache"), false)
+	sm, err := gps.NewSourceManager(dependency.Analyzer{}, filepath.Join(installer.Home, "cache"))
 	if err != nil {
 		msg.Err(err.Error())
 		return
diff --git a/glide.lock b/glide.lock
index 04611c5..bd87515 100644
--- a/glide.lock
+++ b/glide.lock
@@ -14,8 +14,8 @@
   version: v1.8.0
   revision: fbe9fb6ad5b5f35b3e82a7c21123cfc526cbf895
 - name: github.com/sdboyer/gps
-  branch: master
-  revision: 166f36103aedbb9d835b9b6dcc7762a6bd900a98
+  version: v0.11.1
+  revision: 507f709c7eb2429371a22cff9f6077630827e450
 - name: github.com/termie/go-shutil
   revision: bcacb06fecaeec8dc42af03c87c6949f4a05c74c
 - name: gopkg.in/yaml.v2
diff --git a/glide.yaml b/glide.yaml
index 2bd32d8..dcc78aa 100644
--- a/glide.yaml
+++ b/glide.yaml
@@ -18,4 +18,4 @@
 - package: github.com/Masterminds/semver
   branch: 2.x
 - package: github.com/sdboyer/gps
-  branch: master
+  version: ^0.11.0
diff --git a/vendor/github.com/sdboyer/gps/README.md b/vendor/github.com/sdboyer/gps/README.md
index 381c2a8..0cb902b 100644
--- a/vendor/github.com/sdboyer/gps/README.md
+++ b/vendor/github.com/sdboyer/gps/README.md
@@ -66,16 +66,16 @@
 * A [**manifest** and
   **lock**](https://github.com/sdboyer/gps/wiki/gps-for-Implementors#manifests-and-locks)
   approach to tracking version and constraint information
-* Source repositories can be `git`, `bzr`, `hg` or `svn` (Most of the work here is through a [separate lib](https://github.com/Masterminds/vcs))
+* Upstream sources are one of `git`, `bzr`, `hg` or `svn` repositories
 * What the available versions are for a given project/repository (all branches, tags, or revs are eligible)
-  * In general, semver tags are preferred to plain tags, are preferred to branches
-* The actual packages required (determined through import graph static analysis)
+  * In general, semver tags are preferred to branches, are preferred to plain tags
+* The actual packages that must be present (determined through import graph static analysis)
   * How the import graph is statically analyzed (Similar to `go/build`, but with a combinatorial view of build tags)
+* All packages from the same source (repository) must be the same version
 * Package import cycles are not allowed ([not yet implemented](https://github.com/sdboyer/gps/issues/66))
 
 There are also some current non-choices that we would like to push into the realm of choice:
 
-* Different versions of packages from the same repository cannot be used
 * Importable projects that are not bound to the repository root
 * Source inference around different import path patterns (e.g., how `github.com/*` or `my_company/*` are handled)
 
diff --git a/vendor/github.com/sdboyer/gps/example.go b/vendor/github.com/sdboyer/gps/example.go
index c3a827a..728439f 100644
--- a/vendor/github.com/sdboyer/gps/example.go
+++ b/vendor/github.com/sdboyer/gps/example.go
@@ -38,7 +38,7 @@
 	params.RootPackageTree, _ = gps.ListPackages(root, importroot)
 
 	// Set up a SourceManager with the NaiveAnalyzer
-	sourcemgr, _ := gps.NewSourceManager(NaiveAnalyzer{}, ".repocache", false)
+	sourcemgr, _ := gps.NewSourceManager(NaiveAnalyzer{}, ".repocache")
 	defer sourcemgr.Release()
 
 	// Prep and run the solver
diff --git a/vendor/github.com/sdboyer/gps/hash.go b/vendor/github.com/sdboyer/gps/hash.go
index ca9c9a2..acede5c 100644
--- a/vendor/github.com/sdboyer/gps/hash.go
+++ b/vendor/github.com/sdboyer/gps/hash.go
@@ -2,7 +2,6 @@
 
 import (
 	"crypto/sha256"
-	"fmt"
 	"sort"
 )
 
@@ -16,15 +15,7 @@
 // unnecessary.
 //
 // (Basically, this is for memoization.)
-func (s *solver) HashInputs() ([]byte, error) {
-	// 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: 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()))
-	}
-
+func (s *solver) HashInputs() []byte {
 	c, tc := s.rm.DependencyConstraints(), s.rm.TestDependencyConstraints()
 	// Apply overrides to the constraints from the root. Otherwise, the hash
 	// would be computed on the basis of a constraint from root that doesn't
@@ -51,7 +42,7 @@
 
 	// Write each of the packages, or the errors that were found for a
 	// particular subpath, into the hash.
-	for _, perr := range ptree.Packages {
+	for _, perr := range s.rpt.Packages {
 		if perr.Err != nil {
 			h.Write([]byte(perr.Err.Error()))
 		} else {
@@ -97,5 +88,5 @@
 	h.Write([]byte(an))
 	h.Write([]byte(av.String()))
 
-	return h.Sum(nil), nil
+	return h.Sum(nil)
 }
diff --git a/vendor/github.com/sdboyer/gps/hash_test.go b/vendor/github.com/sdboyer/gps/hash_test.go
index 51732ca..a257252 100644
--- a/vendor/github.com/sdboyer/gps/hash_test.go
+++ b/vendor/github.com/sdboyer/gps/hash_test.go
@@ -16,12 +16,12 @@
 	}
 
 	s, err := Prepare(params, newdepspecSM(fix.ds, nil))
-
-	dig, err := s.HashInputs()
 	if err != nil {
-		t.Fatalf("HashInputs returned unexpected err: %s", err)
+		t.Errorf("Unexpected error while prepping solver: %s", err)
+		t.FailNow()
 	}
 
+	dig := s.HashInputs()
 	h := sha256.New()
 
 	elems := []string{
@@ -64,12 +64,12 @@
 	}
 
 	s, err := Prepare(params, newdepspecSM(fix.ds, nil))
-
-	dig, err := s.HashInputs()
 	if err != nil {
-		t.Fatalf("HashInputs returned unexpected err: %s", err)
+		t.Errorf("Unexpected error while prepping solver: %s", err)
+		t.FailNow()
 	}
 
+	dig := s.HashInputs()
 	h := sha256.New()
 
 	elems := []string{
@@ -116,12 +116,12 @@
 	}
 
 	s, err := Prepare(params, newdepspecSM(fix.ds, nil))
-
-	dig, err := s.HashInputs()
 	if err != nil {
-		t.Fatalf("HashInputs returned unexpected err: %s", err)
+		t.Errorf("Unexpected error while prepping solver: %s", err)
+		t.FailNow()
 	}
 
+	dig := s.HashInputs()
 	h := sha256.New()
 
 	elems := []string{
@@ -154,11 +154,7 @@
 	rm.ovr["d"] = ProjectProperties{
 		Constraint: NewBranch("foobranch"),
 	}
-	dig, err = s.HashInputs()
-	if err != nil {
-		t.Fatalf("HashInputs returned unexpected err: %s", err)
-	}
-
+	dig = s.HashInputs()
 	h = sha256.New()
 
 	elems = []string{
@@ -194,11 +190,7 @@
 		NetworkName: "groucho",
 		Constraint:  NewBranch("plexiglass"),
 	}
-	dig, err = s.HashInputs()
-	if err != nil {
-		t.Fatalf("HashInputs returned unexpected err: %s", err)
-	}
-
+	dig = s.HashInputs()
 	h = sha256.New()
 
 	elems = []string{
@@ -236,11 +228,7 @@
 	rm.ovr["a"] = ProjectProperties{
 		Constraint: NewVersion("fluglehorn"),
 	}
-	dig, err = s.HashInputs()
-	if err != nil {
-		t.Fatalf("HashInputs returned unexpected err: %s", err)
-	}
-
+	dig = s.HashInputs()
 	h = sha256.New()
 
 	elems = []string{
@@ -280,11 +268,7 @@
 	rm.ovr["a"] = ProjectProperties{
 		NetworkName: "nota",
 	}
-	dig, err = s.HashInputs()
-	if err != nil {
-		t.Fatalf("HashInputs returned unexpected err: %s", err)
-	}
-
+	dig = s.HashInputs()
 	h = sha256.New()
 
 	elems = []string{
@@ -326,11 +310,7 @@
 		NetworkName: "nota",
 		Constraint:  NewVersion("fluglehorn"),
 	}
-	dig, err = s.HashInputs()
-	if err != nil {
-		t.Fatalf("HashInputs returned unexpected err: %s", err)
-	}
-
+	dig = s.HashInputs()
 	h = sha256.New()
 
 	elems = []string{
diff --git a/vendor/github.com/sdboyer/gps/manager_test.go b/vendor/github.com/sdboyer/gps/manager_test.go
index f3892d6..0daaef9 100644
--- a/vendor/github.com/sdboyer/gps/manager_test.go
+++ b/vendor/github.com/sdboyer/gps/manager_test.go
@@ -44,7 +44,7 @@
 		t.FailNow()
 	}
 
-	sm, err := NewSourceManager(naiveAnalyzer{}, cpath, false)
+	sm, err := NewSourceManager(naiveAnalyzer{}, cpath)
 	if err != nil {
 		t.Errorf("Unexpected error on SourceManager creation: %s", err)
 		t.FailNow()
@@ -69,32 +69,45 @@
 	if err != nil {
 		t.Errorf("Failed to create temp dir: %s", err)
 	}
-	_, err = NewSourceManager(naiveAnalyzer{}, cpath, false)
+	sm, err := NewSourceManager(naiveAnalyzer{}, cpath)
 
 	if err != nil {
 		t.Errorf("Unexpected error on SourceManager creation: %s", err)
 	}
-	defer func() {
-		err := removeAll(cpath)
-		if err != nil {
-			t.Errorf("removeAll failed: %s", err)
-		}
-	}()
 
-	_, err = NewSourceManager(naiveAnalyzer{}, cpath, false)
+	_, err = NewSourceManager(naiveAnalyzer{}, cpath)
 	if err == nil {
 		t.Errorf("Creating second SourceManager should have failed due to file lock contention")
-	}
-
-	sm, err := NewSourceManager(naiveAnalyzer{}, cpath, true)
-	defer sm.Release()
-	if err != nil {
-		t.Errorf("Creating second SourceManager should have succeeded when force flag was passed, but failed with err %s", err)
+	} else if te, ok := err.(CouldNotCreateLockError); !ok {
+		t.Errorf("Should have gotten CouldNotCreateLockError error type, but got %T", te)
 	}
 
 	if _, err = os.Stat(path.Join(cpath, "sm.lock")); err != nil {
 		t.Errorf("Global cache lock file not created correctly")
 	}
+
+	sm.Release()
+	err = removeAll(cpath)
+	if err != nil {
+		t.Errorf("removeAll failed: %s", err)
+	}
+
+	if _, err = os.Stat(path.Join(cpath, "sm.lock")); !os.IsNotExist(err) {
+		t.Errorf("Global cache lock file not cleared correctly on Release()")
+		t.FailNow()
+	}
+
+	// Set another one up at the same spot now, just to be sure
+	sm, err = NewSourceManager(naiveAnalyzer{}, cpath)
+	if err != nil {
+		t.Errorf("Creating a second SourceManager should have succeeded when the first was released, but failed with err %s", err)
+	}
+
+	sm.Release()
+	err = removeAll(cpath)
+	if err != nil {
+		t.Errorf("removeAll failed: %s", err)
+	}
 }
 
 func TestSourceInit(t *testing.T) {
@@ -109,7 +122,7 @@
 		t.FailNow()
 	}
 
-	sm, err := NewSourceManager(naiveAnalyzer{}, cpath, false)
+	sm, err := NewSourceManager(naiveAnalyzer{}, cpath)
 	if err != nil {
 		t.Errorf("Unexpected error on SourceManager creation: %s", err)
 		t.FailNow()
@@ -144,10 +157,17 @@
 		SortForUpgrade(v)
 
 		for k, e := range expected {
-			if v[k] != e {
+			if !v[k].Matches(e) {
 				t.Errorf("Expected version %s in position %v but got %s", e, k, v[k])
 			}
 		}
+
+		if !v[1].(versionPair).v.(branchVersion).isDefault {
+			t.Error("Expected master branch version to have isDefault flag, but it did not")
+		}
+		if v[2].(versionPair).v.(branchVersion).isDefault {
+			t.Error("Expected test branch version not to have isDefault flag, but it did")
+		}
 	}
 
 	// Two birds, one stone - make sure the internal ProjectManager vlist cache
@@ -175,10 +195,17 @@
 		}
 
 		for k, e := range expected {
-			if v[k] != e {
+			if !v[k].Matches(e) {
 				t.Errorf("Expected version %s in position %v but got %s", e, k, v[k])
 			}
 		}
+
+		if !v[1].(versionPair).v.(branchVersion).isDefault {
+			t.Error("Expected master branch version to have isDefault flag, but it did not")
+		}
+		if v[2].(versionPair).v.(branchVersion).isDefault {
+			t.Error("Expected test branch version not to have isDefault flag, but it did")
+		}
 	}
 
 	present, err := smc.RevisionPresentIn(id, rev)
@@ -217,6 +244,51 @@
 	}
 }
 
+func TestDefaultBranchAssignment(t *testing.T) {
+	if testing.Short() {
+		t.Skip("Skipping default branch assignment test in short mode")
+	}
+
+	sm, clean := mkNaiveSM(t)
+	defer clean()
+
+	id := mkPI("github.com/sdboyer/test-multibranch")
+	v, err := sm.ListVersions(id)
+	if err != nil {
+		t.Errorf("Unexpected error during initial project setup/fetching %s", err)
+	}
+
+	if len(v) != 3 {
+		t.Errorf("Expected three version results from the test repo, got %v", len(v))
+	} else {
+		brev := Revision("fda020843ac81352004b9dca3fcccdd517600149")
+		mrev := Revision("9f9c3a591773d9b28128309ac7a9a72abcab267d")
+		expected := []Version{
+			NewBranch("branchone").Is(brev),
+			NewBranch("otherbranch").Is(brev),
+			NewBranch("master").Is(mrev),
+		}
+
+		SortForUpgrade(v)
+
+		for k, e := range expected {
+			if !v[k].Matches(e) {
+				t.Errorf("Expected version %s in position %v but got %s", e, k, v[k])
+			}
+		}
+
+		if !v[0].(versionPair).v.(branchVersion).isDefault {
+			t.Error("Expected branchone branch version to have isDefault flag, but it did not")
+		}
+		if !v[0].(versionPair).v.(branchVersion).isDefault {
+			t.Error("Expected otherbranch branch version to have isDefault flag, but it did not")
+		}
+		if v[2].(versionPair).v.(branchVersion).isDefault {
+			t.Error("Expected master branch version not to have isDefault flag, but it did")
+		}
+	}
+}
+
 func TestMgrMethodsFailWithBadPath(t *testing.T) {
 	// a symbol will always bork it up
 	bad := mkPI("foo/##&^").normalize()
diff --git a/vendor/github.com/sdboyer/gps/remove_go16.go b/vendor/github.com/sdboyer/gps/remove_go16.go
index 8c7844d..a25ea2f 100644
--- a/vendor/github.com/sdboyer/gps/remove_go16.go
+++ b/vendor/github.com/sdboyer/gps/remove_go16.go
@@ -24,8 +24,8 @@
 	}
 
 	// make sure all files are writable so we can delete them
-	return filepath.Walk(path, func(path string, info os.FileInfo, err error) error {
-		if err != nil {
+	err = filepath.Walk(path, func(path string, info os.FileInfo, err error) error {
+		if err != nil && err != filepath.SkipDir {
 			// walk gave us some error, give it back.
 			return err
 		}
@@ -33,6 +33,12 @@
 		if mode|0200 == mode {
 			return nil
 		}
+
 		return os.Chmod(path, mode|0200)
 	})
+	if err != nil {
+		return err
+	}
+
+	return os.Remove(path)
 }
diff --git a/vendor/github.com/sdboyer/gps/result_test.go b/vendor/github.com/sdboyer/gps/result_test.go
index ac98678..d0fd972 100644
--- a/vendor/github.com/sdboyer/gps/result_test.go
+++ b/vendor/github.com/sdboyer/gps/result_test.go
@@ -73,7 +73,7 @@
 	tmp := path.Join(os.TempDir(), "vsolvtest")
 
 	clean := true
-	sm, err := NewSourceManager(naiveAnalyzer{}, path.Join(tmp, "cache"), true)
+	sm, err := NewSourceManager(naiveAnalyzer{}, path.Join(tmp, "cache"))
 	if err != nil {
 		b.Errorf("NewSourceManager errored unexpectedly: %q", err)
 		clean = false
@@ -81,7 +81,7 @@
 
 	// Prefetch the projects before timer starts
 	for _, lp := range r.p {
-		_, _, err := sm.GetManifestAndLock(lp.Ident(), lp.Version())
+		err := sm.SyncSourceFor(lp.Ident())
 		if err != nil {
 			b.Errorf("failed getting project info during prefetch: %s", err)
 			clean = false
diff --git a/vendor/github.com/sdboyer/gps/solver.go b/vendor/github.com/sdboyer/gps/solver.go
index 8993b78..5556589 100644
--- a/vendor/github.com/sdboyer/gps/solver.go
+++ b/vendor/github.com/sdboyer/gps/solver.go
@@ -175,7 +175,7 @@
 	// this Solver's inputs.
 	//
 	// In such a case, it may not be necessary to run Solve() at all.
-	HashInputs() ([]byte, error)
+	HashInputs() []byte
 
 	// Solve initiates a solving run. It will either complete successfully with
 	// a Solution, or fail with an informative error.
@@ -304,10 +304,7 @@
 			att: s.attempts,
 		}
 
-		// An err here is impossible; it could only be caused by a parsing error
-		// of the root tree, but that necessarily already succeeded back up in
-		// selectRoot(), so we can ignore the err return here
-		soln.hd, _ = s.HashInputs()
+		soln.hd = s.HashInputs()
 
 		// Convert ProjectAtoms into LockedProjects
 		soln.p = make([]LockedProject, len(all))
@@ -440,17 +437,16 @@
 		v: rootRev,
 	}
 
-	ptree, err := s.b.ListPackages(pa.id, nil)
-	if err != nil {
-		return err
-	}
-
-	list := make([]string, len(ptree.Packages))
+	list := make([]string, len(s.rpt.Packages))
 	k := 0
-	for path := range ptree.Packages {
-		list[k] = path
-		k++
+	for path, pkg := range s.rpt.Packages {
+		if pkg.Err != nil {
+			list[k] = path
+			k++
+		}
 	}
+	list = list[:k]
+	sort.Strings(list)
 
 	a := atomWithPackages{
 		a:  pa,
@@ -489,7 +485,7 @@
 		heap.Push(s.unsel, bimodalIdentifier{id: dep.Ident, pl: dep.pl, fromRoot: true})
 	}
 
-	s.traceSelectRoot(ptree, deps)
+	s.traceSelectRoot(s.rpt, deps)
 	return nil
 }
 
@@ -515,8 +511,8 @@
 	allex := ptree.ExternalReach(false, false, s.ig)
 	// Use a map to dedupe the unique external packages
 	exmap := make(map[string]struct{})
-	// Add the packages reached by the packages explicitly listed in the atom to
-	// the list
+	// Add to the list those packages that are reached by the packages
+	// explicitly listed in the atom
 	for _, pkg := range a.pl {
 		expkgs, exists := allex[pkg]
 		if !exists {
@@ -543,6 +539,7 @@
 		reach[k] = pkg
 		k++
 	}
+	sort.Strings(reach)
 
 	deps := s.ovr.overrideAll(m.DependencyConstraints())
 	return s.intersectConstraintsWithImports(deps, reach)
diff --git a/vendor/github.com/sdboyer/gps/source_manager.go b/vendor/github.com/sdboyer/gps/source_manager.go
index 82064e4..f59ae62 100644
--- a/vendor/github.com/sdboyer/gps/source_manager.go
+++ b/vendor/github.com/sdboyer/gps/source_manager.go
@@ -83,6 +83,7 @@
 // tools; control via dependency injection is intended to be sufficient.
 type SourceMgr struct {
 	cachedir string
+	lf       *os.File
 	srcs     map[string]source
 	srcmut   sync.RWMutex
 	an       ProjectAnalyzer
@@ -94,22 +95,19 @@
 
 // NewSourceManager produces an instance of gps's built-in SourceManager. It
 // takes a cache directory (where local instances of upstream repositories are
-// stored), a vendor directory for the project currently being worked on, and a
-// force flag indicating whether to overwrite the global cache lock file (if
-// present).
+// stored), and a ProjectAnalyzer that is used to extract manifest and lock
+// information from source trees.
 //
 // The returned SourceManager aggressively caches information wherever possible.
-// It is recommended that, if tools need to do preliminary, work involving
-// upstream repository analysis prior to invoking a solve run, that they create
-// this SourceManager as early as possible and use it to their ends. That way,
-// the solver can benefit from any caches that may have already been warmed.
+// If tools need to do preliminary work involving upstream repository analysis
+// prior to invoking a solve run, it is recommended that they create this
+// SourceManager as early as possible and use it to their ends. That way, the
+// solver can benefit from any caches that may have already been warmed.
 //
-// gps's SourceManager is intended to be threadsafe (if it's not, please
-// file a bug!). It should certainly be safe to reuse from one solving run to
-// the next; however, the fact that it takes a basedir as an argument makes it
-// much less useful for simultaneous use by separate solvers operating on
-// different root projects. This architecture may change in the future.
-func NewSourceManager(an ProjectAnalyzer, cachedir string, force bool) (*SourceMgr, error) {
+// gps's SourceManager is intended to be threadsafe (if it's not, please file a
+// bug!). It should be safe to reuse across concurrent solving runs, even on
+// unrelated projects.
+func NewSourceManager(an ProjectAnalyzer, cachedir string) (*SourceMgr, error) {
 	if an == nil {
 		return nil, fmt.Errorf("a ProjectAnalyzer must be provided to the SourceManager")
 	}
@@ -121,17 +119,24 @@
 
 	glpath := filepath.Join(cachedir, "sm.lock")
 	_, err = os.Stat(glpath)
-	if err == nil && !force {
-		return nil, fmt.Errorf("cache lock file %s exists - another process crashed or is still running?", glpath)
+	if err == nil {
+		return nil, CouldNotCreateLockError{
+			Path: glpath,
+			Err:  fmt.Errorf("cache lock file %s exists - another process crashed or is still running?", glpath),
+		}
 	}
 
-	_, err = os.OpenFile(glpath, os.O_CREATE|os.O_RDONLY, 0700) // is 0700 sane for this purpose?
+	fi, err := os.OpenFile(glpath, os.O_CREATE|os.O_EXCL, 0600) // is 0600 sane for this purpose?
 	if err != nil {
-		return nil, fmt.Errorf("failed to create global cache lock file at %s with err %s", glpath, err)
+		return nil, CouldNotCreateLockError{
+			Path: glpath,
+			Err:  fmt.Errorf("err on attempting to create global cache lock: %s", err),
+		}
 	}
 
 	return &SourceMgr{
 		cachedir: cachedir,
+		lf:       fi,
 		srcs:     make(map[string]source),
 		an:       an,
 		dxt:      pathDeducerTrie(),
@@ -139,8 +144,18 @@
 	}, nil
 }
 
+type CouldNotCreateLockError struct {
+	Path string
+	Err  error
+}
+
+func (e CouldNotCreateLockError) Error() string {
+	return e.Err.Error()
+}
+
 // Release lets go of any locks held by the SourceManager.
 func (sm *SourceMgr) Release() {
+	sm.lf.Close()
 	os.Remove(filepath.Join(sm.cachedir, "sm.lock"))
 }
 
diff --git a/vendor/github.com/sdboyer/gps/source_test.go b/vendor/github.com/sdboyer/gps/source_test.go
index ffee963..787e573 100644
--- a/vendor/github.com/sdboyer/gps/source_test.go
+++ b/vendor/github.com/sdboyer/gps/source_test.go
@@ -86,7 +86,7 @@
 		SortForUpgrade(vlist)
 		evl := []Version{
 			NewVersion("1.0.0").Is(Revision("30605f6ac35fcb075ad0bfa9296f90a7d891523e")),
-			NewBranch("master").Is(Revision("30605f6ac35fcb075ad0bfa9296f90a7d891523e")),
+			newDefaultBranch("master").Is(Revision("30605f6ac35fcb075ad0bfa9296f90a7d891523e")),
 			NewBranch("test").Is(Revision("30605f6ac35fcb075ad0bfa9296f90a7d891523e")),
 		}
 		if !reflect.DeepEqual(vlist, evl) {
@@ -147,6 +147,10 @@
 	if ident != un {
 		t.Errorf("Expected %s as source ident, got %s", un, ident)
 	}
+	evl := []Version{
+		NewVersion("1.0.0").Is(Revision("matt@mattfarina.com-20150731135137-pbphasfppmygpl68")),
+		newDefaultBranch("(default)").Is(Revision("matt@mattfarina.com-20150731135137-pbphasfppmygpl68")),
+	}
 
 	// check that an expected rev is present
 	is, err := src.revisionPresentIn(Revision("matt@mattfarina.com-20150731135137-pbphasfppmygpl68"))
@@ -168,12 +172,12 @@
 		t.Errorf("bzrSource.listVersions() should have set the upstream and cache existence bits for found")
 	}
 
-	if len(vlist) != 1 {
-		t.Errorf("bzr test repo should've produced one version, got %v", len(vlist))
+	if len(vlist) != 2 {
+		t.Errorf("bzr test repo should've produced two versions, got %v", len(vlist))
 	} else {
-		v := NewVersion("1.0.0").Is(Revision("matt@mattfarina.com-20150731135137-pbphasfppmygpl68"))
-		if vlist[0] != v {
-			t.Errorf("bzr pair fetch reported incorrect first version, got %s", vlist[0])
+		SortForUpgrade(vlist)
+		if !reflect.DeepEqual(vlist, evl) {
+			t.Errorf("bzr version list was not what we expected:\n\t(GOT): %s\n\t(WNT): %s", vlist, evl)
 		}
 	}
 
@@ -190,12 +194,12 @@
 		t.Errorf("bzrSource.listVersions() should have set the upstream and cache existence bits for found")
 	}
 
-	if len(vlist) != 1 {
-		t.Errorf("bzr test repo should've produced one version, got %v", len(vlist))
+	if len(vlist) != 2 {
+		t.Errorf("bzr test repo should've produced two versions, got %v", len(vlist))
 	} else {
-		v := NewVersion("1.0.0").Is(Revision("matt@mattfarina.com-20150731135137-pbphasfppmygpl68"))
-		if vlist[0] != v {
-			t.Errorf("bzr pair fetch reported incorrect first version, got %s", vlist[0])
+		SortForUpgrade(vlist)
+		if !reflect.DeepEqual(vlist, evl) {
+			t.Errorf("bzr version list was not what we expected:\n\t(GOT): %s\n\t(WNT): %s", vlist, evl)
 		}
 	}
 
@@ -225,94 +229,111 @@
 		}
 	}
 
-	n := "bitbucket.org/mattfarina/testhgrepo"
-	un := "https://" + n
-	u, err := url.Parse(un)
-	if err != nil {
-		t.Errorf("URL was bad, lolwut? errtext: %s", err)
-		rf()
-		t.FailNow()
-	}
-	mb := maybeHgSource{
-		url: u,
-	}
+	tfunc := func(n string, evl []Version) {
+		un := "https://" + n
+		u, err := url.Parse(un)
+		if err != nil {
+			t.Errorf("URL was bad, lolwut? errtext: %s", err)
+			return
+		}
+		mb := maybeHgSource{
+			url: u,
+		}
 
-	isrc, ident, err := mb.try(cpath, naiveAnalyzer{})
-	if err != nil {
-		t.Errorf("Unexpected error while setting up hgSource for test repo: %s", err)
-		rf()
-		t.FailNow()
-	}
-	src, ok := isrc.(*hgSource)
-	if !ok {
-		t.Errorf("Expected a hgSource, got a %T", isrc)
-		rf()
-		t.FailNow()
-	}
-	if ident != un {
-		t.Errorf("Expected %s as source ident, got %s", un, ident)
-	}
+		isrc, ident, err := mb.try(cpath, naiveAnalyzer{})
+		if err != nil {
+			t.Errorf("Unexpected error while setting up hgSource for test repo: %s", err)
+			return
+		}
+		src, ok := isrc.(*hgSource)
+		if !ok {
+			t.Errorf("Expected a hgSource, got a %T", isrc)
+			return
+		}
+		if ident != un {
+			t.Errorf("Expected %s as source ident, got %s", un, ident)
+		}
 
-	// check that an expected rev is present
-	is, err := src.revisionPresentIn(Revision("d680e82228d206935ab2eaa88612587abe68db07"))
-	if err != nil {
-		t.Errorf("Unexpected error while checking revision presence: %s", err)
-	} else if !is {
-		t.Errorf("Revision that should exist was not present")
-	}
+		// check that an expected rev is present
+		is, err := src.revisionPresentIn(Revision("103d1bddef2199c80aad7c42041223083d613ef9"))
+		if err != nil {
+			t.Errorf("Unexpected error while checking revision presence: %s", err)
+		} else if !is {
+			t.Errorf("Revision that should exist was not present")
+		}
 
-	vlist, err := src.listVersions()
-	if err != nil {
-		t.Errorf("Unexpected error getting version pairs from hg repo: %s", err)
-	}
-	evl := []Version{
-		NewVersion("1.0.0").Is(Revision("d680e82228d206935ab2eaa88612587abe68db07")),
-		NewBranch("test").Is(Revision("6c44ee3fe5d87763616c19bf7dbcadb24ff5a5ce")),
-	}
+		vlist, err := src.listVersions()
+		if err != nil {
+			t.Errorf("Unexpected error getting version pairs from hg repo: %s", err)
+		}
 
-	if src.ex.s&existsUpstream|existsInCache != existsUpstream|existsInCache {
-		t.Errorf("hgSource.listVersions() should have set the upstream and cache existence bits for search")
-	}
-	if src.ex.f&existsUpstream|existsInCache != existsUpstream|existsInCache {
-		t.Errorf("hgSource.listVersions() should have set the upstream and cache existence bits for found")
-	}
+		if src.ex.s&existsUpstream|existsInCache != existsUpstream|existsInCache {
+			t.Errorf("hgSource.listVersions() should have set the upstream and cache existence bits for search")
+		}
+		if src.ex.f&existsUpstream|existsInCache != existsUpstream|existsInCache {
+			t.Errorf("hgSource.listVersions() should have set the upstream and cache existence bits for found")
+		}
 
-	if len(vlist) != 2 {
-		t.Errorf("hg test repo should've produced one version, got %v", len(vlist))
-	} else {
-		SortForUpgrade(vlist)
-		if !reflect.DeepEqual(vlist, evl) {
-			t.Errorf("Version list was not what we expected:\n\t(GOT): %s\n\t(WNT): %s", vlist, evl)
+		if len(vlist) != len(evl) {
+			t.Errorf("hg test repo should've produced %v versions, got %v", len(evl), len(vlist))
+		} else {
+			SortForUpgrade(vlist)
+			if !reflect.DeepEqual(vlist, evl) {
+				t.Errorf("Version list was not what we expected:\n\t(GOT): %s\n\t(WNT): %s", vlist, evl)
+			}
+		}
+
+		// Run again, this time to ensure cache outputs correctly
+		vlist, err = src.listVersions()
+		if err != nil {
+			t.Errorf("Unexpected error getting version pairs from hg repo: %s", err)
+		}
+
+		if src.ex.s&existsUpstream|existsInCache != existsUpstream|existsInCache {
+			t.Errorf("hgSource.listVersions() should have set the upstream and cache existence bits for search")
+		}
+		if src.ex.f&existsUpstream|existsInCache != existsUpstream|existsInCache {
+			t.Errorf("hgSource.listVersions() should have set the upstream and cache existence bits for found")
+		}
+
+		if len(vlist) != len(evl) {
+			t.Errorf("hg test repo should've produced %v versions, got %v", len(evl), len(vlist))
+		} else {
+			SortForUpgrade(vlist)
+			if !reflect.DeepEqual(vlist, evl) {
+				t.Errorf("Version list was not what we expected:\n\t(GOT): %s\n\t(WNT): %s", vlist, evl)
+			}
+		}
+
+		// recheck that rev is present, this time interacting with cache differently
+		is, err = src.revisionPresentIn(Revision("103d1bddef2199c80aad7c42041223083d613ef9"))
+		if err != nil {
+			t.Errorf("Unexpected error while re-checking revision presence: %s", err)
+		} else if !is {
+			t.Errorf("Revision that should exist was not present on re-check")
 		}
 	}
 
-	// Run again, this time to ensure cache outputs correctly
-	vlist, err = src.listVersions()
-	if err != nil {
-		t.Errorf("Unexpected error getting version pairs from hg repo: %s", err)
-	}
+	// simultaneously run for both the repo with and without the magic bookmark
+	donech := make(chan struct{})
+	go func() {
+		tfunc("bitbucket.org/sdboyer/withbm", []Version{
+			NewVersion("v1.0.0").Is(Revision("aa110802a0c64195d0a6c375c9f66668827c90b4")),
+			newDefaultBranch("@").Is(Revision("b10d05d581e5401f383e48ccfeb84b48fde99d06")),
+			NewBranch("another").Is(Revision("b10d05d581e5401f383e48ccfeb84b48fde99d06")),
+			NewBranch("default").Is(Revision("3d466f437f6616da594bbab6446cc1cb4328d1bb")),
+			NewBranch("newbranch").Is(Revision("5e2a01be9aee942098e44590ae545c7143da9675")),
+		})
+		close(donech)
+	}()
 
-	if src.ex.s&existsUpstream|existsInCache != existsUpstream|existsInCache {
-		t.Errorf("hgSource.listVersions() should have set the upstream and cache existence bits for search")
-	}
-	if src.ex.f&existsUpstream|existsInCache != existsUpstream|existsInCache {
-		t.Errorf("hgSource.listVersions() should have set the upstream and cache existence bits for found")
-	}
+	tfunc("bitbucket.org/sdboyer/nobm", []Version{
+		NewVersion("v1.0.0").Is(Revision("aa110802a0c64195d0a6c375c9f66668827c90b4")),
+		newDefaultBranch("default").Is(Revision("3d466f437f6616da594bbab6446cc1cb4328d1bb")),
+		NewBranch("another").Is(Revision("b10d05d581e5401f383e48ccfeb84b48fde99d06")),
+		NewBranch("newbranch").Is(Revision("5e2a01be9aee942098e44590ae545c7143da9675")),
+	})
 
-	if len(vlist) != 2 {
-		t.Errorf("hg test repo should've produced one version, got %v", len(vlist))
-	} else {
-		SortForUpgrade(vlist)
-		if !reflect.DeepEqual(vlist, evl) {
-			t.Errorf("Version list was not what we expected:\n\t(GOT): %s\n\t(WNT): %s", vlist, evl)
-		}
-	}
-
-	// recheck that rev is present, this time interacting with cache differently
-	is, err = src.revisionPresentIn(Revision("d680e82228d206935ab2eaa88612587abe68db07"))
-	if err != nil {
-		t.Errorf("Unexpected error while re-checking revision presence: %s", err)
-	} else if !is {
-		t.Errorf("Revision that should exist was not present on re-check")
-	}
+	<-donech
+	rf()
 }
diff --git a/vendor/github.com/sdboyer/gps/types.go b/vendor/github.com/sdboyer/gps/types.go
index 11221e3..33b57f9 100644
--- a/vendor/github.com/sdboyer/gps/types.go
+++ b/vendor/github.com/sdboyer/gps/types.go
@@ -211,12 +211,6 @@
 	}
 }
 
-//type byImportPath []Package
-
-//func (s byImportPath) Len() int           { return len(s) }
-//func (s byImportPath) Less(i, j int) bool { return s[i].ImportPath < s[j].ImportPath }
-//func (s byImportPath) Swap(i, j int)      { s[i], s[j] = s[j], s[i] }
-
 // completeDep (name hopefully to change) provides the whole picture of a
 // dependency - the root (repo and project, since currently we assume the two
 // are the same) name, a constraint, and the actual packages needed that are
diff --git a/vendor/github.com/sdboyer/gps/vcs_source.go b/vendor/github.com/sdboyer/gps/vcs_source.go
index ecded0c..338a2da 100644
--- a/vendor/github.com/sdboyer/gps/vcs_source.go
+++ b/vendor/github.com/sdboyer/gps/vcs_source.go
@@ -136,13 +136,59 @@
 	s.ex.s |= existsUpstream
 	s.ex.f |= existsUpstream
 
+	// pull out the HEAD rev (it's always first) so we know what branches to
+	// mark as default. This is, perhaps, not the best way to glean this, but it
+	// was good enough for git itself until 1.8.5. Also, the alternative is
+	// sniffing data out of the pack protocol, which is a separate request, and
+	// also waaaay more than we want to do right now.
+	//
+	// The cost is that we could potentially have multiple branches marked as
+	// the default. If that does occur, a later check (again, emulating git
+	// <1.8.5 behavior) further narrows the failure mode by choosing master as
+	// the sole default branch if a) master exists and b) master is one of the
+	// branches marked as a default.
+	//
+	// This all reduces the failure mode to a very narrow range of
+	// circumstances. Nevertheless, if we do end up emitting multiple
+	// default branches, it is possible that a user could end up following a
+	// non-default branch, IF:
+	//
+	// * Multiple branches match the HEAD rev
+	// * None of them are master
+	// * The solver makes it into the branch list in the version queue
+	// * The user has provided no constraint, or DefaultBranch
+	// * A branch that is not actually the default, but happens to share the
+	// rev, is lexicographically earlier than the true default branch
+	//
+	// Then the user could end up with an erroneous non-default branch in their
+	// lock file.
+	headrev := Revision(all[0][:40])
+	var onedef, multidef, defmaster bool
+
 	smap := make(map[string]bool)
 	uniq := 0
 	vlist = make([]Version, len(all)-1) // less 1, because always ignore HEAD
 	for _, pair := range all {
 		var v PairedVersion
 		if string(pair[46:51]) == "heads" {
-			v = NewBranch(string(pair[52:])).Is(Revision(pair[:40])).(PairedVersion)
+			rev := Revision(pair[:40])
+
+			isdef := rev == headrev
+			n := string(pair[52:])
+			if isdef {
+				if onedef {
+					multidef = true
+				}
+				onedef = true
+				if n == "master" {
+					defmaster = true
+				}
+			}
+			v = branchVersion{
+				name:      n,
+				isDefault: isdef,
+			}.Is(rev).(PairedVersion)
+
 			vlist[uniq] = v
 			uniq++
 		} else if string(pair[46:50]) == "tags" {
@@ -169,6 +215,20 @@
 	// Trim off excess from the slice
 	vlist = vlist[:uniq]
 
+	// There were multiple default branches, but one was master. So, go through
+	// and strip the default flag from all the non-master branches.
+	if multidef && defmaster {
+		for k, v := range vlist {
+			pv := v.(PairedVersion)
+			if bv, ok := pv.Unpair().(branchVersion); ok {
+				if bv.name != "master" && bv.isDefault == true {
+					bv.isDefault = false
+					vlist[k] = bv.Is(pv.Underlying())
+				}
+			}
+		}
+	}
+
 	// Process the version data into the cache
 	//
 	// reset the rmap and vmap, as they'll be fully repopulated by this
@@ -226,23 +286,30 @@
 	}
 
 	var out []byte
-
 	// Now, list all the tags
 	out, err = r.RunFromDir("bzr", "tags", "--show-ids", "-v")
 	if err != nil {
-		return
+		return nil, fmt.Errorf("%s: %s", err, string(out))
 	}
 
 	all := bytes.Split(bytes.TrimSpace(out), []byte("\n"))
 
-	// reset the rmap and vmap, as they'll be fully repopulated by this
-	// TODO(sdboyer) detect out-of-sync pairings as we do this?
+	var branchrev []byte
+	branchrev, err = r.RunFromDir("bzr", "version-info", "--custom", "--template={revision_id}", "--revision=branch:.")
+	br := string(branchrev)
+	if err != nil {
+		return nil, fmt.Errorf("%s: %s", err, br)
+	}
+
+	// Both commands completed successfully, so there's no further possibility
+	// of errors. That means it's now safe to reset the rmap and vmap, as
+	// they're about to be fully repopulated.
 	s.dc.vMap = make(map[UnpairedVersion]Revision)
 	s.dc.rMap = make(map[Revision][]UnpairedVersion)
+	vlist = make([]Version, len(all)+1)
 
-	vlist = make([]Version, len(all))
-	k := 0
-	for _, line := range all {
+	// Now, all the tags.
+	for k, line := range all {
 		idx := bytes.IndexByte(line, 32) // space
 		v := NewVersion(string(line[:idx]))
 		r := Revision(bytes.TrimSpace(line[idx:]))
@@ -250,9 +317,16 @@
 		s.dc.vMap[v] = r
 		s.dc.rMap[r] = append(s.dc.rMap[r], v)
 		vlist[k] = v.Is(r)
-		k++
 	}
 
+	// Last, add the default branch, hardcoding the visual representation of it
+	// that bzr uses when operating in the workflow mode we're using.
+	v := newDefaultBranch("(default)")
+	rev := Revision(string(branchrev))
+	s.dc.vMap[v] = rev
+	s.dc.rMap[rev] = append(s.dc.rMap[rev], v)
+	vlist[len(vlist)-1] = v.Is(rev)
+
 	// Cache is now in sync with upstream's version list
 	s.cvsync = true
 	return
@@ -301,7 +375,7 @@
 	// Now, list all the tags
 	out, err = r.RunFromDir("hg", "tags", "--debug", "--verbose")
 	if err != nil {
-		return
+		return nil, fmt.Errorf("%s: %s", err, string(out))
 	}
 
 	all := bytes.Split(bytes.TrimSpace(out), []byte("\n"))
@@ -330,30 +404,71 @@
 		vlist = append(vlist, v)
 	}
 
-	out, err = r.RunFromDir("hg", "branches", "--debug", "--verbose")
+	// bookmarks next, because the presence of the magic @ bookmark has to
+	// determine how we handle the branches
+	var magicAt bool
+	out, err = r.RunFromDir("hg", "bookmarks", "--debug")
 	if err != nil {
 		// better nothing than partial and misleading
-		vlist = nil
-		return
+		return nil, fmt.Errorf("%s: %s", err, string(out))
+	}
+
+	out = bytes.TrimSpace(out)
+	if !bytes.Equal(out, []byte("no bookmarks set")) {
+		all = bytes.Split(out, []byte("\n"))
+		for _, line := range all {
+			// Trim leading spaces, and * marker if present
+			line = bytes.TrimLeft(line, " *")
+			pair := bytes.Split(line, []byte(":"))
+			// if this doesn't split exactly once, we have something weird
+			if len(pair) != 2 {
+				continue
+			}
+
+			// Split on colon; this gets us the rev and the branch plus local revno
+			idx := bytes.IndexByte(pair[0], 32) // space
+			// if it's the magic @ marker, make that the default branch
+			str := string(pair[0][:idx])
+			var v Version
+			if str == "@" {
+				magicAt = true
+				v = newDefaultBranch(str).Is(Revision(pair[1])).(PairedVersion)
+			} else {
+				v = NewBranch(str).Is(Revision(pair[1])).(PairedVersion)
+			}
+			vlist = append(vlist, v)
+		}
+	}
+
+	out, err = r.RunFromDir("hg", "branches", "-c", "--debug")
+	if err != nil {
+		// better nothing than partial and misleading
+		return nil, fmt.Errorf("%s: %s", err, string(out))
 	}
 
 	all = bytes.Split(bytes.TrimSpace(out), []byte("\n"))
-	lbyt = []byte("(inactive)")
 	for _, line := range all {
-		if bytes.Equal(lbyt, line[len(line)-len(lbyt):]) {
-			// Skip inactive branches
-			continue
-		}
+		// Trim inactive and closed suffixes, if present; we represent these
+		// anyway
+		line = bytes.TrimSuffix(line, []byte(" (inactive)"))
+		line = bytes.TrimSuffix(line, []byte(" (closed)"))
 
 		// Split on colon; this gets us the rev and the branch plus local revno
 		pair := bytes.Split(line, []byte(":"))
 		idx := bytes.IndexByte(pair[0], 32) // space
-		v := NewBranch(string(pair[0][:idx])).Is(Revision(pair[1])).(PairedVersion)
+		str := string(pair[0][:idx])
+		// if there was no magic @ bookmark, and this is mercurial's magic
+		// "default" branch, then mark it as default branch
+		var v Version
+		if !magicAt && str == "default" {
+			v = newDefaultBranch(str).Is(Revision(pair[1])).(PairedVersion)
+		} else {
+			v = NewBranch(str).Is(Revision(pair[1])).(PairedVersion)
+		}
 		vlist = append(vlist, v)
 	}
 
 	// reset the rmap and vmap, as they'll be fully repopulated by this
-	// TODO(sdboyer) detect out-of-sync pairings as we do this?
 	s.dc.vMap = make(map[UnpairedVersion]Revision)
 	s.dc.rMap = make(map[Revision][]UnpairedVersion)
 
diff --git a/vendor/github.com/sdboyer/gps/version.go b/vendor/github.com/sdboyer/gps/version.go
index f288b2a..7912d1e 100644
--- a/vendor/github.com/sdboyer/gps/version.go
+++ b/vendor/github.com/sdboyer/gps/version.go
@@ -69,7 +69,23 @@
 // NewBranch creates a new Version to represent a floating version (in
 // general, a branch).
 func NewBranch(body string) UnpairedVersion {
-	return branchVersion(body)
+	return branchVersion{
+		name: body,
+		// We always set isDefault to false here, because the property is
+		// specifically designed to be internal-only: only the SourceManager
+		// gets to mark it. This is OK because nothing that client code is
+		// responsible for needs to care about has to touch it it.
+		//
+		// TODO(sdboyer) ...maybe. this just ugly.
+		isDefault: false,
+	}
+}
+
+func newDefaultBranch(body string) UnpairedVersion {
+	return branchVersion{
+		name:      body,
+		isDefault: true,
+	}
 }
 
 // NewVersion creates a Semver-typed Version if the provided version string is
@@ -150,13 +166,16 @@
 	return none
 }
 
-type branchVersion string
-
-func (v branchVersion) String() string {
-	return string(v)
+type branchVersion struct {
+	name      string
+	isDefault bool
 }
 
-func (r branchVersion) Type() string {
+func (v branchVersion) String() string {
+	return string(v.name)
+}
+
+func (v branchVersion) Type() string {
 	return "branch"
 }
 
@@ -165,10 +184,10 @@
 	case versionTypeUnion:
 		return tv.Matches(v)
 	case branchVersion:
-		return v == tv
+		return v.name == tv.name
 	case versionPair:
 		if tv2, ok := tv.v.(branchVersion); ok {
-			return tv2 == v
+			return tv2.name == v.name
 		}
 	}
 	return false
@@ -183,10 +202,10 @@
 	case versionTypeUnion:
 		return tc.MatchesAny(v)
 	case branchVersion:
-		return v == tc
+		return v.name == tc.name
 	case versionPair:
 		if tc2, ok := tc.v.(branchVersion); ok {
-			return tc2 == v
+			return tc2.name == v.name
 		}
 	}
 
@@ -202,12 +221,12 @@
 	case versionTypeUnion:
 		return tc.Intersect(v)
 	case branchVersion:
-		if v == tc {
+		if v.name == tc.name {
 			return v
 		}
 	case versionPair:
 		if tc2, ok := tc.v.(branchVersion); ok {
-			if v == tc2 {
+			if v.name == tc2.name {
 				return v
 			}
 		}
@@ -615,9 +634,19 @@
 		panic("unreachable")
 	}
 
-	switch l.(type) {
-	// For these, now nothing to do but alpha sort
-	case Revision, branchVersion, plainVersion:
+	switch tl := l.(type) {
+	case branchVersion:
+		tr := r.(branchVersion)
+		if tl.isDefault != tr.isDefault {
+			// If they're not both defaults, then return the left val: if left
+			// is the default, then it is "less" (true) b/c we want it earlier.
+			// Else the right is the default, and so the left should be later
+			// (false).
+			return tl.isDefault
+		}
+		return l.String() < r.String()
+	case Revision, plainVersion:
+		// All that we can do now is alpha sort
 		return l.String() < r.String()
 	}
 
@@ -652,9 +681,19 @@
 		panic("unreachable")
 	}
 
-	switch l.(type) {
-	// For these, now nothing to do but alpha
-	case Revision, branchVersion, plainVersion:
+	switch tl := l.(type) {
+	case branchVersion:
+		tr := r.(branchVersion)
+		if tl.isDefault != tr.isDefault {
+			// If they're not both defaults, then return the left val: if left
+			// is the default, then it is "less" (true) b/c we want it earlier.
+			// Else the right is the default, and so the left should be later
+			// (false).
+			return tl.isDefault
+		}
+		return l.String() < r.String()
+	case Revision, plainVersion:
+		// All that we can do now is alpha sort
 		return l.String() < r.String()
 	}
 
diff --git a/vendor/github.com/sdboyer/gps/version_test.go b/vendor/github.com/sdboyer/gps/version_test.go
index 394bb27..d375e77 100644
--- a/vendor/github.com/sdboyer/gps/version_test.go
+++ b/vendor/github.com/sdboyer/gps/version_test.go
@@ -10,7 +10,7 @@
 	v4 := NewVersion("1.0.1")
 	v5 := NewVersion("v2.0.5")
 	v6 := NewVersion("2.0.5.2")
-	v7 := NewBranch("unwrapped")
+	v7 := newDefaultBranch("unwrapped")
 	v8 := NewVersion("20.0.5.2")
 
 	start := []Version{
@@ -32,14 +32,14 @@
 
 	edown := []Version{
 		v3, v4, v5, // semvers
-		v1, v2, v7, // floating/branches
+		v7, v1, v2, // floating/branches
 		v6, v8, // plain versions
 		rev, // revs
 	}
 
 	eup := []Version{
 		v5, v4, v3, // semvers
-		v1, v2, v7, // floating/branches
+		v7, v1, v2, // floating/branches
 		v6, v8, // plain versions
 		rev, // revs
 	}
diff --git a/vendor/gopkg.in/yaml.v2/README.md b/vendor/gopkg.in/yaml.v2/README.md
index 1884de6..7b8bd86 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 Apache License 2.0. Please see the LICENSE file for details.
+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.
 
 
 Example