Chain prior-attempt failures in retry_with_backoff exhaustion

The exhaustion raise previously carried only the last error;
diagnostic context for "node A went VOTER → STANDBY between attempts
1 and 3" was lost. Chain via _bounded_group (the same helper used
for find_leader / pool.initialize aggregates) so every attempt is
preserved on __cause__ as a BaseExceptionGroup.

Single-attempt path stays unchanged so simple cases keep their
existing exception shape.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

Author: antoineleclair

src/dqliteclient/retry.py

@@ -136,6 +136,7 @@ async def retry_with_backoff[T](
     deadline = None if max_elapsed_seconds is None else loop.time() + max_elapsed_seconds
 
     last_error: BaseException | None = None
+    history: list[BaseException] = []
 
     for attempt in range(max_attempts):
         # Deadline re-check BEFORE the next func() call: a previous
@@ -153,6 +154,7 @@ async def retry_with_backoff[T](
             raise
         except retryable_exceptions as e:
             last_error = e
+            history.append(e)
 
             if attempt == max_attempts - 1:
                 break
@@ -182,4 +184,17 @@ async def retry_with_backoff[T](
     # would still leave the invariant intact at this point because the
     # break path always sets last_error first).
     assert last_error is not None
+    if len(history) > 1:
+        # Chain prior-attempt failures so a forensic walker can see
+        # the full timeline rather than only the last error. Mirrors
+        # the discipline ``_find_leader_impl`` and
+        # ``ConnectionPool.initialize`` apply for per-node aggregates.
+        # ``_bounded_group`` caps children so the chain stays
+        # picklable for cross-process error capture. Local import to
+        # avoid the retry <-> cluster import cycle at module load.
+        from dqliteclient.cluster import _bounded_group
+
+        raise last_error from _bounded_group(
+            f"retry exhausted after {len(history)} attempts", history
+        )
     raise last_error

tests/test_retry_chains_prior_attempt_context.py

@@ -0,0 +1,64 @@
+"""``retry_with_backoff``'s exhaustion path chains prior-attempt
+failures via ``BaseExceptionGroup`` so the diagnostic for an
+exhausted retry loop carries every attempt's error, not just the
+last one. Mirrors the per-node aggregate discipline in
+``_find_leader_impl`` and ``ConnectionPool.initialize``.
+"""
+
+import pytest
+
+from dqliteclient.exceptions import DqliteConnectionError
+from dqliteclient.retry import retry_with_backoff
+
+
+@pytest.mark.asyncio
+async def test_retry_exhaustion_chains_via_bounded_group() -> None:
+    """The exhaustion raise's ``__cause__`` is a
+    ``BaseExceptionGroup`` carrying every attempt when ``len > 1``."""
+    attempts = 0
+
+    async def always_fail() -> None:
+        nonlocal attempts
+        attempts += 1
+        raise DqliteConnectionError(f"attempt {attempts}")
+
+    with pytest.raises(DqliteConnectionError) as excinfo:
+        await retry_with_backoff(
+            always_fail,
+            max_attempts=3,
+            retryable_exceptions=(DqliteConnectionError,),
+            base_delay=0.0,
+            max_delay=0.0,
+            jitter=0.0,
+        )
+
+    cause = excinfo.value.__cause__
+    assert isinstance(cause, BaseExceptionGroup)
+    assert len(cause.exceptions) == 3
+    # Each child carries the per-attempt message.
+    msgs = [str(e) for e in cause.exceptions]
+    for i in range(1, 4):
+        assert any(f"attempt {i}" in m for m in msgs)
+
+
+@pytest.mark.asyncio
+async def test_single_attempt_path_no_group_wrap() -> None:
+    """When max_attempts=1, the single-attempt failure raises
+    directly without a chain group — preserves the simple-case shape
+    callers are used to."""
+
+    async def fail_once() -> None:
+        raise DqliteConnectionError("only attempt")
+
+    with pytest.raises(DqliteConnectionError, match="only attempt") as excinfo:
+        await retry_with_backoff(
+            fail_once,
+            max_attempts=1,
+            retryable_exceptions=(DqliteConnectionError,),
+            base_delay=0.0,
+            max_delay=0.0,
+            jitter=0.0,
+        )
+
+    # No chain group wrap on single attempt.
+    assert excinfo.value.__cause__ is None