diff --git a/changelog.d/fixed-15559-review-decision.md b/changelog.d/fixed-15559-review-decision.md new file mode 100644 index 0000000000..401e65b62d --- /dev/null +++ b/changelog.d/fixed-15559-review-decision.md @@ -0,0 +1 @@ +- Preserve in-flight review decision dispatches during delivery so their verdicts can bind to the intended decision ([#15559](https://github.com/hivecommons/hive/issues/15559)). diff --git a/src/cmd/hive/main.go b/src/cmd/hive/main.go index 3c639a2843..cf1382f1f1 100644 --- a/src/cmd/hive/main.go +++ b/src/cmd/hive/main.go @@ -7841,7 +7841,7 @@ func runEvalCycle( onReviewDelivered: func(msg scheduler.KickMessage) { if k, ok := reviewKickByMessage[msg.Agent+"\x00"+msg.Message]; ok { deliveredReviewKicks = append(deliveredReviewKicks, k) - persistReviewDispatchState(reviewPlan, deliveredReviewKicks, logger) + persistReviewDispatchStateIntermediate(reviewPlan, deliveredReviewKicks, logger) } }, onFailed: func(msg scheduler.KickMessage, err error) { @@ -11410,6 +11410,19 @@ func postReviewAcknowledgements(ctx context.Context, poster reviewCommentPoster, } } +// Intermediate delivery checkpoints retain all planned pending entries: other +// kicks in this pass may still be in flight. Final reconciliation releases +// those that were never delivered. +func persistReviewDispatchStateIntermediate(plan review.DispatchPlan, delivered []review.DispatchKick, logger *slog.Logger) { + if plan.State.GeneratedAt.IsZero() && len(plan.ReviewKicks) == 0 && len(plan.FixKicks) == 0 { + return + } + state := review.ConfirmDelivered(plan.State, nil, delivered) + if err := review.WriteDispatchState("", state); err != nil { + logger.Warn("failed to persist review dispatch state", "error", err) + } +} + func persistReviewDispatchState(plan review.DispatchPlan, delivered []review.DispatchKick, logger *slog.Logger) { planned := append(append([]review.DispatchKick(nil), plan.ReviewKicks...), plan.FixKicks...) if plan.State.GeneratedAt.IsZero() && len(planned) == 0 { diff --git a/src/cmd/hive/review_dispatch_wiring_test.go b/src/cmd/hive/review_dispatch_wiring_test.go index 7ae4c8be11..5c1928ecd5 100644 --- a/src/cmd/hive/review_dispatch_wiring_test.go +++ b/src/cmd/hive/review_dispatch_wiring_test.go @@ -357,6 +357,33 @@ func TestPersistReviewDispatchState_KeepsOnlyDeliveredKicks(t *testing.T) { } } +func TestIntermediateReviewDispatchStateKeepsInFlightDecision(t *testing.T) { + redirectReviewPaths(t) + now := time.Now().UTC() + first := review.DispatchKick{Kind: "review", Agent: "head", Repo: "o/r", Number: 42, HeadSHA: reviewTestSHA, Perspective: review.PerspectiveSecurity} + decision := review.DispatchKick{Kind: "review", Agent: "reviewer", Repo: "o/r", Number: 42, HeadSHA: reviewTestSHA, Perspective: review.PerspectiveCorrectness, Decision: true} + plan := review.DispatchPlan{ReviewKicks: []review.DispatchKick{first, decision}, State: review.DispatchState{GeneratedAt: now, Pending: []review.PendingReview{ + {Repo: first.Repo, Number: first.Number, HeadSHA: first.HeadSHA, Perspective: first.Perspective, Agent: first.Agent, Dispatched: now}, + {Repo: decision.Repo, Number: decision.Number, HeadSHA: decision.HeadSHA, Perspective: decision.Perspective, Agent: decision.Agent, Decision: true, Dispatched: now}, + }}} + persistReviewDispatchStateIntermediate(plan, []review.DispatchKick{first}, restoreTestLogger()) + state, err := review.LoadDispatchState("") + if err != nil { + t.Fatal(err) + } + if len(state.Pending) != 2 || !state.Pending[1].Decision { + t.Fatalf("intermediate pending = %+v, want in-flight decision", state.Pending) + } + persistReviewDispatchState(plan, []review.DispatchKick{first}, restoreTestLogger()) + state, err = review.LoadDispatchState("") + if err != nil { + t.Fatal(err) + } + if len(state.Pending) != 1 || state.Pending[0].Agent != first.Agent { + t.Fatalf("final pending = %+v, want only delivered kick", state.Pending) + } +} + func TestPersistReviewDispatchState_WriteFailureIsNonFatal(t *testing.T) { dir := redirectReviewPaths(t) // Point the state file inside a plain file so MkdirAll/rename must fail. diff --git a/src/pkg/github/review_verdict_relay.go b/src/pkg/github/review_verdict_relay.go index f04c724e96..35f4150642 100644 --- a/src/pkg/github/review_verdict_relay.go +++ b/src/pkg/github/review_verdict_relay.go @@ -537,6 +537,25 @@ func (c *Client) verdictDispatchAuthorized(report review.PerspectiveReport, req } return verdictAuthorization{OK: true, Dispatched: true, HeadSHA: r.HeadSHA, BodyDigest: r.BodyDigest, HiveAuthored: strings.TrimSpace(r.AuthorAgent) != "", ReviewHead: strings.TrimSpace(r.Head), Decided: r.Decision} } + // Record the rows considered when a dispatched reviewer falls back to + // advisory, so a missing or mismatched decision dispatch is diagnosable. + var candidates []string + dispatchedAgent := false + for _, p := range state.Pending { + if strings.EqualFold(strings.TrimSpace(p.Repo), strings.TrimSpace(report.Repo)) && p.Number == report.Number { + candidates = append(candidates, fmt.Sprintf("pending agent=%s perspective=%s head=%s decision=%t", p.Agent, p.Perspective, p.HeadSHA, p.Decision)) + dispatchedAgent = dispatchedAgent || strings.TrimSpace(p.Agent) == strings.TrimSpace(req.Agent) + } + } + for _, r := range state.Recent { + if strings.EqualFold(strings.TrimSpace(r.Repo), strings.TrimSpace(report.Repo)) && r.Number == report.Number { + candidates = append(candidates, fmt.Sprintf("recent agent=%s perspective=%s head=%s decision=%t", r.Agent, r.Perspective, r.HeadSHA, r.Decision)) + dispatchedAgent = dispatchedAgent || strings.TrimSpace(r.Agent) == strings.TrimSpace(req.Agent) + } + } + if dispatchedAgent && c.logger != nil { + c.logger.Info("review verdict falling back to advisory", "repo", report.Repo, "number", report.Number, "agent", req.Agent, "perspective", report.Perspective, "head", report.HeadSHA, "candidates", candidates) + } // Queue-mode reviewer prompts can reach the relay through the ordinary // PR-list comment path rather than a review-swarm dispatch. That still is // an authorized hive-review request, and with an explicit head SHA it is