feat(client): make reconnect exponential backoff configurable

crates/irtt-client/src/managed/model.rs

@@ -104,6 +104,12 @@ pub struct ManagedClientConfig {
     /// Retry failed/closed sessions and detect silence while sending. Only valid
     /// for continuous measurement runs. None (the default) disables reconnection.
     pub reconnect_timeout: Option<Duration>,
+    /// First retry delay, also restored after a valid reply (default: 250 ms).
+    /// Must be positive and at most half of `reconnect_max_delay`.
+    pub reconnect_initial_delay: Duration,
+    /// Cap for per-target exponential backoff with a fixed multiplier of two
+    /// (default: 10 seconds). Must be schedulable from the current instant.
+    pub reconnect_max_delay: Duration,
 }
 
 impl Default for ManagedClientConfig {
@@ -118,6 +124,8 @@ impl Default for ManagedClientConfig {
             max_live_target_generations: DEFAULT_MANAGED_MAX_LIVE_TARGET_GENERATIONS,
             final_drain: DEFAULT_MANAGED_FINAL_DRAIN,
             reconnect_timeout: None,
+            reconnect_initial_delay: Duration::from_millis(250),
+            reconnect_max_delay: Duration::from_secs(10),
         }
     }
 }
@@ -370,6 +378,11 @@ pub struct ManagedTargetFailure {
 pub enum ManagedConfigError {
     #[error("reconnection requires continuous measurement mode and a positive, schedulable silence timeout")]
     InvalidReconnectPolicy,
+    #[error("reconnection delays must be positive and schedulable, with maximum delay at least twice the initial delay (initial: {initial:?}, maximum: {maximum:?})")]
+    InvalidReconnectDelays {
+        initial: Duration,
+        maximum: Duration,
+    },
     #[error("FinishWhenQuiescent requires at least one initial target")]
     EmptyInitialTargets,
     #[error("duplicate managed target id {id}")]

crates/irtt-client/src/managed/task/control.rs

@@ -367,6 +367,26 @@ fn build_task(
             maximum: tokio::sync::Semaphore::MAX_PERMITS,
         });
     }
+    if config.reconnect_initial_delay.is_zero()
+        || config.reconnect_max_delay.is_zero()
+        || config
+            .reconnect_initial_delay
+            .checked_mul(2)
+            .is_none_or(|minimum| config.reconnect_max_delay < minimum)
+        // Tokio represents timer deadlines in u64 milliseconds, reserving the
+        // top two values for state. Leave room for its millisecond rounding.
+        || config.reconnect_max_delay.as_millis() >= u128::from(u64::MAX - 2)
+        || config
+            .reconnect_max_delay
+            .checked_add(std::time::Duration::from_millis(1))
+            .and_then(|delay| Instant::now().checked_add(delay))
+            .is_none()
+    {
+        return Err(ManagedConfigError::InvalidReconnectDelays {
+            initial: config.reconnect_initial_delay,
+            maximum: config.reconnect_max_delay,
+        });
+    }
     if let Some(timeout) = config.reconnect_timeout {
         if timeout.is_zero()
             || Instant::now().checked_add(timeout).is_none()
@@ -427,7 +447,7 @@ fn build_task(
             remote: None,
             counters: TargetCounters::default(),
             sent_before_session: 0,
-            retry_delay: std::time::Duration::from_millis(250),
+            retry_delay: config.reconnect_initial_delay,
             silence_since: None,
             last_reply_at: None,
             phase: Some(TargetPhase::Pending { client_config }),

crates/irtt-client/src/managed/task/target.rs

@@ -329,7 +329,7 @@ impl ManagedClientTask {
                     // A healthy sender with a long interval can remain idle.
                     self.targets[index].silence_since = None;
                     self.targets[index].last_reply_at = Some(received_at.mono);
-                    self.targets[index].retry_delay = Duration::from_millis(250);
+                    self.targets[index].retry_delay = self.config.reconnect_initial_delay;
                 }
                 _ => {}
             }
@@ -344,7 +344,7 @@ impl ManagedClientTask {
     fn finish_target(
         &mut self,
         index: usize,
-        end_reason: ManagedTargetEndReason,
+        mut end_reason: ManagedTargetEndReason,
         cleanup_failure: Option<ManagedTargetFailure>,
     ) {
         if self.can_reconnect(index)
@@ -359,10 +359,17 @@ impl ManagedClientTask {
             target.sent_before_session = target.counters.packets_sent;
             target.silence_since = None;
             target.last_reply_at = None;
-            let deadline = Instant::now() + target.retry_delay;
-            target.retry_delay = (target.retry_delay * 2).min(Duration::from_secs(10));
-            self.install_target_phase(index, TargetPhase::Retrying { deadline });
-            return;
+            if let Some(deadline) = Instant::now().checked_add(target.retry_delay) {
+                target.retry_delay = target
+                    .retry_delay
+                    .checked_mul(2)
+                    .unwrap_or(self.config.reconnect_max_delay)
+                    .min(self.config.reconnect_max_delay);
+                self.install_target_phase(index, TargetPhase::Retrying { deadline });
+                return;
+            }
+            // A delay validated at construction may no longer fit after a long run.
+            end_reason = ManagedTargetEndReason::Failed(duration_overflow_failure());
         }
         let outcome = Arc::new(self.targets[index].outcome(end_reason, cleanup_failure));
         // Finalize history before the phase publisher installs Terminal, updates

crates/irtt-client/src/managed/task/update.rs

@@ -142,7 +142,7 @@ impl ManagedClientTask {
                 remote: None,
                 counters: TargetCounters::default(),
                 sent_before_session: 0,
-                retry_delay: std::time::Duration::from_millis(250),
+                retry_delay: self.config.reconnect_initial_delay,
                 silence_since: None,
                 last_reply_at: None,
                 phase: Some(TargetPhase::Pending {