diff --git a/gopls/internal/lsp/cache/load.go b/gopls/internal/lsp/cache/load.go
index 269ab31..f62ab43 100644
--- a/gopls/internal/lsp/cache/load.go
+++ b/gopls/internal/lsp/cache/load.go
@@ -435,6 +435,13 @@
 	// Allow for multiple ad-hoc packages in the workspace (see #47584).
 	pkgPath := PackagePath(pkg.PkgPath)
 	id := PackageID(pkg.ID)
+
+	// TODO(rfindley): this creates at most one command-line-arguments package
+	// per load, but if we pass multiple file= queries to go/packages, there may
+	// be multiple command-line-arguments packages.
+	//
+	// As reported in golang/go#59318, this can result in accidentally quadratic
+	// loading behavior.
 	if source.IsCommandLineArguments(id) {
 		suffix := ":" + strings.Join(query, ",")
 		id = PackageID(pkg.ID + suffix)
diff --git a/gopls/internal/lsp/cache/snapshot.go b/gopls/internal/lsp/cache/snapshot.go
index 1f530b4..7771ce9 100644
--- a/gopls/internal/lsp/cache/snapshot.go
+++ b/gopls/internal/lsp/cache/snapshot.go
@@ -1553,6 +1553,11 @@
 	return err
 }
 
+// reloadOrphanedOpenFiles attempts to load a package for each open file that
+// does not yet have an associated package. If loading finishes without being
+// canceled, any files still not contained in a package are marked as unloadable.
+//
+// An error is returned if the load is canceled.
 func (s *snapshot) reloadOrphanedOpenFiles(ctx context.Context) error {
 	// When we load ./... or a package path directly, we may not get packages
 	// that exist only in overlays. As a workaround, we search all of the files
@@ -1586,22 +1591,35 @@
 	// mark the failures so we don't bother retrying until the file's
 	// content changes.
 	//
-	// TODO(rstambler): This may be an overestimate if the load stopped
-	// early for an unrelated errors. Add a fallback?
+	// TODO(rfindley): is it possible that the the load stopped early for an
+	// unrelated errors? If so, add a fallback?
 	//
 	// Check for context cancellation so that we don't incorrectly mark files
 	// as unloadable, but don't return before setting all workspace packages.
-	if ctx.Err() == nil && err != nil {
-		event.Error(ctx, "reloadOrphanedFiles: failed to load", err, tag.Query.Of(scopes))
-		s.mu.Lock()
-		for _, scope := range scopes {
-			uri := span.URI(scope.(fileLoadScope))
-			if s.noValidMetadataForURILocked(uri) {
-				s.unloadableFiles[uri] = struct{}{}
-			}
-		}
-		s.mu.Unlock()
+	if ctx.Err() != nil {
+		return ctx.Err()
 	}
+
+	// If the context was not canceled, we assume that the result of loading
+	// packages is deterministic (though as we saw in golang/go#59318, it may not
+	// be in the presence of bugs). Marking all unloaded files as unloadable here
+	// prevents us from falling into recursive reloading where we only make a bit
+	// of progress each time.
+	s.mu.Lock()
+	for _, scope := range scopes {
+		// TODO(rfindley): instead of locking here, we should have load return the
+		// metadata graph that resulted from loading.
+		uri := span.URI(scope.(fileLoadScope))
+		if s.noValidMetadataForURILocked(uri) {
+			s.unloadableFiles[uri] = struct{}{}
+		}
+	}
+	s.mu.Unlock()
+
+	if err != nil && !errors.Is(err, errNoPackages) {
+		event.Error(ctx, "reloadOrphanedFiles: failed to load", err, tag.Query.Of(scopes))
+	}
+
 	return nil
 }