Method requeue

crates/buzz-acp/src/queue.rs:385–454

Re-queue a batch of events that failed to process. Events are pushed back to the **front** of the channel's queue so they are processed first on the next flush cycle. This prevents event loss when session creation or `session/prompt` fails transiently. Original `received_at` timestamps are preserved so the channel retains its fairness position. The retry delay comes from exponential backoff, not

(&mut self, batch: FlushBatch)

    /// Note: does NOT remove from `in_flight_channels` — caller must call
    /// `mark_complete` separately.
    pub fn requeue(&mut self, batch: FlushBatch) -> Option<FlushBatch> {
        let channel_id = batch.channel_id;
        let attempt = {
            let count = self.retry_counts.entry(channel_id).or_insert(0);
            *count += 1;
            *count
        };

        if attempt > MAX_RETRIES {
            tracing::error!(
                channel_id = %channel_id,
                attempt,
                events = batch.events.len(),
                "dead-lettering batch after {} retries — discarding {} events",
                MAX_RETRIES,
                batch.events.len(),
            );
            self.retry_counts.remove(&channel_id);
            // Also clear retry_after so fresh traffic on this channel isn't
            // throttled by stale backoff from the discarded poison batch.
            self.retry_after.remove(&channel_id);
            return Some(batch);
        }

        // Exponential backoff: BASE * 2^(attempt-1), capped at MAX, with ±20% jitter.
        let base_secs = BASE_RETRY_DELAY_SECS.saturating_mul(1u64 << (attempt - 1).min(6));
        let capped_secs = base_secs.min(MAX_RETRY_DELAY_SECS);
        // Jitter: multiply by 0.8..1.2 using subsecond nanos as entropy source.
        let jitter = {
            let nanos = std::time::SystemTime::now()
                .duration_since(std::time::UNIX_EPOCH)
                .unwrap_or_default()
                .subsec_nanos();
            0.8 + (nanos as f64 / u32::MAX as f64) * 0.4
        };
        let delay = Duration::from_secs_f64(capped_secs as f64 * jitter);

        tracing::warn!(
            channel_id = %channel_id,
            attempt,
            max = MAX_RETRIES,
            delay_secs = delay.as_secs_f64(),
            events = batch.events.len(),
            "requeueing failed batch with backoff"
        );

        let queue = self.queues.entry(channel_id).or_default();
        // Push to front in reverse order so original order is preserved.
        for be in batch.events.into_iter().rev() {
            queue.push_front(QueuedEvent {
                channel_id,
                event: be.event,
                prompt_tag: be.prompt_tag,
                received_at: be.received_at, // preserve original timestamp (#46)
            });
        }
        // Enforce per-channel cap: trim oldest (back) events if requeue pushed
        // the queue over the limit. Without this, repeated requeue+push cycles