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..8eb210ef9a
--- /dev/null
+++ b/src/cmd/hive/fixer_queue.go
@@ -0,0 +1,90 @@
+package main
+
+import (
+ "strconv"
+ "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
+ 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(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(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
+ }
+ 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, 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[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
new file mode 100644
index 0000000000..cc2282ae5f
--- /dev/null
+++ b/src/cmd/hive/fixer_queue_test.go
@@ -0,0 +1,185 @@
+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, "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, "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 3ed4ccf2d5..3aacf02c1b 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, 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) {
@@ -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, 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.
@@ -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 6a2c4eb941..990b805bdc 100644
--- a/src/pkg/dashboard/static/index.html
+++ b/src/pkg/dashboard/static/index.html
@@ -43441,6 +43441,14 @@