diff --git a/src/main/java/com/google/devtools/build/lib/skyframe/ProcessPackageDirectory.java b/src/main/java/com/google/devtools/build/lib/skyframe/ProcessPackageDirectory.java
index cd434404d964b4..7813fad2f5921d 100644
--- a/src/main/java/com/google/devtools/build/lib/skyframe/ProcessPackageDirectory.java
+++ b/src/main/java/com/google/devtools/build/lib/skyframe/ProcessPackageDirectory.java
@@ -123,19 +123,14 @@ public ProcessPackageDirectoryResult getPackageExistenceAndSubdirDeps(
 
     PackageIdentifier packageId = PackageIdentifier.create(repositoryName, rootRelativePath);
 
-    if (packageId.getRepository().isMain()
-        && fileValue.isSymlink()
-        && fileValue
-            .getUnresolvedLinkTarget()
-            .startsWith(directories.getExecRootBase().asFragment())) {
-      // Symlinks back to the execroot are not traversed so that we avoid convenience symlinks.
-      // Note that it's not enough to just check for the convenience symlinks themselves,
-      // because if the value of --symlink_prefix changes, the old symlinks are left in place. This
-      // algorithm also covers more creative use cases where people create convenience symlinks
-      // somewhere in the directory tree manually.
+    if (packageId.getRepository().isMain() && isConvenienceSymlink(fileValue, rootedPath, env)) {
       return ProcessPackageDirectoryResult.EMPTY_RESULT;
     }
 
+    if(env.valuesMissing()) {
+      return null;
+    }
+
     SkyKey pkgLookupKey = PackageLookupValue.key(packageId);
     SkyKey dirListingKey = DirectoryListingValue.key(rootedPath);
     SkyframeLookupResult pkgLookupAndDirectoryListingDeps =
@@ -187,6 +182,74 @@ public ProcessPackageDirectoryResult getPackageExistenceAndSubdirDeps(
         /*additionalValuesToAggregate=*/ ImmutableMap.of());
   }
 
+  // Note that it's not enough to just check for the convenience symlinks themselves,
+  // because if the value of --symlink_prefix changes, the old symlinks are left in place. It
+  // is also not sufficient to check whether the symlink points to a directory in the current
+  // exec root, since this can change between bazel invocations. Therefore we check if the
+  // suffix of the symlink source suggests it is a convenience symlink, then see if the symlink
+  // target is in a directory that looks like an execroot. This algorithm also covers more
+  // creative use cases where people create convenience symlinks somewhere in the directory
+  // tree manually.
+  private boolean isConvenienceSymlink(FileValue fileValue, RootedPath rootedPath, SkyFunction.Environment env) throws InterruptedException {
+    if (!fileValue.isSymlink()) {
+      return false;
+    }
+
+    PathFragment linkTarget = fileValue.getUnresolvedLinkTarget();
+
+    if(linkTarget.startsWith(directories.getExecRootBase().asFragment())) {
+      return true;
+    }
+
+    PathFragment rootRelativePath = rootedPath.getRootRelativePath();
+    Root root = rootedPath.getRoot();
+
+    if(rootRelativePath.getBaseName().endsWith("-bin") && isInExecRoot(linkTarget, root, 4, env)) {
+      return true;
+    }
+
+    if(rootRelativePath.getBaseName().endsWith("-genfiles") && isInExecRoot(linkTarget, root, 4, env)) {
+      return true;
+    }
+
+    if(rootRelativePath.getBaseName().endsWith("-out") && isInExecRoot(linkTarget, root, 2, env)) {
+      return true;
+    }
+
+    if(rootRelativePath.getBaseName().endsWith("-testlogs") && isInExecRoot(linkTarget, root, 4, env)) {
+      return true;
+    }
+
+    if(rootRelativePath.getBaseName().endsWith("-" + directories.getWorkingDirectory().getBaseName()) && isInExecRoot(linkTarget, root, 1, env)) {
+      return true;
+    }
+
+    return false;
+  }
+
+  private boolean isInExecRoot(PathFragment path, Root root, int depth, SkyFunction.Environment env) throws InterruptedException {
+    int segmentCount = path.segmentCount();
+
+    if(segmentCount <= depth) {
+      return false;
+    }
+
+    PathFragment candidateExecRoot = path.subFragment(0, segmentCount - depth);
+
+    if(!candidateExecRoot.getBaseName().equals("execroot")) {
+      return false;
+    }
+
+    Root absoluteRoot = Root.absoluteRoot(root.getFileSystem());
+    RootedPath doNotBuildPath = RootedPath.toRootedPath(absoluteRoot, candidateExecRoot.getChild("DO_NOT_BUILD_HERE"));
+    FileValue doNotBuildValue = (FileValue)env.getValue(FileValue.key(doNotBuildPath));
+    if (doNotBuildValue == null) { 
+      return false;
+    }
+
+    return doNotBuildValue.exists();
+  }
+
   private Iterable<SkyKey> getSubdirDeps(
       DirectoryListingValue dirListingValue,
       RootedPath rootedPath,
diff --git a/src/test/py/bazel/query_test.py b/src/test/py/bazel/query_test.py
index 0af495e1281fb5..fff5b053d4c4ab 100644
--- a/src/test/py/bazel/query_test.py
+++ b/src/test/py/bazel/query_test.py
@@ -13,6 +13,8 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+import os
+import tempfile
 from absl.testing import absltest
 from src.test.py.bazel import test_base
 
@@ -129,6 +131,18 @@ def testBuildFilesForExternalRepos_NoDuplicates(self):
       self.assertNotIn(item, result)
       result.add(item)
 
+  def testQueryWithDifferentOutputBaseAfterBuilding(self):
+    output_base = tempfile.mkdtemp(dir = os.getenv("TEST_TMPDIR"))
+
+    self.ScratchFile('MODULE.bazel')
+    self.ScratchFile('BUILD', [
+        'py_binary(name="a", srcs=["a.py"])',
+    ])
+    self.ScratchFile('a.py')
+    self.RunBazel(["build", "//..."])
+    self.RunBazel([f"--output_base={output_base}", "query", "//..."])
+
+
   def _AssertQueryOutput(self, query_expr, *expected_results):
     _, stdout, _ = self.RunBazel(['query', query_expr])