@@ -1870,9 +1870,10 @@ where
             .map_err(ControllerError::WalletError)?;
 
         if per_account.values().all(Vec::is_empty) {
-            // Nothing pending at all; drop any leftover tracker entries here,
-            // otherwise they persist until the next non-empty pass (or restart).
-            self.repush_tracker.retain_where(|_| false);
+            // Nothing pending at all; drop leftover tracker entries except
+            // stuck markers, which the Stuck log line promises persist until
+            // they are abandoned or the wallet restarts.
+            self.repush_tracker.clear_except_stuck();
             return Ok(());
         }
 
@@ -1939,7 +1940,7 @@ where
             presence.insert(tx.id, present);
         }
 
-        let outcome = rebroadcast::reconcile(&pending, &presence, &self.repush_tracker);
+        let outcome = rebroadcast::reconcile(&pending, &presence, &mut self.repush_tracker);
 
         for tx_id in &outcome.to_prune {
             let Some(account_index) = account_of.get(tx_id) else {
@@ -1959,6 +1960,11 @@ where
         }
 
         let now = get_time();
+        // Transactions whose submission failed this pass: their pending
+        // descendants are skipped for the remainder of the pass (submitting a
+        // child of a failed parent is a guaranteed rejection, and for
+        // account-nonce chains it would also skip a nonce).
+        let mut failed_this_pass: BTreeSet<Id<Transaction>> = BTreeSet::new();
         for tx_id in &outcome.to_submit {
             if !self.repush_tracker.is_due(tx_id, now) {
                 continue;
@@ -1968,12 +1974,23 @@ where
                 continue;
             };
 
+            let pending_parents = pending
+                .iter()
+                .find(|pending_tx| pending_tx.id == *tx_id)
+                .map(|pending_tx| pending_tx.pending_parents.clone())
+                .unwrap_or_default();
+            if pending_parents.iter().any(|parent| failed_this_pass.contains(parent)) {
+                log::debug!("Skipping transaction {tx_id:x}: a parent failed submission this pass");
+                continue;
+            }
+
             log::info!("Rebroadcasting transaction {tx_id:x}");
             match self.rpc_client.submit_transaction((*tx).clone(), Default::default()).await {
                 Ok(()) => {
                     self.repush_tracker.on_success(tx_id, get_time());
                 }
                 Err(error) => {
+                    failed_this_pass.insert(*tx_id);
                     let verdict = if error.is_node_rejection() {
                         self.repush_tracker.on_rejected(tx_id, get_time())
                     } else {
 
@@ -27,7 +27,7 @@
 //!
 //! The imperative shell (RPC calls, wallet access) lives in `lib.rs`.
 
-use std::collections::{BTreeMap, HashSet};
+use std::collections::{BTreeMap, BTreeSet, HashSet};
 use std::time::Duration;
 
 use common::chain::Transaction;
@@ -46,6 +46,11 @@ pub const MAX_ATTEMPTS: u32 = 10;
 /// Give up retrying (mark as stuck) once a transaction has been pending for this long.
 pub const MAX_PENDING_AGE: Duration = Duration::from_secs(24 * 60 * 60);
 
+/// Consecutive reconcile passes showing "parent present, transaction missing"
+/// (with a node-observed submission) required before a transaction is treated
+/// as deterministically rejected and pruned.
+pub const PRUNE_ABSENCE_THRESHOLD: u32 = 3;
+
 /// A pending (unconfirmed) transaction with the information needed to plan its submission.
 #[derive(Debug, Clone)]
 pub struct PendingTx {
@@ -75,6 +80,10 @@ struct EntryState {
 #[derive(Debug, Default)]
 pub struct RepushTracker {
     entries: BTreeMap<Id<Transaction>, EntryState>,
+    /// Consecutive reconcile passes in which a transaction was missing from the
+    /// mempool while its parent was present (the deterministic-rejection
+    /// signature). See [`Self::bump_absence`].
+    absence_streaks: BTreeMap<Id<Transaction>, u32>,
 }
 
 /// The result of a failed submission attempt.
@@ -96,6 +105,25 @@ impl RepushTracker {
         self.entries.get(tx_id).is_some_and(|state| state.stuck)
     }
 
+    /// Record one reconcile pass in which the transaction was missing from the
+    /// mempool while its parent was present, and return the consecutive-pass
+    /// count. Any pass that does not match that signature resets the count.
+    pub fn bump_absence(&mut self, tx_id: &Id<Transaction>) -> u32 {
+        let streak = self.absence_streaks.entry(tx_id.clone()).or_insert(0);
+        *streak += 1;
+        *streak
+    }
+
+    /// Reset the consecutive-absence count (e.g. the transaction was seen in
+    /// the mempool again, or the observation signature did not match).
+    pub fn reset_absence(&mut self, tx_id: &Id<Transaction>) {
+        self.absence_streaks.remove(tx_id);
+    }
+
+    pub fn absence_streak(&self, tx_id: &Id<Transaction>) -> u32 {
+        self.absence_streaks.get(tx_id).copied().unwrap_or(0)
+    }
+
     /// Whether the node itself has observed at least one submission of this
     /// transaction (a submission that failed with a node rejection response).
     /// Delivery failures (transport errors, timeouts) do not count: the node
@@ -108,6 +136,20 @@ impl RepushTracker {
     /// tracker does not accumulate entries for confirmed/pruned transactions.
     pub fn retain_where(&mut self, mut keep: impl FnMut(&Id<Transaction>) -> bool) {
         self.entries.retain(|id, _| keep(id));
+        self.absence_streaks.retain(|id, _| keep(id));
+    }
+
+    /// Drops all state except stuck markers (which persist until they are
+    /// abandoned or the wallet restarts, as documented in the Stuck log line).
+    pub fn clear_except_stuck(&mut self) {
+        let stuck: BTreeSet<Id<Transaction>> = self
+            .entries
+            .iter()
+            .filter(|(_, state)| state.stuck)
+            .map(|(id, _)| *id)
+            .collect();
+        self.entries.retain(|id, _| stuck.contains(id));
+        self.absence_streaks.retain(|id, _| stuck.contains(id));
     }
 
     /// Whether the transaction should be (re)submitted now. Transactions that
@@ -191,6 +233,7 @@ impl RepushTracker {
     /// Forget a transaction entirely (e.g. it was pruned or confirmed).
     pub fn forget(&mut self, tx_id: &Id<Transaction>) {
         self.entries.remove(tx_id);
+        self.absence_streaks.remove(tx_id);
     }
 }
 
@@ -268,8 +311,9 @@ pub fn topological_order(pending: &[PendingTx]) -> Vec<Id<Transaction>> {
              in tie-break order, children may be submitted before their parents",
             pending.len() - ordered.len(),
         );
+        let ordered_set: HashSet<Id<Transaction>> = ordered.iter().copied().collect();
         let mut leftovers: Vec<Id<Transaction>> =
-            remaining_parents.into_keys().filter(|id| !ordered.contains(id)).collect();
+            remaining_parents.into_keys().filter(|id| !ordered_set.contains(id)).collect();
         leftovers.sort_by_key(|id| tie_break_key(&by_id, id));
         ordered.extend(leftovers);
     }
@@ -306,7 +350,7 @@ pub struct ReconcileOutcome {
 pub fn reconcile(
     pending: &[PendingTx],
     presence: &BTreeMap<Id<Transaction>, bool>,
-    tracker: &RepushTracker,
+    tracker: &mut RepushTracker,
 ) -> ReconcileOutcome {
     if pending.len() != presence.len() {
         logging::log::error!(
@@ -327,19 +371,38 @@ pub fn reconcile(
         };
 
         if present {
+            // Alive again: the consecutive-absence evidence no longer applies.
+            tracker.reset_absence(&tx.id);
             continue;
         }
 
-        let parent_present = tx
-            .pending_parents
-            .iter()
-            .any(|parent| presence.get(parent).copied().unwrap_or(false));
+        if tx.pending_parents.is_empty() {
+            // No pending parents: the absence says nothing about rejection.
+            tracker.reset_absence(&tx.id);
+        } else {
+            let all_parents_present = tx
+                .pending_parents
+                .iter()
+                .all(|parent| presence.get(parent).copied().unwrap_or(false));
+
+            if all_parents_present {
+                // The deterministic-rejection signature (all pending parents
+                // present, transaction missing, node-observed submission)
+                // held again this pass.
+                let streak = tracker.bump_absence(&tx.id);
+                if tracker.node_observed(&tx.id) && streak >= PRUNE_ABSENCE_THRESHOLD {
+                    outcome.to_prune.push(tx.id);
+                    continue;
+                }
+            } else {
+                // Only some pending parents are present: the signature is
+                // incomplete, and the missing parents are about to be
+                // resubmitted. The evidence chain restarts.
+                tracker.reset_absence(&tx.id);
+            }
+        }
 
-        if parent_present && tracker.node_observed(&tx.id) {
-            // The node saw the transaction, had everything needed to connect it
-            // and still does not have it: deterministically rejected.
-            outcome.to_prune.push(tx.id);
-        } else if !tracker.is_stuck(&tx.id) {
+        if !tracker.is_stuck(&tx.id) {
             outcome.to_submit.push(tx.id);
         }
     }
@@ -378,6 +441,12 @@ pub fn reconcile(
             .collect::<Vec<_>>(),
     );
 
+    // Pruned transactions (and their descendants) leave the tracker entirely:
+    // their absence-evidence and retry state no longer apply.
+    for id in &outcome.to_prune {
+        tracker.forget(id);
+    }
+
     outcome
 }
 
@@ -473,9 +542,9 @@ mod tests {
     fn reconcile_submits_all_missing_without_present_parents() {
         let pending = vec![pt(1, vec![]), pt(2, vec![1]), pt(3, vec![])];
         let presence: BTreeMap<_, _> = (1..=3).map(|i| (test_id(i), false)).collect();
-        let tracker = RepushTracker::new();
+        let mut tracker = RepushTracker::new();
 
-        let outcome = reconcile(&pending, &presence, &tracker);
+        let outcome = reconcile(&pending, &presence, &mut tracker);
         assert_eq!(outcome.to_prune, Vec::<Id<Transaction>>::new());
         // 1 and 3 are ready immediately; 2 becomes ready after 1
         assert_eq!(outcome.to_submit, vec![test_id(1), test_id(3), test_id(2)]);
@@ -492,7 +561,14 @@ mod tests {
         let mut tracker = RepushTracker::new();
         tracker.on_rejected(&test_id(2), now()); // the node rejected one submission of 2
 
-        let outcome = reconcile(&pending, &presence, &tracker);
+        // The signature must hold for PRUNE_ABSENCE_THRESHOLD consecutive
+        // passes before pruning; build up the streak first.
+        for _ in 0..(PRUNE_ABSENCE_THRESHOLD - 1) {
+            let outcome = reconcile(&pending, &presence, &mut tracker);
+            assert!(outcome.to_prune.is_empty(), "premature prune");
+        }
+
+        let outcome = reconcile(&pending, &presence, &mut tracker);
         assert_eq!(outcome.to_prune, vec![test_id(2), test_id(3)]);
         assert_eq!(outcome.to_submit, vec![test_id(4)]);
     }
@@ -504,9 +580,9 @@ mod tests {
         // it must be (re)submitted, not pruned.
         let pending = vec![pt(1, vec![]), pt(2, vec![1]), pt(3, vec![2])];
         let presence: BTreeMap<_, _> = (1..=3).map(|i| (test_id(i), i == 1)).collect();
-        let tracker = RepushTracker::new();
+        let mut tracker = RepushTracker::new();
 
-        let outcome = reconcile(&pending, &presence, &tracker);
+        let outcome = reconcile(&pending, &presence, &mut tracker);
         assert_eq!(outcome.to_submit, vec![test_id(2), test_id(3)]);
         assert!(outcome.to_prune.is_empty());
     }
@@ -523,7 +599,7 @@ mod tests {
         tracker.on_rejected(&test_id(2), now());
         tracker.on_success(&test_id(2), now());
 
-        let outcome = reconcile(&pending, &presence, &tracker);
+        let outcome = reconcile(&pending, &presence, &mut tracker);
         assert_eq!(outcome.to_submit, vec![test_id(2)]);
         assert!(outcome.to_prune.is_empty());
     }
@@ -563,11 +639,83 @@ mod tests {
         let mut tracker = RepushTracker::new();
         tracker.on_delivery_failure(&test_id(2), now());
 
-        let outcome = reconcile(&pending, &presence, &tracker);
+        let outcome = reconcile(&pending, &presence, &mut tracker);
         assert_eq!(outcome.to_submit, vec![test_id(2)]);
         assert!(outcome.to_prune.is_empty());
     }
 
+    #[test]
+    fn reconcile_requires_consecutive_absences_before_pruning() {
+        // A transient overload reply sets node_observed; a single pass with
+        // "parent present, child missing" must NOT prune the live transaction.
+        let pending = vec![pt(1, vec![]), pt(2, vec![1])];
+        let presence: BTreeMap<_, _> = (1..=2).map(|i| (test_id(i), i == 1)).collect();
+
+        let mut tracker = RepushTracker::new();
+        tracker.on_rejected(&test_id(2), now()); // e.g. a server-busy rejection
+
+        for pass in 1..=PRUNE_ABSENCE_THRESHOLD {
+            let outcome = reconcile(&pending, &presence, &mut tracker);
+            if pass < PRUNE_ABSENCE_THRESHOLD {
+                assert_eq!(outcome.to_submit, vec![test_id(2)], "pass {pass}");
+                assert!(outcome.to_prune.is_empty(), "pass {pass}");
+            } else {
+                assert_eq!(outcome.to_prune, vec![test_id(2)], "pass {pass}");
+            }
+        }
+    }
+
+    #[test]
+    fn reconcile_resets_absence_streak_when_transaction_reappears() {
+        // Presence S: the signature holds (parent present, child missing).
+        // Presence R: the child reappeared in the mempool (streak resets).
+        // Presence G: both gone (parent missing too; signature broken).
+        let pending = vec![pt(1, vec![]), pt(2, vec![1])];
+        let presence_signature = |child_present: bool| -> BTreeMap<Id<Transaction>, bool> {
+            [(1, true), (2, child_present)]
+                .into_iter()
+                .map(|(i, present)| (test_id(i), present))
+                .collect()
+        };
+        let presence_gone: BTreeMap<Id<Transaction>, bool> =
+            (1..=2).map(|i| (test_id(i), false)).collect();
+
+        let mut tracker = RepushTracker::new();
+        tracker.on_rejected(&test_id(2), now()); // e.g. a server-busy rejection
+
+        // Build the streak up to threshold - 1...
+        for pass in 1..PRUNE_ABSENCE_THRESHOLD {
+            let outcome = reconcile(&pending, &presence_signature(false), &mut tracker);
+            assert_eq!(outcome.to_submit, vec![test_id(2)], "pass {pass}");
+            assert!(outcome.to_prune.is_empty(), "pass {pass}");
+        }
+
+        // ...the transaction reappears in the mempool: the evidence chain
+        // resets, so it is not pruned even though it goes missing again.
+        let outcome = reconcile(&pending, &presence_signature(true), &mut tracker);
+        assert!(outcome.to_submit.is_empty());
+        assert!(outcome.to_prune.is_empty());
+        assert_eq!(tracker.absence_streak(&test_id(2)), 0);
+
+        // Both the parent and the child vanish: the signature is broken, the
+        // streak resets, and both are simply resubmitted.
+        let outcome = reconcile(&pending, &presence_gone, &mut tracker);
+        assert_eq!(outcome.to_submit, vec![test_id(1), test_id(2)]);
+        assert_eq!(tracker.absence_streak(&test_id(2)), 0);
+
+        // The streak restarts from zero: threshold - 1 further signature
+        // passes still do not prune.
+        for pass in 1..PRUNE_ABSENCE_THRESHOLD {
+            let outcome = reconcile(&pending, &presence_signature(false), &mut tracker);
+            assert_eq!(outcome.to_submit, vec![test_id(2)], "pass {pass}");
+            assert!(outcome.to_prune.is_empty(), "pass {pass}");
+        }
+
+        // Only the pass that completes the streak prunes.
+        let outcome = reconcile(&pending, &presence_signature(false), &mut tracker);
+        assert_eq!(outcome.to_prune, vec![test_id(2)]);
+    }
+
     #[test]
     fn reconcile_skips_stuck() {
         let pending = vec![pt(1, vec![])];
@@ -580,7 +728,7 @@ mod tests {
             tracker.on_rejected(&id, t);
         }
 
-        let outcome = reconcile(&pending, &presence, &tracker);
+        let outcome = reconcile(&pending, &presence, &mut tracker);
         assert!(outcome.to_submit.is_empty());
         assert!(outcome.to_prune.is_empty());
     }
@@ -589,9 +737,9 @@ mod tests {
     fn reconcile_present_transactions_left_alone() {
         let pending = vec![pt(1, vec![]), pt(2, vec![1])];
         let presence: BTreeMap<_, _> = (1..=2).map(|i| (test_id(i), true)).collect();
-        let tracker = RepushTracker::new();
+        let mut tracker = RepushTracker::new();
 
-        let outcome = reconcile(&pending, &presence, &tracker);
+        let outcome = reconcile(&pending, &presence, &mut tracker);
         assert!(outcome.to_submit.is_empty());
         assert!(outcome.to_prune.is_empty());
     }