fix: keep retryable failures retrying (#499)

mrcfps · web-flow · commit 50c549e11ebb · 2026-06-12T23:12:33.000+08:00
diff --git a/internal/fixer/runner.go b/internal/fixer/runner.go
@@ -6004,10 +6004,7 @@ func isRetryableFailure(kind QueueFailureKind) bool {
 }
 
 func shouldRetryQueueFailure(kind QueueFailureKind, nextAttempts, maxAttempts int64) bool {
-	if !isRetryableFailure(kind) {
-		return false
-	}
-	return maxAttempts <= 0 || nextAttempts < maxAttempts
+	return isRetryableFailure(kind)
 }
 
 func normalizePRState(value string) string {
diff --git a/internal/fixer/runner_test.go b/internal/fixer/runner_test.go
@@ -5145,16 +5145,16 @@ func TestProcessClaimedQueueItemResumeValidationFailureUpdatesLoopState(t *testi
 	if err != nil {
 		t.Fatalf("Queue.GetByID() error = %v", err)
 	}
-	if queue == nil || queue.Status != "manual_intervention" || queue.LastErrorKind == nil || *queue.LastErrorKind != string(FailureRetryableTransient) || queue.FinishedAt == nil {
-		t.Fatalf("queue = %#v, want parked retryable_transient queue item after exhaustion", queue)
+	if queue == nil || queue.Status != "queued" || queue.LastErrorKind == nil || *queue.LastErrorKind != string(FailureRetryableTransient) || queue.FinishedAt != nil {
+		t.Fatalf("queue = %#v, want requeued retryable_transient queue item after max attempts", queue)
 	}
 
 	loop, err := fixture.repos.Loops.GetByID(context.Background(), "loop_fixer_resume_parse_status")
 	if err != nil {
 		t.Fatalf("Loops.GetByID() error = %v", err)
 	}
-	if loop == nil || loop.Status != "paused" || loop.NextRunAt != nil {
-		t.Fatalf("loop = %#v, want paused parked loop after exhaustion", loop)
+	if loop == nil || loop.Status != "queued" || loop.NextRunAt == nil {
+		t.Fatalf("loop = %#v, want queued loop after max attempts", loop)
 	}
 	if len(git.cleanupCalls) != 0 {
 		t.Fatalf("len(git.cleanupCalls) = %d, want no cleanup for manual intervention", len(git.cleanupCalls))
diff --git a/internal/planner/runner.go b/internal/planner/runner.go
@@ -2123,10 +2123,7 @@ func isRetryableFailure(kind QueueFailureKind) bool {
 }
 
 func shouldRetryQueueFailure(kind QueueFailureKind, nextAttempts, maxAttempts int64) bool {
-	if !isRetryableFailure(kind) {
-		return false
-	}
-	return maxAttempts <= 0 || nextAttempts < maxAttempts
+	return isRetryableFailure(kind)
 }
 
 func cappedRetryDelayAttempt(attempts, maxAttempts int64) int64 {
diff --git a/internal/reviewer/runner.go b/internal/reviewer/runner.go
@@ -4153,8 +4153,7 @@ func isRetryableTransientWithRemainingAttempts(queue storage.QueueItemRecord) bo
 }
 
 func queueHasRemainingAttempts(queue storage.QueueItemRecord) bool {
-	nextAttempts := queue.Attempts + 1
-	return queue.MaxAttempts > 0 && nextAttempts < queue.MaxAttempts
+	return true
 }
 
 func isKnownReviewerRediscoveryGuardrail(message string) bool {
@@ -6064,10 +6063,7 @@ func isRetryableFailure(kind QueueFailureKind) bool {
 }
 
 func shouldRetryQueueFailure(kind QueueFailureKind, nextAttempts, maxAttempts int64) bool {
-	if !isRetryableFailure(kind) {
-		return false
-	}
-	return maxAttempts <= 0 || nextAttempts < maxAttempts
+	return isRetryableFailure(kind)
 }
 
 func cloneStrings(values []string) []string {
diff --git a/internal/reviewer/runner_test.go b/internal/reviewer/runner_test.go
@@ -445,7 +445,7 @@ func TestReviewerFailedLoopRecoveryEligibilityWhitelist(t *testing.T) {
 		{name: "retryable restart from discover", seed: failedReviewerRecoverySeed{ResumePolicy: "restart_from_discover", QueueErrorKind: string(FailureRetryableAfterResume), ErrorMessage: "PR head changed before publish"}, pr: PullRequestSummary{Number: 42, State: "OPEN"}, want: true},
 		{name: "retryable transient attempts remaining", seed: failedReviewerRecoverySeed{ResumePolicy: "replay_step", QueueErrorKind: string(FailureRetryableTransient), ErrorMessage: "reviewer agent timed out", QueueAttempts: 3, QueueMaxAttempts: 5}, pr: PullRequestSummary{Number: 42, State: "OPEN"}, want: true},
 		{name: "historical guardrail non retryable", seed: failedReviewerRecoverySeed{ResumePolicy: "replay_step", QueueErrorKind: string(FailureNonRetryable), ErrorMessage: "review request removed before publish"}, pr: PullRequestSummary{Number: 42, State: "OPEN"}, want: true},
-		{name: "retryable transient exhausted on final allowed run", seed: failedReviewerRecoverySeed{ResumePolicy: "replay_step", QueueErrorKind: string(FailureRetryableTransient), ErrorMessage: "reviewer agent timed out", QueueAttempts: 4, QueueMaxAttempts: 5}, pr: PullRequestSummary{Number: 42, State: "OPEN"}, want: false},
+		{name: "retryable transient ignores final allowed run", seed: failedReviewerRecoverySeed{ResumePolicy: "replay_step", QueueErrorKind: string(FailureRetryableTransient), ErrorMessage: "reviewer agent timed out", QueueAttempts: 4, QueueMaxAttempts: 5}, pr: PullRequestSummary{Number: 42, State: "OPEN"}, want: true},
 		{name: "manual intervention kind", seed: failedReviewerRecoverySeed{ResumePolicy: "replay_step", QueueErrorKind: string(FailureManualIntervention), ErrorMessage: "operator needed"}, pr: PullRequestSummary{Number: 42, State: "OPEN"}, want: false},
 		{name: "manual intervention resume policy", seed: failedReviewerRecoverySeed{ResumePolicy: "manual_intervention", QueueErrorKind: string(FailureRetryableAfterResume), ErrorMessage: "operator needed"}, pr: PullRequestSummary{Number: 42, State: "OPEN"}, want: false},
 		{name: "closed pr", seed: failedReviewerRecoverySeed{ResumePolicy: "restart_from_discover", QueueErrorKind: string(FailureRetryableAfterResume), ErrorMessage: "PR head changed before publish"}, pr: PullRequestSummary{Number: 42, State: "CLOSED"}, want: false},
@@ -6188,7 +6188,7 @@ func TestExecuteStepRetriesTransientDiscoverShellFailure(t *testing.T) {
 	}
 }
 
-func TestProcessClaimedItemPersistsExhaustedTransientDiscoverShellFailureAsRetryable(t *testing.T) {
+func TestProcessClaimedItemRequeuesTransientDiscoverShellFailureAfterMaxAttempts(t *testing.T) {
 	fixture := newRunnerFixture(t)
 	github := &fakeGitHubGateway{}
 	runner := New(Options{DB: fixture.coordinator.DB(), Repos: fixture.repos, GitHub: github, Git: &fakeGitGateway{}, AgentExecutor: &fakeAgentExecutor{}, Logger: fixture.logger, Now: fixture.now, RetryBaseDelay: time.Nanosecond, RetryMaxAttempts: 1})
@@ -6213,8 +6213,8 @@ func TestProcessClaimedItemPersistsExhaustedTransientDiscoverShellFailureAsRetry
 	if err != nil || queue == nil {
 		t.Fatalf("Queue.GetByID() = (%#v, %v), want queue", queue, err)
 	}
-	if queue.Status != "manual_intervention" || queue.LastErrorKind == nil || *queue.LastErrorKind != string(FailureRetryableTransient) || queue.LastError == nil || !strings.Contains(*queue.LastError, "unexpected EOF") || queue.FinishedAt == nil {
-		t.Fatalf("queue = %#v, want parked retryable transient item preserving GitHub error after exhaustion", queue)
+	if queue.Status != "queued" || queue.LastErrorKind == nil || *queue.LastErrorKind != string(FailureRetryableTransient) || queue.LastError == nil || !strings.Contains(*queue.LastError, "unexpected EOF") || queue.FinishedAt != nil {
+		t.Fatalf("queue = %#v, want requeued retryable transient item preserving GitHub error after max attempts", queue)
 	}
 }
 
diff --git a/internal/runtime/runtime.go b/internal/runtime/runtime.go
@@ -2703,8 +2703,7 @@ func runtimeRecoverableEnhancedTransient(policy config.ReviewerRetryConfig, queu
 }
 
 func runtimeQueueHasRemainingAttempts(queue storage.QueueItemRecord) bool {
-	nextAttempts := queue.Attempts + 1
-	return queue.MaxAttempts > 0 && nextAttempts < queue.MaxAttempts
+	return true
 }
 
 func autoRecoveredReviewerLoop(loop storage.LoopRecord, nowISO string) storage.LoopRecord {
diff --git a/internal/runtime/runtime_test.go b/internal/runtime/runtime_test.go
@@ -3658,8 +3658,8 @@ func TestShouldAutoRecoverFailedReviewerLoopAllowsRetryableTransientWithAttempts
 		t.Fatalf("shouldAutoRecoverFailedReviewerLoop() = false, want true")
 	}
 	queue.Attempts = 4
-	if shouldAutoRecoverFailedReviewerLoop(loop, &run, &queue, policy) {
-		t.Fatalf("shouldAutoRecoverFailedReviewerLoop() = true, want false on final allowed run")
+	if !shouldAutoRecoverFailedReviewerLoop(loop, &run, &queue, policy) {
+		t.Fatalf("shouldAutoRecoverFailedReviewerLoop() = false, want true after max attempts")
 	}
 }
 
@@ -3686,8 +3686,8 @@ func TestShouldAutoRecoverFailedReviewerLoopAllowsEnhancedMatchedTransientWhenCo
 		t.Fatal("shouldAutoRecoverFailedReviewerLoop(enabled) = false, want true")
 	}
 	queue.Attempts = 4
-	if shouldAutoRecoverFailedReviewerLoop(loop, &run, &queue, enabledPolicy) {
-		t.Fatal("shouldAutoRecoverFailedReviewerLoop(enabled final attempt) = true, want false")
+	if !shouldAutoRecoverFailedReviewerLoop(loop, &run, &queue, enabledPolicy) {
+		t.Fatal("shouldAutoRecoverFailedReviewerLoop(enabled final attempt) = false, want true")
 	}
 }
 
diff --git a/internal/runtime/scheduler.go b/internal/runtime/scheduler.go
@@ -1773,7 +1773,7 @@ func failSnapshotQueueItem(ctx context.Context, item storage.QueueItemRecord, in
 	}
 	nowISO := formatJavaScriptISOString(now().UTC())
 	nextAttempts := item.Attempts + 1
-	if kind == "retryable_transient" && nextAttempts < item.MaxAttempts {
+	if kind == "retryable_transient" {
 		retryAt := formatJavaScriptISOString(now().UTC().Add(time.Minute * time.Duration(cappedRetryDelayAttempt(nextAttempts, item.MaxAttempts))))
 		return input.Repos.Queue.MarkRetry(ctx, storage.QueueMarkRetryInput{ID: item.ID, AvailableAt: retryAt, Attempts: nextAttempts, ErrorMessage: &message, ErrorKind: kind, UpdatedAt: nowISO})
 	}
diff --git a/internal/sweeper/runner.go b/internal/sweeper/runner.go
@@ -381,10 +381,7 @@ func (r *Runner) recoverClaimedQueueItem(ctx context.Context, queueItem storage.
 }
 
 func shouldRetryQueueFailure(kind string, nextAttempts, maxAttempts int64) bool {
-	if kind != "retryable_transient" {
-		return false
-	}
-	return maxAttempts <= 0 || nextAttempts < maxAttempts
+	return kind == "retryable_transient"
 }
 
 func cappedRetryDelayAttempt(attempts, maxAttempts int64) int64 {
diff --git a/internal/sweeper/runner_test.go b/internal/sweeper/runner_test.go
@@ -1502,7 +1502,7 @@ func TestProcessWarnRecoversAfterCommentPostedButLabelFails(t *testing.T) {
 	}
 }
 
-func TestProcessWarnFailsQueueItemAfterMaxAttempts(t *testing.T) {
+func TestProcessWarnRequeuesRetryableFailureAfterMaxAttempts(t *testing.T) {
 	t.Parallel()
 
 	fixture := newRunnerFixture(t)
@@ -1525,8 +1525,8 @@ func TestProcessWarnFailsQueueItemAfterMaxAttempts(t *testing.T) {
 	if err != nil {
 		t.Fatalf("Queue.GetByID() error = %v", err)
 	}
-	if stored == nil || stored.Status != "manual_intervention" || stored.Attempts != 3 || stored.FinishedAt == nil || stored.LastErrorKind == nil || *stored.LastErrorKind != "retryable_transient" {
-		t.Fatalf("stored queue item = %#v, want parked queue item after max attempts", stored)
+	if stored == nil || stored.Status != "queued" || stored.Attempts != 3 || stored.FinishedAt != nil || stored.LastErrorKind == nil || *stored.LastErrorKind != "retryable_transient" {
+		t.Fatalf("stored queue item = %#v, want requeued queue item after max attempts", stored)
 	}
 }
 
diff --git a/internal/worker/runner.go b/internal/worker/runner.go
@@ -2668,10 +2668,7 @@ func shouldNotifyCompletedRun(kind QueueFailureKind, failedQueue *storage.QueueI
 }
 
 func shouldRetryQueueFailure(kind QueueFailureKind, nextAttempts, maxAttempts int64) bool {
-	if kind != FailureRetryableTransient && kind != FailureRetryableAfterResume {
-		return false
-	}
-	return maxAttempts <= 0 || nextAttempts < maxAttempts
+	return kind == FailureRetryableTransient || kind == FailureRetryableAfterResume
 }
 
 func issueClaimStatusForFailure(checkpoint workerCheckpoint, failedQueue *storage.QueueItemRecord, kind QueueFailureKind) string {
diff --git a/internal/worker/runner_test.go b/internal/worker/runner_test.go
@@ -1025,16 +1025,16 @@ func TestProcessClaimedQueueItemResumeValidationFailureUpdatesLoopState(t *testi
 	if err != nil {
 		t.Fatalf("Queue.GetByID() error = %v", err)
 	}
-	if queue == nil || queue.Status != "manual_intervention" || queue.LastErrorKind == nil || *queue.LastErrorKind != string(FailureRetryableTransient) || queue.FinishedAt == nil {
-		t.Fatalf("queue = %#v, want parked retryable_transient queue item after max attempts", queue)
+	if queue == nil || queue.Status != "queued" || queue.LastErrorKind == nil || *queue.LastErrorKind != string(FailureRetryableTransient) || queue.FinishedAt != nil {
+		t.Fatalf("queue = %#v, want requeued retryable_transient queue item after max attempts", queue)
 	}
 
 	loop, err := fixture.repos.Loops.GetByID(context.Background(), "loop_worker_1")
 	if err != nil {
 		t.Fatalf("Loops.GetByID() error = %v", err)
 	}
-	if loop == nil || loop.Status != "paused" || loop.NextRunAt != nil {
-		t.Fatalf("loop = %#v, want paused loop after max attempts", loop)
+	if loop == nil || loop.Status != "queued" || loop.NextRunAt == nil {
+		t.Fatalf("loop = %#v, want queued loop after max attempts", loop)
 	}
 }
 

Original file line number	Diff line number	Diff line change
`@@ -6004,10 +6004,7 @@ func isRetryableFailure(kind QueueFailureKind) bool {`
`6004`	`6004`	`}`
`6005`	`6005`
`6006`	`6006`	`func shouldRetryQueueFailure(kind QueueFailureKind, nextAttempts, maxAttempts int64) bool {`
`6007`		`- if !isRetryableFailure(kind) {`
`6008`		`- return false`
`6009`		`- }`
`6010`		`- return maxAttempts <= 0 \|\| nextAttempts < maxAttempts`
	`6007`	`+ return isRetryableFailure(kind)`
`6011`	`6008`	`}`
`6012`	`6009`
`6013`	`6010`	`func normalizePRState(value string) string {`
Original file line number	Diff line number	Diff line change
`@@ -5145,16 +5145,16 @@ func TestProcessClaimedQueueItemResumeValidationFailureUpdatesLoopState(t *testi`
`5145`	`5145`	`if err != nil {`
`5146`	`5146`	`t.Fatalf("Queue.GetByID() error = %v", err)`
`5147`	`5147`	`}`
`5148`		`- if queue == nil \|\| queue.Status != "manual_intervention" \|\| queue.LastErrorKind == nil \|\| *queue.LastErrorKind != string(FailureRetryableTransient) \|\| queue.FinishedAt == nil {`
`5149`		`- t.Fatalf("queue = %#v, want parked retryable_transient queue item after exhaustion", queue)`
	`5148`	`+ if queue == nil \|\| queue.Status != "queued" \|\| queue.LastErrorKind == nil \|\| *queue.LastErrorKind != string(FailureRetryableTransient) \|\| queue.FinishedAt != nil {`
	`5149`	`+ t.Fatalf("queue = %#v, want requeued retryable_transient queue item after max attempts", queue)`
`5150`	`5150`	`}`
`5151`	`5151`
`5152`	`5152`	`loop, err := fixture.repos.Loops.GetByID(context.Background(), "loop_fixer_resume_parse_status")`
`5153`	`5153`	`if err != nil {`
`5154`	`5154`	`t.Fatalf("Loops.GetByID() error = %v", err)`
`5155`	`5155`	`}`
`5156`		`- if loop == nil \|\| loop.Status != "paused" \|\| loop.NextRunAt != nil {`
`5157`		`- t.Fatalf("loop = %#v, want paused parked loop after exhaustion", loop)`
	`5156`	`+ if loop == nil \|\| loop.Status != "queued" \|\| loop.NextRunAt == nil {`
	`5157`	`+ t.Fatalf("loop = %#v, want queued loop after max attempts", loop)`
`5158`	`5158`	`}`
`5159`	`5159`	`if len(git.cleanupCalls) != 0 {`
`5160`	`5160`	`t.Fatalf("len(git.cleanupCalls) = %d, want no cleanup for manual intervention", len(git.cleanupCalls))`
Original file line number	Diff line number	Diff line change
`@@ -2123,10 +2123,7 @@ func isRetryableFailure(kind QueueFailureKind) bool {`
`2123`	`2123`	`}`
`2124`	`2124`
`2125`	`2125`	`func shouldRetryQueueFailure(kind QueueFailureKind, nextAttempts, maxAttempts int64) bool {`
`2126`		`- if !isRetryableFailure(kind) {`
`2127`		`- return false`
`2128`		`- }`
`2129`		`- return maxAttempts <= 0 \|\| nextAttempts < maxAttempts`
	`2126`	`+ return isRetryableFailure(kind)`
`2130`	`2127`	`}`
`2131`	`2128`
`2132`	`2129`	`func cappedRetryDelayAttempt(attempts, maxAttempts int64) int64 {`
Original file line number	Diff line number	Diff line change
`@@ -4153,8 +4153,7 @@ func isRetryableTransientWithRemainingAttempts(queue storage.QueueItemRecord) bo`
`4153`	`4153`	`}`
`4154`	`4154`
`4155`	`4155`	`func queueHasRemainingAttempts(queue storage.QueueItemRecord) bool {`
`4156`		`- nextAttempts := queue.Attempts + 1`
`4157`		`- return queue.MaxAttempts > 0 && nextAttempts < queue.MaxAttempts`
	`4156`	`+ return true`
`4158`	`4157`	`}`
`4159`	`4158`
`4160`	`4159`	`func isKnownReviewerRediscoveryGuardrail(message string) bool {`
`@@ -6064,10 +6063,7 @@ func isRetryableFailure(kind QueueFailureKind) bool {`
`6064`	`6063`	`}`
`6065`	`6064`
`6066`	`6065`	`func shouldRetryQueueFailure(kind QueueFailureKind, nextAttempts, maxAttempts int64) bool {`
`6067`		`- if !isRetryableFailure(kind) {`
`6068`		`- return false`
`6069`		`- }`
`6070`		`- return maxAttempts <= 0 \|\| nextAttempts < maxAttempts`
	`6066`	`+ return isRetryableFailure(kind)`
`6071`	`6067`	`}`
`6072`	`6068`
`6073`	`6069`	`func cloneStrings(values []string) []string {`
Original file line number	Diff line number	Diff line change
`@@ -445,7 +445,7 @@ func TestReviewerFailedLoopRecoveryEligibilityWhitelist(t *testing.T) {`
`445`	`445`	`{name: "retryable restart from discover", seed: failedReviewerRecoverySeed{ResumePolicy: "restart_from_discover", QueueErrorKind: string(FailureRetryableAfterResume), ErrorMessage: "PR head changed before publish"}, pr: PullRequestSummary{Number: 42, State: "OPEN"}, want: true},`
`446`	`446`	`{name: "retryable transient attempts remaining", seed: failedReviewerRecoverySeed{ResumePolicy: "replay_step", QueueErrorKind: string(FailureRetryableTransient), ErrorMessage: "reviewer agent timed out", QueueAttempts: 3, QueueMaxAttempts: 5}, pr: PullRequestSummary{Number: 42, State: "OPEN"}, want: true},`
`447`	`447`	`{name: "historical guardrail non retryable", seed: failedReviewerRecoverySeed{ResumePolicy: "replay_step", QueueErrorKind: string(FailureNonRetryable), ErrorMessage: "review request removed before publish"}, pr: PullRequestSummary{Number: 42, State: "OPEN"}, want: true},`
`448`		`- {name: "retryable transient exhausted on final allowed run", seed: failedReviewerRecoverySeed{ResumePolicy: "replay_step", QueueErrorKind: string(FailureRetryableTransient), ErrorMessage: "reviewer agent timed out", QueueAttempts: 4, QueueMaxAttempts: 5}, pr: PullRequestSummary{Number: 42, State: "OPEN"}, want: false},`
	`448`	`+ {name: "retryable transient ignores final allowed run", seed: failedReviewerRecoverySeed{ResumePolicy: "replay_step", QueueErrorKind: string(FailureRetryableTransient), ErrorMessage: "reviewer agent timed out", QueueAttempts: 4, QueueMaxAttempts: 5}, pr: PullRequestSummary{Number: 42, State: "OPEN"}, want: true},`
`449`	`449`	`{name: "manual intervention kind", seed: failedReviewerRecoverySeed{ResumePolicy: "replay_step", QueueErrorKind: string(FailureManualIntervention), ErrorMessage: "operator needed"}, pr: PullRequestSummary{Number: 42, State: "OPEN"}, want: false},`
`450`	`450`	`{name: "manual intervention resume policy", seed: failedReviewerRecoverySeed{ResumePolicy: "manual_intervention", QueueErrorKind: string(FailureRetryableAfterResume), ErrorMessage: "operator needed"}, pr: PullRequestSummary{Number: 42, State: "OPEN"}, want: false},`
`451`	`451`	`{name: "closed pr", seed: failedReviewerRecoverySeed{ResumePolicy: "restart_from_discover", QueueErrorKind: string(FailureRetryableAfterResume), ErrorMessage: "PR head changed before publish"}, pr: PullRequestSummary{Number: 42, State: "CLOSED"}, want: false},`
`@@ -6188,7 +6188,7 @@ func TestExecuteStepRetriesTransientDiscoverShellFailure(t *testing.T) {`
`6188`	`6188`	`}`
`6189`	`6189`	`}`
`6190`	`6190`
`6191`		`-func TestProcessClaimedItemPersistsExhaustedTransientDiscoverShellFailureAsRetryable(t *testing.T) {`
	`6191`	`+func TestProcessClaimedItemRequeuesTransientDiscoverShellFailureAfterMaxAttempts(t *testing.T) {`
`6192`	`6192`	`fixture := newRunnerFixture(t)`
`6193`	`6193`	`github := &fakeGitHubGateway{}`
`6194`	`6194`	`runner := New(Options{DB: fixture.coordinator.DB(), Repos: fixture.repos, GitHub: github, Git: &fakeGitGateway{}, AgentExecutor: &fakeAgentExecutor{}, Logger: fixture.logger, Now: fixture.now, RetryBaseDelay: time.Nanosecond, RetryMaxAttempts: 1})`
`@@ -6213,8 +6213,8 @@ func TestProcessClaimedItemPersistsExhaustedTransientDiscoverShellFailureAsRetry`
`6213`	`6213`	`if err != nil \|\| queue == nil {`
`6214`	`6214`	`t.Fatalf("Queue.GetByID() = (%#v, %v), want queue", queue, err)`
`6215`	`6215`	`}`
`6216`		`- if queue.Status != "manual_intervention" \|\| queue.LastErrorKind == nil \|\| queue.LastErrorKind != string(FailureRetryableTransient) \|\| queue.LastError == nil \|\| !strings.Contains(queue.LastError, "unexpected EOF") \|\| queue.FinishedAt == nil {`
`6217`		`- t.Fatalf("queue = %#v, want parked retryable transient item preserving GitHub error after exhaustion", queue)`
	`6216`	`+ if queue.Status != "queued" \|\| queue.LastErrorKind == nil \|\| queue.LastErrorKind != string(FailureRetryableTransient) \|\| queue.LastError == nil \|\| !strings.Contains(queue.LastError, "unexpected EOF") \|\| queue.FinishedAt != nil {`
	`6217`	`+ t.Fatalf("queue = %#v, want requeued retryable transient item preserving GitHub error after max attempts", queue)`
`6218`	`6218`	`}`
`6219`	`6219`	`}`
`6220`	`6220`
Original file line number	Diff line number	Diff line change
`@@ -2703,8 +2703,7 @@ func runtimeRecoverableEnhancedTransient(policy config.ReviewerRetryConfig, queu`
`2703`	`2703`	`}`
`2704`	`2704`
`2705`	`2705`	`func runtimeQueueHasRemainingAttempts(queue storage.QueueItemRecord) bool {`
`2706`		`- nextAttempts := queue.Attempts + 1`
`2707`		`- return queue.MaxAttempts > 0 && nextAttempts < queue.MaxAttempts`
	`2706`	`+ return true`
`2708`	`2707`	`}`
`2709`	`2708`
`2710`	`2709`	`func autoRecoveredReviewerLoop(loop storage.LoopRecord, nowISO string) storage.LoopRecord {`
Original file line number	Diff line number	Diff line change
`@@ -3658,8 +3658,8 @@ func TestShouldAutoRecoverFailedReviewerLoopAllowsRetryableTransientWithAttempts`
`3658`	`3658`	`t.Fatalf("shouldAutoRecoverFailedReviewerLoop() = false, want true")`
`3659`	`3659`	`}`
`3660`	`3660`	`queue.Attempts = 4`
`3661`		`- if shouldAutoRecoverFailedReviewerLoop(loop, &run, &queue, policy) {`
`3662`		`- t.Fatalf("shouldAutoRecoverFailedReviewerLoop() = true, want false on final allowed run")`
	`3661`	`+ if !shouldAutoRecoverFailedReviewerLoop(loop, &run, &queue, policy) {`
	`3662`	`+ t.Fatalf("shouldAutoRecoverFailedReviewerLoop() = false, want true after max attempts")`
`3663`	`3663`	`}`
`3664`	`3664`	`}`
`3665`	`3665`
`@@ -3686,8 +3686,8 @@ func TestShouldAutoRecoverFailedReviewerLoopAllowsEnhancedMatchedTransientWhenCo`
`3686`	`3686`	`t.Fatal("shouldAutoRecoverFailedReviewerLoop(enabled) = false, want true")`
`3687`	`3687`	`}`
`3688`	`3688`	`queue.Attempts = 4`
`3689`		`- if shouldAutoRecoverFailedReviewerLoop(loop, &run, &queue, enabledPolicy) {`
`3690`		`- t.Fatal("shouldAutoRecoverFailedReviewerLoop(enabled final attempt) = true, want false")`
	`3689`	`+ if !shouldAutoRecoverFailedReviewerLoop(loop, &run, &queue, enabledPolicy) {`
	`3690`	`+ t.Fatal("shouldAutoRecoverFailedReviewerLoop(enabled final attempt) = false, want true")`
`3691`	`3691`	`}`
`3692`	`3692`	`}`
`3693`	`3693`
Original file line number	Diff line number	Diff line change
`@@ -1773,7 +1773,7 @@ func failSnapshotQueueItem(ctx context.Context, item storage.QueueItemRecord, in`
`1773`	`1773`	`}`
`1774`	`1774`	`nowISO := formatJavaScriptISOString(now().UTC())`
`1775`	`1775`	`nextAttempts := item.Attempts + 1`
`1776`		`- if kind == "retryable_transient" && nextAttempts < item.MaxAttempts {`
	`1776`	`+ if kind == "retryable_transient" {`
`1777`	`1777`	`retryAt := formatJavaScriptISOString(now().UTC().Add(time.Minute * time.Duration(cappedRetryDelayAttempt(nextAttempts, item.MaxAttempts))))`
`1778`	`1778`	`return input.Repos.Queue.MarkRetry(ctx, storage.QueueMarkRetryInput{ID: item.ID, AvailableAt: retryAt, Attempts: nextAttempts, ErrorMessage: &message, ErrorKind: kind, UpdatedAt: nowISO})`
`1779`	`1779`	`}`
Original file line number	Diff line number	Diff line change
`@@ -381,10 +381,7 @@ func (r *Runner) recoverClaimedQueueItem(ctx context.Context, queueItem storage.`
`381`	`381`	`}`
`382`	`382`
`383`	`383`	`func shouldRetryQueueFailure(kind string, nextAttempts, maxAttempts int64) bool {`
`384`		`- if kind != "retryable_transient" {`
`385`		`- return false`
`386`		`- }`
`387`		`- return maxAttempts <= 0 \|\| nextAttempts < maxAttempts`
	`384`	`+ return kind == "retryable_transient"`
`388`	`385`	`}`
`389`	`386`
`390`	`387`	`func cappedRetryDelayAttempt(attempts, maxAttempts int64) int64 {`
Original file line number	Diff line number	Diff line change
`@@ -1502,7 +1502,7 @@ func TestProcessWarnRecoversAfterCommentPostedButLabelFails(t *testing.T) {`
`1502`	`1502`	`}`
`1503`	`1503`	`}`
`1504`	`1504`
`1505`		`-func TestProcessWarnFailsQueueItemAfterMaxAttempts(t *testing.T) {`
	`1505`	`+func TestProcessWarnRequeuesRetryableFailureAfterMaxAttempts(t *testing.T) {`
`1506`	`1506`	`t.Parallel()`
`1507`	`1507`
`1508`	`1508`	`fixture := newRunnerFixture(t)`
`@@ -1525,8 +1525,8 @@ func TestProcessWarnFailsQueueItemAfterMaxAttempts(t *testing.T) {`
`1525`	`1525`	`if err != nil {`
`1526`	`1526`	`t.Fatalf("Queue.GetByID() error = %v", err)`
`1527`	`1527`	`}`
`1528`		`- if stored == nil \|\| stored.Status != "manual_intervention" \|\| stored.Attempts != 3 \|\| stored.FinishedAt == nil \|\| stored.LastErrorKind == nil \|\| *stored.LastErrorKind != "retryable_transient" {`
`1529`		`- t.Fatalf("stored queue item = %#v, want parked queue item after max attempts", stored)`
	`1528`	`+ if stored == nil \|\| stored.Status != "queued" \|\| stored.Attempts != 3 \|\| stored.FinishedAt != nil \|\| stored.LastErrorKind == nil \|\| *stored.LastErrorKind != "retryable_transient" {`
	`1529`	`+ t.Fatalf("stored queue item = %#v, want requeued queue item after max attempts", stored)`
`1530`	`1530`	`}`
`1531`	`1531`	`}`
`1532`	`1532`