code-coordinator 0.5.161__tar.gz → 0.5.164__tar.gz

{code_coordinator-0.5.161 → code_coordinator-0.5.164}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: code-coordinator
-Version: 0.5.161
+Version: 0.5.164
 Summary: Coordinate Claude Code workers across multiple machines and repos.
 Author-email: John Donaghy <johnfdonaghy@gmail.com>
 License-Expression: LicenseRef-FSL-1.1-MIT

{code_coordinator-0.5.161 → code_coordinator-0.5.164}/code_coordinator.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: code-coordinator
-Version: 0.5.161
+Version: 0.5.164
 Summary: Coordinate Claude Code workers across multiple machines and repos.
 Author-email: John Donaghy <johnfdonaghy@gmail.com>
 License-Expression: LicenseRef-FSL-1.1-MIT

{code_coordinator-0.5.161 → code_coordinator-0.5.164}/code_coordinator.egg-info/scm_version.json

@@ -1,7 +1,7 @@
 {
-  "tag": "0.5.161",
+  "tag": "0.5.164",
   "distance": 0,
-  "node": "g2c9d3ac54cc47979d8229c26e8852ac4852dc577",
+  "node": "gacacc73c143b2a972a04f33649be185678913aa4",
   "dirty": false,
   "branch": "HEAD",
   "node_date": "2026-08-19"

{code_coordinator-0.5.161 → code_coordinator-0.5.164}/coord/_board_mapping.py

@@ -161,6 +161,12 @@ def row_to_assignment(row: object) -> Assignment:
         # #2316: raw terminal stop_reason; None for rows predating this
         # column or a worker whose log carried no such field.
         stop_reason=d.get("stop_reason"),
+        # #2417: the calling worker's own assignment id, when this row was
+        # dispatched from INSIDE another worker's turn (e.g. `coord
+        # acceptance author`/`coord fix` shelled out to from a `type="work"`
+        # session's own bash tool). None for a hand or coordinator/brain
+        # dispatch, and for rows predating this column.
+        dispatched_by_assignment_id=d.get("dispatched_by_assignment_id"),
     )
 
 

{code_coordinator-0.5.161 → code_coordinator-0.5.164}/coord/dashboard/webapp/src/api/generated.ts

@@ -174,4 +174,5 @@ export interface Assignment {
   for_issue_number: number | null
   driven_by: string | null
   stop_reason: string | null
+  dispatched_by_assignment_id: string | null
 }

{code_coordinator-0.5.161 → code_coordinator-0.5.164}/coord/db.py

@@ -926,6 +926,14 @@ def _migrate_add_columns(conn: sqlite3.Connection) -> None:
         # submission with no preview queued yet, same as `open_question`'s
         # own default.
         "ALTER TABLE portal_submissions ADD COLUMN preview_url TEXT NOT NULL DEFAULT ''",
+        # #2417: the CALLING assignment's id when this row was dispatched by
+        # a `coord` subcommand run from INSIDE another worker's own turn
+        # (e.g. `coord acceptance author`/`coord fix` shelled out to from a
+        # `type="work"` session's own bash tool) rather than typed by a
+        # human — see `coord.models.Assignment.dispatched_by_assignment_id`.
+        # NULL for a hand dispatch, a coordinator/brain-proposed dispatch,
+        # and every row predating this column.
+        "ALTER TABLE assignments ADD COLUMN dispatched_by_assignment_id TEXT",
     ]
     for sql in migrations:
         try:

{code_coordinator-0.5.161 → code_coordinator-0.5.164}/coord/drive.py

@@ -996,22 +996,35 @@ def _decide_acceptance_landing(
     something that will happen, and waiting for the fourth is the #1526
     defect: an unbounded wait for an event that cannot occur.
 
-    Three shapes get an immediate, actionable exit instead of a wait,
-    because for each of them the corrective action belongs to a loop that
-    will never run for this row:
+    Two shapes get an immediate, actionable exit instead of a wait, because
+    for each of them the corrective action belongs to a loop that will never
+    run for this row:
 
     * a FAILED slice test — the work row's equivalent dispatches
       ``coord fix``, but nothing dispatches one for a ``test-author`` row
       whose Test stage failed;
-    * a ``request-changes`` slice review — ``auto_loop`` accepts a
-      ``test-author`` fix (``FIX_DISPATCH_TYPES``), but the daemon drain
-      deliberately excludes fix dispatch (#476/#477, and #1692's own
-      analysis), so for the work row it is THIS driver that runs
-      ``coord fix``; there was no such arm for the slice;
     * ``--no-merge`` — the slice merge is a hard prerequisite for
       dispatching any work at all (#1138), so with merging switched off the
       run cannot progress, and saying so beats idling to the deadline.
 
+    A third shape — a ``request-changes`` slice review — used to be a fourth
+    immediate exit for the identical reason (``auto_loop`` accepts a
+    ``test-author`` fix via ``FIX_DISPATCH_TYPES``, but the daemon drain
+    deliberately excludes fix dispatch — #476/#477, and #1692's own
+    analysis — so for the work row it is THIS driver that runs
+    ``coord fix``, and there was no such arm for the slice). #2425: it no
+    longer is. Every retry of this lane re-dispatched a fresh author on the
+    SAME branch name instead of fixing the one review blocking it
+    (claude-coordinator#2286 — 11 re-authoring attempts over ~11h with the
+    review's findings never once addressed), because re-authoring was the
+    only path this lane had. Below, ``request-changes`` now gets the same
+    bounded ``coord fix <acceptance_review_aid>`` arm :func:`decide` already
+    runs for the work row's own review (the ``REVIEW: request-changes → fix
+    round`` arm), spending :attr:`DriveCounters.acceptance`'s OWN
+    ``fix_rounds`` — not the work row's — for the same #2079 reason the
+    slice's merge attempts get their own budget: a struggling slice review
+    must not silently leave the issue's real fix budget at zero.
+
     The merge itself reuses :func:`_decide_merge` verbatim against a shadow
     :class:`~coord.drive_state.IssueState` whose "work row" IS the slice —
     that is what carries #1891 (CI not reported → wait, don't retry), #1892
@@ -1049,15 +1062,81 @@ def _decide_acceptance_landing(
         )
 
     if state.acceptance_review_verdict == "request-changes":
-        return _die(
-            f"the JIT acceptance slice {aid} was reviewed REQUEST-CHANGES "
-            f"(review {state.acceptance_review_aid or 'unknown'}) — it will "
-            "never reach the merge queue until that is addressed, and no "
-            "loop dispatches the fix for a test-author row on its own.\n"
-            f"   Findings: coord log {state.acceptance_review_aid or aid}\n"
-            f"   Fix it: coord fix {state.acceptance_review_aid or aid}\n"
-            "   or re-run coord drive with --no-acceptance to skip JIT "
-            "authoring."
+        # #2425: the slice's own twin of `decide()`'s `REVIEW: request-
+        # changes → fix round` arm — see the docstring above for why this
+        # used to be a bare `_die()`. `coord fix` already accepts a
+        # `type="test-author"` review id (#1622/#1692:
+        # `auto_loop.FIX_DISPATCH_TYPES` includes `SEALED_PATH_AUTHOR_TYPES`,
+        # which is where "test-author" lives), so this is the SAME command
+        # the work-row arm dispatches, not a second implementation of it.
+        slice_counters = counters.slice_budget()
+        if not state.auto_loop:
+            return _die(
+                "the JIT acceptance slice's review requested changes, but "
+                "pipeline.auto_loop is OFF — the review→fix path is "
+                "switched off in coordinator.yml, so no fix can be "
+                "dispatched.\n"
+                f"   Findings: coord log {state.acceptance_review_aid or aid}\n"
+                "   Continue by hand: coord assign --interactive --fix-of "
+                f"{state.acceptance_review_aid or aid}"
+            )
+        # Belt-and-braces, mirroring the work-row arm: `acceptance_review_
+        # verdict` and `acceptance_review_aid` are read off the SAME board
+        # row (drive_state.project), so a verdict without an id is
+        # impossible today. Refuse to guess rather than dispatch `coord fix`
+        # against the wrong assignment.
+        if not state.acceptance_review_aid:
+            return _die(
+                "the JIT acceptance slice's review verdict is "
+                "'request-changes' but no review assignment id is on the "
+                "board — refusing to guess which review to fix. Inspect: "
+                f"coord gates {state.repo} {state.issue}"
+            )
+        # Same de-duplication latch as `review_fix_dispatched_for` on the
+        # work row's own arm, just on the slice's own counters: `coord fix`
+        # returns as soon as the fix worker is dispatched, and the board
+        # this driver polls needs a beat to show the new row.
+        if slice_counters.review_fix_dispatched_for == state.acceptance_review_aid:
+            return _wait(
+                label=(
+                    "ACCEPTANCE: fix already dispatched for "
+                    f"{state.acceptance_review_aid} — waiting for the fix "
+                    "row to appear on the board"
+                )
+            )
+        if slice_counters.fix_rounds >= opts.max_fix_rounds:
+            return _die(
+                f"the JIT acceptance slice {aid} was reviewed REQUEST-"
+                f"CHANGES (review {state.acceptance_review_aid}) after "
+                f"{slice_counters.fix_rounds} fix round(s) this drive spent "
+                "landing the slice — stopping.\n"
+                f"   Findings: coord log {state.acceptance_review_aid}\n"
+                f"   Continue by hand: coord fix {state.acceptance_review_aid}\n"
+                "   or re-run coord drive with --no-acceptance to skip JIT "
+                "authoring."
+            )
+        slice_counters.fix_rounds += 1
+        slice_counters.review_fix_dispatched_for = state.acceptance_review_aid
+        return Action(
+            kind=RUN,
+            label=(
+                "ACCEPTANCE: review request-changes → fix round "
+                f"{slice_counters.fix_rounds}/{opts.max_fix_rounds} "
+                f"(coord fix {state.acceptance_review_aid})"
+            ),
+            command=("fix", state.acceptance_review_aid),
+            error_message=(
+                f"coord fix {state.acceptance_review_aid} failed to "
+                "dispatch a fix for the JIT acceptance slice's review.\n"
+                "   Its refusals are all guards doing their job: auto_loop "
+                "disabled, no structured\n"
+                "   findings, approve-with-nits (#476), max_review_"
+                "iterations, or the #522\n"
+                "   terminal-work guard — the message above names which.\n"
+                f"   Check: coord log {state.acceptance_review_aid}   /   "
+                "continue by hand: coord assign --interactive --fix-of "
+                f"{state.acceptance_review_aid}"
+            ),
         )
 
     if not opts.do_merge:

{code_coordinator-0.5.161 → code_coordinator-0.5.164}/coord/models.py

@@ -723,6 +723,29 @@ class Assignment:
     # `advisory` — the same bucket as a worker that looked and correctly
     # found nothing to do — so nobody re-drove it.
     stop_reason: str | None = None
+    # #2417: the CALLING assignment's id when this row was dispatched by a
+    # `coord` subcommand run from INSIDE another worker's own turn (e.g. a
+    # `type="work"` session shelling out to `coord acceptance author repo ms
+    # --issue N` or `coord fix <other-id>`), as opposed to a human typing the
+    # same command in their own shell. Populated centrally in
+    # `coord.state.record_dispatched`/`record_dispatched_assignment` from the
+    # `COORD_ASSIGNMENT_ID` env var (see `coord.agent._build_worker_env`'s
+    # #2217 note — every headless worker's subprocess environment carries its
+    # own assignment id, so a `coord` CLI the worker shells out to inherits
+    # it automatically; a human's own shell never has it set). `None` for a
+    # hand dispatch, a coordinator/brain-proposed dispatch, and rows
+    # predating this column.
+    #
+    # This is the missing link #2417 reported: before this field, the only
+    # way to discover that a work row had dispatched an independent sibling
+    # assignment (and whether that sibling then succeeded) was grepping the
+    # worker's raw `claude -p` transcript for the printed "Dispatched ... to
+    # ..." line and manually cross-referencing a second `coord log` by hand.
+    # With this field, the ORIGIN row can be found by any consumer (the
+    # board, `coord audit`, the TUI) via a reverse lookup: "which assignment
+    # has `dispatched_by_assignment_id == this row's id`?" — see
+    # `coord.state.find_dispatched_children`.
+    dispatched_by_assignment_id: str | None = None
 
 
 def effective_issue_number(assignment: "Assignment | dict") -> int:
@@ -859,6 +882,15 @@ class Proposal:
     # through) carries durable provenance. `None` for every other caller
     # (brain-proposed, milestone dispatch, ...).
     driven_by: str | None = None
+    # #2417: mirrors `Assignment.dispatched_by_assignment_id` — see that
+    # field's docstring. Set here (rather than left for the caller to
+    # populate) by `coord.state.record_dispatched` reading
+    # `COORD_ASSIGNMENT_ID` from the environment at record time, so every
+    # `Proposal`-based dispatch path (`coord fix`/`coord pr`/`coord review`
+    # follow-ups via `_dispatch_followup`, `coord assign`,
+    # `coord/dispatch_workers.py`, ...) gets this for free without each call
+    # site threading it through by hand.
+    dispatched_by_assignment_id: str | None = None
 
 
 @dataclass

{code_coordinator-0.5.161 → code_coordinator-0.5.164}/coord/state.py

@@ -17,7 +17,7 @@ import os
 import sqlite3
 import time
 import warnings
-from dataclasses import asdict
+from dataclasses import asdict, replace
 from datetime import datetime, timezone
 from pathlib import Path
 from typing import TYPE_CHECKING
@@ -561,6 +561,10 @@ def _dispatched_dict_from_payload(a: dict) -> dict:
         "provider_name": a.get("provider_name"),
         # #1499: durable drive provenance; None for a hand `coord assign`.
         "driven_by": a.get("driven_by"),
+        # #2417: the calling worker's own assignment id, when this row was
+        # dispatched from INSIDE another worker's turn. None for a hand or
+        # coordinator/brain dispatch.
+        "dispatched_by_assignment_id": a.get("dispatched_by_assignment_id"),
     }
 
 
@@ -605,6 +609,10 @@ def _row_to_dispatched_dict(row: object) -> dict:
         "provider_name": d.get("provider_name"),
         # #1499: durable drive provenance; None for a hand `coord assign`.
         "driven_by": d.get("driven_by"),
+        # #2417: the calling worker's own assignment id, when this row was
+        # dispatched from INSIDE another worker's turn. None for a hand or
+        # coordinator/brain dispatch.
+        "dispatched_by_assignment_id": d.get("dispatched_by_assignment_id"),
     }
 
 
@@ -799,6 +807,21 @@ def _thin_client_local_board_guard(fn_name: str) -> None:
     _log.warning(msg)
 
 
+def _dispatched_by_from_env() -> str | None:
+    """The calling worker's own assignment id, if this process is running
+    INSIDE a headless worker's turn (#2417).
+
+    `COORD_ASSIGNMENT_ID` is set on a worker subprocess's own environment by
+    `coord.agent._build_worker_env` (#2217) — so a `coord` CLI invocation
+    the worker shells out to (e.g. `coord acceptance author` dispatching an
+    independent test-author sibling, `coord fix <other-id>` escalating an
+    unrelated assignment) inherits it automatically. A human typing the same
+    command in their own shell never has it set, so this correctly returns
+    `None` for a hand/coordinator dispatch.
+    """
+    return os.environ.get("COORD_ASSIGNMENT_ID") or None
+
+
 def record_dispatched(
     *,
     assignment_id: str,
@@ -807,6 +830,15 @@ def record_dispatched(
     provider_name: str | None = None,
 ) -> None:
     """Record a newly dispatched assignment — routes to the daemon when set."""
+    # #2417: stamp the calling worker's own assignment id (if any) BEFORE
+    # this crosses the HTTP boundary to a possibly-remote daemon — the env
+    # var only exists on the machine/process that is actually dispatching,
+    # never on the daemon host. Caller-supplied values (none of today's
+    # callers set one explicitly) are left alone.
+    if proposal.dispatched_by_assignment_id is None:
+        proposal = replace(
+            proposal, dispatched_by_assignment_id=_dispatched_by_from_env()
+        )
     svc = _board_service()
     resp = _route_write(
         svc,
@@ -874,8 +906,8 @@ def _record_dispatched_local(
             assignment_id, machine_name, repo_name, repo_github,
             issue_number, issue_title, status, type, briefing,
             files_allowed, model, dispatched_at, required_gates,
-            provider_name, branch, driven_by
-        ) VALUES (?, ?, ?, ?, ?, ?, 'running', ?, ?, ?, ?, ?, ?, ?, ?, ?)
+            provider_name, branch, driven_by, dispatched_by_assignment_id
+        ) VALUES (?, ?, ?, ?, ?, ?, 'running', ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
         ON CONFLICT(assignment_id) DO NOTHING""",
         (
             assignment_id,
@@ -893,6 +925,7 @@ def _record_dispatched_local(
             provider_name,
             branch,
             proposal.driven_by,
+            proposal.dispatched_by_assignment_id,
         ),
     )
     conn.commit()
@@ -915,7 +948,16 @@ def _record_dispatched_local(
             # the audit log alone, after the driver process has exited.
             actor="drive" if proposal.driven_by else "coordinator",
             summary=f"Dispatched {proposal.type} to {proposal.machine_name}: "
-            f"{proposal.repo_name}#{proposal.issue_number}",
+            f"{proposal.repo_name}#{proposal.issue_number}"
+            # #2417: make the sibling-dispatch link visible in the default
+            # (non-`--json`) `coord audit` table, not just in `details` —
+            # this is what let coord-portal#119's dispatch of a test-author
+            # sibling go unnoticed without grepping the raw worker transcript.
+            + (
+                f" (dispatched by assignment {proposal.dispatched_by_assignment_id})"
+                if proposal.dispatched_by_assignment_id
+                else ""
+            ),
             repo=proposal.repo_name,
             issue=proposal.issue_number,
             assignment_id=assignment_id,
@@ -924,6 +966,11 @@ def _record_dispatched_local(
                 "type": proposal.type,
                 "branch": branch,
                 "driven_by": proposal.driven_by,
+                # #2417: surfaces "this was dispatched BY a worker's own
+                # turn" directly in `coord audit`, without cross-referencing
+                # the raw `claude -p` transcript for the printed "Dispatched
+                # ... to ..." line.
+                "dispatched_by_assignment_id": proposal.dispatched_by_assignment_id,
             },
         )
 
@@ -934,6 +981,12 @@ def record_dispatched_assignment(
     repo_github: str,
 ) -> None:
     """Record a dispatched assignment — routes to the daemon when set."""
+    # #2417: see record_dispatched's matching comment — must be stamped here,
+    # on the dispatching process's own env, before the daemon HTTP hop.
+    if assignment.dispatched_by_assignment_id is None:
+        assignment = replace(
+            assignment, dispatched_by_assignment_id=_dispatched_by_from_env()
+        )
     svc = _board_service()
     resp = _route_write(
         svc, "/dispatched", {"assignment": asdict(assignment), "repo_github": repo_github}
@@ -971,7 +1024,8 @@ def _record_dispatched_assignment_local(
             issue_number, issue_title, status, type, briefing,
             files_allowed, model, dispatched_at, review_of_assignment_id,
             review_target, required_gates, review_iteration,
-            provider_name, branch, for_issue_number, driven_by
+            provider_name, branch, for_issue_number, driven_by,
+            dispatched_by_assignment_id
         ) VALUES (?, ?, ?, ?, ?, ?, 'running', ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?,
             -- #1553: a follow-up dispatched off another assignment (review,
             -- smoke, [fix-N], retry, pr-helper) inherits that parent's
@@ -989,7 +1043,7 @@ def _record_dispatched_assignment_local(
                 SELECT p.for_issue_number FROM assignments p
                 WHERE p.assignment_id = ?
             )),
-            ?)
+            ?, ?)
         ON CONFLICT(assignment_id) DO UPDATE SET
             status = 'running',
             machine_name = excluded.machine_name,
@@ -1013,7 +1067,13 @@ def _record_dispatched_assignment_local(
             for_issue_number = COALESCE(excluded.for_issue_number, for_issue_number),
             -- #1499: COALESCE so a re-dispatch/reload doesn't clear the
             -- drive provenance already recorded for this assignment.
-            driven_by = COALESCE(excluded.driven_by, driven_by)""",
+            driven_by = COALESCE(excluded.driven_by, driven_by),
+            -- #2417: COALESCE so a re-dispatch/reload doesn't clear the
+            -- calling-worker provenance already recorded for this
+            -- assignment.
+            dispatched_by_assignment_id = COALESCE(
+                excluded.dispatched_by_assignment_id, dispatched_by_assignment_id
+            )""",
         (
             assignment.assignment_id or "",
             assignment.machine_name,
@@ -1039,6 +1099,7 @@ def _record_dispatched_assignment_local(
             # positional).
             assignment.review_of_assignment_id,
             assignment.driven_by,
+            assignment.dispatched_by_assignment_id,
         ),
     )
     conn.commit()
@@ -1051,7 +1112,13 @@ def _record_dispatched_assignment_local(
         # to a human `coord assign` (the exact gap #1499 reported).
         actor="drive" if assignment.driven_by else "coordinator",
         summary=f"Dispatched {assignment.type} to {assignment.machine_name}: "
-        f"{assignment.repo_name}#{assignment.issue_number}",
+        f"{assignment.repo_name}#{assignment.issue_number}"
+        # #2417: see the matching Proposal-path comment above.
+        + (
+            f" (dispatched by assignment {assignment.dispatched_by_assignment_id})"
+            if assignment.dispatched_by_assignment_id
+            else ""
+        ),
         repo=assignment.repo_name,
         issue=assignment.issue_number,
         assignment_id=assignment.assignment_id,
@@ -1062,6 +1129,8 @@ def _record_dispatched_assignment_local(
             "review_target": assignment.review_target,
             "review_iteration": assignment.review_iteration,
             "driven_by": assignment.driven_by,
+            # #2417: see record_dispatched's matching comment.
+            "dispatched_by_assignment_id": assignment.dispatched_by_assignment_id,
         },
     )
 

{code_coordinator-0.5.161 → code_coordinator-0.5.164}/tests/test_drive.py

@@ -1304,18 +1304,112 @@ def test_failed_slice_test_stops_with_the_fix_command():
     assert "coord fix ta1" in action.message
 
 
-def test_slice_review_request_changes_stops_with_the_fix_command():
+def test_slice_review_request_changes_dispatches_a_fix():
+    """#2425: the JIT lane's own twin of the work row's `REVIEW:
+    request-changes → fix round` arm — before this, a request-changes
+    verdict on the slice was a dead end nothing ever dispatched a fix for
+    (claude-coordinator#2286: 11 re-authoring retries over ~11h, never once
+    addressing the review)."""
+    counters = DriveCounters()
+    action = landing_step(
+        landing_state(
+            acceptance_review_verdict="request-changes",
+            acceptance_merge_status="",
+        ),
+        counters=counters,
+    )
+    assert action.kind == RUN
+    assert action.command == ("fix", "rv1")
+    assert "rv1" in action.label
+    assert not action.is_exit
+    # Spends the SLICE's own budget, not the work row's (#2079's rule,
+    # extended to fix rounds): landing the slice must not silently leave
+    # the issue's own fix budget at zero.
+    assert counters.fix_rounds == 0
+    assert counters.acceptance is not None
+    assert counters.acceptance.fix_rounds == 1
+    assert counters.acceptance.review_fix_dispatched_for == "rv1"
+
+
+def test_slice_review_fix_already_dispatched_waits_for_the_board():
+    """The de-dup latch: a second poll against the SAME review id must not
+    spawn a second fix worker on the same branch (#476/#477)."""
+    counters = DriveCounters()
+    counters.slice_budget().review_fix_dispatched_for = "rv1"
     action = landing_step(
         landing_state(
             acceptance_review_verdict="request-changes",
             acceptance_merge_status="",
+        ),
+        counters=counters,
+    )
+    assert action.kind == WAIT
+    assert "rv1" in action.label
+    assert counters.acceptance.fix_rounds == 0
+
+
+def test_slice_review_fix_rounds_are_bounded_then_die():
+    """Bounded the same way the work row's fix loop is — a slice review that
+    keeps coming back request-changes must eventually escalate, not spin."""
+    opts = DriveOptions(machine="precision", max_fix_rounds=2)
+    counters = DriveCounters()
+    for expected_round in (1, 2):
+        action = landing_step(
+            landing_state(
+                acceptance_review_verdict="request-changes",
+                acceptance_merge_status="",
+            ),
+            opts,
+            counters=counters,
         )
+        assert action.kind == RUN
+        assert action.command == ("fix", "rv1")
+        assert counters.acceptance.fix_rounds == expected_round
+        # Clear the latch between rounds the same way a changed review row
+        # would on the real board (a fresh review after the fix landed).
+        counters.acceptance.review_fix_dispatched_for = ""
+
+    action = landing_step(
+        landing_state(
+            acceptance_review_verdict="request-changes",
+            acceptance_merge_status="",
+        ),
+        opts,
+        counters=counters,
     )
     assert action.is_exit
     assert action.exit_code == EXIT_TERMINAL_FAILURE
+    assert "2 fix round(s)" in action.message
     assert "coord fix rv1" in action.message
 
 
+def test_slice_review_request_changes_with_auto_loop_off_dies_without_dispatching():
+    action = landing_step(
+        landing_state(
+            acceptance_review_verdict="request-changes",
+            acceptance_merge_status="",
+            auto_loop=False,
+        )
+    )
+    assert action.is_exit
+    assert action.exit_code == EXIT_TERMINAL_FAILURE
+    assert "auto_loop is OFF" in action.message
+    assert "coord assign --interactive --fix-of rv1" in action.message
+
+
+def test_slice_review_request_changes_with_no_review_id_refuses_to_guess():
+    action = landing_step(
+        landing_state(
+            acceptance_review_verdict="request-changes",
+            acceptance_merge_status="",
+            acceptance_review_aid="",
+        )
+    )
+    assert action.is_exit
+    assert action.exit_code == EXIT_TERMINAL_FAILURE
+    assert "refusing to guess" in action.message
+
+
 def test_no_merge_refuses_up_front_instead_of_idling_to_the_deadline():
     """`--no-merge` makes the run unable to progress at all (#1138 refuses
     the work dispatch until the slice lands) — say so immediately."""