From 4568358f80798dfb3f62ebb57abd64a3ae034681 Mon Sep 17 00:00:00 2001 From: thatguywob Date: Wed, 4 Nov 2026 04:23:05 +0000 Subject: [PATCH 1/3] =?UTF-8?q?=F0=9F=90=9B=20fix:=20expose=20deferred=20P?= =?UTF-8?q?R=20fixer=20queue=20positions?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Remember the first deferral of each review fix kick in the governor and remove it on delivery or when enumeration no longer sees the PR open. Expose optional queue status through the governor and review queue APIs, and show the number ahead beside the PR's dashboard stage metadata. Hive-Run: hivecommons/hive#16537 Hive-Plan: issue-16526/deferred-fixer-queue Hive-Spec: issue-16537#acceptance-criteria Signed-off-by: thatguywob --- changelog.d/fixed-16537-fixer-queue.md | 1 + src/cmd/hive/eval_cycle_seams.go | 6 + src/cmd/hive/fixer_queue.go | 50 ++++++++ src/cmd/hive/fixer_queue_test.go | 116 ++++++++++++++++++ src/cmd/hive/main_eval_cycle.go | 4 + src/pkg/dashboard/api_governor_pr_models.go | 15 ++- src/pkg/dashboard/api_review_queue.go | 25 +++- src/pkg/dashboard/fixer_queue_test.go | 92 ++++++++++++++ .../dashboard/review_queue_view_9607_test.go | 10 +- src/pkg/dashboard/static/index.html | 10 ++ src/pkg/governor/fixer_queue.go | 94 ++++++++++++++ src/pkg/governor/fixer_queue_test.go | 72 +++++++++++ src/pkg/governor/governor.go | 1 + 13 files changed, 486 insertions(+), 10 deletions(-) create mode 100644 changelog.d/fixed-16537-fixer-queue.md create mode 100644 src/cmd/hive/fixer_queue.go create mode 100644 src/cmd/hive/fixer_queue_test.go create mode 100644 src/pkg/dashboard/fixer_queue_test.go create mode 100644 src/pkg/governor/fixer_queue.go create mode 100644 src/pkg/governor/fixer_queue_test.go 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..5d1b568eaf --- /dev/null +++ b/src/cmd/hive/fixer_queue.go @@ -0,0 +1,50 @@ +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) +} diff --git a/src/cmd/hive/fixer_queue_test.go b/src/cmd/hive/fixer_queue_test.go new file mode 100644 index 0000000000..0e60be86d2 --- /dev/null +++ b/src/cmd/hive/fixer_queue_test.go @@ -0,0 +1,116 @@ +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") + } +} diff --git a/src/cmd/hive/main_eval_cycle.go b/src/cmd/hive/main_eval_cycle.go index 3ed4ccf2d5..fd04c772d9 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) @@ -1140,6 +1141,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 +1184,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/index.html b/src/pkg/dashboard/static/index.html index 6a2c4eb941..990b805bdc 100644 --- a/src/pkg/dashboard/static/index.html +++ b/src/pkg/dashboard/static/index.html @@ -43441,6 +43441,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 || ''); @@ -43456,6 +43464,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..fe17bfa36c --- /dev/null +++ b/src/pkg/governor/fixer_queue.go @@ -0,0 +1,94 @@ +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 no longer in the enumeration's open-PR set, +// including PRs closed or merged while their fixer was busy. +func (g *Governor) ReconcileFixerQueue(open map[string]bool) { + if g == nil { + return + } + g.mu.Lock() + defer g.mu.Unlock() + kept := g.deferredFixKicks[:0] + for _, kick := range g.deferredFixKicks { + if open[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 From db77c85e3ca8d394b485718a5d2f063be4428b40 Mon Sep 17 00:00:00 2001 From: scanner <280983584+hivecommons-hive[bot]@users.noreply.github.com> Date: Wed, 4 Nov 2026 00:02:14 -0500 Subject: [PATCH 2/3] fix(fixer-queue): source the queue hint from review-queue.js; drop entries whose PR no longer plans a fix kick Signed-off-by: scanner <280983584+hivecommons-hive[bot]@users.noreply.github.com> --- src/cmd/hive/fixer_queue.go | 14 ++++++++++++++ src/cmd/hive/fixer_queue_test.go | 17 +++++++++++++++++ src/cmd/hive/main_eval_cycle.go | 1 + src/pkg/dashboard/static-src/js/review-queue.js | 10 ++++++++++ src/pkg/governor/fixer_queue.go | 9 +++++---- 5 files changed, 47 insertions(+), 4 deletions(-) diff --git a/src/cmd/hive/fixer_queue.go b/src/cmd/hive/fixer_queue.go index 5d1b568eaf..17b652c196 100644 --- a/src/cmd/hive/fixer_queue.go +++ b/src/cmd/hive/fixer_queue.go @@ -48,3 +48,17 @@ func reconcileDeferredFixQueue(gov *governor.Governor, org string, actionable *g } 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 index 0e60be86d2..3829deb8d6 100644 --- a/src/cmd/hive/fixer_queue_test.go +++ b/src/cmd/hive/fixer_queue_test.go @@ -114,3 +114,20 @@ func TestReconcileDeferredFixQueueOpenHeldAndClosedPRs(t *testing.T) { 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 fd04c772d9..36dbe0e003 100644 --- a/src/cmd/hive/main_eval_cycle.go +++ b/src/cmd/hive/main_eval_cycle.go @@ -1004,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) { 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/governor/fixer_queue.go b/src/pkg/governor/fixer_queue.go index fe17bfa36c..5c2688a2d0 100644 --- a/src/pkg/governor/fixer_queue.go +++ b/src/pkg/governor/fixer_queue.go @@ -56,9 +56,10 @@ func (g *Governor) RecordFixKickDelivered(ref string) { } } -// ReconcileFixerQueue drops PRs no longer in the enumeration's open-PR set, -// including PRs closed or merged while their fixer was busy. -func (g *Governor) ReconcileFixerQueue(open map[string]bool) { +// 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 } @@ -66,7 +67,7 @@ func (g *Governor) ReconcileFixerQueue(open map[string]bool) { defer g.mu.Unlock() kept := g.deferredFixKicks[:0] for _, kick := range g.deferredFixKicks { - if open[kick.ref] { + if keep[kick.ref] { kept = append(kept, kick) } } From c6fa651dc395f8a43cf28ecad019a64ca89ac8cc Mon Sep 17 00:00:00 2001 From: scanner <280983584+hivecommons-hive[bot]@users.noreply.github.com> Date: Wed, 4 Nov 2026 01:52:36 -0500 Subject: [PATCH 3/3] =?UTF-8?q?=F0=9F=90=9B=20fix:=20key=20the=20deferred?= =?UTF-8?q?=20fixer=20queue=20by=20org-qualified=20PR=20across=20record,?= =?UTF-8?q?=20reconcile=20and=20lookup?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Dispatch plans carry pr.Repo as configured (often the bare repo name), so RecordFixKickDeferred stored "repo#N" while reconcileDeferredFixQueue kept only ReviewQueueKey("org/repo", N). Each cycle evicted the entry, losing the first-deferral timestamp, and /api/review/queue's full-key lookup never matched, so fixer_queue_position was never emitted. Route Deferred, Delivered and reconcilePlannedFixQueue through one fixerQueueKey helper that qualifies bare repos with the project org, and pass cfg.Project.Org from the eval cycle. Adds a regression test that drives a bare-repo kick through several busy reconcile cycles and checks it stays queued under the dashboard's key until delivery. Refs #16537 Hive-Fix-Attempt: 1/6 Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com> Signed-off-by: scanner <280983584+hivecommons-hive[bot]@users.noreply.github.com> --- src/cmd/hive/fixer_queue.go | 34 ++++++++++++++++--- src/cmd/hive/fixer_queue_test.go | 56 ++++++++++++++++++++++++++++++-- src/cmd/hive/main_eval_cycle.go | 4 +-- 3 files changed, 86 insertions(+), 8 deletions(-) diff --git a/src/cmd/hive/fixer_queue.go b/src/cmd/hive/fixer_queue.go index 17b652c196..8eb210ef9a 100644 --- a/src/cmd/hive/fixer_queue.go +++ b/src/cmd/hive/fixer_queue.go @@ -1,6 +1,7 @@ package main import ( + "strconv" "strings" "time" @@ -14,21 +15,46 @@ import ( // governor kicks must not create or clear a PR's deferred-fixer hint. type reviewFixKickQueue struct { governor *governor.Governor + org string 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()) + q.governor.RecordFixKickDeferred(fixerQueueKey(q.org, k), 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) + q.governor.RecordFixKickDelivered(fixerQueueKey(q.org, k)) } } +// fixerQueueKey is the governor's identity for a fix kick's PR. Dispatch plans +// carry pr.Repo as configured (often the bare "repo"), while the enumeration +// reconcile and /api/review/queue key by github.ReviewQueueKey("org/repo", N). +// Every writer and reader must agree on the qualified form, or a bare-repo +// entry is evicted on the next reconcile and the dashboard never finds it. +func fixerQueueKey(org string, k review.DispatchKick) string { + repo, number := k.Repo, k.Number + if repo == "" || number == 0 { + // Older callers (and tests) only populate PRRef. + ref := strings.TrimSpace(k.PRRef) + if i := strings.LastIndex(ref, "#"); i > 0 { + repo = ref[:i] + if n, err := strconv.Atoi(ref[i+1:]); err == nil { + number = n + } + } + } + repo = strings.TrimSpace(repo) + if org != "" && repo != "" && !strings.Contains(repo, "/") { + repo = org + "/" + repo + } + return github.ReviewQueueKey(repo, number) +} + func reconcileDeferredFixQueue(gov *governor.Governor, org string, actionable *github.ActionableResult) { if actionable == nil { return // no new enumeration is not evidence that a PR closed @@ -52,13 +78,13 @@ func reconcileDeferredFixQueue(gov *governor.Governor, org string, actionable *g // 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) { +func reconcilePlannedFixQueue(gov *governor.Governor, org string, 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 + planned[fixerQueueKey(org, k)] = true } gov.ReconcileFixerQueue(planned) } diff --git a/src/cmd/hive/fixer_queue_test.go b/src/cmd/hive/fixer_queue_test.go index 3829deb8d6..cc2282ae5f 100644 --- a/src/cmd/hive/fixer_queue_test.go +++ b/src/cmd/hive/fixer_queue_test.go @@ -119,15 +119,67 @@ 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) + reconcilePlannedFixQueue(gov, "org", 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"}}) + reconcilePlannedFixQueue(gov, "org", &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) } } + +// Regression for hivecommons/hive#16537: dispatch plans carry the bare repo +// name from config, so a deferred fix recorded as "repo#N" used to be evicted +// by the next enumeration reconcile (keyed "org/repo#N") and never matched the +// dashboard's ReviewQueueKey lookup. Every path must agree on the qualified key. +func TestFixerQueueBareRepoKicksSurviveReconcileAndMatchDashboardKey(t *testing.T) { + gov := &governor.Governor{} + msg := scheduler.KickMessage{Agent: "scanner", Message: "fix bare"} + kick := review.DispatchKick{Kind: "fix", PRRef: "Repo#7", Repo: "Repo", Number: 7} + q := reviewFixKickQueue{governor: gov, org: "Org", kicks: map[string]review.DispatchKick{reviewKickKey(msg): kick}} + r := newKickDispatchRecorder() + r.sendErr["scanner"] = fmt.Errorf("prompt wait: %w", crux.ErrAgentBusy) + deps := r.deps() + deps.onDeferred = q.Deferred + deps.onReviewDelivered = q.Delivered + dispatchAgentKicks([]scheduler.KickMessage{msg}, false, deps, discardLogger()) + + want := github.ReviewQueueKey("org/repo", 7) + if got := fixerQueueKey("Org", kick); got != want { + t.Fatalf("fixerQueueKey = %q, want %q", got, want) + } + if got := fixerQueueKey("Org", review.DispatchKick{Kind: "fix", PRRef: "Repo#7"}); got != want { + t.Fatalf("fixerQueueKey from PRRef only = %q, want %q", got, want) + } + if got := fixerQueueKey("Org", review.DispatchKick{Kind: "fix", PRRef: "other/repo#7"}); got != "other/repo#7" { + t.Fatalf("already-qualified repo must not be re-prefixed: %q", got) + } + if queue := gov.FixerQueue(); queue[want].FixerQueuePosition != 1 { + t.Fatalf("deferred bare-repo fix not recorded under %q: %+v", want, queue) + } + + // Several enumeration + plan cycles while the fixer stays busy must keep + // the entry (and its first-deferral position) rather than evicting it. + for i := 0; i < 3; i++ { + reconcileDeferredFixQueue(gov, "Org", &github.ActionableResult{PRs: github.PRResult{ + Items: []github.PullRequest{{Repo: "Repo", Number: 7, State: "open"}}, + }}) + reconcilePlannedFixQueue(gov, "Org", &github.ActionableResult{}, []review.DispatchKick{kick}) + dispatchAgentKicks([]scheduler.KickMessage{msg}, false, deps, discardLogger()) + } + queue := gov.FixerQueue() + if len(queue) != 1 || queue[want].FixerQueuePosition != 1 { + t.Fatalf("bare-repo deferred fix evicted across cycles: %+v", queue) + } + + // Delivery clears it under the same key. + delete(r.sendErr, "scanner") + dispatchAgentKicks([]scheduler.KickMessage{msg}, false, deps, discardLogger()) + if len(gov.FixerQueue()) != 0 { + t.Fatalf("delivered bare-repo fix still queued: %+v", gov.FixerQueue()) + } +} diff --git a/src/cmd/hive/main_eval_cycle.go b/src/cmd/hive/main_eval_cycle.go index 36dbe0e003..3aacf02c1b 100644 --- a/src/cmd/hive/main_eval_cycle.go +++ b/src/cmd/hive/main_eval_cycle.go @@ -1004,7 +1004,7 @@ func runEvalCycle( "agents_skipped", agentsSkipped, ) - reconcilePlannedFixQueue(gov, actionable, reviewPlan.FixKicks) + reconcilePlannedFixQueue(gov, cfg.Project.Org, 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) { @@ -1142,7 +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} + fixQueue := reviewFixKickQueue{governor: gov, org: cfg.Project.Org, 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.