diff --git a/base/src/com/google/idea/blaze/base/qsync/ProjectLoader.java b/base/src/com/google/idea/blaze/base/qsync/ProjectLoader.java
index 56a5ed6c60e..ff331c466a1 100644
--- a/base/src/com/google/idea/blaze/base/qsync/ProjectLoader.java
+++ b/base/src/com/google/idea/blaze/base/qsync/ProjectLoader.java
@@ -151,7 +151,11 @@ public QuerySyncProject loadProject(BlazeContext context) throws BuildException
     RenderJarArtifactTracker renderJarArtifactTracker;
     AppInspectorArtifactTracker appInspectorArtifactTracker;
     if (QuerySync.USE_NEW_BUILD_ARTIFACT_MANAGEMENT) {
-      artifactTracker = new NewArtifactTracker<>();
+      NewArtifactTracker tracker =
+          new NewArtifactTracker<>(
+              BlazeDataStorage.getProjectDataDir(importSettings).toPath(), artifactCache, executor);
+
+      artifactTracker = tracker;
       renderJarArtifactTracker = new RenderJarArtifactTrackerImpl();
       appInspectorArtifactTracker = new AppInspectorArtifactTrackerImpl();
     } else {
diff --git a/base/src/com/google/idea/blaze/base/qsync/cache/ArtifactTrackerImpl.java b/base/src/com/google/idea/blaze/base/qsync/cache/ArtifactTrackerImpl.java
index 247934426b1..f2e8dea58e9 100644
--- a/base/src/com/google/idea/blaze/base/qsync/cache/ArtifactTrackerImpl.java
+++ b/base/src/com/google/idea/blaze/base/qsync/cache/ArtifactTrackerImpl.java
@@ -72,6 +72,7 @@
 import com.google.idea.blaze.exception.BuildException;
 import com.google.idea.blaze.qsync.ProjectProtoTransform;
 import com.google.idea.blaze.qsync.TestSourceGlobMatcher;
+import com.google.idea.blaze.qsync.artifacts.BuildArtifact;
 import com.google.idea.blaze.qsync.cc.CcDependenciesInfo;
 import com.google.idea.blaze.qsync.deps.ArtifactTracker;
 import com.google.idea.blaze.qsync.deps.OutputGroup;
@@ -283,10 +284,11 @@ private void loadFromDisk() {
               .collect(toImmutableMap(e -> Path.of(e.getKey()), e -> Path.of(e.getValue()))));
       javaArtifacts.putAll(
           saved.getArtifactInfo().getArtifactsList().stream()
-              .map(JavaArtifactInfo::create)
+              .map(p -> JavaArtifactInfo.create(p, BuildArtifact.NO_DIGESTS))
               .collect(toImmutableMap(JavaArtifactInfo::label, Function.identity())));
       for (JavaTargetArtifacts targetArtifact : saved.getArtifactInfo().getArtifactsList()) {
-        JavaArtifactInfo javaArtifactInfo = JavaArtifactInfo.create(targetArtifact);
+        JavaArtifactInfo javaArtifactInfo =
+            JavaArtifactInfo.create(targetArtifact, BuildArtifact.NO_DIGESTS);
         javaArtifacts.put(javaArtifactInfo.label(), javaArtifactInfo);
       }
       ccDepencenciesInfo = CcDependenciesInfo.create(saved.getCcCompilationInfo());
@@ -615,7 +617,8 @@ private ImmutableListMultimap<Boolean, OutputArtifact> getGensrcsByInclusion(
    */
   private void updateMaps(Set<Label> targets, JavaArtifacts newArtifacts) {
     for (JavaTargetArtifacts targetArtifacts : newArtifacts.getArtifactsList()) {
-      JavaArtifactInfo javaArtifactInfo = JavaArtifactInfo.create(targetArtifacts);
+      JavaArtifactInfo javaArtifactInfo =
+          JavaArtifactInfo.create(targetArtifacts, BuildArtifact.NO_DIGESTS);
       javaArtifacts.put(javaArtifactInfo.label(), javaArtifactInfo);
     }
     for (Label label : targets) {
@@ -666,17 +669,17 @@ private ProjectProto.Project updateProjectProtoForJavaDeps(ProjectProto.Project
       if (!projectDefinition.isIncluded(ai.label())) {
         continue;
       }
-      for (Path blazeOutRelativePath : ai.genSrcs()) {
+      for (BuildArtifact artifact : ai.genSrcs()) {
         // TODO(mathewi) depending on `JAVA_ARCHIVE_EXTENSIONS` here exposes a design problem, we
         //  shouldn't have to depend on such implementation details. Figure out a better design
         //  for the dance between this class and the cache.
         if (!JavaSourcesArchiveCacheLayout.JAVA_ARCHIVE_EXTENSIONS.contains(
-            FileUtilRt.getExtension(blazeOutRelativePath.toString()))) {
+            artifact.getExtension())) {
           continue;
         }
-        Optional<Path> artifactPath = generatedSrcFileCache.getCacheFile(blazeOutRelativePath);
+        Optional<Path> artifactPath = generatedSrcFileCache.getCacheFile(artifact.path());
         if (artifactPath.isEmpty()) {
-          logger.warn("No cached artifact found for source jar " + blazeOutRelativePath);
+          logger.warn("No cached artifact found for source jar " + artifact.path());
           continue;
         }
         generatedProjectSrcJars.add(
@@ -707,6 +710,7 @@ private ProjectProto.Project updateProjectProtoForJavaDeps(ProjectProto.Project
             .filter(not(ai -> projectDefinition.isIncluded(ai.label())))
             .map(JavaArtifactInfo::genSrcs)
             .flatMap(List::stream)
+            .map(BuildArtifact::path)
             .filter(ArtifactTrackerImpl::hasJarOrZipExtension)
             .map(generatedExternalSrcFileCache::getCacheFile)
             .filter(Optional::isPresent)
diff --git a/querysync/java/com/google/idea/blaze/qsync/artifacts/BUILD b/querysync/java/com/google/idea/blaze/qsync/artifacts/BUILD
index b5e43b75fbd..0353c68a557 100644
--- a/querysync/java/com/google/idea/blaze/qsync/artifacts/BUILD
+++ b/querysync/java/com/google/idea/blaze/qsync/artifacts/BUILD
@@ -8,8 +8,10 @@ java_library(
     deps = [
         "//querysync/java/com/google/idea/blaze/qsync/project:project_java_proto",
         "//querysync/java/com/google/idea/blaze/qsync/query",
+        "//shared",
         "//shared:artifact",
         "//shared:exception",
+        "//third_party/auto_value",
         "@com_google_guava_guava//jar",
         "@com_google_protobuf//:protobuf_java",
         "@jsr305_annotations//jar",
diff --git a/querysync/java/com/google/idea/blaze/qsync/artifacts/BuildArtifact.java b/querysync/java/com/google/idea/blaze/qsync/artifacts/BuildArtifact.java
new file mode 100644
index 00000000000..4fe0b578939
--- /dev/null
+++ b/querysync/java/com/google/idea/blaze/qsync/artifacts/BuildArtifact.java
@@ -0,0 +1,86 @@
+/*
+ * Copyright 2024 The Bazel Authors. All rights reserved.
+ *
+ * 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
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * 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.
+ */
+package com.google.idea.blaze.qsync.artifacts;
+
+import com.google.auto.value.AutoValue;
+import com.google.common.base.Preconditions;
+import com.google.common.io.ByteSource;
+import com.google.common.util.concurrent.Uninterruptibles;
+import com.google.idea.blaze.common.Label;
+import com.google.idea.blaze.common.artifact.BuildArtifactCache;
+import com.google.idea.blaze.exception.BuildException;
+import java.nio.file.Path;
+import java.util.concurrent.ExecutionException;
+import java.util.function.Function;
+
+/**
+ * An artifact produced by a build.
+ *
+ * <p>This includes the digest of the artifact as indicated by bazel, it's output path and the
+ * target that produced it.
+ *
+ * <p>Note, for the old {@link com.google.idea.blaze.base.qsync.cache.ArtifactTrackerImpl} codepaths
+ * the digest will not be populated.
+ */
+@AutoValue
+public abstract class BuildArtifact {
+
+  /**
+   * Special case to support legacy codepaths that don't use digests in here
+   *
+   * <p>TODO(b/323346056) remove this when the old codepaths are deleted.
+   */
+  public static final Function<Path, String> NO_DIGESTS = p -> "";
+
+  public abstract String digest();
+
+  public abstract Path path();
+
+  public abstract Label target();
+
+  public static BuildArtifact create(String digest, Path path, Label target) {
+    return new AutoValue_BuildArtifact(digest, path, target);
+  }
+
+  public static BuildArtifact create(Path path, Label target, Function<Path, String> digestMap) {
+    String digest =
+        Preconditions.checkNotNull(digestMap.apply(path), "No digest for %s from %s", path, target);
+    if (digestMap != NO_DIGESTS) {
+      Preconditions.checkState(!digest.isEmpty(), "Empty digest for %s from %s", path, target);
+    }
+    return create(digest, path, target);
+  }
+
+  public ByteSource blockingGetFrom(BuildArtifactCache cache) throws BuildException {
+    try {
+      return Uninterruptibles.getUninterruptibly(
+          cache
+              .get(digest())
+              .orElseThrow(() -> new BuildException("Artifact %s missing from the cache" + this)));
+    } catch (ExecutionException e) {
+      throw new BuildException("Failed to get artifact " + this, e);
+    }
+  }
+
+  public String getExtension() {
+    String fileName = path().getFileName().toString();
+    int lastDot = fileName.lastIndexOf('.');
+    if (lastDot == -1) {
+      return "";
+    }
+    return fileName.substring(lastDot + 1);
+  }
+}
diff --git a/querysync/java/com/google/idea/blaze/qsync/deps/ArtifactTrackerStateDeserializer.java b/querysync/java/com/google/idea/blaze/qsync/deps/ArtifactTrackerStateDeserializer.java
new file mode 100644
index 00000000000..4c25b846761
--- /dev/null
+++ b/querysync/java/com/google/idea/blaze/qsync/deps/ArtifactTrackerStateDeserializer.java
@@ -0,0 +1,100 @@
+/*
+ * Copyright 2024 The Bazel Authors. All rights reserved.
+ *
+ * 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
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * 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.
+ */
+package com.google.idea.blaze.qsync.deps;
+
+import static com.google.common.collect.ImmutableList.toImmutableList;
+import static com.google.common.collect.ImmutableSet.toImmutableSet;
+
+import com.google.common.base.Preconditions;
+import com.google.common.collect.ImmutableList;
+import com.google.common.collect.ImmutableMap;
+import com.google.common.collect.Maps;
+import com.google.idea.blaze.common.Label;
+import com.google.idea.blaze.common.vcs.VcsState;
+import com.google.idea.blaze.qsync.artifacts.BuildArtifact;
+import com.google.idea.blaze.qsync.java.ArtifactTrackerProto;
+import com.google.idea.blaze.qsync.java.JavaArtifactInfo;
+import com.google.idea.blaze.qsync.java.cc.CcCompilationInfoOuterClass.CcToolchainInfo;
+import com.google.idea.blaze.qsync.project.SnapshotDeserializer;
+import java.nio.file.Path;
+import java.time.Instant;
+import java.util.List;
+import java.util.Map;
+import java.util.Optional;
+
+/** Deserializes {@link NewArtifactTracker} state from a proto. */
+public class ArtifactTrackerStateDeserializer {
+
+  private final ImmutableMap.Builder<Label, TargetBuildInfo> map = ImmutableMap.builder();
+  private final Map<String, DependencyBuildContext> buildContexts = Maps.newHashMap();
+  private final ImmutableMap.Builder<String, CcToolchainInfo> ccToolchainMap =
+      ImmutableMap.builder();
+
+  public void visit(ArtifactTrackerProto.ArtifactTrackerState proto) {
+    proto.getBuildContextsList().forEach(this::visitBuildContext);
+    proto.getBuiltDepsMap().entrySet().forEach(this::visitTargetBuildInfo);
+  }
+
+  public ImmutableMap<Label, TargetBuildInfo> getBuiltDepsMap() {
+    return map.buildOrThrow();
+  }
+
+  private void visitBuildContext(ArtifactTrackerProto.BuildContext buildContext) {
+    Optional<VcsState> vcsState = Optional.empty();
+    if (buildContext.hasVcsState()) {
+      vcsState = Optional.of(SnapshotDeserializer.convertVcsState(buildContext.getVcsState()));
+    }
+    buildContexts.put(
+        buildContext.getBuildId(),
+        DependencyBuildContext.create(
+            buildContext.getBuildId(),
+            Instant.ofEpochMilli(buildContext.getStartTimeMillis()),
+            vcsState));
+  }
+
+  private void visitTargetBuildInfo(Map.Entry<String, ArtifactTrackerProto.TargetBuildInfo> entry) {
+    ArtifactTrackerProto.TargetBuildInfo proto = entry.getValue();
+    DependencyBuildContext buildContext =
+        Preconditions.checkNotNull(buildContexts.get(proto.getBuildId()));
+    Label owner = Label.of(entry.getKey());
+    if (proto.hasJavaArtifacts()) {
+      map.put(
+          owner,
+          TargetBuildInfo.forJavaTarget(
+              convertJavaArtifactInfo(owner, proto.getJavaArtifacts()), buildContext));
+    }
+  }
+
+  private JavaArtifactInfo convertJavaArtifactInfo(
+      Label owner, ArtifactTrackerProto.JavaArtifacts proto) {
+    return JavaArtifactInfo.builder()
+        .setLabel(owner)
+        .setJars(toArtifactList(proto.getJarsList(), owner))
+        .setIdeAars(toArtifactList(proto.getIdeAarsList(), owner))
+        .setGenSrcs(toArtifactList(proto.getGenSrcsList(), owner))
+        .setSources(proto.getSourcesList().stream().map(Path::of).collect(toImmutableSet()))
+        .setSrcJars(proto.getSrcJarsList().stream().map(Path::of).collect(toImmutableSet()))
+        .setAndroidResourcesPackage(proto.getAndroidResourcesPackage())
+        .build();
+  }
+
+  private ImmutableList<BuildArtifact> toArtifactList(
+      List<ArtifactTrackerProto.Artifact> protos, Label owner) {
+    return protos.stream()
+        .map(a -> BuildArtifact.create(a.getDigest(), Path.of(a.getPath()), owner))
+        .collect(toImmutableList());
+  }
+}
diff --git a/querysync/java/com/google/idea/blaze/qsync/deps/ArtifactTrackerStateSerializer.java b/querysync/java/com/google/idea/blaze/qsync/deps/ArtifactTrackerStateSerializer.java
new file mode 100644
index 00000000000..4969900c024
--- /dev/null
+++ b/querysync/java/com/google/idea/blaze/qsync/deps/ArtifactTrackerStateSerializer.java
@@ -0,0 +1,99 @@
+/*
+ * Copyright 2024 The Bazel Authors. All rights reserved.
+ *
+ * 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
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * 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.
+ */
+package com.google.idea.blaze.qsync.deps;
+
+import static com.google.common.collect.ImmutableList.toImmutableList;
+
+import com.google.common.collect.ImmutableList;
+import com.google.common.collect.Sets;
+import com.google.errorprone.annotations.CanIgnoreReturnValue;
+import com.google.idea.blaze.common.Label;
+import com.google.idea.blaze.qsync.artifacts.BuildArtifact;
+import com.google.idea.blaze.qsync.java.ArtifactTrackerProto;
+import com.google.idea.blaze.qsync.java.ArtifactTrackerProto.Artifact;
+import com.google.idea.blaze.qsync.java.ArtifactTrackerProto.ArtifactTrackerState;
+import com.google.idea.blaze.qsync.java.ArtifactTrackerProto.BuildContext;
+import com.google.idea.blaze.qsync.java.JavaArtifactInfo;
+import com.google.idea.blaze.qsync.project.SnapshotSerializer;
+import java.nio.file.Path;
+import java.util.Map;
+import java.util.Set;
+
+/** Serializes {@link NewArtifactTracker} state to a proto. */
+public class ArtifactTrackerStateSerializer {
+
+  public static final int VERSION = 1;
+
+  private final ArtifactTrackerProto.ArtifactTrackerState.Builder proto =
+      ArtifactTrackerProto.ArtifactTrackerState.newBuilder().setVersion(VERSION);
+  private final Set<String> buildIdsSeen = Sets.newHashSet();
+
+  @CanIgnoreReturnValue
+  public ArtifactTrackerStateSerializer visitDepsMap(Map<Label, TargetBuildInfo> builtDeps) {
+    builtDeps.entrySet().forEach(e -> visitTargetBuildInfo(e.getKey(), e.getValue()));
+    return this;
+  }
+
+  public ArtifactTrackerState toProto() {
+    return proto.build();
+  }
+
+  private void visitTargetBuildInfo(Label target, TargetBuildInfo targetBuildInfo) {
+    visitBuildContext(targetBuildInfo.buildContext());
+
+    ArtifactTrackerProto.TargetBuildInfo.Builder builder =
+        ArtifactTrackerProto.TargetBuildInfo.newBuilder();
+    builder.setBuildId(targetBuildInfo.buildContext().buildId());
+    targetBuildInfo.javaInfo().ifPresent(ji -> visitJavaInfo(ji, builder));
+    proto.putBuiltDeps(target.toString(), builder.build());
+  }
+
+  private void visitBuildContext(DependencyBuildContext buildContext) {
+    if (buildIdsSeen.add(buildContext.buildId())) {
+      BuildContext.Builder builder =
+          proto
+              .addBuildContextsBuilder()
+              .setStartTimeMillis(buildContext.startTime().toEpochMilli())
+              .setBuildId(buildContext.buildId());
+      buildContext
+          .vcsState()
+          .ifPresent(vcs -> SnapshotSerializer.visitVcsState(vcs, builder.getVcsStateBuilder()));
+    }
+  }
+
+  private void visitJavaInfo(
+      JavaArtifactInfo javaInfo, ArtifactTrackerProto.TargetBuildInfo.Builder builder) {
+    builder
+        .getJavaArtifactsBuilder()
+        .addAllGenSrcs(toProtos(javaInfo.genSrcs()))
+        .addAllIdeAars(toProtos(javaInfo.ideAars()))
+        .addAllJars(toProtos(javaInfo.jars()))
+        .addAllSources(javaInfo.sources().stream().map(Path::toString).collect(toImmutableList()))
+        .addAllSrcJars(javaInfo.srcJars().stream().map(Path::toString).collect(toImmutableList()))
+        .setAndroidResourcesPackage(javaInfo.androidResourcesPackage());
+  }
+
+  private ImmutableList<Artifact> toProtos(ImmutableList<BuildArtifact> artifacts) {
+    return artifacts.stream()
+        .map(
+            artifact ->
+                ArtifactTrackerProto.Artifact.newBuilder()
+                    .setDigest(artifact.digest())
+                    .setPath(artifact.path().toString())
+                    .build())
+        .collect(toImmutableList());
+  }
+}
diff --git a/querysync/java/com/google/idea/blaze/qsync/deps/BUILD b/querysync/java/com/google/idea/blaze/qsync/deps/BUILD
index d705d0f19f7..4d75034fd68 100644
--- a/querysync/java/com/google/idea/blaze/qsync/deps/BUILD
+++ b/querysync/java/com/google/idea/blaze/qsync/deps/BUILD
@@ -6,12 +6,36 @@ java_library(
         "//querysync:__subpackages__",
     ],
     deps = [
+        ":artifact_tracker_state_java_proto",
+        "//querysync/java/com/google/idea/blaze/qsync",
+        "//querysync/java/com/google/idea/blaze/qsync/artifacts",
         "//querysync/java/com/google/idea/blaze/qsync/cc:cc_compilation_info_java_proto",
+        "//querysync/java/com/google/idea/blaze/qsync/java",
         "//querysync/java/com/google/idea/blaze/qsync/java:java_target_info_java_proto",
+        "//querysync/java/com/google/idea/blaze/qsync/project",
+        "//querysync/java/com/google/idea/blaze/qsync/project:project_java_proto",
         "//shared",
         "//shared:artifact",
+        "//shared:proto",
         "//shared:vcs",
         "//third_party/auto_value",
         "@com_google_guava_guava//jar",
+        "@jsr305_annotations//jar",
     ],
 )
+
+proto_library(
+    name = "artifact_tracker_state_proto",
+    srcs = ["artifact_tracker_state.proto"],
+    deps = [
+        "//querysync/java/com/google/idea/blaze/qsync/project:snapshot_proto",
+    ],
+)
+
+java_proto_library(
+    name = "artifact_tracker_state_java_proto",
+    visibility = [
+        "//querysync:__subpackages__",
+    ],
+    deps = [":artifact_tracker_state_proto"],
+)
diff --git a/querysync/java/com/google/idea/blaze/qsync/deps/NewArtifactTracker.java b/querysync/java/com/google/idea/blaze/qsync/deps/NewArtifactTracker.java
index 07641d24155..23b04874648 100644
--- a/querysync/java/com/google/idea/blaze/qsync/deps/NewArtifactTracker.java
+++ b/querysync/java/com/google/idea/blaze/qsync/deps/NewArtifactTracker.java
@@ -15,31 +15,112 @@
  */
 package com.google.idea.blaze.qsync.deps;
 
+import static com.google.common.collect.ImmutableMap.toImmutableMap;
+
+import com.google.common.collect.ImmutableCollection;
 import com.google.common.collect.ImmutableList;
+import com.google.common.collect.ImmutableMap;
 import com.google.common.collect.ImmutableSet;
+import com.google.common.collect.Maps;
+import com.google.common.util.concurrent.FutureCallback;
+import com.google.common.util.concurrent.Futures;
+import com.google.common.util.concurrent.ListenableFuture;
+import com.google.common.util.concurrent.ListeningExecutorService;
+import com.google.common.util.concurrent.Uninterruptibles;
 import com.google.idea.blaze.common.Context;
 import com.google.idea.blaze.common.Label;
+import com.google.idea.blaze.common.artifact.BuildArtifactCache;
+import com.google.idea.blaze.common.artifact.OutputArtifact;
+import com.google.idea.blaze.common.proto.ProtoStringInterner;
 import com.google.idea.blaze.exception.BuildException;
+import com.google.idea.blaze.qsync.java.ArtifactTrackerProto;
+import com.google.idea.blaze.qsync.java.JavaArtifactInfo;
+import com.google.idea.blaze.qsync.java.JavaTargetInfo.JavaArtifacts;
+import com.google.idea.blaze.qsync.java.JavaTargetInfo.JavaTargetArtifacts;
 import java.io.IOException;
+import java.io.InputStream;
+import java.io.OutputStream;
+import java.nio.file.Files;
 import java.nio.file.Path;
+import java.util.Map;
 import java.util.Optional;
 import java.util.Set;
+import java.util.concurrent.ExecutionException;
+import java.util.logging.Level;
+import java.util.logging.Logger;
+import java.util.zip.GZIPInputStream;
+import java.util.zip.GZIPOutputStream;
 
 /** Placeholder for the new artifact tracker logic. */
 public class NewArtifactTracker<C extends Context<C>> implements ArtifactTracker<C> {
 
-  public NewArtifactTracker() {
-    // TODO(b/323346056) Implement this.
+  private static final Logger logger = Logger.getLogger(NewArtifactTracker.class.getName());
+
+  private final BuildArtifactCache artifactCache;
+  private final Object lock = new Object();
+  private final Map<Label, TargetBuildInfo> builtDeps = Maps.newConcurrentMap();
+  private final Path stateFile;
+  private final ListeningExecutorService executor;
+
+  public NewArtifactTracker(
+      Path projectDirectory,
+      BuildArtifactCache artifactCache,
+      ListeningExecutorService executorService) {
+    this.artifactCache = artifactCache;
+    this.stateFile = projectDirectory.resolve("artifact_state");
+    this.executor = executorService;
+    loadState();
+  }
+
+  public ImmutableCollection<TargetBuildInfo> getBuiltDeps() {
+    return ImmutableList.copyOf(builtDeps.values());
   }
 
   @Override
   public void clear() throws IOException {
-    // TODO(b/323346056) Implement this.
+    // TODO(b/323346056) the caller also expects the artifacts that the IDE consumes to be cleared
+    //   but we don't own those here.
+    builtDeps.clear();
+    saveStateAsync();
   }
 
   @Override
   public void update(Set<Label> targets, OutputInfo outputInfo, C context) throws BuildException {
-    // TODO(b/323346056) Implement this.
+    ListenableFuture<?> artifactsCached =
+        artifactCache.addAll(outputInfo.getOutputGroups().values(), context);
+
+    ImmutableMap<Path, String> digestMap =
+        outputInfo.getOutputGroups().values().stream()
+            .collect(toImmutableMap(a -> Path.of(a.getRelativePath()), OutputArtifact::getDigest));
+
+    synchronized (lock) {
+      for (JavaArtifacts javaArtifacts : outputInfo.getArtifactInfo()) {
+        for (JavaTargetArtifacts javaTarget : javaArtifacts.getArtifactsList()) {
+          JavaArtifactInfo artifactInfo = JavaArtifactInfo.create(javaTarget, digestMap::get);
+          TargetBuildInfo targetInfo =
+              TargetBuildInfo.forJavaTarget(artifactInfo, outputInfo.getBuildContext());
+          builtDeps.put(artifactInfo.label(), targetInfo);
+        }
+      }
+
+      for (Label label : targets) {
+        if (!builtDeps.containsKey(label)) {
+          logger.warning(
+              "Target " + label + " was not built. If the target is an alias, this is expected");
+          builtDeps.put(
+              label,
+              TargetBuildInfo.forJavaTarget(
+                  JavaArtifactInfo.empty(label), outputInfo.getBuildContext()));
+        }
+      }
+    }
+    saveStateAsync();
+
+    try {
+      Object unused = Uninterruptibles.getUninterruptibly(artifactsCached);
+    } catch (ExecutionException e) {
+      throw new BuildException("Failed to cache build artifacts", e);
+    }
   }
 
   @Override
@@ -56,8 +137,7 @@ public ImmutableSet<Path> getTargetSources(Path cachedArtifact) {
 
   @Override
   public Set<Label> getLiveCachedTargets() {
-    // TODO(b/323346056) Implement this.
-    return ImmutableSet.of();
+    return builtDeps.keySet();
   }
 
   @Override
@@ -68,6 +148,7 @@ public Path getExternalAarDirectory() {
 
   @Override
   public Integer getJarsCount() {
+    // TODO(b/323346056) figure out where this functionality should live now.
     return 0;
   }
 
@@ -75,4 +156,51 @@ public Integer getJarsCount() {
   public Iterable<Path> getBugreportFiles() {
     return ImmutableList.of();
   }
+
+  private void saveStateAsync() {
+    ListenableFuture<?> save = executor.submit(this::saveState);
+    Futures.addCallback(
+        save,
+        new FutureCallback<Object>() {
+          @Override
+          public void onSuccess(Object result) {}
+
+          @Override
+          public void onFailure(Throwable t) {
+            logger.log(Level.WARNING, "Artifact track state save failed", t);
+          }
+        },
+        executor);
+  }
+
+  private void saveState() {
+    ArtifactTrackerStateSerializer serializer;
+    synchronized (lock) {
+      serializer = new ArtifactTrackerStateSerializer().visitDepsMap(builtDeps);
+    }
+    try (OutputStream stream = new GZIPOutputStream(Files.newOutputStream(stateFile))) {
+      serializer.toProto().writeTo(stream);
+    } catch (IOException e) {
+      logger.log(Level.WARNING, "Failed to save artifact fetcher state", e);
+    }
+  }
+
+  private void loadState() {
+    if (Files.exists(stateFile)) {
+      return;
+    }
+    ArtifactTrackerProto.ArtifactTrackerState state;
+    try (InputStream stream = new GZIPInputStream(Files.newInputStream(stateFile))) {
+      state =
+          ProtoStringInterner.intern(ArtifactTrackerProto.ArtifactTrackerState.parseFrom(stream));
+    } catch (IOException e) {
+      logger.log(Level.WARNING, "Failed to read artifact tracker state from " + stateFile, e);
+      return;
+    }
+
+    ArtifactTrackerStateDeserializer deserializer = new ArtifactTrackerStateDeserializer();
+    deserializer.visit(state);
+
+    builtDeps.putAll(deserializer.getBuiltDepsMap());
+  }
 }
diff --git a/querysync/java/com/google/idea/blaze/qsync/deps/TargetBuildInfo.java b/querysync/java/com/google/idea/blaze/qsync/deps/TargetBuildInfo.java
new file mode 100644
index 00000000000..f23cb013905
--- /dev/null
+++ b/querysync/java/com/google/idea/blaze/qsync/deps/TargetBuildInfo.java
@@ -0,0 +1,34 @@
+/*
+ * Copyright 2024 The Bazel Authors. All rights reserved.
+ *
+ * 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
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * 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.
+ */
+package com.google.idea.blaze.qsync.deps;
+
+import com.google.auto.value.AutoValue;
+import com.google.idea.blaze.qsync.java.JavaArtifactInfo;
+import java.util.Optional;
+
+@AutoValue
+abstract class TargetBuildInfo {
+  abstract Optional<JavaArtifactInfo> javaInfo();
+
+  // TODO(b/323346056) Add cc info here.
+
+  abstract DependencyBuildContext buildContext();
+
+  static TargetBuildInfo forJavaTarget(
+      JavaArtifactInfo javaInfo, DependencyBuildContext buildContext) {
+    return new AutoValue_TargetBuildInfo(Optional.of(javaInfo), buildContext);
+  }
+}
diff --git a/querysync/java/com/google/idea/blaze/qsync/deps/artifact_tracker_state.proto b/querysync/java/com/google/idea/blaze/qsync/deps/artifact_tracker_state.proto
new file mode 100644
index 00000000000..e0af3553231
--- /dev/null
+++ b/querysync/java/com/google/idea/blaze/qsync/deps/artifact_tracker_state.proto
@@ -0,0 +1,54 @@
+// Copyright 2024 The Bazel Authors. All rights reserved.
+//
+// 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
+//
+//    http://www.apache.org/licenses/LICENSE-2.0
+//
+// 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.
+
+syntax = "proto3";
+
+package ij.qsync.deps;
+
+import "querysync/java/com/google/idea/blaze/qsync/project/snapshot.proto";
+
+// option java_api_version = 2;
+option java_package = "com.google.idea.blaze.qsync.java";
+option java_outer_classname = "ArtifactTrackerProto";
+
+message ArtifactTrackerState {
+  int32 version = 1;
+  map<string, TargetBuildInfo> built_deps = 2;
+  repeated BuildContext build_contexts = 3;
+}
+
+message TargetBuildInfo {
+  string build_id = 1;
+  JavaArtifacts java_artifacts = 2;
+}
+
+message Artifact {
+  string digest = 1;
+  string path = 2;
+}
+
+message JavaArtifacts {
+  repeated Artifact jars = 1;
+  repeated Artifact ide_aars = 2;
+  repeated Artifact gen_srcs = 3;
+  repeated string sources = 4;
+  repeated string src_jars = 5;
+  string android_resources_package = 6;
+}
+
+message BuildContext {
+  string build_id = 1;
+  int64 start_time_millis = 2;
+  VcsState vcs_state = 3;
+}
diff --git a/querysync/java/com/google/idea/blaze/qsync/java/BUILD b/querysync/java/com/google/idea/blaze/qsync/java/BUILD
index d34e86990e3..309d1934eb4 100644
--- a/querysync/java/com/google/idea/blaze/qsync/java/BUILD
+++ b/querysync/java/com/google/idea/blaze/qsync/java/BUILD
@@ -21,6 +21,7 @@ java_library(
     srcs = glob(["*.java"]),
     deps = [
         ":java_target_info_java_proto",
+        "//querysync/java/com/google/idea/blaze/qsync/artifacts",
         "//querysync/java/com/google/idea/blaze/qsync/project",
         "//querysync/java/com/google/idea/blaze/qsync/project:project_java_proto",
         "//shared",
diff --git a/querysync/java/com/google/idea/blaze/qsync/java/JavaArtifactInfo.java b/querysync/java/com/google/idea/blaze/qsync/java/JavaArtifactInfo.java
index 2a1388ef6cc..b0307dc8193 100644
--- a/querysync/java/com/google/idea/blaze/qsync/java/JavaArtifactInfo.java
+++ b/querysync/java/com/google/idea/blaze/qsync/java/JavaArtifactInfo.java
@@ -24,8 +24,12 @@
 import com.google.common.collect.Streams;
 import com.google.idea.blaze.common.Interners;
 import com.google.idea.blaze.common.Label;
+import com.google.idea.blaze.qsync.artifacts.BuildArtifact;
 import com.google.idea.blaze.qsync.java.JavaTargetInfo.JavaTargetArtifacts;
 import java.nio.file.Path;
+import java.util.List;
+import java.util.function.Function;
+import java.util.function.Predicate;
 import java.util.stream.Stream;
 
 /** Information about a project dependency that is calculated when the dependency is built. */
@@ -39,19 +43,19 @@ public abstract class JavaArtifactInfo {
    * The jar artifacts relative path (blaze-out/xxx) that can be used to retrieve local copy in the
    * cache.
    */
-  public abstract ImmutableList<Path> jars();
+  public abstract ImmutableList<BuildArtifact> jars();
 
   /**
    * The aar artifacts relative path (blaze-out/xxx) that can be used to retrieve local copy in the
    * cache.
    */
-  public abstract ImmutableList<Path> ideAars();
+  public abstract ImmutableList<BuildArtifact> ideAars();
 
   /**
    * The gensrc artifacts relative path (blaze-out/xxx) that can be used to retrieve local copy in
    * the cache.
    */
-  public abstract ImmutableList<Path> genSrcs();
+  public abstract ImmutableList<BuildArtifact> genSrcs();
 
   /** Workspace relative sources for this dependency, extracted at dependency build time. */
   public abstract ImmutableSet<Path> sources();
@@ -60,48 +64,87 @@ public abstract class JavaArtifactInfo {
 
   public abstract String androidResourcesPackage();
 
-  public static JavaArtifactInfo create(JavaTargetArtifacts proto) {
+  public static Builder builder() {
+    return new AutoValue_JavaArtifactInfo.Builder();
+  }
+
+  public static JavaArtifactInfo create(
+      JavaTargetArtifacts proto, Function<Path, String> digestMap) {
     // Note, the proto contains a list of sources, we take the parent as we want directories instead
-    return new AutoValue_JavaArtifactInfo(
-        Label.of(proto.getTarget()),
-        proto.getJarsList().stream().map(Interners::pathOf).collect(toImmutableList()),
-        proto.getIdeAarsList().stream().map(Interners::pathOf).collect(toImmutableList()),
-        proto.getGenSrcsList().stream().map(Interners::pathOf).collect(toImmutableList()),
-        proto.getSrcsList().stream().map(Interners::pathOf).collect(toImmutableSet()),
-        proto.getSrcjarsList().stream().map(Interners::pathOf).collect(toImmutableSet()),
-        proto.getAndroidResourcesPackage());
+    Label target = Label.of(proto.getTarget());
+    return builder()
+        .setLabel(target)
+        .setJars(toArtifacts(proto.getJarsList(), digestMap, target))
+        .setIdeAars(toArtifacts(proto.getIdeAarsList(), digestMap, target))
+        .setGenSrcs(toArtifacts(proto.getGenSrcsList(), digestMap, target))
+        .setSources(proto.getSrcsList().stream().map(Interners::pathOf).collect(toImmutableSet()))
+        .setSrcJars(
+            proto.getSrcjarsList().stream().map(Interners::pathOf).collect(toImmutableSet()))
+        .setAndroidResourcesPackage(proto.getAndroidResourcesPackage())
+        .build();
+  }
+
+  private static ImmutableList<BuildArtifact> toArtifacts(
+      List<String> paths, Function<Path, String> digestMap, Label target) {
+    return paths.stream()
+        .map(Interners::pathOf)
+        .map(p -> BuildArtifact.create(p, target, digestMap))
+        .collect(toImmutableList());
   }
 
   public JavaTargetArtifacts toProto() {
     return JavaTargetArtifacts.newBuilder()
         .setTarget(label().toString())
-        .addAllJars(jars().stream().map(Path::toString).collect(toImmutableList()))
-        .addAllIdeAars(ideAars().stream().map(Path::toString).collect(toImmutableList()))
-        .addAllGenSrcs(genSrcs().stream().map(Path::toString).collect(toImmutableList()))
+        .addAllJars(toPathStrings(jars()))
+        .addAllIdeAars(toPathStrings(ideAars()))
+        .addAllGenSrcs(toPathStrings(genSrcs()))
         .addAllSrcs(sources().stream().map(Path::toString).collect(toImmutableList()))
         .addAllSrcjars(srcJars().stream().map(Path::toString).collect(toImmutableList()))
         .setAndroidResourcesPackage(androidResourcesPackage())
         .build();
   }
 
+  private static ImmutableList<String> toPathStrings(ImmutableList<BuildArtifact> artifacts) {
+    return artifacts.stream()
+        .map(BuildArtifact::path)
+        .map(Path::toString)
+        .collect(toImmutableList());
+  }
+
   public final boolean containsPath(Path artifactPath) {
-    return jars().contains(artifactPath)
-        || ideAars().contains(artifactPath)
-        || genSrcs().contains(artifactPath);
+    Predicate<BuildArtifact> pathMatch = a -> a.path().equals(artifactPath);
+    return jars().stream().anyMatch(pathMatch)
+        || ideAars().stream().anyMatch(pathMatch)
+        || genSrcs().stream().anyMatch(pathMatch);
   }
 
   public final Stream<Path> artifactStream() {
-    return Streams.concat(jars().stream(), ideAars().stream(), genSrcs().stream());
+    return Streams.concat(jars().stream(), ideAars().stream(), genSrcs().stream())
+        .map(BuildArtifact::path);
   }
 
   public static JavaArtifactInfo empty(Label target) {
-    return new AutoValue_JavaArtifactInfo(
-        target,
-        ImmutableList.of(),
-        ImmutableList.of(),
-        ImmutableList.of(),
-        ImmutableSet.of(),
-        ImmutableSet.of(),
-        "");
+    return builder().setLabel(target).setAndroidResourcesPackage("").build();
+  }
+
+  /** Builder for {@link JavaArtifactInfo}. */
+  @AutoValue.Builder
+  public abstract static class Builder {
+
+    public abstract Builder setLabel(Label value);
+
+    public abstract Builder setJars(ImmutableList<BuildArtifact> value);
+
+    public abstract Builder setIdeAars(ImmutableList<BuildArtifact> value);
+
+    public abstract Builder setGenSrcs(ImmutableList<BuildArtifact> value);
+
+    public abstract Builder setSources(ImmutableSet<Path> value);
+
+    public abstract Builder setSrcJars(ImmutableSet<Path> value);
+
+    public abstract Builder setAndroidResourcesPackage(String value);
+
+    public abstract JavaArtifactInfo build();
   }
 }
diff --git a/querysync/java/com/google/idea/blaze/qsync/project/SnapshotDeserializer.java b/querysync/java/com/google/idea/blaze/qsync/project/SnapshotDeserializer.java
index 6a9b3a3c2cf..e81c6e0a1bb 100644
--- a/querysync/java/com/google/idea/blaze/qsync/project/SnapshotDeserializer.java
+++ b/querysync/java/com/google/idea/blaze/qsync/project/SnapshotDeserializer.java
@@ -75,20 +75,22 @@ private void visitProjectDefinition(SnapshotProto.ProjectDefinition proto) {
   }
 
   private void visitVcsState(SnapshotProto.VcsState proto) {
-    VcsState state =
-        new VcsState(
-            proto.getWorkspaceId(),
-            proto.getUpstreamRevision(),
-            proto.getWorkingSetList().stream()
-                .map(
-                    c ->
-                        new WorkspaceFileChange(
-                            OP_MAP.get(c.getOperation()), Path.of(c.getWorkspaceRelativePath())))
-                .collect(toImmutableSet()),
-            proto.hasWorkspaceSnapshot()
-                ? Optional.of(Path.of(proto.getWorkspaceSnapshot().getPath()))
-                : Optional.empty());
-    snapshot.setVcsState(Optional.of(state));
+    snapshot.setVcsState(Optional.of(convertVcsState(proto)));
+  }
+
+  public static VcsState convertVcsState(SnapshotProto.VcsState proto) {
+    return new VcsState(
+        proto.getWorkspaceId(),
+        proto.getUpstreamRevision(),
+        proto.getWorkingSetList().stream()
+            .map(
+                c ->
+                    new WorkspaceFileChange(
+                        OP_MAP.get(c.getOperation()), Path.of(c.getWorkspaceRelativePath())))
+            .collect(toImmutableSet()),
+        proto.hasWorkspaceSnapshot()
+            ? Optional.of(Path.of(proto.getWorkspaceSnapshot().getPath()))
+            : Optional.empty());
   }
 
   private void visitQuerySummay(Query.Summary proto) {
diff --git a/querysync/java/com/google/idea/blaze/qsync/project/SnapshotSerializer.java b/querysync/java/com/google/idea/blaze/qsync/project/SnapshotSerializer.java
index 872761fd736..235b079fabb 100644
--- a/querysync/java/com/google/idea/blaze/qsync/project/SnapshotSerializer.java
+++ b/querysync/java/com/google/idea/blaze/qsync/project/SnapshotSerializer.java
@@ -75,7 +75,10 @@ private void visitProjectDefinition(ProjectDefinition projectDefinition) {
   }
 
   private void visitVcsState(VcsState vcsState) {
-    SnapshotProto.VcsState.Builder vcsProto = proto.getVcsStateBuilder();
+    visitVcsState(vcsState, proto.getVcsStateBuilder());
+  }
+
+  public static void visitVcsState(VcsState vcsState, SnapshotProto.VcsState.Builder vcsProto) {
     vcsProto.setWorkspaceId(vcsState.workspaceId).setUpstreamRevision(vcsState.upstreamRevision);
     for (WorkspaceFileChange change : vcsState.workingSet) {
       vcsProto.addWorkingSet(
diff --git a/querysync/javatests/com/google/idea/blaze/qsync/deps/ArtifactTrackerStateSerializationTest.java b/querysync/javatests/com/google/idea/blaze/qsync/deps/ArtifactTrackerStateSerializationTest.java
new file mode 100644
index 00000000000..d2627feb3fc
--- /dev/null
+++ b/querysync/javatests/com/google/idea/blaze/qsync/deps/ArtifactTrackerStateSerializationTest.java
@@ -0,0 +1,91 @@
+/*
+ * Copyright 2024 The Bazel Authors. All rights reserved.
+ *
+ * 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
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * 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.
+ */
+package com.google.idea.blaze.qsync.deps;
+
+import static com.google.common.truth.Truth.assertThat;
+
+import com.google.common.collect.ImmutableList;
+import com.google.common.collect.ImmutableMap;
+import com.google.common.collect.ImmutableSet;
+import com.google.idea.blaze.common.Label;
+import com.google.idea.blaze.common.vcs.VcsState;
+import com.google.idea.blaze.qsync.artifacts.BuildArtifact;
+import com.google.idea.blaze.qsync.java.ArtifactTrackerProto.ArtifactTrackerState;
+import com.google.idea.blaze.qsync.java.JavaArtifactInfo;
+import java.nio.file.Path;
+import java.time.Instant;
+import java.util.Map;
+import java.util.Optional;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+@RunWith(JUnit4.class)
+public class ArtifactTrackerStateSerializationTest {
+
+  private Map<Label, TargetBuildInfo> roundTrip(Map<Label, TargetBuildInfo> depsMap) {
+    ArtifactTrackerState proto =
+        new ArtifactTrackerStateSerializer().visitDepsMap(depsMap).toProto();
+    ArtifactTrackerStateDeserializer deserializer = new ArtifactTrackerStateDeserializer();
+    deserializer.visit(proto);
+    return deserializer.getBuiltDepsMap();
+  }
+
+  @Test
+  public void test_empty() {
+    ImmutableMap<Label, TargetBuildInfo> depsMap = ImmutableMap.of();
+    assertThat(roundTrip(depsMap)).containsExactlyEntriesIn(depsMap);
+  }
+
+  @Test
+  public void test_java_info() {
+    DependencyBuildContext buildContext =
+        DependencyBuildContext.create(
+            "abc-def",
+            Instant.ofEpochMilli(1000),
+            Optional.of(new VcsState("workspaceId", "12345", ImmutableSet.of(), Optional.empty())));
+    ImmutableMap<Label, TargetBuildInfo> depsMap =
+        ImmutableMap.of(
+            Label.of("//my/package:target"),
+            TargetBuildInfo.forJavaTarget(
+                JavaArtifactInfo.builder()
+                    .setLabel(Label.of("//my/package:target"))
+                    .setJars(
+                        ImmutableList.of(
+                            BuildArtifact.create(
+                                "jardigest",
+                                Path.of("/build/out/classes.jar"),
+                                Label.of("//my/package:target"))))
+                    .setIdeAars(
+                        ImmutableList.of(
+                            BuildArtifact.create(
+                                "aardigest",
+                                Path.of("/build/out/resources.aar"),
+                                Label.of("//my/package:target"))))
+                    .setGenSrcs(
+                        ImmutableList.of(
+                            BuildArtifact.create(
+                                "gensrcdigest",
+                                Path.of("/build/out/Generated.java"),
+                                Label.of("//my/package:target"))))
+                    .setSources(ImmutableSet.of(Path.of("/workspace/path/Source.java")))
+                    .setSrcJars(ImmutableSet.of(Path.of("/workspace/path/sources.srcjar")))
+                    .setAndroidResourcesPackage("com.my.package")
+                    .build(),
+                buildContext));
+    assertThat(roundTrip(depsMap)).containsExactlyEntriesIn(depsMap);
+  }
+}
diff --git a/querysync/javatests/com/google/idea/blaze/qsync/deps/BUILD b/querysync/javatests/com/google/idea/blaze/qsync/deps/BUILD
new file mode 100644
index 00000000000..e828bada5c1
--- /dev/null
+++ b/querysync/javatests/com/google/idea/blaze/qsync/deps/BUILD
@@ -0,0 +1,20 @@
+load("//:build-visibility.bzl", "DEFAULT_TEST_VISIBILITY")
+
+package(default_visibility = DEFAULT_TEST_VISIBILITY)
+
+java_test(
+    name = "ArtifactTrackerStateSerializationTest",
+    size = "small",
+    srcs = ["ArtifactTrackerStateSerializationTest.java"],
+    deps = [
+        "//querysync/java/com/google/idea/blaze/qsync/artifacts",
+        "//querysync/java/com/google/idea/blaze/qsync/deps",
+        "//querysync/java/com/google/idea/blaze/qsync/deps:artifact_tracker_state_java_proto",
+        "//querysync/java/com/google/idea/blaze/qsync/java",
+        "//shared",
+        "//shared:vcs",
+        "@com_google_guava_guava//jar",
+        "@junit//jar",
+        "@truth//jar",
+    ],
+)