Fix ScanningRecipe accumulator loss in preconditioned DeclarativeRecipes (#6913)

BellwetherDecoratedScanningRecipe gets a new UUID-based accumulator key
each time it is instantiated. Since DeclarativeRecipe.getRecipeList()
creates new wrapper instances on every call, a fresh RecipeStack (which
triggers new getRecipeList() calls) causes accumulators stored under old
keys to become unreachable.

Override getAccumulator() to delegate to the wrapped recipe's stable UUID.

Author: pstreef

rewrite-core/src/main/java/org/openrewrite/config/DeclarativeRecipe.java

@@ -365,6 +365,11 @@ static class BellwetherDecoratedScanningRecipe<T> extends ScanningRecipe<T> impl
         DeclarativeRecipe.PreconditionBellwether bellwether;
         ScanningRecipe<T> delegate;
 
+        @Override
+        public T getAccumulator(Cursor cursor, ExecutionContext ctx) {
+            return delegate.getAccumulator(cursor, ctx);
+        }
+
         @Override
         public T getInitialValue(ExecutionContext ctx) {
             return delegate.getInitialValue(ctx);

rewrite-core/src/test/java/org/openrewrite/config/DeclarativeRecipeTest.java

@@ -20,7 +20,14 @@
 import org.jspecify.annotations.Nullable;
 import org.junit.jupiter.api.Test;
 import org.openrewrite.*;
+import org.openrewrite.internal.InMemoryLargeSourceSet;
 import org.openrewrite.marker.SearchResult;
+import org.openrewrite.scheduling.RecipeRunCycle;
+import org.openrewrite.scheduling.WatchableExecutionContext;
+import org.openrewrite.table.RecipeRunStats;
+import org.openrewrite.table.SearchResults;
+import org.openrewrite.table.SourcesFileErrors;
+import org.openrewrite.table.SourcesFileResults;
 import org.openrewrite.test.RewriteTest;
 import org.openrewrite.text.ChangeText;
 import org.openrewrite.text.Find;
@@ -29,7 +36,8 @@
 
 import java.net.URI;
 import java.nio.file.Path;
-import java.util.List;
+import java.nio.file.Paths;
+import java.util.*;
 import java.util.concurrent.atomic.AtomicInteger;
 
 import static java.util.Collections.emptyList;
@@ -740,4 +748,95 @@ void deeperCyclicReferencesDetectedAsCycle() {
             .hasMessageContaining("RecipeB")
             .hasMessageContaining("RecipeC");
     }
+
+    // Uses separate RecipeRunCycles for scan and edit to verify that the accumulator
+    // survives when getRecipeList() is called again from a fresh RecipeStack.
+    // This can't be tested via rewriteRun() which uses a single RecipeRunCycle per cycle.
+    @Test
+    void scanningRecipeAccumulatorSurvivesAcrossRecipeRunCycles() {
+        DeclarativeRecipe recipe = new DeclarativeRecipe(
+                "test.WithPrecondition", "With precondition", "Test with precondition.",
+                emptySet(), null, URI.create("test"), true, emptyList()
+        );
+        recipe.addPrecondition(new Singleton());
+        recipe.addUninitialized(new CountingRecipe());
+        recipe.initialize(List.of());
+
+        List<SourceFile> sources = List.of(
+                PlainText.builder().id(Tree.randomId()).sourcePath(Paths.get("file1.txt")).text("hello").build(),
+                PlainText.builder().id(Tree.randomId()).sourcePath(Paths.get("file2.txt")).text("world").build()
+        );
+
+        Cursor rootCursor = new Cursor(null, Cursor.ROOT_VALUE);
+        WatchableExecutionContext ctx = new WatchableExecutionContext(new InMemoryExecutionContext());
+        Recipe noop = Recipe.noop();
+
+        // Cycle 1: scan (simulates first yield batch on the platform)
+        RecipeRunCycle<LargeSourceSet> scanCycle = new RecipeRunCycle<>(
+                recipe, 1, rootCursor, ctx,
+                new RecipeRunStats(noop), new SearchResults(noop),
+                new SourcesFileResults(noop), new SourcesFileErrors(noop),
+                LargeSourceSet::edit
+        );
+        ctx.putCycle(scanCycle);
+        scanCycle.scanSources(new InMemoryLargeSourceSet(sources));
+
+        // Cycle 2: edit (simulates new RecipeRunCycle after worker yield — new RecipeStack, fresh getRecipeList() calls)
+        RecipeRunCycle<LargeSourceSet> editCycle = new RecipeRunCycle<>(
+                recipe, 1, rootCursor, ctx,
+                new RecipeRunStats(noop), new SearchResults(noop),
+                new SourcesFileResults(noop), new SourcesFileErrors(noop),
+                LargeSourceSet::edit
+        );
+        ctx.putCycle(editCycle);
+        LargeSourceSet edited = editCycle.editSources(new InMemoryLargeSourceSet(sources));
+
+        List<SourceFile> results = edited.getChangeset().getAllResults().stream()
+                .map(Result::getAfter)
+                .filter(Objects::nonNull)
+                .toList();
+
+        assertThat(results).anyMatch(sf -> ((PlainText) sf).getText().contains("[scanned:"));
+    }
+
+    static class CountingRecipe extends ScanningRecipe<List<String>> {
+        @Override
+        public String getDisplayName() {
+            return "Counting recipe";
+        }
+
+        @Override
+        public String getDescription() {
+            return "Counts files during scan, appends count during edit.";
+        }
+
+        @Override
+        public List<String> getInitialValue(ExecutionContext ctx) {
+            return new ArrayList<>();
+        }
+
+        @Override
+        public TreeVisitor<?, ExecutionContext> getScanner(List<String> acc) {
+            return new PlainTextVisitor<>() {
+                @Override
+                public PlainText visitText(PlainText text, ExecutionContext ctx) {
+                    acc.add(text.getText());
+                    return text;
+                }
+            };
+        }
+
+        @Override
+        public TreeVisitor<?, ExecutionContext> getVisitor(List<String> acc) {
+            return new PlainTextVisitor<>() {
+                @Override
+                public PlainText visitText(PlainText text, ExecutionContext ctx) {
+                    if (!acc.isEmpty()) {
+                        return text.withText(text.getText() + " [scanned:" + acc.size() + "]");
+                    }
+                    return text;
+                }
+            };
+        }
+    }
 }