From c6e0681388ba8327f8c66e64656cd1172e5f5348 Mon Sep 17 00:00:00 2001 From: kristofferR Date: Wed, 22 Jul 2026 20:12:01 +0200 Subject: [PATCH 1/7] Degrade to Codex-only rounds while CodeRabbit is rate-limited CodeRabbit's account-wide review limit used to stall crq loop for the whole window even when Codex reviews every push. Now, when the account is blocked and Codex shows observed responsiveness on the PR, the round degrades to Codex-only: - DecideFire returns FireCodexDeferred for blocked rounds with a postable required Codex: the pump posts only the Codex command and the round stays queued, so CodeRabbit still fires the moment the window opens (with no duplicate Codex post). - Loop returns Codex findings promptly (exit 10) or a clean Codex verdict (exit 0, status "deferred") instead of extending its deadline past the block; a degraded round is never completed, so the CodeRabbit review stays owed and converged stays false until it lands. Wait hands a blocked slot-wait off to the poll loop on a clean Codex answer instead of spinning out the window. - Reports carry coderabbit_deferred and coderabbit_deferred_until; the deferral requires observed Codex evidence (auto-active or round-bound activity, minus usage-limit notices), never mere configuration. Default on; CRQ_RL_CODEX_DEGRADE=0 restores the old ride-out-the-window behavior. --- internal/crq/config.go | 6 ++ internal/crq/feedback.go | 74 ++++++++++--- internal/crq/service.go | 55 ++++++++++ internal/crq/service_test.go | 176 +++++++++++++++++++++++++++++++ internal/crq/state.go | 13 +-- internal/engine/codex.go | 17 +++ internal/engine/completion.go | 20 ++++ internal/engine/engine.go | 5 + internal/engine/engine_test.go | 103 ++++++++++++++++++ internal/engine/fire.go | 10 ++ llms.txt | 25 +++-- skills/coderabbit-queue/SKILL.md | 14 ++- 12 files changed, 490 insertions(+), 28 deletions(-) diff --git a/internal/crq/config.go b/internal/crq/config.go index 8c237fe..7bb4b62 100644 --- a/internal/crq/config.go +++ b/internal/crq/config.go @@ -69,6 +69,10 @@ type Config struct { // CodeRabbit review following its comment shells) is caught by crq instead // of by a human re-checking the PR. 0 disables. SettleWindow time.Duration + // RateLimitCodexDegrade degrades an account-blocked round to Codex-only + // (return Codex findings promptly, keep CodeRabbit queued for the window) + // instead of waiting the block out. CRQ_RL_CODEX_DEGRADE, default on. + RateLimitCodexDegrade bool } func LoadConfig() (Config, error) { @@ -135,6 +139,8 @@ func LoadConfig() (Config, error) { DryRun: env["CRQ_DRY_RUN"] == "1", FeedbackWaitTimeout: durationEnv(env, "CRQ_FEEDBACK_WAIT_TIMEOUT", 20*time.Minute), SettleWindow: durationEnv(env, "CRQ_SETTLE", 90*time.Second), + + RateLimitCodexDegrade: env["CRQ_RL_CODEX_DEGRADE"] != "0", } if len(cfg.Scope) == 0 && cfg.GateRepo != "" { cfg.Scope = []string{ownerOf(cfg.GateRepo)} diff --git a/internal/crq/feedback.go b/internal/crq/feedback.go index 66d06a2..edf57ec 100644 --- a/internal/crq/feedback.go +++ b/internal/crq/feedback.go @@ -26,6 +26,12 @@ type FeedbackReport struct { ReviewedBy map[string]bool `json:"reviewed_by"` Findings []dialect.Finding `json:"findings"` CheckedAt time.Time `json:"checked_at"` + // CodeRabbitDeferred marks a round degraded to Codex-only while the + // CodeRabbit account is rate-limited: Codex feedback is authoritative for + // this round, the CodeRabbit review stays queued and fires after + // DeferredUntil. Converged stays false until it does. + CodeRabbitDeferred bool `json:"coderabbit_deferred,omitempty"` + DeferredUntil *time.Time `json:"coderabbit_deferred_until,omitempty"` } func (s *Service) Feedback(ctx context.Context, repo string, pr int) (FeedbackReport, error) { @@ -238,9 +244,27 @@ func (s *Service) Feedback(ctx context.Context, repo string, pr int) (FeedbackRe return report.Findings[i].Line < report.Findings[j].Line }) report.Converged = engine.Converged(report.Findings, completion) - if report.Converged { + // Degrade detection: a live rate-limit window plus observed Codex + // responsiveness means this round runs Codex-only for now. Converged is + // structurally false here (CodeRabbit has no review evidence), so a + // deferred round can never masquerade as converged. + if s.cfg.RateLimitCodexDegrade && !report.Converged { + if until, ok := st.AccountBlockedUntil(repo, pr, head, now); ok && + engine.CodexOnlyEligible(completionRound, obs.eng, &until, now) { + report.CodeRabbitDeferred = true + u := until + report.DeferredUntil = &u + } + } + switch { + case report.Converged: report.Status = "converged" - } else if len(report.Findings) == 0 { + case report.CodeRabbitDeferred && len(report.Findings) == 0 && + engine.DoneExcept(report.ReviewedBy, s.cfg.Bot): + report.Status = "deferred" + report.Reason = "codex reviewed clean; coderabbit review deferred until " + + report.DeferredUntil.UTC().Format(time.RFC3339) + " (account rate-limited)" + case len(report.Findings) == 0: report.Status = "waiting" } return report, nil @@ -325,7 +349,7 @@ func (s *Service) Loop(ctx context.Context, repo string, pr int) (FeedbackReport return FeedbackReport{}, 1, err } var lastLog time.Time - var convergedAt time.Time + var settledAt time.Time // Pump keeps the queue moving while we wait, but once a minute is plenty (the // autoreview daemon pumps too); pumping on every tick just burns REST quota. var lastPump time.Time @@ -362,6 +386,12 @@ func (s *Service) Loop(ctx context.Context, repo string, pr int) (FeedbackReport if allReviewed(report.ReviewedBy) { report.Reason = "all required reviewers finished; address findings, push once, and resolve threads" s.completeWaitRound(ctx, repo, pr, head) + } else if report.CodeRabbitDeferred { + // Degraded round: Codex answered while CodeRabbit is rate-limited. + // These findings are this round's work — fixing and pushing is + // exactly right; the CodeRabbit review stays queued and fires + // against the newest head once the window opens. + report.Reason = "codex findings during a coderabbit rate-limit window; fix, push, and loop again — the coderabbit review stays queued and fires when the window opens" } else { // A required reviewer is still pending (e.g. Codex posted a finding // before CodeRabbit reviewed). Return the findings to work on, but leave @@ -372,21 +402,25 @@ func (s *Service) Loop(ctx context.Context, repo string, pr int) (FeedbackReport } return report, 10, nil } - if report.Converged { + if report.Converged || report.Status == "deferred" { // Don't trust the first converged observation: bots deliver in waves // (Codex auto-reviews a pushed head minutes later; CodeRabbit's real // review can trail its comment shells). Hold the verdict for the settle // window and only exit 0 if nothing new lands; any finding or pending - // reviewer resets the normal flow above. - if convergedAt.IsZero() { - convergedAt = s.clock() + // reviewer resets the normal flow above. A deferred (Codex-only) clean + // verdict settles the same way but must NOT complete the round — the + // queued CodeRabbit review is still owed for this head. + if settledAt.IsZero() { + settledAt = s.clock() } - if s.cfg.SettleWindow <= 0 || s.clock().Sub(convergedAt) >= s.cfg.SettleWindow { - s.completeWaitRound(ctx, repo, pr, head) + if s.cfg.SettleWindow <= 0 || s.clock().Sub(settledAt) >= s.cfg.SettleWindow { + if report.Converged { + s.completeWaitRound(ctx, repo, pr, head) + } return report, 0, nil } } else { - convergedAt = time.Time{} + settledAt = time.Time{} } // Keep the queue moving (re-fire once an account-block window clears) and pick up // the Blocked state it leaves behind. Pumping every poll tick is redundant — @@ -411,7 +445,13 @@ func (s *Service) Loop(ctx context.Context, repo string, pr int) (FeedbackReport blockedUntil = &until } } - if blockedUntil != nil { + // A degraded round waits for Codex, not for the window: keep the normal + // poll cadence against the un-extended deadline. (The rate-limit reply + // usually lands before Codex answers, so an iteration or two may extend + // the deadline first — harmless: once Codex evidence arrives the loop + // exits promptly, and if Codex never answers the round degrades + // gracefully back to riding out the window.) + if blockedUntil != nil && !report.CodeRabbitDeferred { extended := extendDeadlineForBlock(deadline, blockedUntil, now, s.cfg.FeedbackWaitTimeout) if extended.After(deadline) { deadline = extended @@ -419,8 +459,12 @@ func (s *Service) Loop(ctx context.Context, repo string, pr int) (FeedbackReport } poll = blockedPollInterval(*blockedUntil, now, s.cfg.PollInterval) } - if now.After(deadline) && convergedAt.IsZero() { - s.completeWaitRound(ctx, repo, pr, head) + if now.After(deadline) && settledAt.IsZero() { + // A degraded round must not be completed on timeout: marking the head + // reviewed would silently cancel the still-owed CodeRabbit review. + if !report.CodeRabbitDeferred { + s.completeWaitRound(ctx, repo, pr, head) + } if len(report.Findings) > 0 { report.Status = "feedback" report.Reason = "review wait timed out; actionable findings must be addressed before retrying" @@ -431,7 +475,9 @@ func (s *Service) Loop(ctx context.Context, repo string, pr int) (FeedbackReport } if s.log != nil && time.Since(lastLog) >= 30*time.Second { activeElapsed := feedbackWaitElapsed(deadline, s.cfg.FeedbackWaitTimeout, now) - if blockedUntil != nil { + if blockedUntil != nil && report.CodeRabbitDeferred { + s.log.Printf("%s#%d degraded to codex-only — coderabbit rate-limited until %s; waiting for codex on %s (%s / %s)", repo, pr, blockedUntil.UTC().Format(time.RFC3339), report.Head, activeElapsed.Round(time.Second), s.cfg.FeedbackWaitTimeout) + } else if blockedUntil != nil { s.log.Printf("%s#%d queued — account blocked until %s; waiting, not counting it against the %s review wait (%s active)", repo, pr, blockedUntil.UTC().Format(time.RFC3339), s.cfg.FeedbackWaitTimeout, activeElapsed.Round(time.Second)) } else { s.log.Printf("%s#%d waiting for review feedback on %s — reviewed %s (%s / %s)", repo, pr, report.Head, reviewedSummary(report.ReviewedBy), activeElapsed.Round(time.Second), s.cfg.FeedbackWaitTimeout) diff --git a/internal/crq/service.go b/internal/crq/service.go index 7e425f3..812a780 100644 --- a/internal/crq/service.go +++ b/internal/crq/service.go @@ -463,6 +463,8 @@ func (s *Service) applyFire(ctx context.Context, round Round, obs engine.Observa return s.dedupeRound(ctx, round, now, d.Reason) case engine.FireCodexOnly: return s.fireCodexOnly(ctx, round, d.Reason, now) + case engine.FireCodexDeferred: + return s.fireCodexDeferred(ctx, round, d.Reason, now) case engine.FireCoReviewWait: return s.fireCoReviewWait(ctx, round, obs, d.Reason, now) case engine.FireSupersede: @@ -958,6 +960,50 @@ func (s *Service) fireCodexReview(ctx context.Context, round Round) { s.sync(ctx, updated) } +// fireCodexDeferred posts ONLY the Codex review command for a round the +// CodeRabbit account block is holding back. Unlike fireCodexOnly (CodeRabbit +// already reviewed the head) the round stays queued/awaiting-retry: the +// CodeRabbit review is still owed and fires normally the moment the window +// opens, at which point PostCodex stays false because CodexCommandID is set. +// The claim-then-post shape mirrors selfHealCodex — this path is not +// serialized by the fire slot either. +func (s *Service) fireCodexDeferred(ctx context.Context, round Round, reason string, now time.Time) (PumpResult, error) { + result := PumpResult{Action: "codex_fired", Repo: round.Repo, PR: round.PR, Head: round.Head, Reason: reason} + if s.cfg.DryRun { + return result, nil + } + claimed := false + updated, err := s.store.Update(ctx, func(st *State) error { + r := st.Round(round.Repo, round.PR) + if !sameRound(r, round) || r.CodexCommandID != 0 { + return ErrNoChange + } + if r.Phase != PhaseQueued && r.Phase != PhaseAwaitingRetry { + return ErrNoChange + } + if r.CodexClaimedAt != nil && now.Sub(r.CodexClaimedAt.UTC()) < codexClaimTTL { + return ErrNoChange + } + t := now.UTC() + r.CodexClaimedAt = &t + r.Note = "codex review requested; coderabbit deferred (account rate-limited)" + st.PutRound(*r) + claimed = true + return nil + }) + if err != nil && !errors.Is(err, ErrNoChange) { + return result, err + } + if !claimed { + result.Action = "deduped" + result.Reason = "codex command already claimed or posted" + return result, nil + } + s.sync(ctx, updated) + s.fireCodexReview(ctx, round) + return result, nil +} + // selfHealCodex re-posts the Codex review command for a fired/reviewing round // whose initial Codex post failed (CodexCommandID still 0). It runs on the // daemon's progress/sweep paths; idempotence comes from the observation — Codex @@ -1441,6 +1487,15 @@ func (s *Service) Wait(ctx context.Context, repo string, pr int) (PumpResult, in } return PumpResult{Action: "deduped", Repo: repo, PR: pr, Head: report.Head, Reason: "feedback already available"}, 3, nil } + // A clean Codex answer on a degraded (rate-limited) round is the + // round's verdict for now — hand off to the feedback poll loop + // instead of spinning here until the CodeRabbit window opens. + if report.Status == "deferred" { + if s.log != nil { + s.log.Printf("%s#%d codex answered on %s; coderabbit deferred — leaving review slot wait", repo, pr, report.Head) + } + return PumpResult{Action: "deduped", Repo: repo, PR: pr, Head: report.Head, Reason: "codex answered; coderabbit deferred"}, 3, nil + } } result, err := s.Pump(ctx) if err != nil { diff --git a/internal/crq/service_test.go b/internal/crq/service_test.go index 40a6784..af98c71 100644 --- a/internal/crq/service_test.go +++ b/internal/crq/service_test.go @@ -1894,3 +1894,179 @@ func TestRefreshQuotaPreservesBlockOnInconclusiveProbe(t *testing.T) { t.Fatalf("an inconclusive probe must preserve the live block %v, got %v", block, updated.Account.BlockedUntil) } } + +// TestLoopDegradesToCodexOnlyOnRateLimit: a rate-limited round with Codex +// activity must return Codex findings promptly — marked deferred — instead of +// waiting out the CodeRabbit window. +func TestLoopDegradesToCodexOnlyOnRateLimit(t *testing.T) { + ctx := context.Background() + cfg := firingConfig() + cfg.RateLimitCodexDegrade = true + cfg.FeedbackBots = []string{"coderabbitai[bot]", "chatgpt-codex-connector[bot]"} + gh := newFakeGitHub() + head := "a0646f010" + pull := ghapi.Pull{State: "open"} + pull.Head.SHA = head + "abcdef0" + gh.pulls[fakeKey("o/carrier", 90)] = pull + store := NewMemoryStore(cfg) + svc := NewService(cfg, gh, store, nil) + + if _, err := svc.Enqueue(ctx, "o/carrier", 90); err != nil { + t.Fatal(err) + } + if res, err := svc.Pump(ctx); err != nil || res.Action != "fired" { + t.Fatalf("expected fire, got %#v err=%v", res, err) + } + answer := time.Now().UTC().Add(time.Second) + rl := ghapi.IssueComment{ID: 501, Body: "\n> ## Review limit reached\n> **Next review available in:** **40 minutes**", CreatedAt: answer, UpdatedAt: answer} + rl.User.Login = "coderabbitai[bot]" + finding := ghapi.IssueComment{ID: 502, Body: "Actionable Codex finding on the current head", CreatedAt: answer.Add(time.Second), UpdatedAt: answer.Add(time.Second)} + finding.User.Login = "chatgpt-codex-connector[bot]" + gh.comments[fakeKey("o/carrier", 90)] = []ghapi.IssueComment{rl, finding} + if res, err := svc.Pump(ctx); err != nil || res.Action != "requeued" { + t.Fatalf("expected rate-limited requeue, got %#v err=%v", res, err) + } + + begin := time.Now() + report, code, err := svc.Loop(ctx, "o/carrier", 90) + if err != nil { + t.Fatal(err) + } + if code != 10 || len(report.Findings) == 0 { + t.Fatalf("degraded loop must return the codex findings, code=%d report=%#v", code, report) + } + if !report.CodeRabbitDeferred || report.DeferredUntil == nil { + t.Fatalf("the report must mark coderabbit deferred with a window, got %#v", report) + } + if report.ReviewedBy["coderabbitai[bot]"] { + t.Fatalf("coderabbit must still read as unreviewed: %#v", report.ReviewedBy) + } + if report.Converged { + t.Fatal("a deferred round must never read as converged") + } + if elapsed := time.Since(begin); elapsed > 5*time.Second { + t.Fatalf("degraded loop must not wait out the rate-limit window, took %s", elapsed) + } +} + +// TestLoopDeferredCodexCleanExitsZeroNotConverged: a clean Codex verdict on a +// degraded round exits 0 as "deferred" without completing the round — the +// CodeRabbit review stays owed. +func TestLoopDeferredCodexCleanExitsZeroNotConverged(t *testing.T) { + ctx := context.Background() + cfg := firingConfig() + cfg.RateLimitCodexDegrade = true + cfg.RequiredBots = []string{"coderabbitai[bot]", "chatgpt-codex-connector[bot]"} + cfg.FeedbackBots = []string{"coderabbitai[bot]", "chatgpt-codex-connector[bot]"} + cfg.CodexCommand = "@codex review" + cfg.SettleWindow = 0 + gh := newFakeGitHub() + pull := ghapi.Pull{State: "open"} + pull.Head.SHA = "abcdef1234567890" + gh.pulls[fakeKey("o/carrier", 91)] = pull + store := NewMemoryStore(cfg) + started := time.Now().UTC().Add(-time.Minute) + seedRound(t, store, cfg, "o/carrier", 91, "abcdef123", PhaseReviewing, started, 1001) + blockedUntil := time.Now().UTC().Add(30 * time.Minute) + if _, err := store.Update(ctx, func(st *State) error { + st.Account.BlockedUntil = &blockedUntil + return nil + }); err != nil { + t.Fatal(err) + } + clean := ghapi.IssueComment{ID: 700, Body: "## Codex Review\n\nDidn't find any major issues. Keep them coming!", CreatedAt: started.Add(30 * time.Second), UpdatedAt: started.Add(30 * time.Second)} + clean.User.Login = "chatgpt-codex-connector[bot]" + gh.comments[fakeKey("o/carrier", 91)] = []ghapi.IssueComment{clean} + + svc := NewService(cfg, gh, store, nil) + report, code, err := svc.Loop(ctx, "o/carrier", 91) + if err != nil { + t.Fatal(err) + } + if code != 0 || report.Status != "deferred" { + t.Fatalf("clean codex on a degraded round must exit 0 as deferred, code=%d report=%#v", code, report) + } + if report.Converged { + t.Fatal("deferred must not be converged") + } + st, _, _ := store.Load(ctx) + if r := st.Round("o/carrier", 91); r == nil || r.Phase == PhaseCompleted { + t.Fatalf("a deferred round must not be completed, got %#v", r) + } + if !st.ContainsActive("o/carrier", 91) { + t.Fatal("the coderabbit review must stay owed (round active)") + } +} + +// TestPumpPostsCodexDeferredDuringBlockThenFiresCodeRabbit: during a block the +// pump posts only the Codex command and keeps the round queued; once the +// window passes it fires the CodeRabbit review without re-posting Codex. +func TestPumpPostsCodexDeferredDuringBlockThenFiresCodeRabbit(t *testing.T) { + ctx := context.Background() + cfg := firingConfig() + cfg.RateLimitCodexDegrade = true + cfg.RequiredBots = []string{"coderabbitai[bot]", "chatgpt-codex-connector[bot]"} + cfg.CodexCommand = "@codex review" + gh := newFakeGitHub() + pull := ghapi.Pull{State: "open"} + pull.Head.SHA = "abcdef1234567890" + gh.pulls[fakeKey("o/carrier", 92)] = pull + store := NewMemoryStore(cfg) + svc := NewService(cfg, gh, store, nil) + now := time.Now().UTC() + svc.now = func() time.Time { return now } + + if _, err := svc.Enqueue(ctx, "o/carrier", 92); err != nil { + t.Fatal(err) + } + blockedUntil := now.Add(30 * time.Minute) + if _, err := store.Update(ctx, func(st *State) error { + st.Account.BlockedUntil = &blockedUntil + return nil + }); err != nil { + t.Fatal(err) + } + res, err := svc.Pump(ctx) + if err != nil { + t.Fatal(err) + } + if res.Action != "codex_fired" { + t.Fatalf("expected the codex-deferred fire, got %#v", res) + } + st, _, _ := store.Load(ctx) + r := st.Round("o/carrier", 92) + if r == nil || r.Phase != PhaseQueued || r.CodexCommandID == 0 { + t.Fatalf("the round must stay queued with the codex command recorded, got %#v", r) + } + if _, err := svc.Pump(ctx); err != nil { + t.Fatal(err) + } + countPosts := func(suffix string) int { + n := 0 + for _, p := range gh.posted { + if strings.HasSuffix(p, suffix) { + n++ + } + } + return n + } + if countPosts(":@codex review") != 1 { + t.Fatalf("exactly one codex command must be posted during the block, got %v", gh.posted) + } + if countPosts(":@coderabbitai review") != 0 { + t.Fatalf("no coderabbit review may fire during the block, got %v", gh.posted) + } + + // Window opens: the queued round fires CodeRabbit, without re-posting Codex. + now = blockedUntil.Add(time.Minute) + res, err = svc.Pump(ctx) + if err != nil { + t.Fatal(err) + } + if res.Action != "fired" { + t.Fatalf("expected the coderabbit fire after the window, got %#v", res) + } + if countPosts(":@coderabbitai review") != 1 || countPosts(":@codex review") != 1 { + t.Fatalf("after the window: one coderabbit fire, still one codex command, got %v", gh.posted) + } +} diff --git a/internal/crq/state.go b/internal/crq/state.go index b3364fd..d4e36aa 100644 --- a/internal/crq/state.go +++ b/internal/crq/state.go @@ -81,12 +81,13 @@ func issueBody(st State, cfg Config) (string, error) { // policy assembles the engine Policy from config. func (s *Service) policy() engine.Policy { return engine.Policy{ - Bot: s.cfg.Bot, - RequiredBots: s.cfg.RequiredBots, - CodexCommand: s.cfg.CodexCommand, - MinInterval: s.cfg.MinInterval, - InflightTimeout: s.cfg.InflightTimeout, - RateLimitFallback: s.cfg.RateLimitFallback, + Bot: s.cfg.Bot, + RequiredBots: s.cfg.RequiredBots, + CodexCommand: s.cfg.CodexCommand, + MinInterval: s.cfg.MinInterval, + InflightTimeout: s.cfg.InflightTimeout, + RateLimitFallback: s.cfg.RateLimitFallback, + RateLimitCodexDegrade: s.cfg.RateLimitCodexDegrade, } } diff --git a/internal/engine/codex.go b/internal/engine/codex.go index 35288b6..c8a19ec 100644 --- a/internal/engine/codex.go +++ b/internal/engine/codex.go @@ -161,6 +161,23 @@ func CodexCommandSince(obs Observation, since time.Time) bool { return false } +// CodexOnlyEligible reports whether an account-blocked round may degrade to a +// Codex-only round: the block is live AND Codex shows observed responsiveness +// on this PR (it auto-reviews, or has activity bound to this round) AND has +// not posted a usage-limit exhaustion notice since the fire. Configuration +// alone (a configured Codex command, or a live unanswered `@codex review`) +// is deliberately not enough — without observed evidence the round falls back +// to riding out the CodeRabbit window. +func CodexOnlyEligible(r state.Round, obs Observation, blockedUntil *time.Time, now time.Time) bool { + if blockedUntil == nil || !blockedUntil.After(now) { + return false + } + if !obs.CodexAutoActive && !obs.CodexActiveThisRound { + return false + } + return !codexUsageLimitedSince(obs, roundCutoff(r)) +} + // codexUsageLimitedSince reports whether Codex posted its usage-limit // exhaustion notice at/after since — the round window it can no longer finish. func codexUsageLimitedSince(obs Observation, since time.Time) bool { diff --git a/internal/engine/completion.go b/internal/engine/completion.go index f8cfe64..1b7b636 100644 --- a/internal/engine/completion.go +++ b/internal/engine/completion.go @@ -277,6 +277,26 @@ func commandReplies(obs Observation, p Policy) []commandReply { return out } +// DoneExcept reports whether every gating bot EXCEPT the named one has review +// evidence — and at least one other bot gates at all. The vacuous case +// matters: with only the excluded bot required, a degraded round must never +// read as done, or a CodeRabbit rate-limit window with no Codex configured +// would let rounds complete with no review evidence whatsoever. +func DoneExcept(reviewedBy map[string]bool, except string) bool { + norm := dialect.NormalizeBotName(except) + others := 0 + for bot, reviewed := range reviewedBy { + if bot == except || dialect.NormalizeBotName(bot) == norm { + continue + } + if !reviewed { + return false + } + others++ + } + return others > 0 +} + // needsBotReview reports whether login gates completion (has a ReviewedBy // key) and its review hasn't been seen yet. func needsBotReview(reviewedBy map[string]bool, login string) bool { diff --git a/internal/engine/engine.go b/internal/engine/engine.go index 287a293..2123522 100644 --- a/internal/engine/engine.go +++ b/internal/engine/engine.go @@ -22,6 +22,11 @@ type Policy struct { InflightTimeout time.Duration // fired round with no bot response at all RateLimitFallback time.Duration // block window when "available in" is unparseable RetryBackoff time.Duration // cooldown after a non-rate-limit retry (timeout, failure) + + // RateLimitCodexDegrade lets an account-blocked round degrade to a + // Codex-only round (post the Codex command now, keep CodeRabbit queued + // for the window) instead of waiting the block out. CRQ_RL_CODEX_DEGRADE. + RateLimitCodexDegrade bool } func (p Policy) rateLimitFallback() time.Duration { diff --git a/internal/engine/engine_test.go b/internal/engine/engine_test.go index 98b7ff3..8511bbf 100644 --- a/internal/engine/engine_test.go +++ b/internal/engine/engine_test.go @@ -636,3 +636,106 @@ func TestFindingsForActiveRoundIncludesOnlyCurrentOrNewlyArrivedFeedback(t *test t.Fatalf("unexpected active-round findings: %#v", got) } } + +// TestCodexOnlyEligible covers the degrade predicate: a live block plus +// OBSERVED Codex responsiveness — configuration or a live command alone never +// qualifies, and a usage-limit notice disengages it. +func TestCodexOnlyEligible(t *testing.T) { + r := firedRound(t, "abcdef123") + now := t0.Add(5 * time.Minute) + blocked := now.Add(25 * time.Minute) + expired := now.Add(-time.Minute) + usageLimit := dialect.BotEvent{Kind: dialect.EvCodexUsageLimit, Bot: dialect.CodexBotLogin, CommentID: 700, + CreatedAt: r.FiredAt.Add(30 * time.Second), UpdatedAt: r.FiredAt.Add(30 * time.Second)} + + active := Observation{Head: "abcdef123", Open: true, CodexActiveThisRound: true} + if CodexOnlyEligible(r, active, nil, now) { + t.Fatal("no block must not degrade") + } + if CodexOnlyEligible(r, active, &expired, now) { + t.Fatal("an expired block must not degrade") + } + if !CodexOnlyEligible(r, active, &blocked, now) { + t.Fatal("a live block with round-bound codex activity must degrade") + } + auto := Observation{Head: "abcdef123", Open: true, CodexAutoActive: true} + if !CodexOnlyEligible(r, auto, &blocked, now) { + t.Fatal("a live block with an auto-active codex must degrade") + } + configOnly := Observation{Head: "abcdef123", Open: true, CodexCommands: []CommandSeen{{ID: 55, CreatedAt: now}}} + if CodexOnlyEligible(r, configOnly, &blocked, now) { + t.Fatal("a live command without observed codex evidence must not degrade") + } + limited := Observation{Head: "abcdef123", Open: true, CodexActiveThisRound: true, Events: []dialect.BotEvent{usageLimit}} + if CodexOnlyEligible(r, limited, &blocked, now) { + t.Fatal("a codex usage limit since the fire must disengage the degrade") + } +} + +// TestDoneExcept covers the Codex-side completeness check for degraded rounds, +// including the vacuous guard: an excluded bot alone never reads as done. +func TestDoneExcept(t *testing.T) { + cr := "coderabbitai[bot]" + if !DoneExcept(map[string]bool{cr: false, dialect.CodexBotLogin: true}, cr) { + t.Fatal("codex reviewed, coderabbit excluded: must be done-except") + } + if DoneExcept(map[string]bool{cr: false}, cr) { + t.Fatal("only the excluded bot gates: must NOT be vacuously done") + } + if DoneExcept(map[string]bool{cr: false, dialect.CodexBotLogin: false}, cr) { + t.Fatal("codex still pending: must not be done-except") + } + if !DoneExcept(map[string]bool{cr: true, dialect.CodexBotLogin: true}, cr) { + t.Fatal("everything reviewed must be done-except too") + } + // Bot-name normalization: the suffixless form excludes the bracketed key. + if DoneExcept(map[string]bool{"coderabbitai": false}, cr) { + t.Fatal("normalized excluded bot alone must not be vacuously done") + } +} + +// TestDecideFireBlockedCodexDeferred: an account block with the degrade flag +// posts only the Codex command and keeps the round queued for CodeRabbit. +func TestDecideFireBlockedCodexDeferred(t *testing.T) { + now := t0.Add(10 * time.Minute) + blocked := now.Add(25 * time.Minute) + g := Global{SlotFree: true, BlockedUntil: &blocked} + head := "abcdef123" + queued := state.Round{Repo: "owner/repo", PR: 448, Head: head, Phase: state.PhaseQueued, Seq: 1} + open := Observation{Head: head, Open: true} + + degrade := policy + degrade.RequiredBots = []string{"coderabbitai[bot]", dialect.CodexBotLogin} + degrade.CodexCommand = "@codex review" + degrade.RateLimitCodexDegrade = true + + if d := DecideFire(g, queued, open, now, degrade); d.Verdict != FireCodexDeferred { + t.Fatalf("blocked + degrade + postable codex must defer to codex, got %+v", d) + } + // Flag off → today's behavior. + off := degrade + off.RateLimitCodexDegrade = false + if d := DecideFire(g, queued, open, now, off); d.Verdict != FireNo { + t.Fatalf("degrade off must stay FireNo blocked, got %+v", d) + } + // Codex command already posted for this round → plain blocked FireNo. + posted := queued + posted.CodexCommandID = 99 + if d := DecideFire(g, posted, open, now, degrade); d.Verdict != FireNo { + t.Fatalf("an already-posted codex command must not re-defer, got %+v", d) + } + // A live command on the PR → nothing to post; blocked FireNo. + cmdObs := Observation{Head: head, Open: true, CodexCommands: []CommandSeen{{ID: 55, CreatedAt: now}}} + if d := DecideFire(g, queued, cmdObs, now, degrade); d.Verdict != FireNo { + t.Fatalf("a live codex command must not re-post, got %+v", d) + } + // Auto-active Codex reviews unprompted → nothing to post; blocked FireNo. + autoObs := Observation{Head: head, Open: true, CodexAutoActive: true} + if d := DecideFire(g, queued, autoObs, now, degrade); d.Verdict != FireNo { + t.Fatalf("auto-active codex must not be commanded, got %+v", d) + } + // Unblocked → the normal fire path is untouched. + if d := DecideFire(Global{SlotFree: true}, queued, open, now, degrade); d.Verdict != FirePost || !d.PostCodex { + t.Fatalf("unblocked fire must stay FirePost with codex, got %+v", d) + } +} diff --git a/internal/engine/fire.go b/internal/engine/fire.go index c8cc93c..f5cc557 100644 --- a/internal/engine/fire.go +++ b/internal/engine/fire.go @@ -20,6 +20,7 @@ const ( FireDedupe // bot already reviewed this head — complete without firing FireCodexOnly // CodeRabbit reviewed the head but a required Codex still must — post only the Codex command FireCoReviewWait // CodeRabbit reviewed the head; a gating co-bot has not — wait for it, bounded, without posting or holding the slot + FireCodexDeferred // account blocked — post only the Codex command now; the round stays queued so CodeRabbit fires when the window opens FireSupersede // observed head differs — supersede the round first FireDrop // PR closed/merged — abandon the round ) @@ -80,6 +81,15 @@ func DecideFire(g Global, r state.Round, obs Observation, now time.Time, p Polic } } if g.BlockedUntil != nil && g.BlockedUntil.After(now) { + // Degrade instead of stalling: the block only gates CodeRabbit quota, + // so ask Codex now and leave the round queued — CodeRabbit still + // fires the moment the window opens. DecideCodexPost's guards + // (command configured, codex required, not auto-active, no live or + // already-posted command) make this idempotent per round. + if p.RateLimitCodexDegrade && DecideCodexPost(r, obs, p, len(obs.CodexCommands) > 0) { + return FireDecision{Verdict: FireCodexDeferred, + Reason: "account blocked; requesting codex review now, coderabbit deferred"} + } return FireDecision{Verdict: FireNo, Reason: "account blocked until " + g.BlockedUntil.UTC().Format(time.RFC3339)} } if g.LastFired != nil && now.Sub(*g.LastFired) < p.MinInterval { diff --git a/llms.txt b/llms.txt index 5d2fb62..267ab7e 100644 --- a/llms.txt +++ b/llms.txt @@ -48,6 +48,8 @@ The loop also returns as soon as any feedback bot reports a finding; it does not remaining required bots or a shared review slot. Fix those findings locally, but HOLD THE HEAD: resolve each addressed thread immediately, but do not commit or push while any `.reviewed_by` value is false, because changing the head restarts the pending checks while thread resolution does not. +Exception: when `.coderabbit_deferred` is true the round is Codex-only (CodeRabbit rate-limited) — +fix, push, and loop again without holding the head; the queued CodeRabbit review is untouched. Keep the queued review alive and poll `crq feedback` with the same `CRQ_REQUIRED_BOTS`. When every required bot is true, fix and resolve the rest, then commit all fixes once and push once. @@ -67,17 +69,28 @@ never when Codex auto-reviews the PR on its own. A Codex that joins a round unin round's convergence dynamically (its usage-limit notice releases the dynamic gate). If a bot reports actionable findings first, it emits them immediately while leaving the queued round alive. Fix and validate locally and resolve or decline each addressed thread immediately. While any required bot's -`.reviewed_by` value is false, do not commit or push. Only after every `CRQ_REQUIRED_BOTS` entry is true -for the current head should you fix and resolve the rest, then commit and push the combined fixes once. -Convergence is reported only after that same condition is met. +`.reviewed_by` value is false, do not commit or push — unless `.coderabbit_deferred` is true, in +which case push freely: the round is Codex-only while CodeRabbit is rate-limited. Only after every +`CRQ_REQUIRED_BOTS` entry is true for the current head should you fix and resolve the rest, then +commit and push the combined fixes once. Convergence is reported only after that same condition is met. Exit codes: -- `0`: done; converged or no actionable findings. +- `0`: done; converged or no actionable findings. Check `.coderabbit_deferred`: when true (with + `.status == "deferred"`), Codex reviewed clean but the CodeRabbit review is still owed — this is + progress, NOT convergence (`.converged` stays false). Re-run `crq loop` after + `.coderabbit_deferred_until` or on the next push; the queued CodeRabbit review fires by itself + once the window opens. - `10`: read `.findings[]`, fix valid issues, and validate locally. If any `.reviewed_by` value is - false, resolve addressed threads but hold the head. After all are true, fix/resolve the rest, - commit/push once, then repeat. + false, resolve addressed threads but hold the head — EXCEPT when `.coderabbit_deferred` is true: + those are Codex-only findings during a CodeRabbit rate-limit window, so fix, push, and loop again + (each Codex round takes minutes; several fit inside one CodeRabbit window). - `2`: timed out waiting for feedback; do not push a stale-feedback round. +Rate-limit degrade: when CodeRabbit is rate-limited ("Review limit reached … Next review available +in: NN minutes") and Codex demonstrably reviews the PR, the loop degrades to Codex-only rounds +instead of waiting the window out, and the pump posts `CRQ_CODEX_CMD` for blocked rounds while +keeping the CodeRabbit review queued. Disable with `CRQ_RL_CODEX_DEGRADE=0` (default on). + Resolve addressed threads on GitHub (crq keys off GitHub resolution state; a finding keeps reappearing until its thread is resolved there): diff --git a/skills/coderabbit-queue/SKILL.md b/skills/coderabbit-queue/SKILL.md index 95347b1..5b9cb9c 100644 --- a/skills/coderabbit-queue/SKILL.md +++ b/skills/coderabbit-queue/SKILL.md @@ -40,10 +40,20 @@ and `CODERABBIT_API_KEY` presence for headless local review. Exit codes: -- `0`: converged or no actionable findings -- `10`: actionable findings were written to JSON +- `0`: converged or no actionable findings. Check `.coderabbit_deferred` first: when true (with + `.status == "deferred"`), Codex reviewed clean while CodeRabbit is rate-limited — the CodeRabbit + review is still owed and `.converged` is false. Treat it as progress, not convergence: re-run + `crq loop` after `.coderabbit_deferred_until` or on the next push. +- `10`: actionable findings were written to JSON. When `.coderabbit_deferred` is true these are + Codex-only findings during a CodeRabbit rate-limit window: fix, push, and loop again immediately + instead of holding the head — the queued CodeRabbit review fires by itself once the window opens. - `2`: timed out waiting for feedback +Rate-limit degrade (default on, `CRQ_RL_CODEX_DEGRADE=0` disables): when CodeRabbit is +rate-limited and Codex demonstrably reviews the PR, the loop returns Codex feedback promptly +instead of waiting out the window, and the pump posts the Codex command for blocked rounds while +keeping the CodeRabbit review queued. + ## Drain Findings Before Waiting An autonomous review loop is a work loop, not a review-status waiter. Before starting or From 08bd5e7fae468736acc55574553985e59dcb0431 Mon Sep 17 00:00:00 2001 From: kristofferR Date: Wed, 22 Jul 2026 20:20:24 +0200 Subject: [PATCH 2/7] Defer to Codex behind a busy fire slot too The degrade only covered the account-quota block, but a round parked behind another PR's in-flight review waits the same way while Codex needs no slot at all. The slot-busy gate now posts the Codex command for a postable required Codex and keeps the round queued; CodeRabbit fires once the slot frees, with CodexCommandID preventing a duplicate Codex post. --- internal/engine/engine_test.go | 7 +++++++ internal/engine/fire.go | 8 ++++++++ 2 files changed, 15 insertions(+) diff --git a/internal/engine/engine_test.go b/internal/engine/engine_test.go index 8511bbf..7e04544 100644 --- a/internal/engine/engine_test.go +++ b/internal/engine/engine_test.go @@ -738,4 +738,11 @@ func TestDecideFireBlockedCodexDeferred(t *testing.T) { if d := DecideFire(Global{SlotFree: true}, queued, open, now, degrade); d.Verdict != FirePost || !d.PostCodex { t.Fatalf("unblocked fire must stay FirePost with codex, got %+v", d) } + // A busy fire slot defers to Codex the same way — Codex needs no slot. + if d := DecideFire(Global{SlotFree: false}, queued, open, now, degrade); d.Verdict != FireCodexDeferred { + t.Fatalf("slot-busy + degrade + postable codex must defer to codex, got %+v", d) + } + if d := DecideFire(Global{SlotFree: false}, queued, open, now, off); d.Verdict != FireNo { + t.Fatalf("slot-busy with degrade off must stay FireNo, got %+v", d) + } } diff --git a/internal/engine/fire.go b/internal/engine/fire.go index f5cc557..bc35f30 100644 --- a/internal/engine/fire.go +++ b/internal/engine/fire.go @@ -65,6 +65,14 @@ func DecideFire(g Global, r state.Round, obs Observation, now time.Time, p Polic return FireDecision{Verdict: FireNo, Reason: reason} } if !g.SlotFree { + // Codex needs no fire slot: a round parked behind another PR's + // in-flight review can start its Codex round immediately. The round + // stays queued and CodeRabbit fires once the slot frees, with + // CodexCommandID preventing a duplicate Codex post. + if p.RateLimitCodexDegrade && DecideCodexPost(r, obs, p, len(obs.CodexCommands) > 0) { + return FireDecision{Verdict: FireCodexDeferred, + Reason: "fire slot busy; requesting codex review now, coderabbit deferred"} + } return FireDecision{Verdict: FireNo, Reason: "fire slot busy"} } // Belt-and-braces live check: even with a fresh round, never fire at a From f5a0988500988900da00716d94285af35f039d8e Mon Sep 17 00:00:00 2001 From: kristofferR Date: Wed, 22 Jul 2026 20:37:16 +0200 Subject: [PATCH 3/7] Address Codex round 1: tighten degrade triggers and pre-fire evidence - Feedback gates the deferred verdict on the ACCOUNT-wide quota block only; a round's own awaiting_retry cooldown also covers non-quota retries (post failures, timeouts) that must keep normal handling. - An unfired round needs current Codex evidence to defer: a head-bound review or auto-activity, not stale PR-level comments that pass the zero round cutoff. - The slot-busy degrade skips heads CodeRabbit already reviewed; those belong to the dedupe resolution once the slot frees, and a queued round cannot complete on a clean Codex answer. - Codex evidence binds from CodexCommandedAt when crq posted the command before the deferred CodeRabbit fire: a SHA-less clean answer delivered in that gap used to fall outside the completion cutoff after the late fire, wedging the round with no repost. --- internal/crq/feedback.go | 14 +++++---- internal/crq/service.go | 2 ++ internal/engine/codex.go | 39 +++++++++++++++++++------ internal/engine/completion.go | 5 +++- internal/engine/engine_test.go | 52 ++++++++++++++++++++++++++++++++++ internal/engine/fire.go | 14 +++++++-- internal/state/state.go | 6 ++++ 7 files changed, 115 insertions(+), 17 deletions(-) diff --git a/internal/crq/feedback.go b/internal/crq/feedback.go index edf57ec..c7e4146 100644 --- a/internal/crq/feedback.go +++ b/internal/crq/feedback.go @@ -247,13 +247,15 @@ func (s *Service) Feedback(ctx context.Context, repo string, pr int) (FeedbackRe // Degrade detection: a live rate-limit window plus observed Codex // responsiveness means this round runs Codex-only for now. Converged is // structurally false here (CodeRabbit has no review evidence), so a - // deferred round can never masquerade as converged. - if s.cfg.RateLimitCodexDegrade && !report.Converged { - if until, ok := st.AccountBlockedUntil(repo, pr, head, now); ok && - engine.CodexOnlyEligible(completionRound, obs.eng, &until, now) { + // deferred round can never masquerade as converged. Only the ACCOUNT-wide + // quota block qualifies — a round's own awaiting_retry cooldown also + // covers non-quota retries (post failures, timeouts) that must keep their + // normal retry handling. + if s.cfg.RateLimitCodexDegrade && !report.Converged && st.Account.BlockedUntil != nil { + until := st.Account.BlockedUntil.UTC() + if until.After(now) && engine.CodexOnlyEligible(completionRound, obs.eng, &until, now) { report.CodeRabbitDeferred = true - u := until - report.DeferredUntil = &u + report.DeferredUntil = &until } } switch { diff --git a/internal/crq/service.go b/internal/crq/service.go index 812a780..7794b56 100644 --- a/internal/crq/service.go +++ b/internal/crq/service.go @@ -947,6 +947,8 @@ func (s *Service) fireCodexReview(ctx context.Context, round Round) { r.CodexClaimedAt = nil if r.CodexCommandID == 0 { r.CodexCommandID = codexID + t := s.clock().UTC() + r.CodexCommandedAt = &t } st.PutRound(*r) return nil diff --git a/internal/engine/codex.go b/internal/engine/codex.go index c8a19ec..7761e03 100644 --- a/internal/engine/codex.go +++ b/internal/engine/codex.go @@ -22,6 +22,21 @@ func roundCutoff(r state.Round) time.Time { return time.Time{} } +// codexCutoff is the evidence floor for Codex specifically: evidence produced +// in response to crq's own Codex command binds from the command time, which +// can precede a deferred CodeRabbit fire (the command posts while the round +// is still queued behind a rate-limit window or busy slot). +func codexCutoff(r state.Round) time.Time { + cut := roundCutoff(r) + if r.CodexCommandedAt != nil { + at := r.CodexCommandedAt.UTC() + if cut.IsZero() || at.Before(cut) { + return at + } + } + return cut +} + // codexReviewedRound reports whether a submitted Codex review binds to this // round: one whose commit prefixes the head, or — SHA-less — one submitted // at/after the fire. @@ -71,7 +86,7 @@ func codexReviewedHead(obs Observation) bool { // thumbs-up. observe() stores it on the Observation so the dynamic completion // gate requires Codex when it participates without being configured-required. func CodexActiveThisRound(r state.Round, obs Observation) bool { - cutoff := roundCutoff(r) + cutoff := codexCutoff(r) return codexReviewedRound(r, obs, cutoff) || codexCommentedRound(obs, cutoff) || obs.CodexThumbsUp } @@ -163,17 +178,25 @@ func CodexCommandSince(obs Observation, since time.Time) bool { // CodexOnlyEligible reports whether an account-blocked round may degrade to a // Codex-only round: the block is live AND Codex shows observed responsiveness -// on this PR (it auto-reviews, or has activity bound to this round) AND has -// not posted a usage-limit exhaustion notice since the fire. Configuration -// alone (a configured Codex command, or a live unanswered `@codex review`) -// is deliberately not enough — without observed evidence the round falls back -// to riding out the CodeRabbit window. +// tied to THIS work — it auto-reviews the PR, or (for a fired round) has +// round-bound activity, or (for an unfired round, e.g. one whose Codex +// command was posted while queued) has reviewed the current head — AND has +// not posted a usage-limit exhaustion notice since the fire. Configuration, +// a live unanswered command, or stale PR-level evidence on an unfired round +// are deliberately not enough — without current evidence the round falls +// back to riding out the CodeRabbit window. func CodexOnlyEligible(r state.Round, obs Observation, blockedUntil *time.Time, now time.Time) bool { if blockedUntil == nil || !blockedUntil.After(now) { return false } - if !obs.CodexAutoActive && !obs.CodexActiveThisRound { - return false + if !obs.CodexAutoActive { + if r.FiredAt != nil { + if !obs.CodexActiveThisRound { + return false + } + } else if !codexReviewedHead(obs) { + return false + } } return !codexUsageLimitedSince(obs, roundCutoff(r)) } diff --git a/internal/engine/completion.go b/internal/engine/completion.go index 1b7b636..07500e3 100644 --- a/internal/engine/completion.go +++ b/internal/engine/completion.go @@ -84,7 +84,10 @@ func Completion(r state.Round, obs Observation, p Policy) CompletionStatus { } continue } - if r.FiredAt != nil && notBefore(ev.ObservedTime(), cutoff) { + // SHA-less summaries bind from the Codex command time when crq posted + // it before the (deferred) CodeRabbit fire — see codexCutoff. + if (r.FiredAt != nil || r.CodexCommandedAt != nil) && + notBefore(ev.ObservedTime(), codexCutoff(r)) { markReviewed(reviewedBy, ev.Bot) } } diff --git a/internal/engine/engine_test.go b/internal/engine/engine_test.go index 7e04544..ebe10a3 100644 --- a/internal/engine/engine_test.go +++ b/internal/engine/engine_test.go @@ -746,3 +746,55 @@ func TestDecideFireBlockedCodexDeferred(t *testing.T) { t.Fatalf("slot-busy with degrade off must stay FireNo, got %+v", d) } } + +// TestCodexOnlyEligibleUnfiredRound: stale PR-level Codex evidence must not +// defer an unfired round — only a head-bound review (or auto-activity) may. +func TestCodexOnlyEligibleUnfiredRound(t *testing.T) { + now := t0.Add(10 * time.Minute) + blocked := now.Add(25 * time.Minute) + queued := state.Round{Repo: "owner/repo", PR: 448, Head: "abcdef123", Phase: state.PhaseQueued, Seq: 1} + // A round-window flag computed from a zero cutoff (an old SHA-less review) + // must not qualify an unfired round. + stale := Observation{Head: "abcdef123", Open: true, CodexActiveThisRound: true} + if CodexOnlyEligible(queued, stale, &blocked, now) { + t.Fatal("stale round-window evidence must not defer an unfired round") + } + headReviewed := Observation{Head: "abcdef123", Open: true, + Reviews: []ReviewSeen{{Bot: dialect.CodexBotLogin, Commit: "abcdef1234567890", SubmittedAt: now}}} + if !CodexOnlyEligible(queued, headReviewed, &blocked, now) { + t.Fatal("a codex review of the current head must defer an unfired round") + } + auto := Observation{Head: "abcdef123", Open: true, CodexAutoActive: true} + if !CodexOnlyEligible(queued, auto, &blocked, now) { + t.Fatal("an auto-active codex must defer an unfired round") + } +} + +// TestCompletionBindsPreFireCodexAnswer: a SHA-less Codex clean summary +// delivered after the deferred command but before the delayed CodeRabbit fire +// must still count for the round — the command time is the codex cutoff. +func TestCompletionBindsPreFireCodexAnswer(t *testing.T) { + r := firedRound(t, "abcdef123") + commandedAt := r.FiredAt.Add(-10 * time.Minute) + r.CodexCommandedAt = &commandedAt + r.CodexCommandID = 77 + gated := policy + gated.RequiredBots = []string{"coderabbitai[bot]", dialect.CodexBotLogin} + crReview := ReviewSeen{Bot: "coderabbitai[bot]", Commit: "abcdef1234567890", SubmittedAt: r.FiredAt.Add(time.Minute)} + cleanBeforeFire := dialect.BotEvent{Kind: dialect.EvCodexClean, Bot: dialect.CodexBotLogin, CommentID: 900, + CreatedAt: commandedAt.Add(2 * time.Minute), UpdatedAt: commandedAt.Add(2 * time.Minute)} + + obs := Observation{Head: "abcdef123", Open: true, Reviews: []ReviewSeen{crReview}, + Events: []dialect.BotEvent{cleanBeforeFire}} + if got := Completion(r, obs, gated); !got.Done { + t.Fatalf("a codex answer after its command but before the deferred fire must count: %+v", got) + } + // Evidence from before the command stays excluded. + early := cleanBeforeFire + early.CreatedAt = commandedAt.Add(-time.Minute) + early.UpdatedAt = early.CreatedAt + obs.Events = []dialect.BotEvent{early} + if got := Completion(r, obs, gated); got.Done { + t.Fatalf("evidence older than the codex command must not count: %+v", got) + } +} diff --git a/internal/engine/fire.go b/internal/engine/fire.go index bc35f30..7931b52 100644 --- a/internal/engine/fire.go +++ b/internal/engine/fire.go @@ -68,8 +68,18 @@ func DecideFire(g Global, r state.Round, obs Observation, now time.Time, p Polic // Codex needs no fire slot: a round parked behind another PR's // in-flight review can start its Codex round immediately. The round // stays queued and CodeRabbit fires once the slot frees, with - // CodexCommandID preventing a duplicate Codex post. - if p.RateLimitCodexDegrade && DecideCodexPost(r, obs, p, len(obs.CodexCommands) > 0) { + // CodexCommandID preventing a duplicate Codex post. NOT for a head + // CodeRabbit already reviewed — that round belongs to the dedupe + // resolution below once the slot frees (a queued round Codex answers + // clean cannot complete, so deferring it here could wedge the wait). + reviewedHead := false + for _, review := range obs.Reviews { + if sameBot(review.Bot, p.Bot) && review.Commit != "" && strings.HasPrefix(review.Commit, obs.Head) { + reviewedHead = true + break + } + } + if !reviewedHead && p.RateLimitCodexDegrade && DecideCodexPost(r, obs, p, len(obs.CodexCommands) > 0) { return FireDecision{Verdict: FireCodexDeferred, Reason: "fire slot busy; requesting codex review now, coderabbit deferred"} } diff --git a/internal/state/state.go b/internal/state/state.go index 821a6ac..7bfa97f 100644 --- a/internal/state/state.go +++ b/internal/state/state.go @@ -67,6 +67,12 @@ type Round struct { // for the same round. A stale claim (the poster died mid-flight) expires and // may be re-claimed. CodexClaimedAt *time.Time `json:"codex_claimed_at,omitempty"` + // CodexCommandedAt records when crq posted this round's Codex command. It + // can precede FiredAt (a deferred post while queued behind a rate-limit + // window or busy slot), and Codex evidence binds from it — otherwise a + // SHA-less Codex answer delivered before the delayed CodeRabbit fire + // would be ignored by the completion cutoff and never re-requested. + CodexCommandedAt *time.Time `json:"codex_commanded_at,omitempty"` // LastAttemptAt is the adoption cutoff: command comments older than the // most recent failed/abandoned attempt must not be adopted as this round's From 3ea9e4048c41a50487f990c110aa3a0091e28019 Mon Sep 17 00:00:00 2001 From: kristofferR Date: Wed, 22 Jul 2026 20:56:26 +0200 Subject: [PATCH 4/7] Address Codex round 2: evidence anchoring and queue fairness - CodexOnlyEligible now requires evidence bound to this work: a review of the current head, or round-window activity anchored by the fire or by crq's own (possibly pre-fire) Codex command. Auto-activity on older heads merely predicts evidence and no longer qualifies, and the usage-limit check shares the same anchored cutoff so a notice from a previous head cannot permanently disqualify a commanded round. - CodexCommandedAt records the command comment's GitHub timestamp, not a local post-return clock reading, so a fast Codex reply cannot land before the stored cutoff and be ignored forever. - A blocked or slot-busy queue head with its Codex command already posted no longer starves later PRs: the pump scans a bounded number of following queued rounds for a postable Codex defer. --- favicon.png | Bin 0 -> 114525 bytes internal/crq/service.go | 55 ++++++++++++++++++++++++++++----- internal/engine/codex.go | 29 +++++++---------- internal/engine/engine_test.go | 25 ++++++++++++--- 4 files changed, 79 insertions(+), 30 deletions(-) create mode 100644 favicon.png diff --git a/favicon.png b/favicon.png new file mode 100644 index 0000000000000000000000000000000000000000..cd42b9c7a4b644ba60f644572b5efb0e1dfe36ef GIT binary patch literal 114525 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 3 { + continue + } + scanned++ + round := r + robs, oerr := s.observe(ctx, round.Repo, round.PR, &round, now) + if oerr != nil { + continue + } + d := engine.DecideFire(s.global(st, now), round, robs.eng, now, s.policy()) + if d.Verdict != engine.FireCodexDeferred { + continue + } + return s.applyFire(ctx, round, robs.eng, d, now) + } + } + return result, nil } func (s *Service) global(st State, now time.Time) engine.Global { @@ -702,7 +735,7 @@ func (s *Service) fireRound(ctx context.Context, round Round, obs engine.Observa // write. A failed post returns 0 (logged) and the self-heal path retries. var codexID int64 if postCodex { - codexID = s.postCodexReviewComment(ctx, round) + codexID, _ = s.postCodexReviewComment(ctx, round) } updated, err := s.recordFire(ctx, round, token, comment.ID, codexID, firedAt, now) if err != nil { @@ -912,18 +945,25 @@ func (s *Service) recordFire(ctx context.Context, round Round, token string, com // id, or 0 on failure. A failed post is non-fatal: it logs and leaves // CodexCommandID unset so a later pump's self-heal retries. The fresh-fire path // folds the returned id into recordFire's write. -func (s *Service) postCodexReviewComment(ctx context.Context, round Round) int64 { +func (s *Service) postCodexReviewComment(ctx context.Context, round Round) (int64, time.Time) { comment, err := s.gh.PostIssueComment(ctx, round.Repo, round.PR, s.cfg.CodexCommand) if err != nil { if s.log != nil { s.log.Printf("warning: Codex review command post failed for %s@%s: %v (will retry on a later pump)", QueueKey(round.Repo, round.PR), round.Head, err) } - return 0 + return 0, time.Time{} } if s.log != nil { s.log.Printf("fire %s@%s (posted %s)", QueueKey(round.Repo, round.PR), round.Head, strings.TrimSpace(s.cfg.CodexCommand)) } - return comment.ID + // The command's GitHub timestamp is the evidence anchor: a fast Codex + // reply can otherwise land before a local post-return clock reading and + // fall outside the stored cutoff forever (with no repost possible). + at := comment.CreatedAt.UTC() + if at.IsZero() { + at = s.clock().UTC() + } + return comment.ID, at } // fireCodexReview posts the Codex review command for an already-fired round and @@ -931,7 +971,7 @@ func (s *Service) postCodexReviewComment(ctx context.Context, round Round) int64 // retry (the fresh-post path records the id inside recordFire instead). The CAS // guard (same head, CodexCommandID still unset) makes a concurrent post benign. func (s *Service) fireCodexReview(ctx context.Context, round Round) { - codexID := s.postCodexReviewComment(ctx, round) + codexID, codexAt := s.postCodexReviewComment(ctx, round) if codexID == 0 { // Failed post: KEEP the claim — its TTL is the retry backoff. Clearing it // here would let the very next pump repost, bypassing codexClaimTTL. @@ -947,8 +987,7 @@ func (s *Service) fireCodexReview(ctx context.Context, round Round) { r.CodexClaimedAt = nil if r.CodexCommandID == 0 { r.CodexCommandID = codexID - t := s.clock().UTC() - r.CodexCommandedAt = &t + r.CodexCommandedAt = &codexAt } st.PutRound(*r) return nil diff --git a/internal/engine/codex.go b/internal/engine/codex.go index 7761e03..2419b69 100644 --- a/internal/engine/codex.go +++ b/internal/engine/codex.go @@ -177,28 +177,23 @@ func CodexCommandSince(obs Observation, since time.Time) bool { } // CodexOnlyEligible reports whether an account-blocked round may degrade to a -// Codex-only round: the block is live AND Codex shows observed responsiveness -// tied to THIS work — it auto-reviews the PR, or (for a fired round) has -// round-bound activity, or (for an unfired round, e.g. one whose Codex -// command was posted while queued) has reviewed the current head — AND has -// not posted a usage-limit exhaustion notice since the fire. Configuration, -// a live unanswered command, or stale PR-level evidence on an unfired round -// are deliberately not enough — without current evidence the round falls -// back to riding out the CodeRabbit window. +// Codex-only round: the block is live AND Codex has evidence bound to THIS +// work — a review of the current head, or round-window activity anchored by +// the fire or by crq's own (possibly pre-fire) Codex command — AND no +// usage-limit exhaustion notice inside that same window. Auto-activity on +// older heads, configuration, or a live unanswered command merely predict +// evidence; degradation waits for the evidence itself, since before Codex +// responds there is nothing to return early anyway, and marking a round +// deferred stops the loop from extending its deadline over the block. func CodexOnlyEligible(r state.Round, obs Observation, blockedUntil *time.Time, now time.Time) bool { if blockedUntil == nil || !blockedUntil.After(now) { return false } - if !obs.CodexAutoActive { - if r.FiredAt != nil { - if !obs.CodexActiveThisRound { - return false - } - } else if !codexReviewedHead(obs) { - return false - } + anchored := r.FiredAt != nil || r.CodexCommandedAt != nil + if !codexReviewedHead(obs) && !(anchored && obs.CodexActiveThisRound) { + return false } - return !codexUsageLimitedSince(obs, roundCutoff(r)) + return !codexUsageLimitedSince(obs, codexCutoff(r)) } // codexUsageLimitedSince reports whether Codex posted its usage-limit diff --git a/internal/engine/engine_test.go b/internal/engine/engine_test.go index ebe10a3..86525cf 100644 --- a/internal/engine/engine_test.go +++ b/internal/engine/engine_test.go @@ -658,9 +658,11 @@ func TestCodexOnlyEligible(t *testing.T) { if !CodexOnlyEligible(r, active, &blocked, now) { t.Fatal("a live block with round-bound codex activity must degrade") } + // Auto-activity alone predicts evidence; it does not qualify until Codex + // actually responds to this head/round. auto := Observation{Head: "abcdef123", Open: true, CodexAutoActive: true} - if !CodexOnlyEligible(r, auto, &blocked, now) { - t.Fatal("a live block with an auto-active codex must degrade") + if CodexOnlyEligible(r, auto, &blocked, now) { + t.Fatal("auto-activity without current evidence must not degrade") } configOnly := Observation{Head: "abcdef123", Open: true, CodexCommands: []CommandSeen{{ID: 55, CreatedAt: now}}} if CodexOnlyEligible(r, configOnly, &blocked, now) { @@ -754,7 +756,7 @@ func TestCodexOnlyEligibleUnfiredRound(t *testing.T) { blocked := now.Add(25 * time.Minute) queued := state.Round{Repo: "owner/repo", PR: 448, Head: "abcdef123", Phase: state.PhaseQueued, Seq: 1} // A round-window flag computed from a zero cutoff (an old SHA-less review) - // must not qualify an unfired round. + // must not qualify an unfired, uncommanded round. stale := Observation{Head: "abcdef123", Open: true, CodexActiveThisRound: true} if CodexOnlyEligible(queued, stale, &blocked, now) { t.Fatal("stale round-window evidence must not defer an unfired round") @@ -765,8 +767,21 @@ func TestCodexOnlyEligibleUnfiredRound(t *testing.T) { t.Fatal("a codex review of the current head must defer an unfired round") } auto := Observation{Head: "abcdef123", Open: true, CodexAutoActive: true} - if !CodexOnlyEligible(queued, auto, &blocked, now) { - t.Fatal("an auto-active codex must defer an unfired round") + if CodexOnlyEligible(queued, auto, &blocked, now) { + t.Fatal("auto-activity without current evidence must not defer an unfired round") + } + // A deferred command anchors the window: command-bound activity (e.g. the + // usual SHA-less clean comment) qualifies, and an old usage-limit notice + // from before the command no longer disqualifies. + commandedAt := now.Add(-5 * time.Minute) + commanded := queued + commanded.CodexCommandID = 77 + commanded.CodexCommandedAt = &commandedAt + answered := Observation{Head: "abcdef123", Open: true, CodexActiveThisRound: true, + Events: []dialect.BotEvent{{Kind: dialect.EvCodexUsageLimit, Bot: dialect.CodexBotLogin, + CommentID: 600, CreatedAt: commandedAt.Add(-time.Hour), UpdatedAt: commandedAt.Add(-time.Hour)}}} + if !CodexOnlyEligible(commanded, answered, &blocked, now) { + t.Fatal("command-bound activity must defer a commanded unfired round despite an old usage-limit notice") } } From 68c46ff3fe2a95dcf15dd997a080928717131abe Mon Sep 17 00:00:00 2001 From: kristofferR Date: Wed, 22 Jul 2026 20:56:43 +0200 Subject: [PATCH 5/7] Remove stray favicon.png committed by mistake An unrelated local file swept into the previous commit; it is not part of this project. --- favicon.png | Bin 114525 -> 0 bytes 1 file changed, 0 insertions(+), 0 deletions(-) delete mode 100644 favicon.png diff --git a/favicon.png b/favicon.png deleted file mode 100644 index cd42b9c7a4b644ba60f644572b5efb0e1dfe36ef..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 114525 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 Date: Wed, 22 Jul 2026 21:12:32 +0200 Subject: [PATCH 6/7] Address Codex round 3: multi-bot holds, scan fairness, adopted anchors MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit - The push-freely guidance on a deferred round now requires every required bot except CodeRabbit to have finished (DoneExcept); a pending third reviewer keeps the hold-head behavior. - The pump's deferred-Codex scan runs for any blocked/slot-busy front round, not only one whose own Codex command is already posted — a CodeRabbit-only front PR no longer starves later PRs of their early Codex round. - Adopted Codex commands (fire-time and co-review-wait adoption) persist their GitHub CreatedAt as CodexCommandedAt so pre-adoption SHA-less answers bind to the round. - The usage-limit floor falls back to the qualifying head review when the round has no fire/command anchor, so an old exhaustion notice cannot suppress the degrade. --- internal/crq/feedback.go | 12 +++++++----- internal/crq/service.go | 17 +++++++++++++++-- internal/engine/codex.go | 15 ++++++++++++++- 3 files changed, 36 insertions(+), 8 deletions(-) diff --git a/internal/crq/feedback.go b/internal/crq/feedback.go index c7e4146..817c67e 100644 --- a/internal/crq/feedback.go +++ b/internal/crq/feedback.go @@ -388,11 +388,13 @@ func (s *Service) Loop(ctx context.Context, repo string, pr int) (FeedbackReport if allReviewed(report.ReviewedBy) { report.Reason = "all required reviewers finished; address findings, push once, and resolve threads" s.completeWaitRound(ctx, repo, pr, head) - } else if report.CodeRabbitDeferred { - // Degraded round: Codex answered while CodeRabbit is rate-limited. - // These findings are this round's work — fixing and pushing is - // exactly right; the CodeRabbit review stays queued and fires - // against the newest head once the window opens. + } else if report.CodeRabbitDeferred && engine.DoneExcept(report.ReviewedBy, s.cfg.Bot) { + // Degraded round: every required bot except the rate-limited + // CodeRabbit has finished. These findings are this round's work — + // fixing and pushing is exactly right; the CodeRabbit review stays + // queued and fires against the newest head once the window opens. + // With ANOTHER required bot still pending, the hold-head branch + // below applies instead: pushing would restart its checks. report.Reason = "codex findings during a coderabbit rate-limit window; fix, push, and loop again — the coderabbit review stays queued and fires when the window opens" } else { // A required reviewer is still pending (e.g. Codex posted a finding diff --git a/internal/crq/service.go b/internal/crq/service.go index 1a93f68..cd2297b 100644 --- a/internal/crq/service.go +++ b/internal/crq/service.go @@ -270,7 +270,6 @@ func (s *Service) Pump(ctx context.Context) (PumpResult, error) { // scan a bounded number of following queued rounds for a postable // Codex defer (each costs one observation; ETag caching keeps it cheap). if s.cfg.RateLimitCodexDegrade && decision.Verdict == engine.FireNo && - next.CodexCommandID != 0 && (strings.Contains(decision.Reason, "account blocked") || strings.Contains(decision.Reason, "fire slot busy")) { scanned := 0 @@ -657,8 +656,16 @@ func (s *Service) fireRound(ctx context.Context, round Round, obs engine.Observa // Not posting because a live `@codex review` command already answers // this head — record its id now. The self-heal scan anchors on FiredAt // and would miss a command posted before the adopted CodeRabbit command, - // posting a duplicate; recording it here keeps the round "asked". + // posting a duplicate; recording it here keeps the round "asked". Its + // timestamp anchors the codex cutoff too, or a SHA-less answer that + // landed before this adopted fire would never bind to the round. r.CodexCommandID = id + for _, c := range obs.CodexCommands { + if c.ID == id && !c.CreatedAt.IsZero() { + at := c.CreatedAt.UTC() + r.CodexCommandedAt = &at + } + } } st.PutRound(*r) recorded = true @@ -881,6 +888,12 @@ func (s *Service) fireCoReviewWait(ctx context.Context, round Round, obs engine. } if r.CodexCommandID == 0 && codexID != 0 { r.CodexCommandID = codexID + for _, c := range obs.CodexCommands { + if c.ID == codexID && !c.CreatedAt.IsZero() { + at := c.CreatedAt.UTC() + r.CodexCommandedAt = &at + } + } } st.PutRound(*r) changed = true diff --git a/internal/engine/codex.go b/internal/engine/codex.go index 2419b69..9e04f28 100644 --- a/internal/engine/codex.go +++ b/internal/engine/codex.go @@ -193,7 +193,20 @@ func CodexOnlyEligible(r state.Round, obs Observation, blockedUntil *time.Time, if !codexReviewedHead(obs) && !(anchored && obs.CodexActiveThisRound) { return false } - return !codexUsageLimitedSince(obs, codexCutoff(r)) + // The usage-limit floor is the evidence window. For an unfired, + // uncommanded round the cutoff is zero — floor it at the head review that + // qualified the round instead, or any old exhaustion notice still on the + // PR would suppress the degrade until the window expires. + floor := codexCutoff(r) + if floor.IsZero() { + for _, review := range obs.Reviews { + if dialect.IsCodexBot(review.Bot) && obs.Head != "" && + strings.HasPrefix(review.Commit, obs.Head) && review.SubmittedAt.After(floor) { + floor = review.SubmittedAt + } + } + } + return !codexUsageLimitedSince(obs, floor) } // codexUsageLimitedSince reports whether Codex posted its usage-limit From 0a42145617dca2dff13f7b50f5db0b85292f4832 Mon Sep 17 00:00:00 2001 From: kristofferR Date: Wed, 22 Jul 2026 22:43:00 +0200 Subject: [PATCH 7/7] Harden Codex-deferred review rounds --- internal/crq/feedback.go | 4 +- internal/crq/service.go | 42 +++++++- internal/crq/service_test.go | 159 +++++++++++++++++++++++++++++++ internal/engine/codex.go | 40 +++++--- internal/engine/completion.go | 20 ++++ internal/engine/engine_test.go | 37 ++++++- internal/engine/fire.go | 67 ++++++++++--- llms.txt | 17 ++-- skills/coderabbit-queue/SKILL.md | 7 +- 9 files changed, 349 insertions(+), 44 deletions(-) diff --git a/internal/crq/feedback.go b/internal/crq/feedback.go index 817c67e..bad4608 100644 --- a/internal/crq/feedback.go +++ b/internal/crq/feedback.go @@ -262,7 +262,7 @@ func (s *Service) Feedback(ctx context.Context, repo string, pr int) (FeedbackRe case report.Converged: report.Status = "converged" case report.CodeRabbitDeferred && len(report.Findings) == 0 && - engine.DoneExcept(report.ReviewedBy, s.cfg.Bot): + engine.DoneExceptWithEvidence(report.ReviewedBy, s.cfg.Bot, dialect.CodexBotLogin): report.Status = "deferred" report.Reason = "codex reviewed clean; coderabbit review deferred until " + report.DeferredUntil.UTC().Format(time.RFC3339) + " (account rate-limited)" @@ -388,7 +388,7 @@ func (s *Service) Loop(ctx context.Context, repo string, pr int) (FeedbackReport if allReviewed(report.ReviewedBy) { report.Reason = "all required reviewers finished; address findings, push once, and resolve threads" s.completeWaitRound(ctx, repo, pr, head) - } else if report.CodeRabbitDeferred && engine.DoneExcept(report.ReviewedBy, s.cfg.Bot) { + } else if report.CodeRabbitDeferred && engine.DoneExceptWithEvidence(report.ReviewedBy, s.cfg.Bot, dialect.CodexBotLogin) { // Degraded round: every required bot except the rate-limited // CodeRabbit has finished. These findings are this round's work — // fixing and pushing is exactly right; the CodeRabbit review stays diff --git a/internal/crq/service.go b/internal/crq/service.go index cd2297b..270a3e6 100644 --- a/internal/crq/service.go +++ b/internal/crq/service.go @@ -496,7 +496,7 @@ func (s *Service) applyFire(ctx context.Context, round Round, obs engine.Observa case engine.FireCodexOnly: return s.fireCodexOnly(ctx, round, d.Reason, now) case engine.FireCodexDeferred: - return s.fireCodexDeferred(ctx, round, d.Reason, now) + return s.fireCodexDeferred(ctx, round, d.AdoptCommandID, d.AdoptAt, d.Reason, now) case engine.FireCoReviewWait: return s.fireCoReviewWait(ctx, round, obs, d.Reason, now) case engine.FireSupersede: @@ -1021,11 +1021,49 @@ func (s *Service) fireCodexReview(ctx context.Context, round Round) { // opens, at which point PostCodex stays false because CodexCommandID is set. // The claim-then-post shape mirrors selfHealCodex — this path is not // serialized by the fire slot either. -func (s *Service) fireCodexDeferred(ctx context.Context, round Round, reason string, now time.Time) (PumpResult, error) { +func (s *Service) fireCodexDeferred(ctx context.Context, round Round, adoptID int64, adoptAt time.Time, reason string, now time.Time) (PumpResult, error) { result := PumpResult{Action: "codex_fired", Repo: round.Repo, PR: round.PR, Head: round.Head, Reason: reason} if s.cfg.DryRun { return result, nil } + if adoptID != 0 { + adopted := false + updated, err := s.store.Update(ctx, func(st *State) error { + r := st.Round(round.Repo, round.PR) + if !sameRound(r, round) || r.CodexCommandID != 0 || + (r.Phase != PhaseQueued && r.Phase != PhaseAwaitingRetry) { + return ErrNoChange + } + // A concurrent worker may already be posting the command represented by + // this observation. Let its fresh claim finish instead of adopting and + // racing its state write; a stale claim no longer blocks recovery. + if r.CodexClaimedAt != nil && now.Sub(r.CodexClaimedAt.UTC()) < codexClaimTTL { + return ErrNoChange + } + at := adoptAt.UTC() + if at.IsZero() { + at = now.UTC() + } + r.CodexCommandID = adoptID + r.CodexCommandedAt = &at + r.CodexClaimedAt = nil + r.Note = "existing codex review command adopted; coderabbit deferred (account rate-limited)" + st.PutRound(*r) + adopted = true + return nil + }) + if err != nil && !errors.Is(err, ErrNoChange) { + return result, err + } + if !adopted { + result.Action = "deduped" + result.Reason = "codex command already adopted or posted" + return result, nil + } + s.sync(ctx, updated) + result.Action = "codex_adopted" + return result, nil + } claimed := false updated, err := s.store.Update(ctx, func(st *State) error { r := st.Round(round.Repo, round.PR) diff --git a/internal/crq/service_test.go b/internal/crq/service_test.go index af98c71..0371553 100644 --- a/internal/crq/service_test.go +++ b/internal/crq/service_test.go @@ -1949,6 +1949,47 @@ func TestLoopDegradesToCodexOnlyOnRateLimit(t *testing.T) { } } +// TestFeedbackDefersCleanAutoCodexWithDefaultRequiredBots covers the default +// feedback-only Codex setup: its SHA-bound clean verdict is sufficient evidence +// even though Completion.ReviewedBy contains only the pending CodeRabbit key. +func TestFeedbackDefersCleanAutoCodexWithDefaultRequiredBots(t *testing.T) { + ctx := context.Background() + cfg := firingConfig() + cfg.RateLimitCodexDegrade = true + cfg.FeedbackBots = []string{"coderabbitai[bot]", "chatgpt-codex-connector[bot]"} + gh := newFakeGitHub() + pull := ghapi.Pull{State: "open"} + pull.Head.SHA = "abcdef1234567890" + gh.pulls[fakeKey("o/carrier", 93)] = pull + cleanAt := time.Now().UTC().Add(-time.Minute) + clean := ghapi.IssueComment{ID: 701, + Body: "Codex Review: Didn't find any major issues. :tada:\n\n**Reviewed commit:** `abcdef1234`", + CreatedAt: cleanAt, UpdatedAt: cleanAt} + clean.User.Login = "chatgpt-codex-connector[bot]" + gh.comments[fakeKey("o/carrier", 93)] = []ghapi.IssueComment{clean} + store := NewMemoryStore(cfg) + seedRound(t, store, cfg, "o/carrier", 93, "abcdef123", PhaseQueued, cleanAt.Add(-time.Minute), 0) + blockedUntil := time.Now().UTC().Add(30 * time.Minute) + if _, err := store.Update(ctx, func(st *State) error { + st.Account.BlockedUntil = &blockedUntil + return nil + }); err != nil { + t.Fatal(err) + } + + svc := NewService(cfg, gh, store, nil) + report, err := svc.Feedback(ctx, "o/carrier", 93) + if err != nil { + t.Fatal(err) + } + if report.Status != "deferred" || !report.CodeRabbitDeferred || report.Converged { + t.Fatalf("clean feedback-only codex must produce a non-converged deferred report, got %#v", report) + } + if len(report.ReviewedBy) != 1 || report.ReviewedBy["coderabbitai[bot]"] { + t.Fatalf("default required-bot state must remain coderabbit-only and pending, got %#v", report.ReviewedBy) + } +} + // TestLoopDeferredCodexCleanExitsZeroNotConverged: a clean Codex verdict on a // degraded round exits 0 as "deferred" without completing the round — the // CodeRabbit review stays owed. @@ -2070,3 +2111,121 @@ func TestPumpPostsCodexDeferredDuringBlockThenFiresCodeRabbit(t *testing.T) { t.Fatalf("after the window: one coderabbit fire, still one codex command, got %v", gh.posted) } } + +func TestPumpAdoptsExistingCodexCommandDuringBlock(t *testing.T) { + ctx := context.Background() + cfg := firingConfig() + cfg.RateLimitCodexDegrade = true + cfg.RequiredBots = []string{"coderabbitai[bot]", "chatgpt-codex-connector[bot]"} + cfg.CodexCommand = "@codex review" + gh := newFakeGitHub() + headTime := time.Now().UTC().Add(-2 * time.Minute) + pull := ghapi.Pull{State: "open"} + pull.Head.SHA = "abcdef1234567890" + gh.pulls[fakeKey("o/carrier", 94)] = pull + commit := ghapi.Commit{SHA: pull.Head.SHA} + commit.Committer.Date = headTime + gh.commits[pull.Head.SHA] = commit + commandAt := headTime.Add(time.Minute) + command := ghapi.IssueComment{ID: 702, Body: cfg.CodexCommand, CreatedAt: commandAt, UpdatedAt: commandAt} + command.User.Login = "kristofferR" + gh.comments[fakeKey("o/carrier", 94)] = []ghapi.IssueComment{command} + gh.graphQL = noForcePush + store := NewMemoryStore(cfg) + svc := NewService(cfg, gh, store, nil) + if _, err := svc.Enqueue(ctx, "o/carrier", 94); err != nil { + t.Fatal(err) + } + blockedUntil := time.Now().UTC().Add(30 * time.Minute) + if _, err := store.Update(ctx, func(st *State) error { + st.Account.BlockedUntil = &blockedUntil + return nil + }); err != nil { + t.Fatal(err) + } + + res, err := svc.Pump(ctx) + if err != nil { + t.Fatal(err) + } + if res.Action != "codex_adopted" { + t.Fatalf("expected the existing codex command to be adopted, got %#v", res) + } + if len(gh.posted) != 0 { + t.Fatalf("adopting the codex command must not post another command, got %v", gh.posted) + } + st, _, err := store.Load(ctx) + if err != nil { + t.Fatal(err) + } + r := st.Round("o/carrier", 94) + if r == nil || r.Phase != PhaseQueued || r.CodexCommandID != command.ID || + r.CodexCommandedAt == nil || !r.CodexCommandedAt.Equal(commandAt) { + t.Fatalf("the queued round must persist the adopted codex anchor, got %#v", r) + } +} + +func TestFireCodexDeferredAdoptionHonorsDryRunAndActiveClaim(t *testing.T) { + ctx := context.Background() + cfg := firingConfig() + cfg.RateLimitCodexDegrade = true + cfg.RequiredBots = []string{"coderabbitai[bot]", "chatgpt-codex-connector[bot]"} + cfg.CodexCommand = "@codex review" + gh := newFakeGitHub() + store := NewMemoryStore(cfg) + now := time.Now().UTC() + seedRound(t, store, cfg, "o/carrier", 95, "abcdef123", PhaseQueued, now.Add(-time.Minute), 0) + svc := NewService(cfg, gh, store, nil) + st, _, err := store.Load(ctx) + if err != nil { + t.Fatal(err) + } + round := *st.Round("o/carrier", 95) + + svc.cfg.DryRun = true + res, err := svc.fireCodexDeferred(ctx, round, 703, now.Add(-time.Minute), "dry run adopt", now) + if err != nil { + t.Fatal(err) + } + if res.Action != "codex_fired" || len(gh.posted) != 0 { + t.Fatalf("dry run must report the existing simulated action without posting, got %#v posts=%v", res, gh.posted) + } + st, _, _ = store.Load(ctx) + if got := st.Round("o/carrier", 95); got == nil || got.CodexCommandID != 0 { + t.Fatalf("dry run must not persist the adopted command, got %#v", got) + } + + svc.cfg.DryRun = false + if _, err := store.Update(ctx, func(st *State) error { + r := st.Round("o/carrier", 95) + r.CodexClaimedAt = &now + st.PutRound(*r) + return nil + }); err != nil { + t.Fatal(err) + } + res, err = svc.fireCodexDeferred(ctx, round, 703, now.Add(-time.Minute), "claimed adopt", now) + if err != nil { + t.Fatal(err) + } + if res.Action != "deduped" { + t.Fatalf("a fresh in-flight claim must defer adoption, got %#v", res) + } + st, _, _ = store.Load(ctx) + if got := st.Round("o/carrier", 95); got == nil || got.CodexCommandID != 0 || got.CodexClaimedAt == nil { + t.Fatalf("the active claim must remain untouched, got %#v", got) + } + + staleNow := now.Add(codexClaimTTL + time.Second) + res, err = svc.fireCodexDeferred(ctx, round, 703, now.Add(-time.Minute), "stale claim adopt", staleNow) + if err != nil { + t.Fatal(err) + } + if res.Action != "codex_adopted" { + t.Fatalf("an expired claim must allow adoption recovery, got %#v", res) + } + st, _, _ = store.Load(ctx) + if got := st.Round("o/carrier", 95); got == nil || got.CodexCommandID != 703 || got.CodexClaimedAt != nil { + t.Fatalf("the recovered adoption must replace the stale claim, got %#v", got) + } +} diff --git a/internal/engine/codex.go b/internal/engine/codex.go index 9e04f28..44f12b1 100644 --- a/internal/engine/codex.go +++ b/internal/engine/codex.go @@ -70,15 +70,35 @@ func codexCommentedRound(obs Observation, cutoff time.Time) bool { return false } -// codexReviewedHead reports whether Codex has a submitted review whose commit -// prefixes the observed head — the "Codex already reviewed this head" fire guard. -func codexReviewedHead(obs Observation) bool { +// codexReviewedHeadAt reports the newest Codex verdict explicitly bound to the +// observed head: either a submitted review or a clean summary naming that SHA. +// The timestamp is the evidence floor used to ignore older usage-limit notices. +func codexReviewedHeadAt(obs Observation) (time.Time, bool) { + var latest time.Time + matched := false for _, review := range obs.Reviews { if dialect.IsCodexBot(review.Bot) && obs.Head != "" && review.Commit != "" && strings.HasPrefix(review.Commit, obs.Head) { - return true + matched = true + if review.SubmittedAt.After(latest) { + latest = review.SubmittedAt + } } } - return false + for _, ev := range obs.Events { + if ev.Kind == dialect.EvCodexClean && obs.Head != "" && dialect.SHAPrefixMatch(ev.SHA, obs.Head) { + matched = true + if at := ev.ObservedTime(); at.After(latest) { + latest = at + } + } + } + return latest, matched +} + +// codexReviewedHead is the "Codex already reviewed this head" fire guard. +func codexReviewedHead(obs Observation) bool { + _, matched := codexReviewedHeadAt(obs) + return matched } // CodexActiveThisRound reports whether Codex shows any activity bound to this @@ -189,8 +209,9 @@ func CodexOnlyEligible(r state.Round, obs Observation, blockedUntil *time.Time, if blockedUntil == nil || !blockedUntil.After(now) { return false } + headEvidenceAt, headReviewed := codexReviewedHeadAt(obs) anchored := r.FiredAt != nil || r.CodexCommandedAt != nil - if !codexReviewedHead(obs) && !(anchored && obs.CodexActiveThisRound) { + if !headReviewed && !(anchored && obs.CodexActiveThisRound) { return false } // The usage-limit floor is the evidence window. For an unfired, @@ -199,12 +220,7 @@ func CodexOnlyEligible(r state.Round, obs Observation, blockedUntil *time.Time, // PR would suppress the degrade until the window expires. floor := codexCutoff(r) if floor.IsZero() { - for _, review := range obs.Reviews { - if dialect.IsCodexBot(review.Bot) && obs.Head != "" && - strings.HasPrefix(review.Commit, obs.Head) && review.SubmittedAt.After(floor) { - floor = review.SubmittedAt - } - } + floor = headEvidenceAt } return !codexUsageLimitedSince(obs, floor) } diff --git a/internal/engine/completion.go b/internal/engine/completion.go index 07500e3..d95a65c 100644 --- a/internal/engine/completion.go +++ b/internal/engine/completion.go @@ -300,6 +300,26 @@ func DoneExcept(reviewedBy map[string]bool, except string) bool { return others > 0 } +// DoneExceptWithEvidence is DoneExcept after applying independently established +// review evidence for one bot. It preserves every other gating bot, while also +// handling configured login spellings that differ only by the "[bot]" suffix. +func DoneExceptWithEvidence(reviewedBy map[string]bool, except, evidenceBot string) bool { + withEvidence := make(map[string]bool, len(reviewedBy)+1) + evidenceNorm := dialect.NormalizeBotName(evidenceBot) + found := false + for bot, reviewed := range reviewedBy { + if dialect.NormalizeBotName(bot) == evidenceNorm { + reviewed = true + found = true + } + withEvidence[bot] = reviewed + } + if !found { + withEvidence[evidenceBot] = true + } + return DoneExcept(withEvidence, except) +} + // needsBotReview reports whether login gates completion (has a ReviewedBy // key) and its review hasn't been seen yet. func needsBotReview(reviewedBy map[string]bool, login string) bool { diff --git a/internal/engine/engine_test.go b/internal/engine/engine_test.go index 86525cf..13f2835 100644 --- a/internal/engine/engine_test.go +++ b/internal/engine/engine_test.go @@ -696,6 +696,28 @@ func TestDoneExcept(t *testing.T) { } } +func TestDoneExceptWithEvidence(t *testing.T) { + cr := "coderabbitai[bot]" + tests := []struct { + name string + reviewedBy map[string]bool + want bool + }{ + {name: "feedback-only evidence supplies non-vacuous gate", reviewedBy: map[string]bool{cr: false}, want: true}, + {name: "configured evidence bot is marked reviewed", reviewedBy: map[string]bool{cr: false, dialect.CodexBotLogin: false}, want: true}, + {name: "suffixless evidence bot is normalized", reviewedBy: map[string]bool{cr: false, "chatgpt-codex-connector": false}, want: true}, + {name: "another pending reviewer still gates", reviewedBy: map[string]bool{cr: false, dialect.CodexBotLogin: false, "other[bot]": false}, want: false}, + {name: "another completed reviewer permits", reviewedBy: map[string]bool{cr: false, "other[bot]": true}, want: true}, + } + for _, tc := range tests { + t.Run(tc.name, func(t *testing.T) { + if got := DoneExceptWithEvidence(tc.reviewedBy, cr, dialect.CodexBotLogin); got != tc.want { + t.Fatalf("DoneExceptWithEvidence() = %v, want %v", got, tc.want) + } + }) + } +} + // TestDecideFireBlockedCodexDeferred: an account block with the degrade flag // posts only the Codex command and keeps the round queued for CodeRabbit. func TestDecideFireBlockedCodexDeferred(t *testing.T) { @@ -726,10 +748,12 @@ func TestDecideFireBlockedCodexDeferred(t *testing.T) { if d := DecideFire(g, posted, open, now, degrade); d.Verdict != FireNo { t.Fatalf("an already-posted codex command must not re-defer, got %+v", d) } - // A live command on the PR → nothing to post; blocked FireNo. + // A live command on the PR is adopted as this round's Codex anchor rather + // than re-posted or left unrecorded. cmdObs := Observation{Head: head, Open: true, CodexCommands: []CommandSeen{{ID: 55, CreatedAt: now}}} - if d := DecideFire(g, queued, cmdObs, now, degrade); d.Verdict != FireNo { - t.Fatalf("a live codex command must not re-post, got %+v", d) + if d := DecideFire(g, queued, cmdObs, now, degrade); d.Verdict != FireCodexDeferred || + d.AdoptCommandID != 55 || !d.AdoptAt.Equal(now) || d.PostCodex { + t.Fatalf("a live codex command must be adopted without re-posting, got %+v", d) } // Auto-active Codex reviews unprompted → nothing to post; blocked FireNo. autoObs := Observation{Head: head, Open: true, CodexAutoActive: true} @@ -770,6 +794,13 @@ func TestCodexOnlyEligibleUnfiredRound(t *testing.T) { if CodexOnlyEligible(queued, auto, &blocked, now) { t.Fatal("auto-activity without current evidence must not defer an unfired round") } + cleanAt := now.Add(-time.Minute) + cleanHead := Observation{Head: "abcdef123", Open: true, CodexAutoActive: true, + Events: []dialect.BotEvent{{Kind: dialect.EvCodexClean, Bot: dialect.CodexBotLogin, + SHA: "abcdef1234567890", CommentID: 601, CreatedAt: cleanAt, UpdatedAt: cleanAt}}} + if !CodexOnlyEligible(queued, cleanHead, &blocked, now) { + t.Fatal("a clean codex summary naming the current head must defer an unfired round") + } // A deferred command anchors the window: command-bound activity (e.g. the // usual SHA-less clean comment) qualifies, and an old usage-limit notice // from before the command no longer disqualifies. diff --git a/internal/engine/fire.go b/internal/engine/fire.go index 7931b52..a74a0ca 100644 --- a/internal/engine/fire.go +++ b/internal/engine/fire.go @@ -14,15 +14,15 @@ import ( type FireVerdict int const ( - FireNo FireVerdict = iota // skip this pass (Reason says why) - FirePost // reserve the slot and post the command - FireAdopt // a command is already on the PR — adopt it - FireDedupe // bot already reviewed this head — complete without firing - FireCodexOnly // CodeRabbit reviewed the head but a required Codex still must — post only the Codex command - FireCoReviewWait // CodeRabbit reviewed the head; a gating co-bot has not — wait for it, bounded, without posting or holding the slot - FireCodexDeferred // account blocked — post only the Codex command now; the round stays queued so CodeRabbit fires when the window opens - FireSupersede // observed head differs — supersede the round first - FireDrop // PR closed/merged — abandon the round + FireNo FireVerdict = iota // skip this pass (Reason says why) + FirePost // reserve the slot and post the command + FireAdopt // a command is already on the PR — adopt it + FireDedupe // bot already reviewed this head — complete without firing + FireCodexOnly // CodeRabbit reviewed the head but a required Codex still must — post only the Codex command + FireCoReviewWait // CodeRabbit reviewed the head; a gating co-bot has not — wait for it, bounded, without posting or holding the slot + FireCodexDeferred // account blocked — post only the Codex command now; the round stays queued so CodeRabbit fires when the window opens + FireSupersede // observed head differs — supersede the round first + FireDrop // PR closed/merged — abandon the round ) type FireDecision struct { @@ -79,9 +79,10 @@ func DecideFire(g Global, r state.Round, obs Observation, now time.Time, p Polic break } } - if !reviewedHead && p.RateLimitCodexDegrade && DecideCodexPost(r, obs, p, len(obs.CodexCommands) > 0) { - return FireDecision{Verdict: FireCodexDeferred, - Reason: "fire slot busy; requesting codex review now, coderabbit deferred"} + if !reviewedHead { + if d, ok := decideCodexDeferred(r, obs, p, "fire slot busy"); ok { + return d + } } return FireDecision{Verdict: FireNo, Reason: "fire slot busy"} } @@ -104,9 +105,8 @@ func DecideFire(g Global, r state.Round, obs Observation, now time.Time, p Polic // fires the moment the window opens. DecideCodexPost's guards // (command configured, codex required, not auto-active, no live or // already-posted command) make this idempotent per round. - if p.RateLimitCodexDegrade && DecideCodexPost(r, obs, p, len(obs.CodexCommands) > 0) { - return FireDecision{Verdict: FireCodexDeferred, - Reason: "account blocked; requesting codex review now, coderabbit deferred"} + if d, ok := decideCodexDeferred(r, obs, p, "account blocked"); ok { + return d } return FireDecision{Verdict: FireNo, Reason: "account blocked until " + g.BlockedUntil.UTC().Format(time.RFC3339)} } @@ -136,6 +136,43 @@ func DecideFire(g Global, r state.Round, obs Observation, now time.Time, p Polic return FireDecision{Verdict: FirePost, PostCodex: postCodex} } +// decideCodexDeferred starts or adopts the Codex half of a round while +// CodeRabbit cannot fire. CodexCommands is cutoff-filtered by observe(), so an +// existing command here is safe to bind to this head and must be recorded as +// the round anchor rather than merely suppressing a duplicate post. +func decideCodexDeferred(r state.Round, obs Observation, p Policy, reason string) (FireDecision, bool) { + if !p.RateLimitCodexDegrade || r.CodexCommandID != 0 { + return FireDecision{}, false + } + if DecideCodexPost(r, obs, p, len(obs.CodexCommands) > 0) { + return FireDecision{ + Verdict: FireCodexDeferred, + Reason: reason + "; requesting codex review now, coderabbit deferred", + PostCodex: true, + }, true + } + var newest *CommandSeen + for i := range obs.CodexCommands { + cmd := &obs.CodexCommands[i] + if newest == nil || cmd.CreatedAt.After(newest.CreatedAt) { + newest = cmd + } + } + if newest == nil { + return FireDecision{}, false + } + at := newest.CreatedAt + if at.IsZero() { + at = newest.UpdatedAt + } + return FireDecision{ + Verdict: FireCodexDeferred, + Reason: reason + "; adopting existing codex review command, coderabbit deferred", + AdoptCommandID: newest.ID, + AdoptAt: at, + }, true +} + // codexAwareDedupe resolves what to do when CodeRabbit already reviewed the head. // If no gating Codex is still outstanding, the round is genuinely done (FireDedupe). // If a required-or-auto-active Codex has no review of this head yet, the round is diff --git a/llms.txt b/llms.txt index 267ab7e..e684910 100644 --- a/llms.txt +++ b/llms.txt @@ -48,8 +48,9 @@ The loop also returns as soon as any feedback bot reports a finding; it does not remaining required bots or a shared review slot. Fix those findings locally, but HOLD THE HEAD: resolve each addressed thread immediately, but do not commit or push while any `.reviewed_by` value is false, because changing the head restarts the pending checks while thread resolution does not. -Exception: when `.coderabbit_deferred` is true the round is Codex-only (CodeRabbit rate-limited) — -fix, push, and loop again without holding the head; the queued CodeRabbit review is untouched. +Exception: when `.coderabbit_deferred` is true and every non-CodeRabbit required reviewer is true, +the round is Codex-only (CodeRabbit rate-limited) — fix, push, and loop again without holding the +head; the queued CodeRabbit review is untouched. Keep the queued review alive and poll `crq feedback` with the same `CRQ_REQUIRED_BOTS`. When every required bot is true, fix and resolve the rest, then commit all fixes once and push once. @@ -69,8 +70,9 @@ never when Codex auto-reviews the PR on its own. A Codex that joins a round unin round's convergence dynamically (its usage-limit notice releases the dynamic gate). If a bot reports actionable findings first, it emits them immediately while leaving the queued round alive. Fix and validate locally and resolve or decline each addressed thread immediately. While any required bot's -`.reviewed_by` value is false, do not commit or push — unless `.coderabbit_deferred` is true, in -which case push freely: the round is Codex-only while CodeRabbit is rate-limited. Only after every +`.reviewed_by` value is false, do not commit or push — unless `.coderabbit_deferred` is true and all +non-CodeRabbit required reviewers are true, in which case push freely: the round is Codex-only while +CodeRabbit is rate-limited. Only after every `CRQ_REQUIRED_BOTS` entry is true for the current head should you fix and resolve the rest, then commit and push the combined fixes once. Convergence is reported only after that same condition is met. @@ -81,9 +83,10 @@ Exit codes: `.coderabbit_deferred_until` or on the next push; the queued CodeRabbit review fires by itself once the window opens. - `10`: read `.findings[]`, fix valid issues, and validate locally. If any `.reviewed_by` value is - false, resolve addressed threads but hold the head — EXCEPT when `.coderabbit_deferred` is true: - those are Codex-only findings during a CodeRabbit rate-limit window, so fix, push, and loop again - (each Codex round takes minutes; several fit inside one CodeRabbit window). + false, resolve addressed threads but hold the head — EXCEPT when `.coderabbit_deferred` is true + and all non-CodeRabbit required reviewers are true: those are Codex-only findings during a + CodeRabbit rate-limit window, so fix, push, and loop again (each Codex round takes minutes; + several fit inside one CodeRabbit window). - `2`: timed out waiting for feedback; do not push a stale-feedback round. Rate-limit degrade: when CodeRabbit is rate-limited ("Review limit reached … Next review available diff --git a/skills/coderabbit-queue/SKILL.md b/skills/coderabbit-queue/SKILL.md index 5b9cb9c..0b97cbd 100644 --- a/skills/coderabbit-queue/SKILL.md +++ b/skills/coderabbit-queue/SKILL.md @@ -44,9 +44,10 @@ Exit codes: `.status == "deferred"`), Codex reviewed clean while CodeRabbit is rate-limited — the CodeRabbit review is still owed and `.converged` is false. Treat it as progress, not convergence: re-run `crq loop` after `.coderabbit_deferred_until` or on the next push. -- `10`: actionable findings were written to JSON. When `.coderabbit_deferred` is true these are - Codex-only findings during a CodeRabbit rate-limit window: fix, push, and loop again immediately - instead of holding the head — the queued CodeRabbit review fires by itself once the window opens. +- `10`: actionable findings were written to JSON. When `.coderabbit_deferred` is true and all + non-CodeRabbit required reviewers are true, these are Codex-only findings during a CodeRabbit + rate-limit window: fix, push, and loop again immediately instead of holding the head — the queued + CodeRabbit review fires by itself once the window opens. - `2`: timed out waiting for feedback Rate-limit degrade (default on, `CRQ_RL_CODEX_DEGRADE=0` disables): when CodeRabbit is