From 6197824e219879da84ddd553fc606e4d1af44e4d Mon Sep 17 00:00:00 2001
From: semen-flamingo <semen@flamingo.cx>
Date: Tue, 3 Nov 2026 00:29:36 +0700
Subject: [PATCH 1/4] fix(delivery): a waiting batch follows the schedule's
 script list, a machine missed fires get one catch-up CU-86akkb8f5

The batch a machine waits for on the engine is the schedule as the user sees it now: a script added to the schedule
joins the batch and gets a leaf under the same fire, one removed leaves it and its leaf closes with the reason. A
machine still offline and waiting for an earlier fire of a repeating schedule gets the next fire instead of both,
the way the reconnect sentinel merged them.

Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_018qx6NqA97kwRxQ4hnD5jtu
---
 .../schedule/ScheduleDeliveryRefresher.java   | 105 +++++++++++++-----
 .../rmm/ScheduleDeliveryRefresherTest.java    |  67 ++++++++++-
 .../service/rmm/ScheduleFireDispatcher.java   |  38 +++++++
 .../service/ScheduleFireDispatcherTest.java   |  32 +++++-
 4 files changed, 213 insertions(+), 29 deletions(-)

diff --git a/openframe-api-lib/src/main/java/com/openframe/api/service/rmm/schedule/ScheduleDeliveryRefresher.java b/openframe-api-lib/src/main/java/com/openframe/api/service/rmm/schedule/ScheduleDeliveryRefresher.java
index cb6540f18..a2171abef 100644
--- a/openframe-api-lib/src/main/java/com/openframe/api/service/rmm/schedule/ScheduleDeliveryRefresher.java
+++ b/openframe-api-lib/src/main/java/com/openframe/api/service/rmm/schedule/ScheduleDeliveryRefresher.java
@@ -4,6 +4,7 @@
 import com.openframe.data.document.delivery.DeliveryType;
 import com.openframe.data.document.rmm.schedule.ScheduleScript;
 import com.openframe.data.document.rmm.schedule.ScheduledScriptCustomParams;
+import com.openframe.data.document.rmm.script.ExecutionSource;
 import com.openframe.data.document.rmm.script.ExecutionStatus;
 import com.openframe.data.document.rmm.script.Script;
 import com.openframe.data.document.rmm.script.ScriptExecution;
@@ -23,7 +24,9 @@
 import org.springframework.stereotype.Service;
 
 import java.time.Instant;
+import java.util.ArrayList;
 import java.util.Collection;
+import java.util.HashSet;
 import java.util.List;
 import java.util.Map;
 import java.util.Objects;
@@ -36,14 +39,16 @@
 import static java.util.stream.Collectors.toSet;
 
 // a batch waiting on the engine for a machine carries what the user sees now, not what was there when the schedule
-// fired: an edit of a script or of the schedule's parameters replaces the waiting bodies, a schedule or a device that
-// is gone withdraws them. A leaf still QUEUED is the sign the machine has not received the batch
+// fired: an edit of a script or of the schedule replaces the waiting bodies and the leaves follow (a script added to
+// the schedule gets a leaf, one removed closes), a schedule or a device that is gone withdraws them. A leaf still
+// QUEUED is the sign the machine has not received the batch
 @Slf4j
 @Service
 @RequiredArgsConstructor
 public class ScheduleDeliveryRefresher {
 
     private static final String NOTHING_LEFT_TO_RUN = "no runnable script left in the batch";
+    private static final String REMOVED_FROM_SCHEDULE = "Script was removed from the schedule before the agent received it";
 
     private final ScriptExecutionRepository scriptExecutionRepository;
     private final ScriptScheduleRepository scheduleRepository;
@@ -109,7 +114,7 @@ private void refreshExecution(String tenantId, String executionId, List<ScriptEx
             return;
         }
         ScheduleScript current = schedule.get();
-        List<Script> scripts = runnableScriptsOf(tenantId, executionId, current);
+        List<Script> scripts = runnableScriptsOf(tenantId, current);
         if (scripts.isEmpty()) {
             cancel(queuedLeaves, NOTHING_LEFT_TO_RUN);
             return;
@@ -126,27 +131,80 @@ private void refreshExecution(String tenantId, String executionId, List<ScriptEx
         ScheduleOfflineRule rule = ScheduleOfflineRule.of(current.getTrigger(), current.getOfflineBehavior(), current.getReconnectWindowSeconds());
         DeliveryOfflineBehavior offlineBehavior = rule.behavior();
         Long reconnectWindowSeconds = rule.reconnectWindowSeconds();
-        long replaced = waitingMachines.stream()
+        Set<String> replaced = waitingMachines.stream()
                 .filter(machineId -> deliveryRefresher.refresh(DeliveryType.SCRIPT_SCHEDULE, executionId, machineId, message,
                         offlineBehavior, reconnectWindowSeconds))
-                .count();
-        followTheScripts(queuedLeaves, scripts);
-        log.info("Waiting batches refreshed: executionId={} machines={} replaced={}", executionId, waitingMachines.size(), replaced);
+                .collect(toSet());
+        List<ScriptExecution> leavesOfTheFire = scriptExecutionRepository.findByTenantIdAndExecutionId(tenantId, executionId);
+        alignLeaves(leavesOfTheFire, replaced, scripts, first);
+        log.info("Waiting batches refreshed: executionId={} machines={} replaced={}", executionId, waitingMachines.size(), replaced.size());
     }
 
-    // the leaf keeps what the agent will run with: the script's privilege and timeout as they are now (the result
-    // watchdog reads the timeout from the leaf)
-    private void followTheScripts(List<ScriptExecution> queuedLeaves, List<Script> scripts) {
+    // the leaves of a machine whose waiting body was replaced are the batch it will get: a script that left the batch
+    // closes, a script that joined it gets a leaf (or its closed leaf back, the fire holds one leaf per script and
+    // machine), the rest keep the script's privilege and timeout as they are now (the result watchdog reads the leaf)
+    private void alignLeaves(List<ScriptExecution> leavesOfTheFire, Set<String> replacedMachines, List<Script> scripts,
+                             ScriptExecution sample) {
+        Instant now = Instant.now();
         Map<String, Script> byId = scripts.stream().collect(toMap(Script::getId, Function.identity(), (first, second) -> first));
-        List<ScriptExecution> changed = queuedLeaves.stream()
-                .filter(leaf -> byId.containsKey(leaf.getScriptId()))
-                .filter(leaf -> follow(leaf, byId.get(leaf.getScriptId())))
-                .toList();
+        List<ScriptExecution> changed = new ArrayList<>();
+        for (String machineId : replacedMachines) {
+            Map<String, ScriptExecution> byScript = leavesOfTheFire.stream()
+                    .filter(leaf -> machineId.equals(leaf.getMachineId()))
+                    .collect(toMap(ScriptExecution::getScriptId, Function.identity(), (first, second) -> first));
+            byScript.values().stream()
+                    .filter(leaf -> isQueued(leaf) && !byId.containsKey(leaf.getScriptId()))
+                    .forEach(leaf -> {
+                        markFailed(leaf, now, REMOVED_FROM_SCHEDULE);
+                        changed.add(leaf);
+                    });
+            for (Script script : scripts) {
+                ScriptExecution leaf = byScript.get(script.getId());
+                if (leaf == null) {
+                    changed.add(newLeaf(sample, machineId, script, now));
+                } else if (!isQueued(leaf)) {
+                    reopen(leaf, script, now);
+                    changed.add(leaf);
+                } else if (follow(leaf, script)) {
+                    changed.add(leaf);
+                }
+            }
+        }
         if (!changed.isEmpty()) {
             scriptExecutionRepository.saveAll(changed);
         }
     }
 
+    private static ScriptExecution newLeaf(ScriptExecution sample, String machineId, Script script, Instant now) {
+        return ScriptExecution.builder()
+                .tenantId(sample.getTenantId())
+                .executionId(sample.getExecutionId())
+                .scheduleId(sample.getScheduleId())
+                .machineId(machineId)
+                .scriptId(script.getId())
+                .privilegeLevel(script.getPrivilegeLevel())
+                .timeoutSeconds(script.getDefaultTimeoutSeconds())
+                .initiatedBy(sample.getInitiatedBy())
+                .source(ExecutionSource.SCHEDULED)
+                .status(ExecutionStatus.QUEUED)
+                .dispatchedAt(sample.getDispatchedAt())
+                .statusChangedAt(now)
+                .build();
+    }
+
+    private static void reopen(ScriptExecution leaf, Script script, Instant now) {
+        leaf.setStatus(ExecutionStatus.QUEUED);
+        leaf.setStatusChangedAt(now);
+        leaf.setFinishedAt(null);
+        leaf.setTimedOut(null);
+        leaf.setError(null);
+        follow(leaf, script);
+    }
+
+    private static boolean isQueued(ScriptExecution leaf) {
+        return leaf.getStatus() == ExecutionStatus.QUEUED;
+    }
+
     private static boolean follow(ScriptExecution leaf, Script script) {
         boolean changed = !Objects.equals(leaf.getPrivilegeLevel(), script.getPrivilegeLevel())
                 || !Objects.equals(leaf.getTimeoutSeconds(), script.getDefaultTimeoutSeconds());
@@ -164,21 +222,14 @@ private Optional<ScheduleScript> activeSchedule(String tenantId, String schedule
                 .filter(ScheduleDeliveryRefresher::isActive);
     }
 
-    // the fire's own scripts, in the schedule's order, as they are now: a script the user removed from the schedule
-    // since stays in a batch that was built with it, the leaves of the fire are what the user sees of it
-    private List<Script> runnableScriptsOf(String tenantId, String executionId, ScheduleScript schedule) {
-        Set<String> fired = scriptExecutionRepository.findByTenantIdAndExecutionId(tenantId, executionId).stream()
-                .map(ScriptExecution::getScriptId)
-                .collect(toSet());
-        Map<String, Script> byId = scriptRepository.findByTenantIdAndIdIn(tenantId, fired).stream()
+    // the schedule's scripts as they are now, in its order, active only: what the machine gets is the schedule the
+    // user sees, not the one that fired
+    private List<Script> runnableScriptsOf(String tenantId, ScheduleScript schedule) {
+        List<String> ids = schedule.getScriptIds() == null ? List.of() : schedule.getScriptIds().stream().distinct().toList();
+        Map<String, Script> byId = scriptRepository.findByTenantIdAndIdIn(tenantId, new HashSet<>(ids)).stream()
                 .filter(ScheduleDeliveryRefresher::isActive)
                 .collect(toMap(Script::getId, Function.identity(), (first, second) -> first));
-        List<String> orderedIds = schedule.getScriptIds() == null ? List.of() : schedule.getScriptIds();
-        List<Script> ordered = orderedIds.stream().distinct().map(byId::get).filter(Objects::nonNull).toList();
-        if (!ordered.isEmpty()) {
-            return ordered;
-        }
-        return fired.stream().map(byId::get).filter(Objects::nonNull).toList();
+        return ids.stream().map(byId::get).filter(Objects::nonNull).toList();
     }
 
     private void cancel(List<ScriptExecution> queuedLeaves, String reason) {
diff --git a/openframe-api-service-core/src/test/java/com/openframe/api/service/rmm/ScheduleDeliveryRefresherTest.java b/openframe-api-service-core/src/test/java/com/openframe/api/service/rmm/ScheduleDeliveryRefresherTest.java
index 5dba99fc5..94107deae 100644
--- a/openframe-api-service-core/src/test/java/com/openframe/api/service/rmm/ScheduleDeliveryRefresherTest.java
+++ b/openframe-api-service-core/src/test/java/com/openframe/api/service/rmm/ScheduleDeliveryRefresherTest.java
@@ -187,7 +187,6 @@ void retireScript_otherScriptsLeft_batchRebuiltWithoutItAndItsLeavesClosed() {
     void retireScript_nothingLeft_rowsWithdrawnAndLeavesClosed() {
         ScriptExecution leaf = queued(EXECUTION_ID, MACHINE_1, SCRIPT_A);
         when(scriptExecutionRepository.findByTenantIdAndScriptIdAndStatus(TENANT_ID, SCRIPT_A, ExecutionStatus.QUEUED)).thenReturn(List.of(leaf));
-        when(scriptExecutionRepository.findByTenantIdAndExecutionId(TENANT_ID, EXECUTION_ID)).thenReturn(List.of(leaf));
         when(scheduleRepository.findByTenantIdAndId(TENANT_ID, SCHEDULE_ID)).thenReturn(Optional.of(schedule(ScriptStatus.ACTIVE, List.of(SCRIPT_A))));
         Script deleted = script(SCRIPT_A, "echo a");
         deleted.setStatus(ScriptStatus.DELETED);
@@ -223,6 +222,72 @@ void refreshForSchedule_waitingSchedule_windowTravelsAndLeavesFollowTheScript()
         verify(scriptExecutionRepository).saveAll(List.of(leaf));
     }
 
+    @Test
+    @DisplayName("refreshForSchedule: a script added to the schedule joins the waiting batch: the body carries it and the machine gets a QUEUED leaf for it under the same fire")
+    void refreshForSchedule_scriptAdded_bodyAndLeafFollow() {
+        ScriptExecution leafA = queued(EXECUTION_ID, MACHINE_1, SCRIPT_A);
+        when(scriptExecutionRepository.findByTenantIdAndScheduleIdAndStatus(TENANT_ID, SCHEDULE_ID, ExecutionStatus.QUEUED)).thenReturn(List.of(leafA));
+        when(scriptExecutionRepository.findByTenantIdAndExecutionId(TENANT_ID, EXECUTION_ID)).thenReturn(List.of(leafA));
+        when(scheduleRepository.findByTenantIdAndId(TENANT_ID, SCHEDULE_ID)).thenReturn(Optional.of(schedule(ScriptStatus.ACTIVE, List.of(SCRIPT_A, SCRIPT_B))));
+        when(scriptRepository.findByTenantIdAndIdIn(eq(TENANT_ID), any())).thenReturn(List.of(script(SCRIPT_A, "echo a"), script(SCRIPT_B, "echo b")));
+        when(deliveryRefresher.refresh(eq(DeliveryType.SCRIPT_SCHEDULE), eq(EXECUTION_ID), eq(MACHINE_1), messageCaptor.capture(), any(), any())).thenReturn(true);
+
+        refresher.refreshForSchedule(SCHEDULE_ID);
+
+        assertThat(messageCaptor.getValue().getScripts()).extracting(ScriptScheduleExecutionItem::getScriptId).containsExactly(SCRIPT_A, SCRIPT_B);
+        ArgumentCaptor<List<ScriptExecution>> saved = leavesCaptor();
+        verify(scriptExecutionRepository).saveAll(saved.capture());
+        assertThat(saved.getValue()).extracting(ScriptExecution::getScriptId).containsExactly(SCRIPT_A, SCRIPT_B);
+        ScriptExecution leafB = saved.getValue().getLast();
+        assertThat(leafB.getExecutionId()).isEqualTo(EXECUTION_ID);
+        assertThat(leafB.getMachineId()).isEqualTo(MACHINE_1);
+        assertThat(leafB.getStatus()).isEqualTo(ExecutionStatus.QUEUED);
+        assertThat(leafB.getInitiatedBy()).isEqualTo(OWNER);
+        assertThat(leafB.getTimeoutSeconds()).isEqualTo(60);
+    }
+
+    @Test
+    @DisplayName("refreshForSchedule: a script removed from the schedule leaves the waiting batch: its leaf closes with the reason, the body goes on without it")
+    void refreshForSchedule_scriptRemoved_leafClosesBodyGoesOn() {
+        ScriptExecution leafA = queued(EXECUTION_ID, MACHINE_1, SCRIPT_A);
+        ScriptExecution leafB = queued(EXECUTION_ID, MACHINE_1, SCRIPT_B);
+        when(scriptExecutionRepository.findByTenantIdAndScheduleIdAndStatus(TENANT_ID, SCHEDULE_ID, ExecutionStatus.QUEUED)).thenReturn(List.of(leafA, leafB));
+        when(scriptExecutionRepository.findByTenantIdAndExecutionId(TENANT_ID, EXECUTION_ID)).thenReturn(List.of(leafA, leafB));
+        when(scheduleRepository.findByTenantIdAndId(TENANT_ID, SCHEDULE_ID)).thenReturn(Optional.of(schedule(ScriptStatus.ACTIVE, List.of(SCRIPT_B))));
+        when(scriptRepository.findByTenantIdAndIdIn(eq(TENANT_ID), any())).thenReturn(List.of(script(SCRIPT_B, "echo b")));
+        when(deliveryRefresher.refresh(eq(DeliveryType.SCRIPT_SCHEDULE), eq(EXECUTION_ID), eq(MACHINE_1), messageCaptor.capture(), any(), any())).thenReturn(true);
+
+        refresher.refreshForSchedule(SCHEDULE_ID);
+
+        assertThat(messageCaptor.getValue().getScripts()).extracting(ScriptScheduleExecutionItem::getScriptId).containsExactly(SCRIPT_B);
+        assertThat(leafA.getStatus()).isEqualTo(ExecutionStatus.FAILED);
+        assertThat(leafA.getError()).isEqualTo("Script was removed from the schedule before the agent received it");
+        assertThat(leafB.getStatus()).isEqualTo(ExecutionStatus.QUEUED);
+        assertThat(leafB.getTimeoutSeconds()).isEqualTo(60);
+        verify(scriptExecutionRepository).saveAll(List.of(leafA, leafB));
+    }
+
+    @Test
+    @DisplayName("refreshForSchedule: the machine already has the batch (its row was not replaced): its leaves are left as they are")
+    void refreshForSchedule_rowNotReplaced_leavesUntouched() {
+        ScriptExecution leafA = queued(EXECUTION_ID, MACHINE_1, SCRIPT_A);
+        when(scriptExecutionRepository.findByTenantIdAndScheduleIdAndStatus(TENANT_ID, SCHEDULE_ID, ExecutionStatus.QUEUED)).thenReturn(List.of(leafA));
+        when(scriptExecutionRepository.findByTenantIdAndExecutionId(TENANT_ID, EXECUTION_ID)).thenReturn(List.of(leafA));
+        when(scheduleRepository.findByTenantIdAndId(TENANT_ID, SCHEDULE_ID)).thenReturn(Optional.of(schedule(ScriptStatus.ACTIVE, List.of(SCRIPT_B))));
+        when(scriptRepository.findByTenantIdAndIdIn(eq(TENANT_ID), any())).thenReturn(List.of(script(SCRIPT_B, "echo b")));
+        when(deliveryRefresher.refresh(eq(DeliveryType.SCRIPT_SCHEDULE), eq(EXECUTION_ID), eq(MACHINE_1), any(), any(), any())).thenReturn(false);
+
+        refresher.refreshForSchedule(SCHEDULE_ID);
+
+        assertThat(leafA.getStatus()).isEqualTo(ExecutionStatus.QUEUED);
+        verify(scriptExecutionRepository, never()).saveAll(any());
+    }
+
+    @SuppressWarnings("unchecked")
+    private static ArgumentCaptor<List<ScriptExecution>> leavesCaptor() {
+        return ArgumentCaptor.forClass(List.class);
+    }
+
     private static ScriptExecution queued(String executionId, String machineId, String scriptId) {
         return ScriptExecution.builder()
                 .tenantId(TENANT_ID)
diff --git a/openframe-client-core/src/main/java/com/openframe/client/service/rmm/ScheduleFireDispatcher.java b/openframe-client-core/src/main/java/com/openframe/client/service/rmm/ScheduleFireDispatcher.java
index 04b705b19..620e29ab5 100644
--- a/openframe-client-core/src/main/java/com/openframe/client/service/rmm/ScheduleFireDispatcher.java
+++ b/openframe-client-core/src/main/java/com/openframe/client/service/rmm/ScheduleFireDispatcher.java
@@ -20,6 +20,7 @@
 import com.openframe.data.nats.rmm.model.ScriptScheduleExecutionItem;
 import com.openframe.data.nats.rmm.model.ScriptScheduleExecutionMessage;
 import com.openframe.data.nats.rmm.util.ScriptScheduleBatch;
+import com.openframe.delivery.track.DeliveryTracker;
 import com.openframe.data.repository.device.MachineRepository;
 import com.openframe.data.repository.rmm.DeviceOnlineDispatchRepository;
 import com.openframe.data.repository.rmm.ScheduleScriptExecutionRepository;
@@ -56,6 +57,9 @@ public class ScheduleFireDispatcher {
     private final MachineRepository machineRepository;
     private final DeviceOnlineDispatchRepository dispatchRepository;
     private final ScriptDeliveryRetryStore retryStore;
+    private final DeliveryTracker deliveryTracker;
+
+    private static final String SUPERSEDED = "superseded by the schedule's next fire";
 
     public void dispatch(ScheduleScript schedule, Instant now) {
         List<String> targets = targetResolver.resolveTargetMachineIds(schedule);
@@ -176,6 +180,10 @@ private void dispatch(ScheduleScript schedule, List<String> machineIds, Instant
             return;
         }
 
+        if (rule.isWaiting()) {
+            withdrawEarlierFires(schedule, machineIds);
+        }
+
         // One executionId for the whole fire, shared across every script and machine.
         Fire fire = new Fire(schedule, UUID.randomUUID().toString(), scripts, machineIds, now, rule);
         saveHeader(fire);
@@ -197,6 +205,36 @@ private List<Script> resolveRunnableScripts(String tenantId, List<String> script
         return scriptIds.stream().distinct().map(byId::get).filter(Objects::nonNull).toList();
     }
 
+    // the fires a machine missed while offline were one catch-up on the reconnect sentinel (one per schedule and
+    // machine); on the engine each fire is a batch of its own, so a machine still offline and waiting for an earlier
+    // fire of this schedule gets this one instead of both
+    private void withdrawEarlierFires(ScheduleScript schedule, List<String> machineIds) {
+        String tenantId = schedule.getTenantId();
+        List<ScriptExecution> waiting = scriptExecutionRepository.findByTenantIdAndScheduleIdAndStatus(
+                tenantId, schedule.getId(), ExecutionStatus.QUEUED);
+        Set<String> targets = new HashSet<>(machineIds);
+        Set<String> heldMachines = waiting.stream()
+                .map(ScriptExecution::getMachineId)
+                .filter(targets::contains)
+                .filter(this::isHeldOnRoute)
+                .collect(Collectors.toSet());
+        if (heldMachines.isEmpty()) {
+            return;
+        }
+        Set<String> online = onlineTargets(tenantId, List.copyOf(heldMachines));
+        Set<DeliveryKey> superseded = waiting.stream()
+                .filter(leaf -> heldMachines.contains(leaf.getMachineId()) && !online.contains(leaf.getMachineId()))
+                .map(leaf -> new DeliveryKey(leaf.getExecutionId(), leaf.getMachineId()))
+                .collect(Collectors.toSet());
+        superseded.forEach(key -> deliveryTracker.cancel(DeliveryType.SCRIPT_SCHEDULE, key.executionId(), key.machineId(), SUPERSEDED));
+        if (!superseded.isEmpty()) {
+            log.info("Earlier fires withdrawn for machines still offline: scheduleId={} deliveries={}", schedule.getId(), superseded.size());
+        }
+    }
+
+    private record DeliveryKey(String executionId, String machineId) {
+    }
+
     private void saveHeader(Fire fire) {
         scheduleScriptExecutionRepository.save(ScheduleScriptExecution.builder()
                 .tenantId(fire.tenantId())
diff --git a/openframe-client-core/src/test/java/com/openframe/client/service/ScheduleFireDispatcherTest.java b/openframe-client-core/src/test/java/com/openframe/client/service/ScheduleFireDispatcherTest.java
index a5199e513..40b0df50e 100644
--- a/openframe-client-core/src/test/java/com/openframe/client/service/ScheduleFireDispatcherTest.java
+++ b/openframe-client-core/src/test/java/com/openframe/client/service/ScheduleFireDispatcherTest.java
@@ -29,6 +29,7 @@
 import com.openframe.data.repository.rmm.ScriptExecutionRepository;
 import com.openframe.data.repository.rmm.ScriptRepository;
 import com.openframe.data.service.rmm.ScheduleDeviceTargetResolver;
+import com.openframe.delivery.track.DeliveryTracker;
 import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.DisplayName;
 import org.junit.jupiter.api.Test;
@@ -72,6 +73,7 @@ class ScheduleFireDispatcherTest {
     @Mock private MachineRepository machineRepository;
     @Mock private DeviceOnlineDispatchRepository dispatchRepository;
     @Mock private com.openframe.client.service.rmm.ScriptDeliveryRetryStore retryStore;
+    @Mock private DeliveryTracker deliveryTracker;
 
     private ScheduleFireDispatcher dispatcher;
 
@@ -79,7 +81,35 @@ class ScheduleFireDispatcherTest {
     void setUp() {
         dispatcher = new ScheduleFireDispatcher(targetResolver, scriptRepository,
                 scriptExecutionRepository, scheduleScriptExecutionRepository, deliveryRouter,
-                machineRepository, dispatchRepository, retryStore);
+                machineRepository, dispatchRepository, retryStore, deliveryTracker);
+    }
+
+    @Test
+    @DisplayName("route that holds the batch, RETRY_ON_RECONNECT: a machine still offline and waiting for an earlier fire of the schedule gets this fire instead, the earlier batch is withdrawn")
+    void dispatch_heldRoute_machineStillWaitingForAnEarlierFire_earlierBatchWithdrawn() {
+        Instant now = Instant.now();
+        ScheduleScript schedule = schedule(List.of("script-a"));
+        schedule.setTrigger(ScheduleScriptTrigger.DATE_TIME);
+        schedule.setOfflineBehavior(ScheduleOfflineBehavior.RETRY_ON_RECONNECT);
+        schedule.setReconnectWindowSeconds(3600L);
+        when(targetResolver.resolveTargetMachineIds(schedule)).thenReturn(List.of("m-online", "m-offline"));
+        when(deliveryRouter.holdsForOfflineMachine(eq(DeliveryType.SCRIPT_SCHEDULE), anyString())).thenReturn(true);
+        when(scriptRepository.findByTenantIdAndIdIn(eq(TENANT), any()))
+                .thenReturn(List.of(script("script-a", ScriptShell.BASH)));
+        ScriptExecution earlierOffline = ScriptExecution.builder().executionId("exec-earlier").machineId("m-offline").scriptId("script-a").status(ExecutionStatus.QUEUED).build();
+        ScriptExecution earlierOnline = ScriptExecution.builder().executionId("exec-earlier").machineId("m-online").scriptId("script-a").status(ExecutionStatus.QUEUED).build();
+        when(scriptExecutionRepository.findByTenantIdAndScheduleIdAndStatus(TENANT, SCHEDULE_ID, ExecutionStatus.QUEUED))
+                .thenReturn(List.of(earlierOffline, earlierOnline));
+        Machine online = new Machine();
+        online.setMachineId("m-online");
+        online.setStatus(DeviceStatus.ONLINE);
+        when(machineRepository.findByTenantIdAndMachineIdIn(eq(TENANT), any())).thenReturn(List.of(online));
+
+        dispatcher.dispatch(schedule, now);
+
+        verify(deliveryTracker).cancel(DeliveryType.SCRIPT_SCHEDULE, "exec-earlier", "m-offline", "superseded by the schedule's next fire");
+        verify(deliveryTracker, never()).cancel(eq(DeliveryType.SCRIPT_SCHEDULE), anyString(), eq("m-online"), anyString());
+        verify(deliveryRouter, times(2)).dispatch(any(ScriptScheduleDeliverySeed.class));
     }
 
     @Test

From 9535d8aa0452641af6cc828272fd79830368457e Mon Sep 17 00:00:00 2001
From: semen-flamingo <semen@flamingo.cx>
Date: Tue, 3 Nov 2026 00:41:19 +0700
Subject: [PATCH 2/4] fix(delivery): drop the catch-up merge, the API keeps a
 schedule's reconnect window under its repeat interval CU-86akkb8f5

Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_018qx6NqA97kwRxQ4hnD5jtu
---
 .../service/rmm/ScheduleFireDispatcher.java   | 38 -------------------
 .../service/ScheduleFireDispatcherTest.java   | 32 +---------------
 2 files changed, 1 insertion(+), 69 deletions(-)

diff --git a/openframe-client-core/src/main/java/com/openframe/client/service/rmm/ScheduleFireDispatcher.java b/openframe-client-core/src/main/java/com/openframe/client/service/rmm/ScheduleFireDispatcher.java
index 620e29ab5..04b705b19 100644
--- a/openframe-client-core/src/main/java/com/openframe/client/service/rmm/ScheduleFireDispatcher.java
+++ b/openframe-client-core/src/main/java/com/openframe/client/service/rmm/ScheduleFireDispatcher.java
@@ -20,7 +20,6 @@
 import com.openframe.data.nats.rmm.model.ScriptScheduleExecutionItem;
 import com.openframe.data.nats.rmm.model.ScriptScheduleExecutionMessage;
 import com.openframe.data.nats.rmm.util.ScriptScheduleBatch;
-import com.openframe.delivery.track.DeliveryTracker;
 import com.openframe.data.repository.device.MachineRepository;
 import com.openframe.data.repository.rmm.DeviceOnlineDispatchRepository;
 import com.openframe.data.repository.rmm.ScheduleScriptExecutionRepository;
@@ -57,9 +56,6 @@ public class ScheduleFireDispatcher {
     private final MachineRepository machineRepository;
     private final DeviceOnlineDispatchRepository dispatchRepository;
     private final ScriptDeliveryRetryStore retryStore;
-    private final DeliveryTracker deliveryTracker;
-
-    private static final String SUPERSEDED = "superseded by the schedule's next fire";
 
     public void dispatch(ScheduleScript schedule, Instant now) {
         List<String> targets = targetResolver.resolveTargetMachineIds(schedule);
@@ -180,10 +176,6 @@ private void dispatch(ScheduleScript schedule, List<String> machineIds, Instant
             return;
         }
 
-        if (rule.isWaiting()) {
-            withdrawEarlierFires(schedule, machineIds);
-        }
-
         // One executionId for the whole fire, shared across every script and machine.
         Fire fire = new Fire(schedule, UUID.randomUUID().toString(), scripts, machineIds, now, rule);
         saveHeader(fire);
@@ -205,36 +197,6 @@ private List<Script> resolveRunnableScripts(String tenantId, List<String> script
         return scriptIds.stream().distinct().map(byId::get).filter(Objects::nonNull).toList();
     }
 
-    // the fires a machine missed while offline were one catch-up on the reconnect sentinel (one per schedule and
-    // machine); on the engine each fire is a batch of its own, so a machine still offline and waiting for an earlier
-    // fire of this schedule gets this one instead of both
-    private void withdrawEarlierFires(ScheduleScript schedule, List<String> machineIds) {
-        String tenantId = schedule.getTenantId();
-        List<ScriptExecution> waiting = scriptExecutionRepository.findByTenantIdAndScheduleIdAndStatus(
-                tenantId, schedule.getId(), ExecutionStatus.QUEUED);
-        Set<String> targets = new HashSet<>(machineIds);
-        Set<String> heldMachines = waiting.stream()
-                .map(ScriptExecution::getMachineId)
-                .filter(targets::contains)
-                .filter(this::isHeldOnRoute)
-                .collect(Collectors.toSet());
-        if (heldMachines.isEmpty()) {
-            return;
-        }
-        Set<String> online = onlineTargets(tenantId, List.copyOf(heldMachines));
-        Set<DeliveryKey> superseded = waiting.stream()
-                .filter(leaf -> heldMachines.contains(leaf.getMachineId()) && !online.contains(leaf.getMachineId()))
-                .map(leaf -> new DeliveryKey(leaf.getExecutionId(), leaf.getMachineId()))
-                .collect(Collectors.toSet());
-        superseded.forEach(key -> deliveryTracker.cancel(DeliveryType.SCRIPT_SCHEDULE, key.executionId(), key.machineId(), SUPERSEDED));
-        if (!superseded.isEmpty()) {
-            log.info("Earlier fires withdrawn for machines still offline: scheduleId={} deliveries={}", schedule.getId(), superseded.size());
-        }
-    }
-
-    private record DeliveryKey(String executionId, String machineId) {
-    }
-
     private void saveHeader(Fire fire) {
         scheduleScriptExecutionRepository.save(ScheduleScriptExecution.builder()
                 .tenantId(fire.tenantId())
diff --git a/openframe-client-core/src/test/java/com/openframe/client/service/ScheduleFireDispatcherTest.java b/openframe-client-core/src/test/java/com/openframe/client/service/ScheduleFireDispatcherTest.java
index 40b0df50e..a5199e513 100644
--- a/openframe-client-core/src/test/java/com/openframe/client/service/ScheduleFireDispatcherTest.java
+++ b/openframe-client-core/src/test/java/com/openframe/client/service/ScheduleFireDispatcherTest.java
@@ -29,7 +29,6 @@
 import com.openframe.data.repository.rmm.ScriptExecutionRepository;
 import com.openframe.data.repository.rmm.ScriptRepository;
 import com.openframe.data.service.rmm.ScheduleDeviceTargetResolver;
-import com.openframe.delivery.track.DeliveryTracker;
 import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.DisplayName;
 import org.junit.jupiter.api.Test;
@@ -73,7 +72,6 @@ class ScheduleFireDispatcherTest {
     @Mock private MachineRepository machineRepository;
     @Mock private DeviceOnlineDispatchRepository dispatchRepository;
     @Mock private com.openframe.client.service.rmm.ScriptDeliveryRetryStore retryStore;
-    @Mock private DeliveryTracker deliveryTracker;
 
     private ScheduleFireDispatcher dispatcher;
 
@@ -81,35 +79,7 @@ class ScheduleFireDispatcherTest {
     void setUp() {
         dispatcher = new ScheduleFireDispatcher(targetResolver, scriptRepository,
                 scriptExecutionRepository, scheduleScriptExecutionRepository, deliveryRouter,
-                machineRepository, dispatchRepository, retryStore, deliveryTracker);
-    }
-
-    @Test
-    @DisplayName("route that holds the batch, RETRY_ON_RECONNECT: a machine still offline and waiting for an earlier fire of the schedule gets this fire instead, the earlier batch is withdrawn")
-    void dispatch_heldRoute_machineStillWaitingForAnEarlierFire_earlierBatchWithdrawn() {
-        Instant now = Instant.now();
-        ScheduleScript schedule = schedule(List.of("script-a"));
-        schedule.setTrigger(ScheduleScriptTrigger.DATE_TIME);
-        schedule.setOfflineBehavior(ScheduleOfflineBehavior.RETRY_ON_RECONNECT);
-        schedule.setReconnectWindowSeconds(3600L);
-        when(targetResolver.resolveTargetMachineIds(schedule)).thenReturn(List.of("m-online", "m-offline"));
-        when(deliveryRouter.holdsForOfflineMachine(eq(DeliveryType.SCRIPT_SCHEDULE), anyString())).thenReturn(true);
-        when(scriptRepository.findByTenantIdAndIdIn(eq(TENANT), any()))
-                .thenReturn(List.of(script("script-a", ScriptShell.BASH)));
-        ScriptExecution earlierOffline = ScriptExecution.builder().executionId("exec-earlier").machineId("m-offline").scriptId("script-a").status(ExecutionStatus.QUEUED).build();
-        ScriptExecution earlierOnline = ScriptExecution.builder().executionId("exec-earlier").machineId("m-online").scriptId("script-a").status(ExecutionStatus.QUEUED).build();
-        when(scriptExecutionRepository.findByTenantIdAndScheduleIdAndStatus(TENANT, SCHEDULE_ID, ExecutionStatus.QUEUED))
-                .thenReturn(List.of(earlierOffline, earlierOnline));
-        Machine online = new Machine();
-        online.setMachineId("m-online");
-        online.setStatus(DeviceStatus.ONLINE);
-        when(machineRepository.findByTenantIdAndMachineIdIn(eq(TENANT), any())).thenReturn(List.of(online));
-
-        dispatcher.dispatch(schedule, now);
-
-        verify(deliveryTracker).cancel(DeliveryType.SCRIPT_SCHEDULE, "exec-earlier", "m-offline", "superseded by the schedule's next fire");
-        verify(deliveryTracker, never()).cancel(eq(DeliveryType.SCRIPT_SCHEDULE), anyString(), eq("m-online"), anyString());
-        verify(deliveryRouter, times(2)).dispatch(any(ScriptScheduleDeliverySeed.class));
+                machineRepository, dispatchRepository, retryStore);
     }
 
     @Test

From aec65b66a0cdb38c5be4b9b920b0c84ee4dd12c9 Mon Sep 17 00:00:00 2001
From: semen-flamingo <semen@flamingo.cx>
Date: Tue, 3 Nov 2026 01:36:48 +0700
Subject: [PATCH 3/4] fix(delivery): a leaf added to a waiting batch takes its
 fire time from the machine's own leaf CU-86akkb8f5

Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_018qx6NqA97kwRxQ4hnD5jtu
---
 .../schedule/ScheduleDeliveryRefresher.java   | 25 +++++++++++--------
 .../rmm/ScheduleDeliveryRefresherTest.java    |  3 +++
 2 files changed, 17 insertions(+), 11 deletions(-)

diff --git a/openframe-api-lib/src/main/java/com/openframe/api/service/rmm/schedule/ScheduleDeliveryRefresher.java b/openframe-api-lib/src/main/java/com/openframe/api/service/rmm/schedule/ScheduleDeliveryRefresher.java
index a2171abef..766a626a0 100644
--- a/openframe-api-lib/src/main/java/com/openframe/api/service/rmm/schedule/ScheduleDeliveryRefresher.java
+++ b/openframe-api-lib/src/main/java/com/openframe/api/service/rmm/schedule/ScheduleDeliveryRefresher.java
@@ -136,15 +136,16 @@ private void refreshExecution(String tenantId, String executionId, List<ScriptEx
                         offlineBehavior, reconnectWindowSeconds))
                 .collect(toSet());
         List<ScriptExecution> leavesOfTheFire = scriptExecutionRepository.findByTenantIdAndExecutionId(tenantId, executionId);
-        alignLeaves(leavesOfTheFire, replaced, scripts, first);
+        alignLeaves(leavesOfTheFire, replaced, scripts);
         log.info("Waiting batches refreshed: executionId={} machines={} replaced={}", executionId, waitingMachines.size(), replaced.size());
     }
 
     // the leaves of a machine whose waiting body was replaced are the batch it will get: a script that left the batch
     // closes, a script that joined it gets a leaf (or its closed leaf back, the fire holds one leaf per script and
-    // machine), the rest keep the script's privilege and timeout as they are now (the result watchdog reads the leaf)
-    private void alignLeaves(List<ScriptExecution> leavesOfTheFire, Set<String> replacedMachines, List<Script> scripts,
-                             ScriptExecution sample) {
+    // machine), the rest keep the script's privilege and timeout as they are now (the result watchdog reads the leaf).
+    // A machine whose body stayed (the agent took it, or it is on the route before the engine) keeps its leaves: they
+    // are the batch the agent runs
+    private void alignLeaves(List<ScriptExecution> leavesOfTheFire, Set<String> replacedMachines, List<Script> scripts) {
         Instant now = Instant.now();
         Map<String, Script> byId = scripts.stream().collect(toMap(Script::getId, Function.identity(), (first, second) -> first));
         List<ScriptExecution> changed = new ArrayList<>();
@@ -152,6 +153,7 @@ private void alignLeaves(List<ScriptExecution> leavesOfTheFire, Set<String> repl
             Map<String, ScriptExecution> byScript = leavesOfTheFire.stream()
                     .filter(leaf -> machineId.equals(leaf.getMachineId()))
                     .collect(toMap(ScriptExecution::getScriptId, Function.identity(), (first, second) -> first));
+            ScriptExecution own = byScript.values().iterator().next();
             byScript.values().stream()
                     .filter(leaf -> isQueued(leaf) && !byId.containsKey(leaf.getScriptId()))
                     .forEach(leaf -> {
@@ -161,7 +163,7 @@ private void alignLeaves(List<ScriptExecution> leavesOfTheFire, Set<String> repl
             for (Script script : scripts) {
                 ScriptExecution leaf = byScript.get(script.getId());
                 if (leaf == null) {
-                    changed.add(newLeaf(sample, machineId, script, now));
+                    changed.add(newLeaf(own, machineId, script, now));
                 } else if (!isQueued(leaf)) {
                     reopen(leaf, script, now);
                     changed.add(leaf);
@@ -175,19 +177,20 @@ private void alignLeaves(List<ScriptExecution> leavesOfTheFire, Set<String> repl
         }
     }
 
-    private static ScriptExecution newLeaf(ScriptExecution sample, String machineId, Script script, Instant now) {
+    // a sibling of the machine's own leaves: same fire, same machine, the fire's dispatch time
+    private static ScriptExecution newLeaf(ScriptExecution own, String machineId, Script script, Instant now) {
         return ScriptExecution.builder()
-                .tenantId(sample.getTenantId())
-                .executionId(sample.getExecutionId())
-                .scheduleId(sample.getScheduleId())
+                .tenantId(own.getTenantId())
+                .executionId(own.getExecutionId())
+                .scheduleId(own.getScheduleId())
                 .machineId(machineId)
                 .scriptId(script.getId())
                 .privilegeLevel(script.getPrivilegeLevel())
                 .timeoutSeconds(script.getDefaultTimeoutSeconds())
-                .initiatedBy(sample.getInitiatedBy())
+                .initiatedBy(own.getInitiatedBy())
                 .source(ExecutionSource.SCHEDULED)
                 .status(ExecutionStatus.QUEUED)
-                .dispatchedAt(sample.getDispatchedAt())
+                .dispatchedAt(own.getDispatchedAt())
                 .statusChangedAt(now)
                 .build();
     }
diff --git a/openframe-api-service-core/src/test/java/com/openframe/api/service/rmm/ScheduleDeliveryRefresherTest.java b/openframe-api-service-core/src/test/java/com/openframe/api/service/rmm/ScheduleDeliveryRefresherTest.java
index 94107deae..724adcdc1 100644
--- a/openframe-api-service-core/src/test/java/com/openframe/api/service/rmm/ScheduleDeliveryRefresherTest.java
+++ b/openframe-api-service-core/src/test/java/com/openframe/api/service/rmm/ScheduleDeliveryRefresherTest.java
@@ -29,6 +29,7 @@
 import org.mockito.Mock;
 import org.mockito.junit.jupiter.MockitoExtension;
 
+import java.time.Instant;
 import java.util.List;
 import java.util.Optional;
 import java.util.Set;
@@ -226,6 +227,7 @@ void refreshForSchedule_waitingSchedule_windowTravelsAndLeavesFollowTheScript()
     @DisplayName("refreshForSchedule: a script added to the schedule joins the waiting batch: the body carries it and the machine gets a QUEUED leaf for it under the same fire")
     void refreshForSchedule_scriptAdded_bodyAndLeafFollow() {
         ScriptExecution leafA = queued(EXECUTION_ID, MACHINE_1, SCRIPT_A);
+        leafA.setDispatchedAt(Instant.parse("2026-11-02T18:28:00Z"));
         when(scriptExecutionRepository.findByTenantIdAndScheduleIdAndStatus(TENANT_ID, SCHEDULE_ID, ExecutionStatus.QUEUED)).thenReturn(List.of(leafA));
         when(scriptExecutionRepository.findByTenantIdAndExecutionId(TENANT_ID, EXECUTION_ID)).thenReturn(List.of(leafA));
         when(scheduleRepository.findByTenantIdAndId(TENANT_ID, SCHEDULE_ID)).thenReturn(Optional.of(schedule(ScriptStatus.ACTIVE, List.of(SCRIPT_A, SCRIPT_B))));
@@ -244,6 +246,7 @@ void refreshForSchedule_scriptAdded_bodyAndLeafFollow() {
         assertThat(leafB.getStatus()).isEqualTo(ExecutionStatus.QUEUED);
         assertThat(leafB.getInitiatedBy()).isEqualTo(OWNER);
         assertThat(leafB.getTimeoutSeconds()).isEqualTo(60);
+        assertThat(leafB.getDispatchedAt()).isEqualTo(leafA.getDispatchedAt());
     }
 
     @Test

From 4255fc0a43c6ae4a88304312c26a7bcab8dbbdbf Mon Sep 17 00:00:00 2001
From: semen-flamingo <semen@flamingo.cx>
Date: Tue, 3 Nov 2026 11:31:03 +0700
Subject: [PATCH 4/4] fix(delivery): a script that leaves a waiting batch loses
 its leaf, the run shows what ran CU-86akkb8f5

A leaf of a batch the agent has not received is the promise of that batch. When a script leaves it (removed from the
schedule, deleted, archived) the leaf is deleted, not closed FAILED: one FAILED leaf marked the whole run FAILED while
every script that ran succeeded. retireScript is gone, a delete or archive refreshes the waiting batches like an edit.

Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_018qx6NqA97kwRxQ4hnD5jtu
---
 .../schedule/ScheduleDeliveryRefresher.java   | 61 +++++--------------
 .../api/service/rmm/script/ScriptService.java |  6 +-
 .../rmm/ScheduleDeliveryRefresherTest.java    | 35 ++++++-----
 .../api/service/rmm/ScriptServiceTest.java    |  4 +-
 4 files changed, 36 insertions(+), 70 deletions(-)

diff --git a/openframe-api-lib/src/main/java/com/openframe/api/service/rmm/schedule/ScheduleDeliveryRefresher.java b/openframe-api-lib/src/main/java/com/openframe/api/service/rmm/schedule/ScheduleDeliveryRefresher.java
index 766a626a0..4663f01b5 100644
--- a/openframe-api-lib/src/main/java/com/openframe/api/service/rmm/schedule/ScheduleDeliveryRefresher.java
+++ b/openframe-api-lib/src/main/java/com/openframe/api/service/rmm/schedule/ScheduleDeliveryRefresher.java
@@ -40,15 +40,15 @@
 
 // a batch waiting on the engine for a machine carries what the user sees now, not what was there when the schedule
 // fired: an edit of a script or of the schedule replaces the waiting bodies and the leaves follow (a script added to
-// the schedule gets a leaf, one removed closes), a schedule or a device that is gone withdraws them. A leaf still
-// QUEUED is the sign the machine has not received the batch
+// the schedule gets a leaf, one that left it loses its leaf: the leaf was the promise of a batch the agent never
+// received, a run shows what ran), a schedule or a device that is gone withdraws them. A leaf still QUEUED is the sign
+// the machine has not received the batch
 @Slf4j
 @Service
 @RequiredArgsConstructor
 public class ScheduleDeliveryRefresher {
 
     private static final String NOTHING_LEFT_TO_RUN = "no runnable script left in the batch";
-    private static final String REMOVED_FROM_SCHEDULE = "Script was removed from the schedule before the agent received it";
 
     private final ScriptExecutionRepository scriptExecutionRepository;
     private final ScriptScheduleRepository scheduleRepository;
@@ -69,20 +69,6 @@ public void refreshForSchedule(String scheduleId) {
         refresh(tenantId, queued);
     }
 
-    // the script is gone: the batches still waiting carry what is left of the fire, a batch with nothing left is
-    // withdrawn, and the script's own leaves close here with the reason, the agent will never run them
-    public void retireScript(String scriptId, String reason) {
-        String tenantId = tenantIdProvider.getTenantId();
-        List<ScriptExecution> queued = scriptExecutionRepository.findByTenantIdAndScriptIdAndStatus(tenantId, scriptId, ExecutionStatus.QUEUED);
-        refresh(tenantId, queued);
-        Instant now = Instant.now();
-        queued.forEach(leaf -> markFailed(leaf, now, reason));
-        if (!queued.isEmpty()) {
-            scriptExecutionRepository.saveAll(queued);
-            log.info("Leaves of a retired script closed: scriptId={} leaves={} reason={}", scriptId, queued.size(), reason);
-        }
-    }
-
     public void cancelForSchedule(String scheduleId, String reason) {
         String tenantId = tenantIdProvider.getTenantId();
         List<ScriptExecution> queued = queuedLeavesOf(tenantId, scheduleId);
@@ -136,19 +122,20 @@ private void refreshExecution(String tenantId, String executionId, List<ScriptEx
                         offlineBehavior, reconnectWindowSeconds))
                 .collect(toSet());
         List<ScriptExecution> leavesOfTheFire = scriptExecutionRepository.findByTenantIdAndExecutionId(tenantId, executionId);
-        alignLeaves(leavesOfTheFire, replaced, scripts);
+        alignLeaves(executionId, leavesOfTheFire, replaced, scripts);
         log.info("Waiting batches refreshed: executionId={} machines={} replaced={}", executionId, waitingMachines.size(), replaced.size());
     }
 
     // the leaves of a machine whose waiting body was replaced are the batch it will get: a script that left the batch
-    // closes, a script that joined it gets a leaf (or its closed leaf back, the fire holds one leaf per script and
-    // machine), the rest keep the script's privilege and timeout as they are now (the result watchdog reads the leaf).
-    // A machine whose body stayed (the agent took it, or it is on the route before the engine) keeps its leaves: they
-    // are the batch the agent runs
-    private void alignLeaves(List<ScriptExecution> leavesOfTheFire, Set<String> replacedMachines, List<Script> scripts) {
+    // loses its leaf, a script that joined it gets one (the fire holds one leaf per script and machine), the rest keep
+    // the script's privilege and timeout as they are now (the result watchdog reads the leaf). A machine whose body
+    // stayed (the agent took it, or it is on the route before the engine) keeps its leaves: they are the batch the
+    // agent runs
+    private void alignLeaves(String executionId, List<ScriptExecution> leavesOfTheFire, Set<String> replacedMachines, List<Script> scripts) {
         Instant now = Instant.now();
         Map<String, Script> byId = scripts.stream().collect(toMap(Script::getId, Function.identity(), (first, second) -> first));
         List<ScriptExecution> changed = new ArrayList<>();
+        List<ScriptExecution> gone = new ArrayList<>();
         for (String machineId : replacedMachines) {
             Map<String, ScriptExecution> byScript = leavesOfTheFire.stream()
                     .filter(leaf -> machineId.equals(leaf.getMachineId()))
@@ -156,22 +143,20 @@ private void alignLeaves(List<ScriptExecution> leavesOfTheFire, Set<String> repl
             ScriptExecution own = byScript.values().iterator().next();
             byScript.values().stream()
                     .filter(leaf -> isQueued(leaf) && !byId.containsKey(leaf.getScriptId()))
-                    .forEach(leaf -> {
-                        markFailed(leaf, now, REMOVED_FROM_SCHEDULE);
-                        changed.add(leaf);
-                    });
+                    .forEach(gone::add);
             for (Script script : scripts) {
                 ScriptExecution leaf = byScript.get(script.getId());
                 if (leaf == null) {
                     changed.add(newLeaf(own, machineId, script, now));
-                } else if (!isQueued(leaf)) {
-                    reopen(leaf, script, now);
-                    changed.add(leaf);
                 } else if (follow(leaf, script)) {
                     changed.add(leaf);
                 }
             }
         }
+        if (!gone.isEmpty()) {
+            scriptExecutionRepository.deleteAll(gone);
+            log.info("Leaves of scripts that left the waiting batches removed: executionId={} leaves={}", executionId, gone.size());
+        }
         if (!changed.isEmpty()) {
             scriptExecutionRepository.saveAll(changed);
         }
@@ -195,15 +180,6 @@ private static ScriptExecution newLeaf(ScriptExecution own, String machineId, Sc
                 .build();
     }
 
-    private static void reopen(ScriptExecution leaf, Script script, Instant now) {
-        leaf.setStatus(ExecutionStatus.QUEUED);
-        leaf.setStatusChangedAt(now);
-        leaf.setFinishedAt(null);
-        leaf.setTimedOut(null);
-        leaf.setError(null);
-        follow(leaf, script);
-    }
-
     private static boolean isQueued(ScriptExecution leaf) {
         return leaf.getStatus() == ExecutionStatus.QUEUED;
     }
@@ -245,13 +221,6 @@ private void cancel(List<ScriptExecution> queuedLeaves, String reason) {
         }
     }
 
-    private static void markFailed(ScriptExecution leaf, Instant now, String reason) {
-        leaf.setStatus(ExecutionStatus.FAILED);
-        leaf.setStatusChangedAt(now);
-        leaf.setFinishedAt(now);
-        leaf.setError(reason);
-    }
-
     private static boolean isActive(ScheduleScript schedule) {
         return schedule.getStatus() == ScriptStatus.ACTIVE;
     }
diff --git a/openframe-api-lib/src/main/java/com/openframe/api/service/rmm/script/ScriptService.java b/openframe-api-lib/src/main/java/com/openframe/api/service/rmm/script/ScriptService.java
index 0ab7f1c99..a27e657fd 100644
--- a/openframe-api-lib/src/main/java/com/openframe/api/service/rmm/script/ScriptService.java
+++ b/openframe-api-lib/src/main/java/com/openframe/api/service/rmm/script/ScriptService.java
@@ -40,8 +40,6 @@
 @RequiredArgsConstructor
 public class ScriptService {
 
-    private static final String SCRIPT_DELETED = "Script was deleted before the agent received it";
-    private static final String SCRIPT_ARCHIVED = "Script was archived before the agent received it";
     private static final List<ScriptStatus> NAME_UNIQUE_STATUSES =
             List.of(ScriptStatus.ACTIVE, ScriptStatus.ARCHIVED);
 
@@ -220,7 +218,7 @@ public String delete(String id) {
         existing.setStatus(ScriptStatus.DELETED);
         existing.setStatusChangedAt(Instant.now());
         scriptRepository.save(existing);
-        deliveryRefresher.retireScript(id, SCRIPT_DELETED);
+        deliveryRefresher.refreshForScript(id);
         log.info("Soft-deleted script id={} tenantId={}", id, tenantId);
         return existing.getId();
     }
@@ -247,7 +245,7 @@ private ScriptResponse transitionTo(String id, ScriptStatus target) {
         existing.setStatusChangedAt(Instant.now());
         Script saved = scriptRepository.save(existing);
         if (target == ScriptStatus.ARCHIVED) {
-            deliveryRefresher.retireScript(id, SCRIPT_ARCHIVED);
+            deliveryRefresher.refreshForScript(id);
         }
         log.info("Script id={} tenantId={} status changed to {}", id, tenantId, target);
         return scriptMapper.toResponse(saved);
diff --git a/openframe-api-service-core/src/test/java/com/openframe/api/service/rmm/ScheduleDeliveryRefresherTest.java b/openframe-api-service-core/src/test/java/com/openframe/api/service/rmm/ScheduleDeliveryRefresherTest.java
index 724adcdc1..983639e94 100644
--- a/openframe-api-service-core/src/test/java/com/openframe/api/service/rmm/ScheduleDeliveryRefresherTest.java
+++ b/openframe-api-service-core/src/test/java/com/openframe/api/service/rmm/ScheduleDeliveryRefresherTest.java
@@ -162,30 +162,30 @@ void cancelForMachines_onlyTheRemovedMachines() {
     }
 
     @Test
-    @DisplayName("retireScript: the batch goes on without the script, the script's own waiting leaves close with the reason")
-    void retireScript_otherScriptsLeft_batchRebuiltWithoutItAndItsLeavesClosed() {
+    @DisplayName("refreshForScript: a deleted script leaves the waiting batch: its leaf goes, the batch goes on without it, the run will show what ran")
+    void refreshForScript_scriptDeleted_itsLeafGoesBatchGoesOn() {
         ScriptExecution leafA = queued(EXECUTION_ID, MACHINE_1, SCRIPT_A);
+        ScriptExecution leafB = queued(EXECUTION_ID, MACHINE_1, SCRIPT_B);
         when(scriptExecutionRepository.findByTenantIdAndScriptIdAndStatus(TENANT_ID, SCRIPT_A, ExecutionStatus.QUEUED)).thenReturn(List.of(leafA));
-        when(scriptExecutionRepository.findByTenantIdAndExecutionId(TENANT_ID, EXECUTION_ID))
-                .thenReturn(List.of(leafA, queued(EXECUTION_ID, MACHINE_1, SCRIPT_B)));
+        when(scriptExecutionRepository.findByTenantIdAndExecutionId(TENANT_ID, EXECUTION_ID)).thenReturn(List.of(leafA, leafB));
         when(scheduleRepository.findByTenantIdAndId(TENANT_ID, SCHEDULE_ID)).thenReturn(Optional.of(schedule(ScriptStatus.ACTIVE, List.of(SCRIPT_A, SCRIPT_B))));
         Script deleted = script(SCRIPT_A, "echo a");
         deleted.setStatus(ScriptStatus.DELETED);
         when(scriptRepository.findByTenantIdAndIdIn(eq(TENANT_ID), any())).thenReturn(List.of(deleted, script(SCRIPT_B, "echo b")));
         when(deliveryRefresher.refresh(eq(DeliveryType.SCRIPT_SCHEDULE), eq(EXECUTION_ID), eq(MACHINE_1), messageCaptor.capture(), any(), any())).thenReturn(true);
 
-        refresher.retireScript(SCRIPT_A, REASON);
+        refresher.refreshForScript(SCRIPT_A);
 
         assertThat(messageCaptor.getValue().getScripts()).extracting(ScriptScheduleExecutionItem::getScriptId).containsExactly(SCRIPT_B);
-        assertThat(leafA.getStatus()).isEqualTo(ExecutionStatus.FAILED);
-        assertThat(leafA.getError()).isEqualTo(REASON);
-        verify(scriptExecutionRepository).saveAll(List.of(leafA));
+        verify(scriptExecutionRepository).deleteAll(List.of(leafA));
+        assertThat(leafB.getStatus()).isEqualTo(ExecutionStatus.QUEUED);
+        verify(scriptExecutionRepository).saveAll(List.of(leafB));
         verifyNoInteractions(deliveryTracker);
     }
 
     @Test
-    @DisplayName("retireScript: it was the only script of the batch, the waiting rows are withdrawn and the leaves close")
-    void retireScript_nothingLeft_rowsWithdrawnAndLeavesClosed() {
+    @DisplayName("refreshForScript: the deleted script was the only one of the batch: the waiting rows are withdrawn, the leaves are left to the engine's closing")
+    void refreshForScript_scriptDeletedNothingLeft_rowsWithdrawnLeavesLeft() {
         ScriptExecution leaf = queued(EXECUTION_ID, MACHINE_1, SCRIPT_A);
         when(scriptExecutionRepository.findByTenantIdAndScriptIdAndStatus(TENANT_ID, SCRIPT_A, ExecutionStatus.QUEUED)).thenReturn(List.of(leaf));
         when(scheduleRepository.findByTenantIdAndId(TENANT_ID, SCHEDULE_ID)).thenReturn(Optional.of(schedule(ScriptStatus.ACTIVE, List.of(SCRIPT_A))));
@@ -193,12 +193,12 @@ void retireScript_nothingLeft_rowsWithdrawnAndLeavesClosed() {
         deleted.setStatus(ScriptStatus.DELETED);
         when(scriptRepository.findByTenantIdAndIdIn(eq(TENANT_ID), any())).thenReturn(List.of(deleted));
 
-        refresher.retireScript(SCRIPT_A, REASON);
+        refresher.refreshForScript(SCRIPT_A);
 
         verify(deliveryTracker).cancel(eq(DeliveryType.SCRIPT_SCHEDULE), eq(EXECUTION_ID), eq(MACHINE_1), anyString());
         verifyNoInteractions(deliveryRefresher);
-        assertThat(leaf.getStatus()).isEqualTo(ExecutionStatus.FAILED);
-        assertThat(leaf.getError()).isEqualTo(REASON);
+        verify(scriptExecutionRepository, never()).deleteAll(any());
+        assertThat(leaf.getStatus()).isEqualTo(ExecutionStatus.QUEUED);
     }
 
     @Test
@@ -250,8 +250,8 @@ void refreshForSchedule_scriptAdded_bodyAndLeafFollow() {
     }
 
     @Test
-    @DisplayName("refreshForSchedule: a script removed from the schedule leaves the waiting batch: its leaf closes with the reason, the body goes on without it")
-    void refreshForSchedule_scriptRemoved_leafClosesBodyGoesOn() {
+    @DisplayName("refreshForSchedule: a script removed from the schedule leaves the waiting batch: its leaf goes (the run shows what ran), the body goes on without it")
+    void refreshForSchedule_scriptRemoved_leafGoesBodyGoesOn() {
         ScriptExecution leafA = queued(EXECUTION_ID, MACHINE_1, SCRIPT_A);
         ScriptExecution leafB = queued(EXECUTION_ID, MACHINE_1, SCRIPT_B);
         when(scriptExecutionRepository.findByTenantIdAndScheduleIdAndStatus(TENANT_ID, SCHEDULE_ID, ExecutionStatus.QUEUED)).thenReturn(List.of(leafA, leafB));
@@ -263,11 +263,10 @@ void refreshForSchedule_scriptRemoved_leafClosesBodyGoesOn() {
         refresher.refreshForSchedule(SCHEDULE_ID);
 
         assertThat(messageCaptor.getValue().getScripts()).extracting(ScriptScheduleExecutionItem::getScriptId).containsExactly(SCRIPT_B);
-        assertThat(leafA.getStatus()).isEqualTo(ExecutionStatus.FAILED);
-        assertThat(leafA.getError()).isEqualTo("Script was removed from the schedule before the agent received it");
+        verify(scriptExecutionRepository).deleteAll(List.of(leafA));
         assertThat(leafB.getStatus()).isEqualTo(ExecutionStatus.QUEUED);
         assertThat(leafB.getTimeoutSeconds()).isEqualTo(60);
-        verify(scriptExecutionRepository).saveAll(List.of(leafA, leafB));
+        verify(scriptExecutionRepository).saveAll(List.of(leafB));
     }
 
     @Test
diff --git a/openframe-api-service-core/src/test/java/com/openframe/api/service/rmm/ScriptServiceTest.java b/openframe-api-service-core/src/test/java/com/openframe/api/service/rmm/ScriptServiceTest.java
index 435ffabed..cde7758c7 100644
--- a/openframe-api-service-core/src/test/java/com/openframe/api/service/rmm/ScriptServiceTest.java
+++ b/openframe-api-service-core/src/test/java/com/openframe/api/service/rmm/ScriptServiceTest.java
@@ -664,7 +664,7 @@ void delete_whenScriptIsActive_softDeletesAndSaves() {
         assertThat(active.getStatusChangedAt()).isNotNull();
         verify(scriptRepository).save(active);
         verify(scriptRepository, never()).deleteByTenantIdAndId(any(), any());
-        verify(deliveryRefresher).retireScript(SCRIPT_ID, "Script was deleted before the agent received it");
+        verify(deliveryRefresher).refreshForScript(SCRIPT_ID);
     }
 
     @Test
@@ -711,7 +711,7 @@ void archive_whenScriptIsActive_setsArchivedAndSaves() {
         assertThat(active.getStatus()).isEqualTo(ScriptStatus.ARCHIVED);
         assertThat(active.getStatusChangedAt()).isNotNull();
         verify(scriptRepository).save(active);
-        verify(deliveryRefresher).retireScript(SCRIPT_ID, "Script was archived before the agent received it");
+        verify(deliveryRefresher).refreshForScript(SCRIPT_ID);
     }
 
     @Test