Consensus loop: PR review redispatch has no hard cap and can run unbounded rounds

[MarketingChronoAi]

Problem

The review controller can keep dispatching review-pr<N>-<role>-r<R> indefinitely when required reviewer evidence remains stale, missing, invalid, pending-dead, or incomplete for the live PR head. Local artifacts showed extreme reviewer churn, including PR #37 continuing review artifacts up to about r98 after the PR was already merged.

Confirmed missing behavior

• No max review rounds per PR.
• No max review rounds per PR head.
• No max review redispatch count for the same stale evidence condition.

Evidence

• /Users/chronoai/.claude/skills/consensus-loop/scripts/codex_refactor_loop/controller_actions.py: dispatch_reviewers() computes the next review round and dispatches another reviewer.
• /Users/chronoai/.claude/skills/consensus-loop/scripts/codex_refactor_loop/controller_actions.py: _next_review_round() returns max existing round plus one.
• /Users/chronoai/.claude/skills/consensus-loop/scripts/codex_refactor_loop/wakeup_plan.py: review_evidence_redispatch_actions() emits redispatch actions when live-head review evidence is incomplete.
• /Users/chronoai/.claude/skills/consensus-loop/scripts/codex_refactor_loop/wakeup_runner.py: wakeup runner dispatches reviewer actions through ControllerActions.dispatch_reviewers().

Suggested fix

• Add a hard cap per PR/head, for example MAX_REVIEW_ROUNDS_PER_HEAD=3.
• Add a broader hard cap per PR, for example MAX_REVIEW_ROUNDS_PER_PR=9.
• When the cap is reached, stop spawning reviewers and write a durable blocker/audit record.
• Route next action to review-fix, human-blocked, terminal merge-transition audit, or explicit no-progress/stale-evidence record.

Acceptance criteria

• New reviewer prompts are not generated after the configured per-head cap.
• New reviewer prompts are not generated after the configured per-PR cap.
• The cap produces a durable status record naming PR, head SHA, roles, last blocker reason, and next action.
• Tests cover stale reviewer evidence loops and repeated missing reviewer evidence.

Review status

This was independently reviewed in /Users/chronoai/Desktop/proposed-main-repo-issues-review-gate.md and classified high confidence.

⟦AI:AUTO-LOOP⟧
ISSUE_RAISED:review-gate-hardening:redispatch-hard-cap

[MarketingChronoAi]

crnd:default-issue-intake-claim

First claimer: MarketingChronoAi

⟦AI:AUTO-LOOP⟧

[MarketingChronoAi]

🤖 Minimal solver proposes bounded review redispatch caps

TL;DR

• What this is: Minimal design-solver output for issue Consensus loop: PR review redispatch has no hard cap and can run unbounded rounds #41.
• Current state or conclusion: The unbounded review redispatch loop is real in the current dispatch_reviewers() and wakeup redispatch path.
• What the maintainer should do OR what the controller does next: Proceed to consensus selection with the smallest viable fix: hard caps plus existing blocked ledger/pending-event records.

---

Minimal design result

I verified the issue against the current consensus-loop source. dispatch_reviewers() computes the next reviewer round from existing prompt/run/log files and then renders another review-pr<N>-<role>-r<R> prompt. _next_review_round() returns max existing round plus one. review_evidence_redispatch_actions() keeps projecting redispatch actions when live-head reviewer evidence is missing, stale, dead, or incomplete. wakeup_runner.py dispatches those actions through ControllerActions.dispatch_reviewers().

The recommended frame is bounded retry/circuit breaker behavior: a bounded retry is a repeat operation with a fixed attempt budget, and a circuit breaker is the stop condition that records why automation must not keep retrying. The minimal change is not a new review system; it is a fixed cap in the current review redispatch path and a durable blocked record when the cap is reached.

Option	Trade-off
Add MAX_REVIEW_ROUNDS_PER_HEAD=3 and MAX_REVIEW_ROUNDS_PER_PR=9 in the existing controller/runner path	Smallest code change; stops new prompts after the cap and reuses existing blocked records.
Also suppress capped actions in wakeup_plan.py	Cleaner plans, but slightly more code; runner/controller caps still provide the hard safety boundary.
Build a new durable review-round database	More explicit state, but too much new authority surface for this issue.

Recommended tests are focused on the existing files that already cover this behavior: test_controller_actions.py for prompt/harness-intent suppression and test_wakeup_runner.py for blocked ledger/pending-event recording. A test_wakeup_plan.py case is only needed if capped actions are suppressed during planning instead of only blocked during runner/controller application.

---

📎 Full raw codex output (archival)

---

solver: minimal
issue: 41
cluster: issue-41
verdict: propose

Recommended framing

采用最小边界修复：在现有 review redispatch 路径上加固定硬上限，而不是重做 review gate。dispatch_reviewers() 当前按角色用 _next_review_round() 取 max+1 并直接渲染 review-pr<N>-<role>-r<R>；review_evidence_redispatch_actions() 会在 live head 证据缺失或陈旧时继续投递同一类 action；wakeup_runner.py 只负责调用 helper。最小可行方案是在 controller dispatch 前判断每个 PR/head/role 与整个 PR 的既有轮次数，超过上限时不写 prompt、不写 harness intent，并复用 pending-events 与 wakeup-runner ledger 写 durable blocker。参考框架：bounded retry / circuit breaker，重复恢复动作必须有预算、终止状态和可审计原因。

Concrete plan

• Files: /Users/chronoai/.claude/skills/consensus-loop/scripts/codex_refactor_loop/controller_actions.py — add MAX_REVIEW_ROUNDS_PER_HEAD = 3 and MAX_REVIEW_ROUNDS_PER_PR = 9; add small private counting helpers near _next_review_round() that count existing review-pr{pr}-*-r* artifacts/logs and extract prompt/log/artifact head_sha; in dispatch_reviewers(), before rendering each role prompt, skip capped roles and append a CONTROLLER_ACTION_BLOCKED:review-redispatch-cap:pr:<pr>:head:<sha>:role:<role>:round:<round>:reason:<per_head|per_pr> pending-event line with roles/head/next action fields compressed into the suffix.
• Files: /Users/chronoai/.claude/skills/consensus-loop/scripts/codex_refactor_loop/wakeup_runner.py — add pre-dispatch validation for review-evidence-redispatch actions that returns a blocked result when the projected head/roles are already capped; this ensures the existing .refactor-loop/state/wakeup-runner-ledger.jsonl durable row records action_id, status=blocked, reason=review_redispatch_cap:<per_head|per_pr>, kind, and timestamp even if the controller helper is not reached.
• Files: /Users/chronoai/.claude/skills/consensus-loop/scripts/codex_refactor_loop/wakeup_plan.py — minimal optional improvement: reuse the same pure cap helper to avoid emitting redispatch actions that the runner will only block; instead emit a status_only action or no spawn action with blocked_reason=review_redispatch_cap:<per_head|per_pr>, target_number, head_sha, stale_review_roles, and next_action=human-blocked-or-review-fix. If keeping the helper only in runner/controller is smaller, this file can remain unchanged because the runner/controller cap still satisfies the no-new-prompt acceptance criteria.
• Files: /Users/chronoai/.claude/skills/consensus-loop/scripts/test_controller_actions.py — add tests that existing r1-r3 artifacts for the same PR/head/role prevent rendering r4, and that nine existing review rounds across roles prevent any further prompt/harness intent for that PR while writing a blocker event.
• Files: /Users/chronoai/.claude/skills/consensus-loop/scripts/test_wakeup_runner.py — add a blocked-action test proving a capped review-evidence-redispatch action records a blocked ledger row and pending event before dispatch_reviewers() is called.
• Files: /Users/chronoai/.claude/skills/consensus-loop/scripts/test_wakeup_plan.py — add or adjust one stale/missing-evidence test only if wakeup_plan.py suppresses capped actions at planning time; otherwise leave existing planner tests intact.
• LOC delta: ~+90 / -0 for controller+runner hard cap; ~+30 / -5 more if planner suppression is included; tests ~+120 / -0 across 2-3 files.
• Tests to add/modify: test_controller_actions.py::test_dispatch_reviewers_blocks_role_after_per_head_cap, test_controller_actions.py::test_dispatch_reviewers_blocks_pr_after_total_pr_cap, test_wakeup_runner.py::test_review_redispatch_cap_records_blocked_ledger_before_dispatch, optionally test_wakeup_plan.py::test_reviewing_pr_at_review_round_cap_projects_blocked_status_not_dispatch.
• Governance/ruleset change (if any): none. This is a controller runtime budget, not a CLAUDE/AGENTS/Tier rule change.
• Migration path: no migration needed; existing high-round artifacts remain historical evidence and will immediately trip the cap for affected PRs.

Risks

• A fixed cap can block a legitimately flaky reviewer after three failed attempts on one head; the durable blocker must name next_action=human-blocked-or-review-fix so a maintainer has an explicit path.
• Counting artifacts/logs across prompts, runs, and logs may double-count the same role/round unless the helper keys by (role, round_number); the implementation must count unique tuples.
• If only controller-side blocking is implemented, wakeup plans may still show redispatch actions that later block. That is acceptable for no-new-prompts but less clean operationally than planner suppression.
• Per-head counting depends on extracting head SHA from prompt/run/log content. Missing head SHA should count toward per-PR cap and should not count toward per-head cap unless the live head is known from the action/PR query.

Escalation triggers (if any)

• none

Reasoning trace (internal — short, for meta-judge)

• Why this is the minimum: the verified violation is an unbounded retry loop in existing dispatch/planning code; adding fixed retry budgets and reusing existing blocked ledger/pending-event paths changes only the review redispatch surface.
• What I considered but rejected: a new durable review-round database, new host.env config, label automation, or full review-gate redesign. Those add authority surfaces and are unnecessary for a hard cap.
• What I cannot decide alone: exact numeric defaults can be tuned by maintainers, but 3 per head and 9 per PR match the issue suggestion and are enough to stop r98 churn.

⟦AI:AUTO-LOOP⟧
SOLVER_DONE:minimal:propose:Add bounded review redispatch caps and reuse existing blocked ledger/pending-event records

⟦AI:AUTO-LOOP⟧

[MarketingChronoAi]

🤖 Structural solver proposes a bounded review redispatch budget

TL;DR

• What this is: Structural design solver output for issue Consensus loop: PR review redispatch has no hard cap and can run unbounded rounds #41.
• Current state or conclusion: The review redispatch loop should be capped by a shared ReviewRoundBudget, a small controller-private evaluator that both planning and dispatch use.
• What the controller does next: Use this as one consensus input for the meta-judge; no code, Git lifecycle mutation, or PR action was performed by this solver.

---

Design summary

I verified the cited source paths and found the unbounded shape described in the issue. In controller_actions.py:1666, dispatch_reviewers() renders reviewer prompts; in controller_actions.py:1740, _next_review_round() returns the maximum existing round plus one without a ceiling, which is the direct prompt-generation risk. In wakeup_plan.py:2664, review_evidence_redispatch_actions() projects another dispatch_reviewers action when live-head reviewer evidence is stale or missing, so the planner can keep feeding that unbounded dispatcher.

The recommended structure is a shared ReviewRoundBudget evaluator. This is a small controller-private retry budget object: it counts unique review rounds for a PR/head and for the PR overall, returns allowed and blocked roles, and formats one durable blocker event when the cap is reached. The same evaluator should be used by the wakeup planner before it projects redispatch and by dispatch_reviewers() before it writes prompts or spawn intents.

Option	Trade-off
Shared ReviewRoundBudget in codex_refactor_loop/review_round_budget.py	Adds one small module, but keeps projection and dispatch enforcement consistent.
Local if round > 3 only in dispatch_reviewers()	Stops prompt creation in one path, but wakeup planning may keep producing doomed redispatch actions.
Human-only process rule	No code cost, but does not enforce the hard cap by construction.

The plan estimates about +300 LOC including tests, with no public schema or protocol changes. Runtime cost is one local artifact scan per PR considered for redispatch, expected to be under 5 ms for ordinary artifact counts.

📎 Full raw codex output (archival)

---

solver: structural
issue: 41
cluster: issue-41
verdict: propose

PROJECT_RULES clause violated (quoted verbatim)

3. No unbounded items - everything injected in the model context must have a bounded size and a hard cap.

• FI-004 Facts that cross processes, turns, or nodes must have an authoritative record; in-process memory, caches, and temporary variables must not masquerade as fact sources.

• MIL-013 Human intervention thresholds are explicit. Stop autonomous
  continuation and request maintainer direction when: three no-progress
  convergence rounds occur without maintainer input; two consecutive candidates
  for the same canonical key are rejected as unclear/not-reproducible without
  new evidence; ownership or repository boundary remains ambiguous after one
  full triage pass; a 12-hour window has zero PRs plus repeated duplicate or
  no-code closures; or no actionable non-duplicate candidate remains after a
  complete intake pass.

• MIL-014 A durable progress record is mandatory for each action. Each issue,
  plan, implementation attempt, triage decision, and 12-hour audit must record:
  timestamp/window, action_mode, canonical key, local issue number, upstream
  reference if any, duplicate search summary, branch, PR, commit, unique diff

Recommended framing

参考框架：bounded retry budget / circuit breaker。当前 review redispatch 把证据陈旧视为可无限重试的调度条件；结构性修复应把“是否还能派发 reviewer”提升为一个共享的 ReviewRoundBudget 判定，而不是在某个循环里加一次性 if。该判定应同时服务 wakeup projection 和 controller dispatch：projection 在达到上限时发出 blocker action，dispatcher 在生成 prompt 前强制执行 hard stop，并写入持久 blocker 事件。这样每个 PR/head 和整个 PR 都有确定上界，陈旧证据不会再通过 max-plus-one round 变成无限 prompt 生成。

Concrete plan

• New abstractions (if any): ReviewRoundBudget + ReviewRoundBudgetDecision in script layer, project codex_refactor_loop, file /Users/chronoai/.claude/skills/consensus-loop/scripts/codex_refactor_loop/review_round_budget.py. Interface:
  • constants MAX_REVIEW_ROUNDS_PER_HEAD = 3, MAX_REVIEW_ROUNDS_PER_PR = 9.
  • review_round_budget(repo_root: Path, pr_number: int, head_sha: str, roles: Sequence[str]) -> ReviewRoundBudgetDecision.
  • decision fields: allowed_roles: tuple[str, ...], blocked_roles: tuple[str, ...], next_round_by_role: dict[str, int], max_round_by_role: dict[str, int], rounds_for_head_by_role: dict[str, int], total_rounds_for_pr: int, blocker_reason: str | None, next_action: Literal["dispatch_reviewers", "review_fix", "human_blocked", "terminal_merge_transition_audit", "no_progress_stale_evidence"].
  • helper format_review_round_cap_event(decision, pr_number, head_sha, roles, last_blocker_reason) -> str returns one JSON-bearing line prefixed REVIEW_ROUND_CAP_BLOCKED.
• Files:
  • /Users/chronoai/.claude/skills/consensus-loop/scripts/codex_refactor_loop/review_round_budget.py: add shared parser/evaluator for prompt/run/log names and head-bound prompt/log metadata.
  • /Users/chronoai/.claude/skills/consensus-loop/scripts/codex_refactor_loop/controller_actions.py: import evaluator; in dispatch_reviewers() compute budget after PR facts and stale roles are known; skip blocked roles; append blocker event when any requested role is blocked; never render a prompt when PR-level cap is reached; replace direct _next_review_round() use with decision.next_round_by_role[role]; keep _next_review_round() only if tests or other callers still need it, otherwise fold into the budget module.
  • /Users/chronoai/.claude/skills/consensus-loop/scripts/codex_refactor_loop/wakeup_plan.py: import evaluator; in review_evidence_redispatch_actions() check budget before appending dispatch_reviewers; if blocked, append a non-spawn action kind such as review-round-cap-blocked with PR, head SHA, roles, blocker reason, next action, and status_only: true only if runner must not execute it; prefer executable blocker action if a runner ledger row is required.
  • /Users/chronoai/.claude/skills/consensus-loop/scripts/codex_refactor_loop/wakeup_runner.py: teach validation/apply to record review-round-cap-blocked actions as non-spawn durable blocker rows, or rely on controller_actions.dispatch_reviewers() hard stop for direct dispatch paths. If adding runner support, use the existing _blocked() / _record() ledger path and .controller-pending-events.log.
  • /Users/chronoai/.claude/skills/consensus-loop/scripts/test_controller_actions.py: add controller hard-stop tests.
  • /Users/chronoai/.claude/skills/consensus-loop/scripts/test_wakeup_plan.py: add projection tests.
  • /Users/chronoai/.claude/skills/consensus-loop/scripts/test_wakeup_runner.py: add runner ledger/blocker action test only if wakeup_plan emits an executable blocker action.
• LOC delta: ~+170 / -20. New module ~95 LOC, controller integration ~35 LOC, wakeup projection ~25 LOC, runner action support ~15 LOC if needed, tests ~130 LOC. Net implementation likely ~+300 including tests.
• Tests to add:
  • test_dispatch_reviewers_stops_at_per_head_cap_and_writes_blocker: create three completed/pending/stale rounds for one PR/head/role, call dispatch_reviewers, assert no review-pr<N>-<role>-r4.md, no HARNESS_SPAWN_INTENT for r4, and pending events contain REVIEW_ROUND_CAP_BLOCKED with pr_number, head_sha, roles, last_blocker_reason, and next_action.
  • test_dispatch_reviewers_stops_at_per_pr_cap_even_for_new_head: create nine total review rounds across heads/roles, call dispatch_reviewers for a live new head, assert no new prompt and blocker reason is max_review_rounds_per_pr.
  • test_dispatch_reviewers_allows_uncapped_roles_when_one_role_hits_head_cap: cap only architect, request architect and tests, assert tests still gets its next round and blocker record names only architect.
  • test_review_evidence_redispatch_projects_blocker_after_head_cap: in test_wakeup_plan.py, create stale/missing live-head evidence plus three rounds for the same head, assert no dispatch_reviewers action and a blocker projection/action exists.
  • test_review_evidence_redispatch_projects_blocker_after_pr_cap: create nine total rounds for PR, assert redispatch is suppressed and blocker includes next_action.
  • test_review_round_budget_counts_prompts_runs_logs_once: unit-level test for the new module if duplicate prompt/run/log records exist for the same role/round; assert total unique round count, not file count. This is justified because the parsing/counting invariant is shared by two callers.
• Schema/protocol changes (if any): none. This is controller-private runtime state in .controller-pending-events.log and wakeup runner ledger rows, not app-server or public API schema.
• Governance/ruleset changes (if any): none. Existing AGENTS.md boundedness, authoritative-record, and human-intervention clauses already require this behavior.
• Runtime cost: one extra scan of .refactor-loop/{prompts,runs,logs} per PR considered for review redispatch and once per dispatch call. Expected local cost: O(file count for one PR glob), usually <5 ms for tens of artifacts and <50 ms for thousands. Allocation: one decision object plus small dicts/tuples, roughly <20 KB per PR in normal cases. No model/context latency and no network calls.
• If the structural answer is issue decomposition, use the controller-private IssueDecompositionPlan boundary and child body artifacts; forbid solver/judge/worker GitHub lifecycle, public issue factories, and any wakeup_plan.py decompose action/projection.
• Do not author helper-owned decomposition tracking comments or child fingerprint lines; the checked-in refactor(history-overlay): split into modular functions & add tests (fixes #402) openai/codex#403 helper is the only writer for the parent tracking grammar and per-child idempotency fingerprints.

Risks

• The structural plan touches both projection and dispatch. That is a larger change than a local if round_number > 3 in dispatch_reviewers(), but it prevents wakeup plans from repeatedly projecting an action that the dispatcher later refuses.
• Counting “rounds per head” depends on reliable head extraction from prompts, logs, and artifacts. Keep the evaluator conservative: unknown head counts toward PR-level cap but not head-level cap unless the artifact filename/metadata proves the head. The dispatcher hard stop still catches PR-level runaway.
• If the blocker action is executable rather than status_only, it adds another wakeup action kind. Keep it bounded to ledger/event recording only; it must not dispatch workers, mutate GitHub lifecycle, or create issues.

Escalation triggers (if any)

• none

Reasoning trace (internal — for meta-judge)

• Why this structure beats a documented exception: The violation is an unbounded retry loop. A documented exception would preserve max-plus-one reviewer dispatch and rely on humans noticing churn. A shared budget decision makes the retry limit a first-class invariant at both planning and execution boundaries.
• Why I picked this abstraction over alternatives: Two concrete callers need the same rule: review_evidence_redispatch_actions() must know whether to project redispatch, and ControllerActions.dispatch_reviewers() must enforce the hard cap before writing prompts. A small module avoids divergent cap math and gives tests one counting invariant.
• What I cannot decide alone: The exact next action after cap exhaustion may be policy-specific. My default is no_progress_stale_evidence for missing/stale/pending-dead evidence, review_fix only when current valid reviewer evidence includes a reject, and human_blocked when the controller cannot infer a safe automated next step.

⟦AI:AUTO-LOOP⟧
SOLVER_DONE:structural:propose:add shared ReviewRoundBudget with per-head/per-PR hard caps, projection suppression, dispatcher enforcement, and durable blocker records

⟦AI:AUTO-LOOP⟧

[MarketingChronoAi]

🤖 Delete solver abstains on review redispatch deletion

TL;DR

• What this is: delete-biased solver output for issue Consensus loop: PR review redispatch has no hard cap and can run unbounded rounds #41.
• Current state or conclusion: redispatch is active review-gate recovery code, so no deletion or collapse is justified from the current evidence.
• What the controller does next: route this to minimal/structural design for a bounded retry cap and durable blocker record instead of deleting redispatch.

---

Delete-solver assessment

I classified this as e) genuinely needed. The issue describes an unbounded retry loop, but the retry path itself is the recovery mechanism for stale or missing live-head PR review evidence.

review_evidence_redispatch_actions() is the planner function that notices missing or stale reviewer evidence for a live PR head. It emits dispatch_reviewers actions only when required review evidence is incomplete. dispatch_reviewers() is the controller action that renders replacement reviewer prompts and appends harness spawn intents for the required review roles.

Option	Trade-off	Delete-solver pick
Delete redispatch	Stops churn, but strands PRs when review evidence is stale, dead, invalid, or missing	Reject
Collapse into an existing cap	Good if an existing per-PR/head review cap exists, but I did not find one in the cited dispatch path	No deletion plan
Keep redispatch and add a cap	Preserves recovery while bounding unbounded rounds and producing a blocker record	Recommended next design path

Evidence checked: wakeup_plan.py emits stale-role redispatch actions; wakeup_runner.py routes dispatch_reviewers to the controller; controller_actions.py computes max(rounds) + 1 without a cap; existing tests assert stale review redispatch, pending suppression, and stale-log round advancement behavior. The source directory was readable but not a Git checkout, so blame history was unavailable there.

📎 Full raw codex output (archival)

---

solver: delete
issue: 41
cluster: issue-41
verdict: abstain

Classification

e) Genuinely needed and right-sized enough for the current issue scope; no current deletion or collapse is justified.

Reference-frame note: circuit-breaker / bounded-retry design. A retry loop that recovers missing external evidence should keep the recovery path and add an explicit budget plus a terminal blocker record when the budget is exhausted; deleting the retry path removes availability rather than bounding it.

Recommended action

Abstain from deletion. The live issue is not evidence of dead code, an orphan feature, or a duplicate abstraction. review_evidence_redispatch_actions() detects PRs whose live head lacks complete required review evidence, and dispatch_reviewers() is the active command path that materializes replacement reviewer prompts. The defect is the missing stop condition after repeated stale, invalid, dead, or missing reviewer evidence; the appropriate fix is a small bounded retry policy plus durable blocked/audit recording, not deletion of redispatch.

Concrete plan (if propose)

• Files to delete: none
• Caller migrations: none
• Tests to delete: none
• LOC delta: 0
• Philosophy/CLAUDE.md/SPEC/Tier changes (if any): none

Reverse-evidence (why deletion is not safe)

• The redispatch path is called by the wakeup runner: /Users/chronoai/.claude/skills/consensus-loop/scripts/codex_refactor_loop/wakeup_runner.py:1419 routes controller_action == "dispatch_reviewers" to ControllerActions.dispatch_reviewers().
• The wakeup plan actively emits redispatch work: /Users/chronoai/.claude/skills/consensus-loop/scripts/codex_refactor_loop/wakeup_plan.py:2664 defines review_evidence_redispatch_actions(), and lines 2680-2697 build stale-role redispatch actions only when the live PR head lacks a complete required review round.
• dispatch_reviewers() is not only initial dispatch. /Users/chronoai/.claude/skills/consensus-loop/scripts/codex_refactor_loop/controller_actions.py:1701 filters to stale_review_roles, line 1709 computes the next role round, lines 1710-1713 suppress pending duplicates, and lines 1714-1737 render the reviewer prompt and append a harness spawn intent.
• _next_review_round() at /Users/chronoai/.claude/skills/consensus-loop/scripts/codex_refactor_loop/controller_actions.py:1740 confirms the issue: it returns max(rounds) + 1 across prompts, runs, and logs without a cap. That is a missing budget, not proof that the redispatch feature is removable.
• Existing tests assert the recovery semantics are intentional. /Users/chronoai/.claude/skills/consensus-loop/scripts/test_controller_actions.py:3435 covers next-round redispatch after completed stale logs, /Users/chronoai/.claude/skills/consensus-loop/scripts/test_controller_actions.py:3500 covers not advancing while a same-role log is pending, and /Users/chronoai/.claude/skills/consensus-loop/scripts/test_controller_actions.py:3548 covers advancing after a stale non-exited log.
• The runner already has durable blocked recording primitives at /Users/chronoai/.claude/skills/consensus-loop/scripts/codex_refactor_loop/wakeup_runner.py:2329, so a bounded-retry implementation can likely reuse existing blocked/action ledger behavior instead of deleting redispatch.
• The host skill source directory was present and readable, but it was not a Git checkout, so git log -S '_next_review_round' -- scripts/codex_refactor_loop/controller_actions.py could not recover original commit intent there. This limits blame evidence, not source-level classification.
• No local audit artifact was provided; the router-injected GitHub issue snapshot was used as the scope spec as instructed.

Risks

• If the host has a separate newer source locator where review-gate no longer depends on redispatch, this abstain could be too conservative; the current readable source shows the dependency is active.
• If another existing cap mechanism outside the inspected files already enforces per-PR and per-head reviewer budgets, the implementation work could collapse into wiring redispatch through that mechanism. The searched symbols and cap/blocker scans did not reveal such a review-round cap in the cited dispatch path.
• If maintainers intentionally want review-gate to fail closed on any missing reviewer evidence, deleting redispatch would be a product decision, not a delete-solver conclusion from the current evidence.

Escalation triggers (if any)

• none

Reasoning trace (internal — for meta-judge)

• Why I claim this should not be deleted: the issue identifies unbounded retry behavior, while the code path provides the recovery mechanism for stale or missing live-head reviewer evidence. Removing it would strand PRs in review-gate when evidence is stale, invalid, dead, or missing.
• What I checked to verify safety: issue Consensus loop: PR review redispatch has no hard cap and can run unbounded rounds #41 body/comments via gh issue view; direct source reads of controller_actions.py, wakeup_plan.py, and wakeup_runner.py; call-site search for dispatch_reviewers, _next_review_round, and review_evidence_redispatch_actions; tests covering stale redispatch behavior; AGENTS deletion-first guidance, including FI-007.
• What I cannot decide alone: the exact budget constants and terminal next action belong to the minimal or structural solver/implementation. The delete role can only say that no deletion/collapse plan is justified by the current evidence.

⟦AI:AUTO-LOOP⟧
SOLVER_DONE:delete:abstain:redispatch is active review-gate recovery; issue needs bounded retry/blocker policy, not deletion

⟦AI:AUTO-LOOP⟧

[MarketingChronoAi]

🤖 Meta-judge selects bounded review redispatch consensus

TL;DR

• What this is: Meta-judge decision for issue Consensus loop: PR review redispatch has no hard cap and can run unbounded rounds #41 design-consensus round 1.
• Current state or conclusion: Consensus is reached on a bounded retry budget for PR review redispatch.
• What the controller does next: Dispatch implementation from the judge artifact; no convergence round is needed.

---

Consensus decision

I compared the three required solver outputs for issue #41. The minimal and structural solvers both propose an implementation-bearing fix: cap review redispatch at 3 rounds per PR/head and 9 rounds per PR, stop generating reviewer prompts and harness spawn intents after the cap, and write durable blocker records. The delete solver abstains because redispatch is active review-gate recovery code; that abstain is compatible with the issue-driven Path A exception because it does not contradict the bounded retry plan.

Reference frame: bounded retry budget / circuit breaker. A retry path that recovers missing external evidence should have a fixed attempt budget, a hard stop, and an auditable terminal record.

Option	Decision	Trade-off
Minimal local caps in dispatch plus runner blocking	Compatible input	Smallest boundary, but planner may still project actions that later block.
Shared ReviewRoundBudget evaluator	Selected consensus	Slightly more code, but planning and dispatch use one cap rule.
Delete redispatch	Rejected by delete solver	Stops churn but removes recovery for stale or missing review evidence.

The selected implementation scope is controller-private consensus-loop code: add a shared ReviewRoundBudget evaluator, use it in review_evidence_redispatch_actions() and dispatch_reviewers(), record capped paths through pending events / wakeup runner ledger behavior, and test per-head cap, per-PR cap, mixed allowed/blocked roles, stale/missing evidence projection, duplicate artifact counting, and durable blocker output.

No CLAUDE.md, AGENTS.md, SPEC, Tier, app-server API, or GitHub lifecycle change is included in the consensus.

📎 Full raw codex output (archival)

---

issue: 41
cluster: issue-41
convergence_round: 1
solver_verdicts:
minimal: propose
structural: propose
delete: abstain
decision: consensus
action_mode: plan
canonical_key: #41
next_action: implement

Decision

达成实现共识。参考框架是 bounded retry budget / circuit breaker：会重复恢复外部证据的自动化路径必须有固定预算、强制停止点和持久审计记录。minimal 与 structural 都确认当前 dispatch_reviewers() / _next_review_round() / review_evidence_redispatch_actions() 组合会把 stale/missing reviewer evidence 转成无上限的下一轮 reviewer prompt；两者都要求 per-head 与 per-PR hard cap、达到 cap 后不再生成 prompt 或 spawn intent、并写入 durable blocker。delete solver 的 abstain 与该实现计划兼容，因为它确认 redispatch 是 active recovery path，问题是缺少 retry budget 而不是应删除 redispatch。选择 structural framing：用一个 controller-private ReviewRoundBudget 共享判定，让 wakeup projection 与 dispatch enforcement 使用同一预算规则。

If consensus

• Chosen framing: structural
• Implement plan (structured fields read by wakeup-plan from this judge artifact only, not from solver artifacts or prompt-body free text):
  • scope_paths:
    • /Users/chronoai/.claude/skills/consensus-loop/scripts/codex_refactor_loop/review_round_budget.py
    • /Users/chronoai/.claude/skills/consensus-loop/scripts/codex_refactor_loop/controller_actions.py
    • /Users/chronoai/.claude/skills/consensus-loop/scripts/codex_refactor_loop/wakeup_plan.py
    • /Users/chronoai/.claude/skills/consensus-loop/scripts/codex_refactor_loop/wakeup_runner.py
    • /Users/chronoai/.claude/skills/consensus-loop/scripts/test_controller_actions.py
    • /Users/chronoai/.claude/skills/consensus-loop/scripts/test_wakeup_plan.py
    • /Users/chronoai/.claude/skills/consensus-loop/scripts/test_wakeup_runner.py
  • old_pattern: Review redispatch treats stale, missing, invalid, pending-dead, or incomplete live-head reviewer evidence as an unbounded max-plus-one prompt generation loop.
  • new_principle: Review redispatch is a bounded retry budget with hard caps of 3 rounds per PR/head and 9 rounds per PR; planning and dispatch share one budget evaluator, capped paths emit durable blocker records, and no capped path writes reviewer prompts or harness spawn intents.
  • verification_hints: Run the consensus-loop Python tests covering controller actions, wakeup planning, and wakeup runner behavior; include cases for per-head cap, per-PR cap, mixed allowed/blocked roles, stale/missing evidence projection, duplicate prompt/run/log counting, and durable blocker ledger/pending-event output.
• Philosophy/CLAUDE.md/SPEC/Tier changes included: none
• Implementation owner: dispatch implement codex with cluster_id=issue-41, design_decision_path=.refactor-loop/runs/phase9-issue41-r1-judge.md
• Add crnd:triage:resume-requested label to issue 41

If converge

• Convergence question (specific): none
• What each solver should address explicitly: not applicable
• Round number this fires: 2; marker payload uses source round 1
• Progress since prior round: not applicable
• Human-intervention threshold: not reached

If triage-only consensus

• Resolution: not applicable
• Canonical key: Consensus loop: PR review redispatch has no hard cap and can run unbounded rounds #41
• Existing issue/PR/branch/commit evidence: issue Consensus loop: PR review redispatch has no hard cap and can run unbounded rounds #41 open; no implementation PR selected by this judge
• New evidence required before reopening: not applicable
• Controller action: implementation dispatch authorized; this is not triage-only

Round audit trail (links to local artifacts)

• solver-minimal: .refactor-loop/logs/phase9-issue41-r1-minimal.log
• solver-structural: .refactor-loop/logs/phase9-issue41-r1-structural.log
• solver-delete: .refactor-loop/logs/phase9-issue41-r1-delete.log
• work-unit-producer: manual-issue (prompt-only provenance)
• work-unit-source-ref: gh-issue-41
• action_mode: plan
• canonical_key: Consensus loop: PR review redispatch has no hard cap and can run unbounded rounds #41
• duplicate_search_summary: Router-scoped inputs only: issue Consensus loop: PR review redispatch has no hard cap and can run unbounded rounds #41 snapshot and the three listed solver logs were used; no sibling judge artifacts, other issue artifacts, other round artifacts, or unlisted solver outputs were consulted. The live issue URL was read only to confirm issue Consensus loop: PR review redispatch has no hard cap and can run unbounded rounds #41 is still open.
• branch: none
• PR: none
• commit: none
• unique_diff_status: not-applicable
• tests_verification: not run; meta-judge arbitration only, no source implementation executed
• resolution: consensus
• next_action: implement

⟦AI:AUTO-LOOP⟧
META_JUDGE_DONE:consensus:structural:Bound review redispatch with shared ReviewRoundBudget caps, durable blockers, and no capped reviewer prompts

⟦AI:AUTO-LOOP⟧