@@ -7,6 +7,8 @@
 import static org.mockito.Mockito.when;
 
 import java.io.*;
+import java.nio.file.Files;
+import java.nio.file.NoSuchFileException;
 import java.util.*;
 import org.eclipse.jgit.api.Git;
 import org.eclipse.jgit.api.LogCommand;
@@ -190,8 +192,6 @@ void testFileLogReturnsOnlyVerifiedPartialPathHistoryWhenFilteredWalkYieldsNothi
     void testFileLogReturnsOnlyVerifiedPartialPathHistoryWithMissingTree() throws Exception {
         // Simulates a shallow clone whose tree objects are missing:  the filtered walk
         // may yield zero results due to missing objects, but should not fall back to total history.
-        GitLogReader gitLogReader = new GitLogReader(git);
-
         String attributeHandler = "AttributeHandler.java";
         InputStream resourceAsStream = getClass().getClassLoader().getResourceAsStream(attributeHandler);
         String contents = convertInputStreamToString(resourceAsStream);
@@ -208,11 +208,19 @@ void testFileLogReturnsOnlyVerifiedPartialPathHistoryWithMissingTree() throws Ex
 
         deleteLooseObject(secondCommit.getTree());
 
-        ScmLogInfo scmLogInfo = Assertions.assertDoesNotThrow(() -> gitLogReader.fileLog(attributeHandler));
-
-        // With missing tree objects, the filtered walk may yield zero verified partial results
-        // rather than falling back to total repository history
-        Assertions.assertEquals(0, scmLogInfo.getCommitCount());
+        // Read through a freshly opened repository: the commits above populated JGit's
+        // in-memory loose-object cache (UnpackedObjectCache, one per ObjectDirectory
+        // instance), which could otherwise serve the deleted tree from memory and let
+        // the walk succeed with 2 commits instead of failing. A new Repository instance
+        // gets an empty cache, so the missing object is really exercised on every OS.
+        try (Git freshGit = Git.open(repository.getDirectory())) {
+            GitLogReader gitLogReader = new GitLogReader(freshGit);
+            ScmLogInfo scmLogInfo = Assertions.assertDoesNotThrow(() -> gitLogReader.fileLog(attributeHandler));
+
+            // With missing tree objects, the filtered walk may yield zero verified partial results
+            // rather than falling back to total repository history
+            Assertions.assertEquals(0, scmLogInfo.getCommitCount());
+        }
     }
 
     @Test
@@ -232,16 +240,39 @@ void testFileLogDoesNotFabricateHistoryForFileNeverCommitted() throws Exception
         Assertions.assertEquals(0, scmLogInfo.getCommitCount());
     }
 
-    private void deleteLooseObject(ObjectId objectId) throws IOException {
+    private void deleteLooseObject(ObjectId objectId) throws IOException, InterruptedException {
         String objectName = objectId.getName();
         File looseObject = new File(
                 new File(repository.getDirectory(), "objects"),
                 objectName.substring(0, 2) + '/' + objectName.substring(2));
         org.junit.jupiter.api.Assumptions.assumeTrue(
                 looseObject.exists(), "loose object " + objectName + " should exist in a fresh repository");
-        if (!looseObject.delete()) {
-            throw new IOException("Unable to delete loose object " + looseObject);
+
+        // JGit writes loose objects with the read-only attribute set (as C git
+        // does). POSIX unlink ignores the read-only bit, but Windows refuses to
+        // delete a read-only file and every retry would fail with
+        // AccessDeniedException — so the attribute must be cleared first.
+        if (!looseObject.setWritable(true) && !looseObject.canWrite()) {
+            throw new IOException("Unable to clear read-only flag on loose object " + looseObject);
+        }
+
+        // On Windows, antivirus or the search indexer can also hold a newly
+        // created file open briefly, making an immediate delete fail
+        // spuriously. Retry for a short window before giving up (harmless on
+        // Linux/macOS, where the first attempt succeeds).
+        IOException lastError = null;
+        for (int attempt = 0; attempt < 50; attempt++) {
+            try {
+                Files.delete(looseObject.toPath());
+                return;
+            } catch (NoSuchFileException alreadyGone) {
+                return;
+            } catch (IOException lockedOrBusy) {
+                lastError = lockedOrBusy;
+                Thread.sleep(50);
+            }
         }
+        throw new IOException("Unable to delete loose object " + looseObject, lastError);
     }
 
     @Test
 
@@ -15,11 +15,6 @@
  * the versioned entry is invisible to the class loader — its class-file
  * version (69.0) can never be loaded — and this base variant answers.
  *
- * <p>This replaces the previous reflection-based loading, runtime-version
- * detection, and force-flag escape hatch: the JVM performs version selection
- * itself, and a forced load is meaningless because version-69 class files
- * physically cannot load on older runtimes.
- *
  * <p>Note: multi-release shadowing only applies when classes are loaded from
  * a <em>jar</em>. In exploded-directory classpaths (e.g. unit tests running
  * against {@code target/classes}) this base variant answers even on JDK 25.
 
@@ -44,7 +44,7 @@ public CodebaseGraphDTO buildGraph(String repositoryPath, String repositoryRoot,
             throws IOException {
         File srcDirectory = new File(repositoryPath);
 
-        JavaParser javaParser = createJavaParser(config);
+        JavaParser javaParser = createJavaParser();
         ExecutionContext ctx = new InMemoryExecutionContext(e -> log.warn("OpenRewrite parse/visit error", e));
 
         final Graph<String, DefaultWeightedEdge> classReferencesGraph =
@@ -113,7 +113,7 @@ public CodebaseGraphDTO buildGraph(String repositoryPath, String repositoryRoot,
      * JDK 25; the {@code fromJavaVersion()} elevation still yields a
      * Java 25-capable parser there when {@code rewrite-java-25} is present.
      */
-    static JavaParser createJavaParser(GraphBuilderConfig config) {
+    static JavaParser createJavaParser() {
         return Java25ParserFactory.createJava25Parser().orElseGet(() -> {
             log.debug("Using JavaParser.fromJavaVersion() (Java 25 multi-release jar variant not active)");
             return JavaParser.fromJavaVersion().build();
 
@@ -44,7 +44,7 @@ void standardParserUsedOnOlderRuntime() {
         if (Runtime.version().feature() >= 25) {
             return; // covered by the JAVA_25-only test below
         }
-        JavaParser parser = JavaSourceFileGraphBuilder.createJavaParser(config());
+        JavaParser parser = JavaSourceFileGraphBuilder.createJavaParser();
         assertFalse(
                 parser.getClass().getSimpleName().contains("25"),
                 "Expected a non-Java-25 parser, got: " + parser.getClass().getName());
@@ -60,7 +60,7 @@ void jdk25YieldsJava25CapableParser() {
                         + "(JEP 238 shadowing applies only to jars)");
         // fromJavaVersion() reflectively elevates to Java25Parser on a 25+
         // runtime because rewrite-java-25 is on the (test) classpath.
-        JavaParser parser = JavaSourceFileGraphBuilder.createJavaParser(config());
+        JavaParser parser = JavaSourceFileGraphBuilder.createJavaParser();
         assertNotNull(parser, "Parser creation must never fail");
         assertTrue(
                 parser.getClass().getName().contains("Java25"),
 
@@ -197,9 +197,7 @@ public String execute() {
 
     /**
      * Verifies report generation succeeds with parser selection left entirely
-     * to the runtime (the parser-forcing overload was removed when
-     * reflection-based parser loading was replaced by the JEP 238
-     * multi-release jar design).
+     * to the runtime (JEP 238 multi-release jar design).
      */
     @Test
     void testExecuteWithoutParserFlags() throws Exception {