refactor: WIP

Author: dieppa

cloud/flamingock-cloud/src/main/java/io/flamingock/cloud/planner/CloudExecutionPlanner.java

@@ -22,6 +22,7 @@
 import io.flamingock.internal.util.ThreadSleeper;
 import io.flamingock.internal.util.TimeService;
 import io.flamingock.internal.common.core.error.FlamingockException;
+import io.flamingock.internal.common.core.response.data.PlannerVerdict;
 import io.flamingock.cloud.api.request.ExecutionPlanRequest;
 import io.flamingock.cloud.api.response.ExecutionPlanResponse;
 import io.flamingock.internal.common.core.targets.TargetSystemAuditMarkType;
@@ -35,6 +36,7 @@
 import io.flamingock.internal.core.external.store.lock.LockException;
 import io.flamingock.internal.core.pipeline.loaded.stage.AbstractLoadedStage;
 import io.flamingock.internal.core.pipeline.run.PipelineRun;
+import io.flamingock.internal.core.pipeline.run.StageRun;
 import io.flamingock.internal.util.log.FlamingockLoggerFactory;
 import org.slf4j.Logger;
 
@@ -102,6 +104,12 @@ public ExecutionPlan getNextExecution(PipelineRun pipelineRun) throws LockExcept
                 }
 
                 if (response.isContinue()) {
+                    //TODO temporally. Remove this
+                    // Server's CONTINUE is authoritative: nothing left to apply for any stage in
+                    // the pipeline. Stamp the planner's UP_TO_DATE verdict on every stage the
+                    // planner hasn't already evaluated this run. No per-change records — the
+                    // server's CONTINUE doesn't carry per-change data and we don't synthesize.
+                    markRemainingStagesUpToDate(pipelineRun);
                     return ExecutionPlan.CONTINUE();
 
                 } else if (response.isExecute()) {
@@ -200,6 +208,22 @@ private ExecutionPlan buildNextExecutionPlan(List<AbstractLoadedStage> loadedSta
         );
     }
 
+    /**
+     * Stamps {@link PlannerVerdict#UP_TO_DATE} on every still-{@code NOT_EVALUATED} stage in the
+     * pipeline. Called when the cloud server returns {@code CONTINUE} — its verdict is authoritative
+     * for the whole pipeline. No per-change records are added; the server's CONTINUE payload doesn't
+     * carry per-change data and we don't synthesize.
+     */
+    private static void markRemainingStagesUpToDate(PipelineRun pipelineRun) {
+        for (StageRun stageRun : pipelineRun.getStageRuns()) {
+            if (stageRun.getResult().getPlannerVerdict() == PlannerVerdict.NOT_EVALUATED
+                    && !stageRun.getState().isFailed()
+                    && !stageRun.getState().isCompleted()) {
+                pipelineRun.markStageVerdict(stageRun.getName(), PlannerVerdict.UP_TO_DATE);
+            }
+        }
+    }
+
     static class AuditMarkSnapshot {
         private final Collection<TargetSystemAuditMark> marks;
         private final Map<String, TargetSystemAuditMarker> markerByChangeId;

core/flamingock-core-commons/src/main/java/io/flamingock/internal/common/core/response/data/ExecuteResponseData.java

@@ -34,11 +34,11 @@ public class ExecuteResponseData {
 
     // Aggregate counts
     private int totalStages;
-    private int reachedStages;
+    private int upToDateStages;
+    private int notReachedStages;
     private int completedStages;
     private int failedStages;
     private int totalChanges;
-    private int reachedChanges;
     private int appliedChanges;
     private int skippedChanges;
     private int failedChanges;
@@ -56,11 +56,11 @@ private ExecuteResponseData(Builder builder) {
         this.endTime = builder.endTime;
         this.totalDurationMs = builder.totalDurationMs;
         this.totalStages = builder.totalStages;
-        this.reachedStages = builder.reachedStages;
+        this.upToDateStages = builder.upToDateStages;
+        this.notReachedStages = builder.notReachedStages;
         this.completedStages = builder.completedStages;
         this.failedStages = builder.failedStages;
         this.totalChanges = builder.totalChanges;
-        this.reachedChanges = builder.reachedChanges;
         this.appliedChanges = builder.appliedChanges;
         this.skippedChanges = builder.skippedChanges;
         this.failedChanges = builder.failedChanges;
@@ -107,12 +107,20 @@ public void setTotalStages(int totalStages) {
         this.totalStages = totalStages;
     }
 
-    public int getReachedStages() {
-        return reachedStages;
+    public int getUpToDateStages() {
+        return upToDateStages;
     }
 
-    public void setReachedStages(int reachedStages) {
-        this.reachedStages = reachedStages;
+    public void setUpToDateStages(int upToDateStages) {
+        this.upToDateStages = upToDateStages;
+    }
+
+    public int getNotReachedStages() {
+        return notReachedStages;
+    }
+
+    public void setNotReachedStages(int notReachedStages) {
+        this.notReachedStages = notReachedStages;
     }
 
     public int getCompletedStages() {
@@ -139,14 +147,6 @@ public void setTotalChanges(int totalChanges) {
         this.totalChanges = totalChanges;
     }
 
-    public int getReachedChanges() {
-        return reachedChanges;
-    }
-
-    public void setReachedChanges(int reachedChanges) {
-        this.reachedChanges = reachedChanges;
-    }
-
     public int getAppliedChanges() {
         return appliedChanges;
     }
@@ -197,11 +197,11 @@ public static class Builder {
         private Instant endTime;
         private long totalDurationMs;
         private int totalStages;
-        private int reachedStages;
+        private int upToDateStages;
+        private int notReachedStages;
         private int completedStages;
         private int failedStages;
         private int totalChanges;
-        private int reachedChanges;
         private int appliedChanges;
         private int skippedChanges;
         private int failedChanges;
@@ -232,8 +232,13 @@ public Builder totalStages(int totalStages) {
             return this;
         }
 
-        public Builder reachedStages(int reachedStages) {
-            this.reachedStages = reachedStages;
+        public Builder upToDateStages(int upToDateStages) {
+            this.upToDateStages = upToDateStages;
+            return this;
+        }
+
+        public Builder notReachedStages(int notReachedStages) {
+            this.notReachedStages = notReachedStages;
             return this;
         }
 
@@ -252,11 +257,6 @@ public Builder totalChanges(int totalChanges) {
             return this;
         }
 
-        public Builder reachedChanges(int reachedChanges) {
-            this.reachedChanges = reachedChanges;
-            return this;
-        }
-
         public Builder appliedChanges(int appliedChanges) {
             this.appliedChanges = appliedChanges;
             return this;

core/flamingock-core-commons/src/main/java/io/flamingock/internal/common/core/response/data/ExecutionReportFormatter.java

@@ -103,39 +103,45 @@ public static String report(ExecuteResponseData result) {
 
         sb.append(" Stages:    ")
           .append(result.getTotalStages()).append(" total — ")
-          .append(result.getReachedStages()).append(" reached, ")
           .append(result.getCompletedStages()).append(" completed, ")
-          .append(result.getFailedStages()).append(" failed")
+          .append(result.getFailedStages()).append(" failed, ")
+          .append(result.getUpToDateStages()).append(" up to date, ")
+          .append(result.getNotReachedStages()).append(" not reached")
           .append(NEWLINE);
         sb.append(" Changes:   ")
           .append(result.getTotalChanges()).append(" total — ")
-          .append(result.getReachedChanges()).append(" reached, ")
           .append(result.getAppliedChanges()).append(" applied, ")
-          .append(result.getSkippedChanges()).append(" skipped, ")
+          .append(result.getSkippedChanges()).append(" already at target state, ")
           .append(result.getFailedChanges()).append(" failed")
           .append(NEWLINE);
 
-        // Per-stage breakdown: only stages the executor actually opened. Stages the planner
-        // short-circuited past are surfaced separately in the "Not reached" section below (when
-        // the coverage is partial — a fully up-to-date run shows neither, the headline carries it).
+        // Per-stage breakdown: include any stage the operation touched (state != NOT_STARTED) OR
+        // the planner verdicted UP_TO_DATE. Stages with verdict NEEDS_WORK / NOT_EVALUATED and
+        // still-NOT_STARTED state fall into the "Not reached" section.
         List<StageResult> stages = nonNullStages(result);
-        List<StageResult> reached = stages.stream()
-                .filter(StageResult::isWasExecuted)
+        List<StageResult> inBreakdown = stages.stream()
+                .filter(s -> !s.getState().isNotStarted()
+                        || s.getPlannerVerdict() == PlannerVerdict.UP_TO_DATE)
                 .collect(Collectors.toList());
-        if (!reached.isEmpty()) {
+        if (!inBreakdown.isEmpty()) {
             sb.append(NEWLINE).append(" Per-stage breakdown:").append(NEWLINE).append(NEWLINE);
-            for (StageResult stage : reached) {
+            for (StageResult stage : inBreakdown) {
                 appendStageBlock(sb, stage);
                 sb.append(NEWLINE);
             }
         }
 
-        // "Not reached" only appears when there's a partial: some stages ran, some didn't. The
-        // all-up-to-date case (0 reached) is communicated by the NO_CHANGES headline alone.
+        // "Not reached" lists stages neither operation-touched nor verdicted UP_TO_DATE. Omitted
+        // when nothing was reached AND nothing was up to date (catastrophic-failure shape; the
+        // headline conveys it).
         List<StageResult> notReached = stages.stream()
-                .filter(s -> !s.isWasExecuted())
+                .filter(s -> s.getState().isNotStarted()
+                        && s.getPlannerVerdict() != PlannerVerdict.UP_TO_DATE)
                 .collect(Collectors.toList());
-        if (!notReached.isEmpty() && result.getReachedStages() > 0) {
+        if (!notReached.isEmpty()
+                && (result.getCompletedStages() > 0
+                    || result.getFailedStages() > 0
+                    || result.getUpToDateStages() > 0)) {
             sb.append(NEWLINE).append(" Not reached (").append(notReached.size()).append("):").append(NEWLINE);
             for (StageResult stage : notReached) {
                 String name = stage.getStageName() != null ? stage.getStageName() : "(unnamed)";
@@ -160,6 +166,26 @@ private static void appendTimeBlock(StringBuilder sb, ExecuteResponseData result
     private static void appendStageBlock(StringBuilder sb, StageResult stage) {
         String label = stageLabel(stage);
         String name = stage.getStageName() != null ? stage.getStageName() : "(unnamed)";
+
+        // [UP TO DATE] rows render without a duration (the executor never ran). Community has
+        // per-change ALREADY_APPLIED records (planner-populated from audit); cloud doesn't —
+        // we emit either a per-change line or a count-only line depending on what's available.
+        boolean isUpToDateOnly = stage.getState().isNotStarted()
+                && stage.getPlannerVerdict() == PlannerVerdict.UP_TO_DATE;
+
+        if (isUpToDateOnly) {
+            int alreadyAppliedCount = stage.getChanges() != null
+                    ? (int) stage.getChanges().stream()
+                        .filter(c -> c != null && c.isAlreadyApplied())
+                        .count()
+                    : 0;
+            int reportableCount = alreadyAppliedCount > 0 ? alreadyAppliedCount : stage.getTotalChanges();
+            sb.append("   ").append(label).append(' ').append(name)
+              .append("  (").append(reportableCount).append(" changes already at target state)")
+              .append(NEWLINE);
+            return;
+        }
+
         sb.append("   ").append(label).append(' ').append(name)
           .append(" (").append(stage.getDurationMs()).append(" ms)").append(NEWLINE);
 
@@ -171,7 +197,7 @@ private static void appendStageBlock(StringBuilder sb, StageResult stage) {
         int failed = (int) changes.stream().filter(c -> c != null && (c.isFailed() || c.isRolledBack())).count();
         sb.append("               changes: ")
           .append(applied).append(" applied, ")
-          .append(skipped).append(" skipped, ")
+          .append(skipped).append(" already at target state, ")
           .append(failed).append(" failed")
           .append(NEWLINE);
 
@@ -209,6 +235,8 @@ private static void appendErrorBlock(StringBuilder sb, ErrorInfo err) {
     }
 
     private static String stageLabel(StageResult stage) {
+        // Two-dimensional resolution. State (operation-owned) wins whenever it's moved off
+        // NOT_STARTED. While state is still NOT_STARTED, the planner verdict decides.
         StageState state = stage.getState();
         if (state == null) {
             return "[UNKNOWN]   ";
@@ -225,10 +253,11 @@ private static String stageLabel(StageResult stage) {
         if (state.isStarted()) {
             return "[STARTED]  ";
         }
-        if (state.isNotStarted()) {
-            return "[PENDING]  ";
+        // state.isNotStarted() — verdict decides.
+        if (stage.getPlannerVerdict() == PlannerVerdict.UP_TO_DATE) {
+            return "[UP TO DATE]";
         }
-        return "[UNKNOWN]   ";
+        return "[NOT REACHED]";
     }
 
     private static String statusLabel(ExecuteResponseData result) {

core/flamingock-core-commons/src/main/java/io/flamingock/internal/common/core/response/data/PlannerVerdict.java

@@ -0,0 +1,59 @@
+/*
+ * Copyright 2026 Flamingock (https://www.flamingock.io)
+ *
+ * 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 io.flamingock.internal.common.core.response.data;
+
+/**
+ * The planner's view of a stage, derived from the audit snapshot (community) or the cloud
+ * server's response. One of two complementary dimensions on {@code StageResult}:
+ *
+ * <ul>
+ *   <li>{@code state} ({@link StageState}) — what the operation observed during execution
+ *       (NOT_STARTED → STARTED → COMPLETED / FAILED / BLOCKED_MI). Operation-only.</li>
+ *   <li>{@code plannerVerdict} (this enum) — what the audit/snapshot reflects. Planner-only.</li>
+ * </ul>
+ *
+ * <p>Operation writes are immutable to the planner. The planner sets a verdict only when the
+ * stage's {@code state} is still {@code NOT_STARTED}; once the operation has reached a terminal
+ * state, that state is the truth for the run.
+ *
+ * <p>Verdict is monotone-forward: NOT_EVALUATED → NEEDS_WORK → UP_TO_DATE. The
+ * NEEDS_WORK → UP_TO_DATE transition is valid (later snapshot reads see new applies); the
+ * reverse is not.
+ *
+ * <p>Notably absent: a "failed" verdict. Failure is an execution observation owned by
+ * {@code state}. From the planner's perspective, a stage with a failed change in the audit
+ * still has pending work — the recovery strategy decides whether to retry.
+ */
+public enum PlannerVerdict {
+
+    /**
+     * Default. The planner has not reached a determination on this stage. Transient under the
+     * community planner's always-walk model; persists for stages the planner couldn't evaluate.
+     */
+    NOT_EVALUATED,
+
+    /**
+     * The planner saw at least one change in the stage that is not in an applied state per
+     * audit. The stage either has work to do or had work that wasn't reached this run.
+     */
+    NEEDS_WORK,
+
+    /**
+     * The planner confirmed every change in the stage is applied per audit. Authoritative —
+     * the executor was not invoked and does not need to be. Renders as {@code [UP TO DATE]}.
+     */
+    UP_TO_DATE
+}