diff --git a/changelog.d/fixed-16537-fixer-queue.md b/changelog.d/fixed-16537-fixer-queue.md new file mode 100644 index 0000000000..8f7843a7ce --- /dev/null +++ b/changelog.d/fixed-16537-fixer-queue.md @@ -0,0 +1 @@ +- Deferred PR fix kicks now retain their queue position until delivery or closure; the governor API exposes the queue and the dashboard review queue shows “fixer queued, N ahead” ([#16537](https://github.com/hivecommons/hive/issues/16537)). diff --git a/src/cmd/hive/eval_cycle_seams.go b/src/cmd/hive/eval_cycle_seams.go index c7e465dea6..91925bc20e 100644 --- a/src/cmd/hive/eval_cycle_seams.go +++ b/src/cmd/hive/eval_cycle_seams.go @@ -482,6 +482,9 @@ type kickDispatchDeps struct { // continuous-mode scheduler uses this to exponential-backoff instead of // returning the same due agent on every eval while the CLI is stalled. onFailed func(msg scheduler.KickMessage, err error) + // onDeferred optionally records kicks that wait for a busy agent's lane. + // It runs in message order, like the delivered and failed effects. + onDeferred func(msg scheduler.KickMessage) // markProbeReleased stamps the provider-budget probe. Called at most once // per dispatch, and only after a kick actually goes out. markProbeReleased func(at time.Time) @@ -609,6 +612,9 @@ func dispatchAgentKicks(msgs []scheduler.KickMessage, releaseProbe bool, deps ki if out.deferred || errors.Is(out.sendErr, crux.ErrAgentBusy) { endSpan(nil) logger.Info("agent busy: deferring kick", "agent", msg.Agent) + if deps.onDeferred != nil { + deps.onDeferred(msg) + } continue } if out.startErr != nil { diff --git a/src/cmd/hive/fixer_queue.go b/src/cmd/hive/fixer_queue.go new file mode 100644 index 0000000000..17b652c196 --- /dev/null +++ b/src/cmd/hive/fixer_queue.go @@ -0,0 +1,64 @@ +package main + +import ( + "strings" + "time" + + "github.com/hivecommons/hive/pkg/github" + "github.com/hivecommons/hive/pkg/governor" + "github.com/hivecommons/hive/pkg/review" + "github.com/hivecommons/hive/pkg/scheduler" +) + +// reviewFixKickQueue maps delivery outcomes back to PRs. Review and routine +// governor kicks must not create or clear a PR's deferred-fixer hint. +type reviewFixKickQueue struct { + governor *governor.Governor + kicks map[string]review.DispatchKick +} + +func (q reviewFixKickQueue) Deferred(msg scheduler.KickMessage) { + if k, ok := q.kicks[reviewKickKey(msg)]; ok && k.Kind == "fix" { + q.governor.RecordFixKickDeferred(k.PRRef, time.Now()) + } +} + +func (q reviewFixKickQueue) Delivered(msg scheduler.KickMessage) { + if k, ok := q.kicks[reviewKickKey(msg)]; ok && k.Kind == "fix" { + q.governor.RecordFixKickDelivered(k.PRRef) + } +} + +func reconcileDeferredFixQueue(gov *governor.Governor, org string, actionable *github.ActionableResult) { + if actionable == nil { + return // no new enumeration is not evidence that a PR closed + } + open := map[string]bool{} + for _, prs := range [][]github.PullRequest{actionable.PRs.Items, actionable.PRs.Held, actionable.PRs.StaleDrafts, actionable.PRs.Attributed} { + for _, pr := range prs { + if strings.EqualFold(pr.State, "closed") || !pr.ClosedAt.IsZero() || !pr.MergedAt.IsZero() { + continue + } + repo := pr.Repo + if org != "" && !strings.Contains(repo, "/") { + repo = org + "/" + repo + } + open[github.ReviewQueueKey(repo, pr.Number)] = true + } + } + gov.ReconcileFixerQueue(open) +} + +// reconcilePlannedFixQueue drops deferred fixes the current plan no longer +// kicks (new head, review passed, lane reassigned away) for PRs that stay +// open; otherwise they would sit in the queue and inflate every "ahead". +func reconcilePlannedFixQueue(gov *governor.Governor, actionable *github.ActionableResult, fixKicks []review.DispatchKick) { + if actionable == nil { + return // no plan was built, so nothing says the fix is no longer needed + } + planned := map[string]bool{} + for _, k := range fixKicks { + planned[strings.ToLower(strings.TrimSpace(k.PRRef))] = true + } + gov.ReconcileFixerQueue(planned) +} diff --git a/src/cmd/hive/fixer_queue_test.go b/src/cmd/hive/fixer_queue_test.go new file mode 100644 index 0000000000..3829deb8d6 --- /dev/null +++ b/src/cmd/hive/fixer_queue_test.go @@ -0,0 +1,133 @@ +package main + +import ( + "errors" + "fmt" + "testing" + "time" + + "github.com/hivecommons/hive/crux" + "github.com/hivecommons/hive/pkg/github" + "github.com/hivecommons/hive/pkg/governor" + "github.com/hivecommons/hive/pkg/review" + "github.com/hivecommons/hive/pkg/scheduler" +) + +func TestDispatchDeferredFixQueueLifecycle(t *testing.T) { + for _, busy := range []bool{false, true} { + t.Run(fmt.Sprintf("busy=%v", busy), func(t *testing.T) { + gov := &governor.Governor{} + msgs := []scheduler.KickMessage{ + {Agent: "scanner", Message: "fix first"}, + {Agent: "scanner", Message: "fix second"}, + {Agent: "scanner", Message: "review third"}, + {Agent: "scanner", Message: "routine governor"}, + } + q := reviewFixKickQueue{governor: gov, kicks: map[string]review.DispatchKick{ + reviewKickKey(msgs[0]): {Kind: "fix", PRRef: "org/repo#1"}, + reviewKickKey(msgs[1]): {Kind: "fix", PRRef: "org/repo#2"}, + reviewKickKey(msgs[2]): {Kind: "review", PRRef: "org/repo#3"}, + }} + r := newKickDispatchRecorder() + if busy { + r.sendErr["scanner"] = fmt.Errorf("prompt wait: %w", crux.ErrAgentBusy) + } + deps := r.deps() + deps.onDeferred = q.Deferred + deps.onReviewDelivered = q.Delivered + dispatchAgentKicks(msgs, false, deps, discardLogger()) + queue := gov.FixerQueue() + if busy { + if len(queue) != 2 || queue["org/repo#1"].FixerQueuePosition != 1 || queue["org/repo#2"].FixerQueuePosition != 2 { + t.Fatalf("busy lane queue = %+v", queue) + } + // Reassign the first fix to a fallback and actually deliver it. + fallback := scheduler.KickMessage{Agent: "fallback", Message: "new fix prompt"} + q.kicks[reviewKickKey(fallback)] = review.DispatchKick{Kind: "fix", PRRef: "org/repo#1"} + dispatchAgentKicks([]scheduler.KickMessage{fallback}, false, deps, discardLogger()) + } else if len(queue) != 1 { + t.Fatalf("kick behind delivered first fix must be queued: %+v", queue) + } + // Delivery from another source must not clear a queued fix. + q.kicks[reviewKickKey(msgs[2])] = review.DispatchKick{Kind: "review", PRRef: "org/repo#2"} + q.Delivered(msgs[2]) + q.Delivered(msgs[3]) + queue = gov.FixerQueue() + second := queue["org/repo#2"] + if len(queue) != 1 || second.FixerQueuePosition != 1 || second.FixerQueueAhead == nil || *second.FixerQueueAhead != 0 { + t.Fatalf("after first delivery: %+v", queue) + } + delete(r.sendErr, "scanner") + dispatchAgentKicks(msgs[1:2], false, deps, discardLogger()) + if len(gov.FixerQueue()) != 0 { + t.Fatal("delivered second fix still queued") + } + }) + } +} + +func TestFixQueueDoesNotRecordWithheldOrFailedKicks(t *testing.T) { + for _, withheld := range []bool{false, true} { + gov := &governor.Governor{} + msg := scheduler.KickMessage{Agent: "scanner", Message: "fix"} + q := reviewFixKickQueue{governor: gov, kicks: map[string]review.DispatchKick{ + reviewKickKey(msg): {Kind: "fix", PRRef: "org/repo#1"}, + }} + r := newKickDispatchRecorder() + r.backoff["scanner"] = withheld + r.sendErr["scanner"] = errors.New("send failed") + deps := r.deps() + deps.onDeferred = q.Deferred + deps.onReviewDelivered = q.Delivered + dispatchAgentKicks([]scheduler.KickMessage{msg}, false, deps, discardLogger()) + if len(gov.FixerQueue()) != 0 { + t.Fatal("non-busy failure or provider backoff recorded as a deferred fix") + } + } +} + +func TestReconcileDeferredFixQueueOpenHeldAndClosedPRs(t *testing.T) { + gov := &governor.Governor{} + for i := 1; i <= 6; i++ { + gov.RecordFixKickDeferred(fmt.Sprintf("org/repo#%d", i), time.Now()) + } + reconcileDeferredFixQueue(gov, "org", nil) + if len(gov.FixerQueue()) != 6 { + t.Fatal("missing enumeration cleared queue") + } + reconcileDeferredFixQueue(gov, "org", &github.ActionableResult{PRs: github.PRResult{ + Items: []github.PullRequest{{Repo: "repo", Number: 1}}, + Held: []github.PullRequest{{Repo: "org/repo", Number: 2}}, + StaleDrafts: []github.PullRequest{{Repo: "repo", Number: 3}}, + Attributed: []github.PullRequest{ + {Repo: "org/repo", Number: 4, State: "open"}, + {Repo: "org/repo", Number: 5, State: "closed"}, + {Repo: "org/repo", Number: 6, MergedAt: time.Now()}, + }, + }}) + queue := gov.FixerQueue() + if len(queue) != 4 || queue["org/repo#4"].FixerQueuePosition != 4 { + t.Fatalf("reconciled queue = %+v", queue) + } + reconcileDeferredFixQueue(gov, "org", &github.ActionableResult{}) + if len(gov.FixerQueue()) != 0 { + t.Fatal("closed or removed PRs still queued") + } +} + +func TestReconcilePlannedFixQueueDropsPRsNoLongerPlanningAFix(t *testing.T) { + gov := &governor.Governor{} + gov.RecordFixKickDeferred("org/repo#1", time.Now()) + gov.RecordFixKickDeferred("org/repo#2", time.Now().Add(time.Minute)) + reconcilePlannedFixQueue(gov, nil, nil) + if len(gov.FixerQueue()) != 2 { + t.Fatal("missing enumeration cleared queue") + } + // #1 stays open but its fix is no longer planned; #2 still needs one. + reconcilePlannedFixQueue(gov, &github.ActionableResult{}, []review.DispatchKick{{Kind: "fix", PRRef: "Org/Repo#2"}}) + queue := gov.FixerQueue() + second := queue["org/repo#2"] + if len(queue) != 1 || second.FixerQueuePosition != 1 || second.FixerQueueAhead == nil || *second.FixerQueueAhead != 0 { + t.Fatalf("planned queue = %+v", queue) + } +} diff --git a/src/cmd/hive/main_eval_cycle.go b/src/cmd/hive/main_eval_cycle.go index 3ed4ccf2d5..36dbe0e003 100644 --- a/src/cmd/hive/main_eval_cycle.go +++ b/src/cmd/hive/main_eval_cycle.go @@ -574,6 +574,7 @@ func runEvalCycle( actionable.Issues = workSourceIssuesForConfiguredCycle(ctx, cfg, ghClient, actionable.Issues, logger) } } + reconcileDeferredFixQueue(gov, cfg.Project.Org, actionable) if swarmRepo := dashSrv.ActiveSwarmRepo(); swarmRepo != "" { github.BoostActionableRepoPriority(actionable.Issues.Items, swarmRepo) logger.Info("swarm priority boost applied", "repo", swarmRepo) @@ -1003,6 +1004,7 @@ func runEvalCycle( "agents_skipped", agentsSkipped, ) + reconcilePlannedFixQueue(gov, actionable, reviewPlan.FixKicks) reviewKickByMessage := map[string]review.DispatchKick{} for _, k := range append(reviewPlan.ReviewKicks, reviewPlan.FixKicks...) { if !gov.AgentEligibleForCELKick(k.Agent) || agentMgr.IsPaused(k.Agent) { @@ -1140,6 +1142,7 @@ func runEvalCycle( // previously unreachable without a tmux session and a live governor. var deliveredReviewKicks []review.DispatchKick var deliveredKicks []scheduler.KickMessage + fixQueue := reviewFixKickQueue{governor: gov, kicks: reviewKickByMessage} if len(messages) > 0 { // governor.kick wraps the whole dispatch pass; each delivered kick // still gets its own agent.kick child via startKickSpan below. @@ -1182,11 +1185,13 @@ func runEvalCycle( } }, onReviewDelivered: func(msg scheduler.KickMessage) { + fixQueue.Delivered(msg) if k, ok := reviewKickByMessage[msg.Agent+"\x00"+msg.Message]; ok { deliveredReviewKicks = append(deliveredReviewKicks, k) persistReviewDispatchStateInProgress(reviewPlan, deliveredReviewKicks, logger) } }, + onDeferred: fixQueue.Deferred, onFailed: func(msg scheduler.KickMessage, err error) { gov.RecordKickFailure(msg.Agent, err, time.Now()) if k, ok := reviewKickByMessage[reviewKickKey(msg)]; ok { diff --git a/src/pkg/dashboard/api_governor_pr_models.go b/src/pkg/dashboard/api_governor_pr_models.go index 9b18959c08..4bbb0c9955 100644 --- a/src/pkg/dashboard/api_governor_pr_models.go +++ b/src/pkg/dashboard/api_governor_pr_models.go @@ -8,6 +8,7 @@ import ( "time" ghpkg "github.com/hivecommons/hive/pkg/github" + "github.com/hivecommons/hive/pkg/governor" "github.com/hivecommons/hive/pkg/modelfamily" ) @@ -21,12 +22,13 @@ const ( ) type governorPRModelsResponse struct { - Window string `json:"window"` - MinMergedPRs int `json:"min_merged_prs"` - Total int `json:"total"` - Buckets []governorPRModelBucket `json:"buckets"` - Unknown int `json:"unknown"` - MostReworked []governorPRMostReworkedItem `json:"most_reworked,omitempty"` + Window string `json:"window"` + MinMergedPRs int `json:"min_merged_prs"` + Total int `json:"total"` + Buckets []governorPRModelBucket `json:"buckets"` + Unknown int `json:"unknown"` + MostReworked []governorPRMostReworkedItem `json:"most_reworked,omitempty"` + FixerQueue map[string]governor.FixerQueueStatus `json:"fixer_queue,omitempty"` } // governorPRModelBucket is one canonical model (modelfamily.Canonical folds @@ -111,6 +113,7 @@ func (s *Server) handleGovernorPRModels(w http.ResponseWriter, r *http.Request) minMergedPRs := effectiveModelsMinMergedPRs() actionable := s.lastActionableForPRModels() resp := aggregateGovernorPRModels(actionable.PRs.Attributed, window, time.Now()) + resp.FixerQueue = s.governorFixerQueue() runs, _, _ := readEffectiveModelRuns(s.effectiveModelTaskRunLogPath(), governorPRModelsWindowDuration(window)) effective := aggregateEffectiveModelsFromPRAggregation(resp, aggregateEffectiveRunStats(runs, effectiveModelsFilterAll), effectiveModelsFilterAll, minMergedPRs) applyGovernorPRModelEffectiveness(&resp, effective, minMergedPRs) diff --git a/src/pkg/dashboard/api_review_queue.go b/src/pkg/dashboard/api_review_queue.go index 909ce51804..1e5c5d56f6 100644 --- a/src/pkg/dashboard/api_review_queue.go +++ b/src/pkg/dashboard/api_review_queue.go @@ -10,6 +10,7 @@ import ( "time" ghpkg "github.com/hivecommons/hive/pkg/github" + "github.com/hivecommons/hive/pkg/governor" "github.com/hivecommons/hive/pkg/review" "github.com/hivecommons/hive/pkg/stagelabels" ) @@ -51,7 +52,19 @@ type reviewQueueResponse struct { // needs attention (hivecommons/hive#12534). HiveHeld int `json:"hive_held"` History []ReviewQueueHistoryEntry `json:"history"` - Items []ghpkg.ReviewQueueEntry `json:"items"` + Items []reviewQueueItem `json:"items"` +} + +type reviewQueueItem struct { + ghpkg.ReviewQueueEntry + governor.FixerQueueStatus +} + +func (s *Server) governorFixerQueue() map[string]governor.FixerQueueStatus { + if s == nil || s.deps == nil { + return nil + } + return s.deps.Governor.FixerQueue() } // handleReviewQueue serves GET /api/review/queue?limit=N&offset=M: every open @@ -110,7 +123,7 @@ func (s *Server) handleReviewQueue(w http.ResponseWriter, r *http.Request) { Limit: limit, Offset: offset, History: history, - Items: []ghpkg.ReviewQueueEntry{}, + Items: []reviewQueueItem{}, } for _, e := range queue { if e.Stage != nil && e.Stage.WaitingOnHive && e.Stage.PastDwell { @@ -122,7 +135,13 @@ func (s *Server) handleReviewQueue(w http.ResponseWriter, r *http.Request) { if end > len(queue) { end = len(queue) } - resp.Items = queue[offset:end] + fixers := s.governorFixerQueue() + for _, entry := range queue[offset:end] { + resp.Items = append(resp.Items, reviewQueueItem{ + ReviewQueueEntry: entry, + FixerQueueStatus: fixers[ghpkg.ReviewQueueKey(entry.Repo, entry.Number)], + }) + } } resp.HasMore = offset+len(resp.Items) < len(queue) jsonResponse(w, resp) diff --git a/src/pkg/dashboard/fixer_queue_test.go b/src/pkg/dashboard/fixer_queue_test.go new file mode 100644 index 0000000000..76aaba7f75 --- /dev/null +++ b/src/pkg/dashboard/fixer_queue_test.go @@ -0,0 +1,92 @@ +package dashboard + +import ( + "encoding/json" + "net/http" + "net/http/httptest" + "path/filepath" + "strings" + "testing" + "time" + + "github.com/hivecommons/hive/pkg/governor" +) + +func TestGovernorPRModelsIncludesLiveFixerQueue(t *testing.T) { + s := covApiServer(t) + s.deps.Governor = &governor.Governor{} + at := time.Now() + s.deps.Governor.RecordFixKickDeferred("myorg/repo1#1", at) + s.deps.Governor.RecordFixKickDeferred("myorg/repo1#2", at.Add(time.Second)) + + get := func() governorPRModelsResponse { + t.Helper() + rec := httptest.NewRecorder() + s.handleGovernorPRModels(rec, httptest.NewRequest(http.MethodGet, "/api/governor/pr-models", nil)) + if rec.Code != http.StatusOK { + t.Fatalf("status = %d: %s", rec.Code, rec.Body.String()) + } + var resp governorPRModelsResponse + if err := json.Unmarshal(rec.Body.Bytes(), &resp); err != nil { + t.Fatal(err) + } + if len(resp.FixerQueue) == 0 && strings.Contains(rec.Body.String(), `"fixer_queue"`) { + t.Fatal("empty queue must be omitted") + } + return resp + } + // Queue visibility is independent of attribution and the model window. + resp := get() + if resp.Total != 0 || len(resp.FixerQueue) != 2 || resp.FixerQueue["myorg/repo1#2"].FixerQueuePosition != 2 { + t.Fatalf("response = %+v", resp) + } + s.deps.Governor.RecordFixKickDelivered("myorg/repo1#1") + second := get().FixerQueue["myorg/repo1#2"] + if second.FixerQueuePosition != 1 || second.FixerQueueAhead == nil || *second.FixerQueueAhead != 0 { + t.Fatalf("after delivery = %+v", second) + } + s.deps.Governor.RecordFixKickDelivered("myorg/repo1#2") + get() + s.deps.Governor = nil + get() +} + +func TestReviewQueueFixerFieldsAreOptionalAndKeepGlobalPosition(t *testing.T) { + s := reviewQueueTestServer(t, filepath.Join(t.TempDir(), "missing.json")) + s.deps.Governor = &governor.Governor{} + at := time.Now() + s.deps.Governor.RecordFixKickDeferred("myorg/other#99", at) + s.deps.Governor.RecordFixKickDeferred("myorg/repo1#2", at.Add(time.Second)) + + get := func() []map[string]json.RawMessage { + t.Helper() + rec := doOwnerGet(s, "/api/review/queue?limit=1") + if rec.Code != http.StatusOK { + t.Fatalf("status = %d: %s", rec.Code, rec.Body.String()) + } + var resp struct { + Items []map[string]json.RawMessage `json:"items"` + } + if err := json.Unmarshal(rec.Body.Bytes(), &resp); err != nil { + t.Fatal(err) + } + return resp.Items + } + items := get() + if len(items) != 1 || string(items[0]["number"]) != "2" || string(items[0]["fixer_queue_position"]) != "2" || string(items[0]["fixer_queue_ahead"]) != "1" { + t.Fatalf("paged items = %+v", items) + } + s.deps.Governor.RecordFixKickDelivered("myorg/other#99") + items = get() + if string(items[0]["fixer_queue_position"]) != "1" || string(items[0]["fixer_queue_ahead"]) != "0" { + t.Fatalf("first queued item must explicitly emit zero ahead: %+v", items) + } + s.deps.Governor.RecordFixKickDelivered("myorg/repo1#2") + items = get() + if _, ok := items[0]["fixer_queue_position"]; ok { + t.Fatal("delivered item still emits fixer_queue_position") + } + if _, ok := items[0]["fixer_queue_ahead"]; ok { + t.Fatal("delivered item still emits fixer_queue_ahead") + } +} diff --git a/src/pkg/dashboard/review_queue_view_9607_test.go b/src/pkg/dashboard/review_queue_view_9607_test.go index 3303ddea36..41a6010cc7 100644 --- a/src/pkg/dashboard/review_queue_view_9607_test.go +++ b/src/pkg/dashboard/review_queue_view_9607_test.go @@ -121,7 +121,7 @@ func TestReviewQueueEntryRendering(t *testing.T) { // The evidence button is role-gated on window state that does not exist // under node; its wiring is pinned in TestReviewQueueViewStaticWiring. source.WriteString("function reviewEvidenceButtonHtml() { return ''; }\n") - for _, name := range []string{"esc", "reviewQueuePriorityMeta", "reviewQueueAgeLabel", "reviewQueueSupersededHtml", "renderReviewQueueEntry"} { + for _, name := range []string{"esc", "reviewQueuePriorityMeta", "reviewQueueAgeLabel", "reviewQueueSupersededHtml", "fixerQueueHint", "renderReviewQueueEntry"} { source.WriteString(jsFunc(t, html, name)) source.WriteByte('\n') } @@ -167,6 +167,14 @@ assert.match(entry({ priority: 'weird' }), /review-priority\/normal/); assert.match(entry({ hive_authored: true }), /agent/); assert.match(entry({ held: true }), /held/); +// Fixer status is independent of review rank and disappears after delivery. +assert.doesNotMatch(entry(), /fixer queued/); +assert.match(entry({ fixer_queue_position: 3, fixer_queue_ahead: 2 }), /fixer queued, 2 ahead/); +assert.match(entry({ fixer_queue_position: 1, fixer_queue_ahead: 0 }), /fixer queued, 0 ahead/); +assert.doesNotMatch(entry({ fixer_queue_position: 0, fixer_queue_ahead: 0 }), /fixer queued/); +assert.doesNotMatch(entry({ fixer_queue_ahead: 4 }), /fixer queued/); +assert.doesNotMatch(entry({ fixer_queue_position: '' }), /fixer queued/); + // No reasons still renders without throwing. assert.match(entry({ reasons: [] }), /no ranking reasons recorded/); diff --git a/src/pkg/dashboard/static-src/js/review-queue.js b/src/pkg/dashboard/static-src/js/review-queue.js index 26ba9fb8f4..ec76c803b5 100644 --- a/src/pkg/dashboard/static-src/js/review-queue.js +++ b/src/pkg/dashboard/static-src/js/review-queue.js @@ -32,6 +32,14 @@ return Math.floor(h / 24) + 'd'; } + function fixerQueueHint(e) { + var position = Number(e && e.fixer_queue_position); + if (!Number.isInteger(position) || position < 1) return ''; + var ahead = Number(e.fixer_queue_ahead); + if (!Number.isInteger(ahead) || ahead < 0) ahead = position - 1; + return 'fixer queued, ' + ahead + ' ahead'; + } + function renderReviewQueueEntry(e) { var meta = reviewQueuePriorityMeta(e.priority); var title = String(e.title || ''); @@ -47,6 +55,8 @@ if (e.confidence_band) metaBits.push(esc(String(e.confidence_band))); metaBits.push(reviewQueueAgeLabel(e.age_hours) + ' old'); if (e.held) metaBits.push('held'); + var fixerHint = fixerQueueHint(e); + if (fixerHint) metaBits.push('' + esc(fixerHint) + ''); // Hive-owned stage/author labels (#12429) tell at a glance where the // PR sits in the pipeline; other labels stay out of the meta line. // stage/stalled means "no activity by anyone but the hive for the diff --git a/src/pkg/dashboard/static/index.html b/src/pkg/dashboard/static/index.html index 58d56b99ef..d72774783b 100644 --- a/src/pkg/dashboard/static/index.html +++ b/src/pkg/dashboard/static/index.html @@ -43340,6 +43340,14 @@ return Math.floor(h / 24) + 'd'; } + function fixerQueueHint(e) { + var position = Number(e && e.fixer_queue_position); + if (!Number.isInteger(position) || position < 1) return ''; + var ahead = Number(e.fixer_queue_ahead); + if (!Number.isInteger(ahead) || ahead < 0) ahead = position - 1; + return 'fixer queued, ' + ahead + ' ahead'; + } + function renderReviewQueueEntry(e) { var meta = reviewQueuePriorityMeta(e.priority); var title = String(e.title || ''); @@ -43355,6 +43363,8 @@ if (e.confidence_band) metaBits.push(esc(String(e.confidence_band))); metaBits.push(reviewQueueAgeLabel(e.age_hours) + ' old'); if (e.held) metaBits.push('held'); + var fixerHint = fixerQueueHint(e); + if (fixerHint) metaBits.push('' + esc(fixerHint) + ''); // Hive-owned stage/author labels (#12429) tell at a glance where the // PR sits in the pipeline; other labels stay out of the meta line. // stage/stalled means "no activity by anyone but the hive for the diff --git a/src/pkg/governor/fixer_queue.go b/src/pkg/governor/fixer_queue.go new file mode 100644 index 0000000000..5c2688a2d0 --- /dev/null +++ b/src/pkg/governor/fixer_queue.go @@ -0,0 +1,95 @@ +package governor + +import ( + "sort" + "strings" + "time" +) + +// FixerQueueStatus describes a PR awaiting delivery of its fix kick. Ahead is +// a pointer so the first queued PR emits zero while an unqueued PR omits it. +type FixerQueueStatus struct { + FixerQueuePosition int `json:"fixer_queue_position,omitempty"` + FixerQueueAhead *int `json:"fixer_queue_ahead,omitempty"` +} + +type deferredFixKick struct { + ref string + firstDeferredAt time.Time +} + +// RecordFixKickDeferred preserves the first deferral across retries, new heads +// and fixer reassignment. This is visibility bookkeeping, not a dispatch gate. +func (g *Governor) RecordFixKickDeferred(ref string, at time.Time) { + ref = strings.ToLower(strings.TrimSpace(ref)) + if g == nil || ref == "" { + return + } + g.mu.Lock() + defer g.mu.Unlock() + for _, kick := range g.deferredFixKicks { + if kick.ref == ref { + return + } + } + g.deferredFixKicks = append(g.deferredFixKicks, deferredFixKick{ref: ref, firstDeferredAt: at}) + // Stable sorting keeps dispatch order when several deferrals share a clock + // tick. Later retries never reset the timestamp or move an entry back. + sort.SliceStable(g.deferredFixKicks, func(i, j int) bool { + return g.deferredFixKicks[i].firstDeferredAt.Before(g.deferredFixKicks[j].firstDeferredAt) + }) +} + +// RecordFixKickDelivered removes a PR only after its fix kick actually lands. +func (g *Governor) RecordFixKickDelivered(ref string) { + ref = strings.ToLower(strings.TrimSpace(ref)) + if g == nil { + return + } + g.mu.Lock() + defer g.mu.Unlock() + for i, kick := range g.deferredFixKicks { + if kick.ref == ref { + g.deferredFixKicks = append(g.deferredFixKicks[:i], g.deferredFixKicks[i+1:]...) + return + } + } +} + +// ReconcileFixerQueue drops PRs absent from keep: the enumeration's open-PR +// set (PRs closed or merged while their fixer was busy) or the current plan's +// fix-kick refs (PRs that no longer need a fix). +func (g *Governor) ReconcileFixerQueue(keep map[string]bool) { + if g == nil { + return + } + g.mu.Lock() + defer g.mu.Unlock() + kept := g.deferredFixKicks[:0] + for _, kick := range g.deferredFixKicks { + if keep[kick.ref] { + kept = append(kept, kick) + } + } + g.deferredFixKicks = kept +} + +// FixerQueue returns an independent snapshot keyed by owner/repo#number. +// Entries are one-based and reflect first-deferral age across all fixer lanes. +// The queue is in memory: after restart, dispatch rebuilds it from busy kicks. +func (g *Governor) FixerQueue() map[string]FixerQueueStatus { + if g == nil { + return nil + } + g.mu.RLock() + defer g.mu.RUnlock() + if len(g.deferredFixKicks) == 0 { + return nil + } + out := make(map[string]FixerQueueStatus, len(g.deferredFixKicks)) + for i, kick := range g.deferredFixKicks { + ahead := i + out[kick.ref] = FixerQueueStatus{FixerQueuePosition: i + 1, FixerQueueAhead: &ahead} + } + return out +} diff --git a/src/pkg/governor/fixer_queue_test.go b/src/pkg/governor/fixer_queue_test.go new file mode 100644 index 0000000000..d865ce8fa8 --- /dev/null +++ b/src/pkg/governor/fixer_queue_test.go @@ -0,0 +1,72 @@ +package governor + +import ( + "encoding/json" + "testing" + "time" +) + +func TestFixerQueueFirstDeferralDeliveryAndClosure(t *testing.T) { + g := &Governor{} + at := time.Date(2026, 11, 4, 0, 0, 0, 0, time.UTC) + g.RecordFixKickDeferred("org/repo#2", at.Add(time.Minute)) + g.RecordFixKickDeferred("ORG/REPO#1", at) + g.RecordFixKickDeferred("org/other#1", at.Add(time.Minute)) + // A retry must preserve its original position, including equal-time ties. + g.RecordFixKickDeferred("org/repo#1", at.Add(time.Hour)) + assertFixerQueue(t, g.FixerQueue(), "org/repo#1", "org/repo#2", "org/other#1") + + // Returned maps and ahead pointers cannot mutate governor state. + snapshot := g.FixerQueue() + *snapshot["org/repo#2"].FixerQueueAhead = 99 + delete(snapshot, "org/repo#1") + assertFixerQueue(t, g.FixerQueue(), "org/repo#1", "org/repo#2", "org/other#1") + + g.RecordFixKickDelivered("ORG/REPO#1") + assertFixerQueue(t, g.FixerQueue(), "org/repo#2", "org/other#1") + g.ReconcileFixerQueue(map[string]bool{"org/other#1": true}) + assertFixerQueue(t, g.FixerQueue(), "org/other#1") + g.RecordFixKickDelivered("org/other#1") + if got := g.FixerQueue(); len(got) != 0 { + t.Fatalf("delivered PRs still queued: %+v", got) + } + // A newly deferred kick after delivery starts a fresh wait. + g.RecordFixKickDeferred("org/repo#2", at.Add(2*time.Hour)) + g.RecordFixKickDeferred("org/other#1", at.Add(3*time.Hour)) + assertFixerQueue(t, g.FixerQueue(), "org/repo#2", "org/other#1") + g.ReconcileFixerQueue(nil) + assertFixerQueue(t, g.FixerQueue()) +} + +func assertFixerQueue(t *testing.T, got map[string]FixerQueueStatus, refs ...string) { + t.Helper() + if len(got) != len(refs) { + t.Fatalf("queue = %+v, want %v", got, refs) + } + for i, ref := range refs { + entry := got[ref] + if entry.FixerQueuePosition != i+1 || entry.FixerQueueAhead == nil || *entry.FixerQueueAhead != i { + t.Fatalf("%s = %+v, want position %d / ahead %d", ref, entry, i+1, i) + } + } +} + +func TestFixerQueueJSONOptionalFields(t *testing.T) { + for _, tc := range []struct { + status FixerQueueStatus + want string + }{ + {FixerQueueStatus{}, `{}`}, + {FixerQueueStatus{FixerQueuePosition: 1, FixerQueueAhead: new(int)}, `{"fixer_queue_position":1,"fixer_queue_ahead":0}`}, + } { + got, err := json.Marshal(tc.status) + if err != nil || string(got) != tc.want { + t.Fatalf("json = %s (%v), want %s", got, err, tc.want) + } + } + var g *Governor + g.RecordFixKickDeferred("org/repo#1", time.Now()) + g.RecordFixKickDelivered("org/repo#1") + g.ReconcileFixerQueue(nil) + assertFixerQueue(t, g.FixerQueue()) +} diff --git a/src/pkg/governor/governor.go b/src/pkg/governor/governor.go index 322a919e30..fb24f398da 100644 --- a/src/pkg/governor/governor.go +++ b/src/pkg/governor/governor.go @@ -254,6 +254,7 @@ type Governor struct { modeHistory []ModeChange evalHistory []EvalSnapshot kickHistory []KickRecord + deferredFixKicks []deferredFixKick agentReports map[string]AgentReportRecord kickOutcomes map[string]KickOutcomeRecord budget BudgetInfo