code-coordinator 0.5.106__tar.gz → 0.5.107__tar.gz

{code_coordinator-0.5.106 → code_coordinator-0.5.107}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: code-coordinator
-Version: 0.5.106
+Version: 0.5.107
 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.106 → code_coordinator-0.5.107}/code_coordinator.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: code-coordinator
-Version: 0.5.106
+Version: 0.5.107
 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.106 → code_coordinator-0.5.107}/code_coordinator.egg-info/scm_version.json

@@ -1,7 +1,7 @@
 {
-  "tag": "0.5.106",
+  "tag": "0.5.107",
   "distance": 0,
-  "node": "g254718dc492ab30f9a86d7fce65cb4a2156430b5",
+  "node": "gd8477c280ee82a9279e982ed0b3aea53dc089761",
   "dirty": false,
   "branch": "HEAD",
   "node_date": "2026-08-16"

{code_coordinator-0.5.106 → code_coordinator-0.5.107}/coord/auto_loop.py

@@ -43,7 +43,7 @@ import httpx
 from coord.config import Config
 from coord.dispatch import AGENT_PORT
 from coord import github_ops
-from coord.models import Assignment, Board
+from coord.models import SEALED_PATH_AUTHOR_TYPES, Assignment, Board
 from coord.review import (
     ReviewFindings,
     blocking_findings_confirmed_absent,
@@ -64,7 +64,16 @@ log = logging.getLogger(__name__)
 # ``coord.notify``'s fix-completion detector doesn't hardcode ``"work"`` and
 # silently miss a newer fix-dispatch type — the same class of bug as #1141
 # ("test-author was never added to WORK_LIKE_TYPES").
-FIX_DISPATCH_TYPES: frozenset[str] = frozenset({"work", "test-author"})
+#
+# #2302: "mock-author" (Gate A) is the same class of bug repeating — a
+# request-changes fix for a mock-author row dispatched as plain "work",
+# which trips coord/review.py's sealed-path tamper rule on every round
+# (the fix worker isn't authorized to write tests/acceptance/ms-NN/, but
+# that's exactly where the diff has to land) until max_review_iterations
+# burns out. `_dispatch_fix` derives `fix_type` from
+# ``coord.models.SEALED_PATH_AUTHOR_TYPES`` rather than a hardcoded string
+# so this set — and this one — never drift from it again.
+FIX_DISPATCH_TYPES: frozenset[str] = frozenset({"work"}) | SEALED_PATH_AUTHOR_TYPES
 
 
 # Every :class:`LoopAction` kind whose production means the in-memory board was
@@ -816,9 +825,16 @@ def _build_fix_briefing(
     instructions instead — "make the acceptance suite pass" is actively
     wrong guidance for an oracle that must stay RED until the real
     implementation lands.
+
+    #2302: a ``type="mock-author"`` source row (Gate A) gets its own
+    variant for the same reason one level up the pipeline — the diff is a
+    specification (``contract.md`` + rendered mocks), not an
+    implementation, so "run tests, make them pass" is equally wrong there.
     """
     if work.type == "test-author":
         return _build_test_author_fix_briefing(work, findings, iteration, max_iter)
+    if work.type == "mock-author":
+        return _build_mock_author_fix_briefing(work, findings, iteration, max_iter)
 
     lines: list[str] = [
         f"# Fix assignment (iteration {iteration}/{max_iter}): {work.issue_title}",
@@ -929,6 +945,93 @@ def _build_test_author_fix_briefing(
     return "\n".join(lines)
 
 
+def _build_mock_author_fix_briefing(
+    work: Assignment,
+    findings,
+    iteration: int,
+    max_iter: int,
+) -> str:
+    """Fix briefing for a ``type="mock-author"`` slice (#2302, Gate A).
+
+    The diff here is a SPECIFICATION — ``contract.md`` plus rendered
+    ``tests/acceptance/ms-NN/mocks/*`` — not an implementation. There is no
+    suite to run, so "run the tests and make them pass" (the generic fix
+    instruction) is actively wrong guidance, the same shape #1176 already
+    fixed for ``test-author``. Findings on a Gate A review are almost
+    always an internal-consistency defect: a mock depicting an end state
+    that the contract's own stated rules cannot produce from the narrated
+    input sequence — so the contract and the mocks must be reconciled to
+    agree with each other in BOTH directions, not just patched locally.
+    The dispatcher pairs this briefing with a bare ``type="mock-author"``
+    dispatch (see ``_dispatch_fix``) — ``agent.py``'s own
+    ``elif spec.type == "mock-author"`` branch supplies
+    ``MOCK_AUTHOR_SYSTEM_PROMPT`` and its deny-list on its own, so no
+    explicit ``system_prompt``/``deny_commands`` injection is needed here
+    the way ``test-author`` (which has no such branch) requires.
+    """
+    lines: list[str] = [
+        f"# Gate A fix (iteration {iteration}/{max_iter}): {work.issue_title}",
+        "",
+        (
+            f"You are the independent mock-author fixing review findings "
+            f"against the Gate A contract and mocks for issue "
+            f"#{work.issue_number}."
+        ),
+        (
+            f"Work on branch `{work.branch or '(check your git branches)'}` — "
+            "**do not change the branch name**."
+        ),
+        "",
+        "## Reviewer findings to address",
+        "",
+        findings.body.strip(),
+        "",
+        "## Instructions",
+        "",
+        (
+            "1. Read the reviewer findings above carefully. Your diff is a "
+            "SPECIFICATION (`contract.md` + rendered `mocks/*`), not an "
+            "implementation — there is no suite to run and nothing to make "
+            "pass. Findings on a Gate A review are almost always an "
+            "internal-consistency defect: a mock depicting an end state "
+            "that the contract's own stated rules cannot produce from the "
+            "narrated input sequence."
+        ),
+        (
+            "2. Fix **every** issue identified by the reviewer so the "
+            "contract and the mocks agree with each other in BOTH "
+            "directions — every rule the contract states must be reachable "
+            "from the mocks' narrated sequence, and every state the mocks "
+            "depict must be producible by the contract's stated rules."
+        ),
+        "3. Stay on the **same branch** — push your fixes to the existing branch.",
+        (
+            "4. Do NOT touch any file outside `tests/acceptance/ms-NN/`. "
+            "Touching anything outside that directory is a mandatory "
+            "`request-changes` for this assignment type — you are pinning "
+            "the milestone's contract, not implementing it."
+        ),
+        (
+            f"5. This is fix iteration {iteration} of {max_iter} allowed. "
+            "Address all findings completely so the next review can approve."
+        ),
+        "",
+        (
+            "STATUS: reading review findings → reconciling contract and mocks "
+            "→ confidence: high"
+        ),
+        "",
+    ]
+    if work.briefing and work.briefing.strip():
+        lines += [
+            "## Original mock-author briefing",
+            "",
+            work.briefing.strip(),
+            "",
+        ]
+    return "\n".join(lines)
+
+
 def _dispatch_fix(
     work: Assignment,
     briefing: str,
@@ -945,11 +1048,18 @@ def _dispatch_fix(
     Prefers the same machine as the original worker (the branch is already
     checked out there).  Falls back to any capable machine.
 
-    #1176: the dispatched type mirrors ``work.type`` for ``"test-author"``
-    (with ``TEST_AUTHOR_SYSTEM_PROMPT`` + its deny-list, since the fix needs
-    the same acceptance-path authorization and independence rules as the
-    original test-author dispatch); every other source type still gets the
-    long-standing plain ``"work"`` fix.
+    #1176/#2302: the dispatched type mirrors ``work.type`` for any
+    :data:`coord.models.SEALED_PATH_AUTHOR_TYPES` member (``"test-author"``,
+    ``"mock-author"``) — those types are the ones ``coord/review.py``
+    inverts its sealed-path tamper rule for, so a fix that needs to write
+    back into ``tests/acceptance/ms-NN/`` must carry the same type as the
+    row it's fixing or every round trips "TAMPER DETECTED" until the
+    iteration cap burns out. ``test-author`` additionally needs
+    ``TEST_AUTHOR_SYSTEM_PROMPT`` + its deny-list injected explicitly since
+    ``agent.py`` has no dispatch-table branch for it; ``mock-author``
+    doesn't — ``agent.py``'s own ``elif spec.type == "mock-author"`` branch
+    supplies its system prompt and deny-list unconditionally. Every other
+    source type still gets the long-standing plain ``"work"`` fix.
 
     Returns the new Assignment (already added to ``board.active``), or None
     on failure.
@@ -1016,12 +1126,16 @@ def _dispatch_fix(
     if repo is None:
         return None
 
-    # #1176: preserve the source row's type for a test-author slice fix —
-    # dispatching `type="work"` sends a plain worker that is forbidden from
-    # (and never given the system prompt authorizing) exactly the
-    # `tests/acceptance/**` path it needs to fix. Every other source type
-    # (including today's "work") keeps the long-standing "work" fix.
-    fix_type = "test-author" if work.type == "test-author" else "work"
+    # #1176/#2302: preserve the source row's type for a sealed-path-author
+    # slice fix (test-author, mock-author) — dispatching `type="work"`
+    # sends a plain worker that is forbidden from (and never given the
+    # system prompt authorizing) exactly the `tests/acceptance/**` path it
+    # needs to fix. Derived from SEALED_PATH_AUTHOR_TYPES rather than a
+    # hardcoded string so this stays in sync with that set — see the
+    # FIX_DISPATCH_TYPES comment above for the class of bug that guards
+    # against. Every other source type (including today's "work") keeps
+    # the long-standing "work" fix.
+    fix_type = work.type if work.type in SEALED_PATH_AUTHOR_TYPES else "work"
 
     payload = {
         "repo_name": work.repo_name,
@@ -1054,6 +1168,12 @@ def _dispatch_fix(
         # stay-RED rules a test-author session needs.
         payload["system_prompt"] = TEST_AUTHOR_SYSTEM_PROMPT
         payload["deny_commands"] = test_author_deny_commands(config, work.repo_name)
+    # #2302: no analogous branch for `fix_type == "mock-author"` — unlike
+    # test-author, `agent.py`'s `elif spec.type == "mock-author"` branch
+    # already supplies `MOCK_AUTHOR_SYSTEM_PROMPT` and unconditionally
+    # appends `MOCK_AUTHOR_DENY_COMMANDS` regardless of `spec.deny_commands`,
+    # so injecting either here would be redundant with what the agent-side
+    # dispatch table already does purely from `type="mock-author"`.
     # Escalated model per bounce iteration (None when pipeline
     # .escalate_fix_model is disabled — preserves today's no-model behaviour).
     # The board record keeps the alias for legibility; the wire payload is

{code_coordinator-0.5.106 → code_coordinator-0.5.107}/coord/notify.py

@@ -1053,7 +1053,13 @@ def dispatch_stalled_pipeline_action(
 
     Gated by ``config.pipeline.auto_dispatch_stalled`` (default ``False`` —
     detection/narration via :func:`post_stalled_pipeline` is unconditional;
-    this is the opt-in action half). Mutates *board* in place exactly like
+    this is the opt-in action half) — EXCEPT for a ``review_request_changes_
+    no_fix`` stall on a :data:`coord.models.SEALED_PATH_AUTHOR_TYPES` row
+    (``test-author``/``mock-author``), which dispatches regardless of the
+    flag: no loop owns that row (#2302), so the flag would only leave it
+    stalled forever with no alternative dispatcher to race. ``work`` rows
+    under the same reason keep the opt-in gate — ``coord drive`` owns those.
+    Mutates *board* in place exactly like
     the auto-loop / review-dispatch helpers it delegates to — the caller is
     responsible for persisting it.
 
@@ -1096,7 +1102,23 @@ def dispatch_stalled_pipeline_action(
     mirroring the one-shot comment (#1441's own guardrail, reused rather
     than re-derived per #1478's own request).
     """
-    if not config.pipeline.auto_dispatch_stalled:
+    # #2302: `pipeline.auto_dispatch_stalled` exists to bound blast radius on
+    # rows another loop already owns (`coord drive`'s request-changes → fix
+    # arm for `work` rows, #1692) — a second dispatcher racing that loop
+    # would duplicate or clobber its fix. A `request-changes` stall on a
+    # SEALED_PATH_AUTHOR_TYPES row (`test-author`/`mock-author`, Gate A/JIT
+    # acceptance slices) has no such owner: `coord drive` explicitly `_die()`s
+    # on those, and `coord acceptance mock` dispatches Gate A standalone with
+    # no drive run over it at all (see #2289). So this one reason+type
+    # combination bypasses the flag — every other reason, and `work` rows
+    # under this same reason, keep the opt-in gate unchanged.
+    from coord.models import SEALED_PATH_AUTHOR_TYPES  # noqa: PLC0415
+
+    sealed_author_stall = (
+        detection.reason == "review_request_changes_no_fix"
+        and work.type in SEALED_PATH_AUTHOR_TYPES
+    )
+    if not config.pipeline.auto_dispatch_stalled and not sealed_author_stall:
         return StalledDispatchAction(
             kind="disabled", detail="pipeline.auto_dispatch_stalled is False",
         )

{code_coordinator-0.5.106 → code_coordinator-0.5.107}/tests/test_auto_loop.py

@@ -958,6 +958,61 @@ class TestBuildFixBriefingTestAuthor:
         assert "ensure all tests pass" in briefing.lower()
 
 
+class TestBuildFixBriefingMockAuthor:
+    """#2302: a type="mock-author" source row (Gate A) gets its own
+    fix-briefing variant instead of the generic "implement + make tests
+    pass" briefing — the diff is a specification (contract.md + rendered
+    mocks), there is no suite to run, and the diff must stay confined to
+    tests/acceptance/ms-NN/."""
+
+    def test_contains_reviewer_findings(self) -> None:
+        work = _work_assignment(type="mock-author")
+        findings = _request_changes_findings()
+        briefing = _build_fix_briefing(work, findings, iteration=1, max_iter=3)
+        assert "Missing test coverage for edge case X" in briefing
+
+    def test_does_not_instruct_making_tests_pass(self) -> None:
+        """The generic fix briefing's "ensure all tests pass" is wrong
+        guidance for a specification diff with no suite behind it — must
+        not leak into the mock-author variant."""
+        work = _work_assignment(type="mock-author")
+        findings = _request_changes_findings()
+        briefing = _build_fix_briefing(work, findings, iteration=1, max_iter=3)
+        assert "ensure all tests pass" not in briefing.lower()
+        assert "make them pass" not in briefing.lower()
+
+    def test_instructs_confining_diff_to_acceptance_dir(self) -> None:
+        work = _work_assignment(type="mock-author")
+        findings = _request_changes_findings()
+        briefing = _build_fix_briefing(work, findings, iteration=1, max_iter=3)
+        assert "tests/acceptance/ms-nn" in briefing.lower()
+        assert "request-changes" in briefing.lower()
+
+    def test_instructs_contract_and_mocks_agree_both_ways(self) -> None:
+        work = _work_assignment(type="mock-author")
+        findings = _request_changes_findings()
+        briefing = _build_fix_briefing(work, findings, iteration=1, max_iter=3)
+        assert "both directions" in briefing.lower()
+
+    def test_contains_branch_name(self) -> None:
+        work = _work_assignment(type="mock-author", branch="ms-65-gate-a")
+        findings = _request_changes_findings()
+        briefing = _build_fix_briefing(work, findings, iteration=1, max_iter=3)
+        assert "ms-65-gate-a" in briefing
+
+    def test_contains_do_not_change_branch_instruction(self) -> None:
+        work = _work_assignment(type="mock-author")
+        findings = _request_changes_findings()
+        briefing = _build_fix_briefing(work, findings, iteration=1, max_iter=3)
+        assert "do not change the branch name" in briefing.lower()
+
+    def test_contains_original_briefing(self) -> None:
+        work = _work_assignment(type="mock-author")
+        findings = _request_changes_findings()
+        briefing = _build_fix_briefing(work, findings, iteration=1, max_iter=3)
+        assert "Original briefing text." in briefing
+
+
 # ── Unit tests: _fix_model_for_iteration ─────────────────────────────────────
 
 
@@ -2424,6 +2479,87 @@ class TestDispatchFixTestAuthorType:
         assert "deny_commands" not in payload
 
 
+# ── #2302: mock-author bounce gets a type="mock-author" fix, not "work" ─────
+
+
+class TestDispatchFixMockAuthorType:
+    """A review bounce of a type="mock-author" (Gate A) row must dispatch a
+    type="mock-author" fix, not a plain type="work" fix — `coord/review.py`
+    only inverts the sealed-path tamper rule for
+    `coord.models.SEALED_PATH_AUTHOR_TYPES`, so a "work"-typed fix confined
+    to `tests/acceptance/ms-NN/**` trips "TAMPER DETECTED" on every round."""
+
+    def _dispatch(
+        self, config: Config, *, work_type: str, for_issue_number: int | None = None
+    ) -> tuple[dict, Assignment]:
+        work = _work_assignment(
+            assignment_id="ma-work-1",
+            branch="ms-65-gate-a",
+            type=work_type,
+            for_issue_number=for_issue_number,
+        )
+        board = Board(completed=[work])
+        mock_http = MagicMock()
+        mock_http.post.return_value.json.return_value = {"id": "fix-ma-1"}
+        mock_http.post.return_value.raise_for_status = MagicMock()
+
+        with patch("coord.auto_loop.record_dispatched_assignment"):
+            result = _dispatch_fix(
+                work, "Fix briefing.", board, config, iteration=1,
+                http_client=mock_http,
+            )
+
+        assert result is not None
+        sent_payload = mock_http.post.call_args.kwargs["json"]
+        return sent_payload, result
+
+    def test_payload_type_is_mock_author(self, config: Config) -> None:
+        payload, _ = self._dispatch(config, work_type="mock-author")
+        assert payload["type"] == "mock-author"
+
+    def test_assignment_type_is_mock_author(self, config: Config) -> None:
+        _, fix = self._dispatch(config, work_type="mock-author")
+        assert fix.type == "mock-author"
+
+    def test_files_forbidden_does_not_block_acceptance_path(
+        self, config: Config
+    ) -> None:
+        """The source mock-author row carries files_forbidden=[] — confirm
+        the fix dispatch doesn't add tests/acceptance/ to it."""
+        payload, _ = self._dispatch(config, work_type="mock-author")
+        assert not any(
+            "tests/acceptance" in f for f in payload["files_forbidden"]
+        )
+
+    def test_for_issue_number_carried_over(self, config: Config) -> None:
+        _, fix = self._dispatch(config, work_type="mock-author", for_issue_number=65)
+        assert fix.for_issue_number == 65
+
+    def test_work_type_bounce_is_unchanged(self, config: Config) -> None:
+        """Regression guard: a type="work" bounce still gets a plain "work"
+        fix — untouched by the mock-author addition."""
+        payload, fix = self._dispatch(config, work_type="work")
+        assert payload["type"] == "work"
+        assert fix.type == "work"
+
+
+class TestFixDispatchTypesIncludesMockAuthor:
+    """#2302: FIX_DISPATCH_TYPES must include every type `_dispatch_fix` can
+    actually emit — this is the same drift class as #1141
+    ("test-author was never added to WORK_LIKE_TYPES")."""
+
+    def test_mock_author_is_a_member(self) -> None:
+        from coord.auto_loop import FIX_DISPATCH_TYPES
+
+        assert "mock-author" in FIX_DISPATCH_TYPES
+
+    def test_all_sealed_path_author_types_are_members(self) -> None:
+        from coord.auto_loop import FIX_DISPATCH_TYPES
+        from coord.models import SEALED_PATH_AUTHOR_TYPES
+
+        assert SEALED_PATH_AUTHOR_TYPES <= FIX_DISPATCH_TYPES
+
+
 class TestProcessReviewCompletionTestAuthorType:
     """End-to-end: a `coord bounce` (via process_review_completion) of a
     request-changes review on a type="test-author" work row dispatches a
@@ -2468,3 +2604,51 @@ class TestProcessReviewCompletionTestAuthorType:
         assert "Dead monkeypatch.setattr" in sent_payload["briefing"]
         assert "Fragile assertion" in sent_payload["briefing"]
         assert "ensure all tests pass" not in sent_payload["briefing"].lower()
+
+
+class TestProcessReviewCompletionMockAuthorType:
+    """End-to-end: a `coord bounce` (via process_review_completion) of a
+    request-changes review on a type="mock-author" (Gate A) work row
+    dispatches a type="mock-author" fix carrying the reviewer's findings —
+    the #2289 shape this issue exists to fix."""
+
+    def test_full_cycle_dispatches_mock_author_fix(
+        self, config: Config, tmp_path
+    ) -> None:
+        log_file = tmp_path / "review.log"
+        log_file.write_text(
+            "REVIEW_VERDICT: request-changes\n"
+            "REVIEW_BODY:\n"
+            "- Mock depicts a state the contract's own rules can't reach\n"
+            "- Contract names a field the mocks never render\n"
+            "END_REVIEW\n"
+        )
+        work = _work_assignment(
+            assignment_id="ma-work-2",
+            branch="ms-65-gate-a",
+            type="mock-author",
+        )
+        review = _review_assignment(assignment_id="ma-review-2", review_of="ma-work-2")
+        board = _board_with(work, review)
+
+        mock_http = MagicMock()
+        mock_http.post.return_value.json.return_value = {"id": "fix-ma-2"}
+        mock_http.post.return_value.raise_for_status = MagicMock()
+
+        with patch("coord.auto_loop.record_dispatched_assignment"):
+            actions = process_review_completion(
+                review, board, config,
+                log_path=str(log_file),
+                http_client=mock_http,
+            )
+
+        assert any(a.kind == "fix_dispatched" for a in actions)
+        sent_payload = mock_http.post.call_args.kwargs["json"]
+        fix = board.active[0]
+
+        assert sent_payload["type"] == "mock-author"
+        assert fix.type == "mock-author"
+        assert "Mock depicts a state" in sent_payload["briefing"]
+        assert "Contract names a field" in sent_payload["briefing"]
+        assert "ensure all tests pass" not in sent_payload["briefing"].lower()
+        assert "make them pass" not in sent_payload["briefing"].lower()

{code_coordinator-0.5.106 → code_coordinator-0.5.107}/tests/test_stalled_pipeline.py

@@ -16,6 +16,7 @@ dispatch/kill/handoff, idempotent via the shared `notified` ledger.
 
 from __future__ import annotations
 
+from dataclasses import replace
 from unittest.mock import MagicMock, patch
 
 import pytest
@@ -149,6 +150,14 @@ def _board(*assignments: Assignment) -> Board:
     return Board(active=active, completed=completed)
 
 
+def _mock_author_work(aid: str = "ma-work-1", **kwargs) -> Assignment:
+    """#2302: a `type="mock-author"` (Gate A) head row — same shape as
+    `_work()` but typed as a SEALED_PATH_AUTHOR_TYPES member so the
+    `dispatch_stalled_pipeline_action` flag-bypass tests below can build a
+    board around one without duplicating `_work`'s field list."""
+    return replace(_work(aid, **kwargs), type="mock-author", branch="ms-65-gate-a")
+
+
 # ── Reference fixture: vimcode #602 ──────────────────────────────────────────
 
 
@@ -1416,6 +1425,159 @@ class TestDispatchPerReason:
         stub.assert_called_once()
 
 
+# ── #2302: sealed-author rows bypass the auto_dispatch_stalled flag ─────────
+#
+# `pipeline.auto_dispatch_stalled` bounds blast radius on rows another loop
+# already owns (`coord drive`'s request-changes -> fix arm for `work` rows,
+# #1692). A `test-author`/`mock-author` row has no such owner — `coord
+# drive` explicitly `_die()`s on those and Gate A is dispatched standalone
+# with no drive run over it at all (#2289) — so THIS one reason+type
+# combination must dispatch regardless of the flag. `work` rows under the
+# same reason keep the opt-in gate unchanged.
+
+
+class TestDispatchSealedAuthorBypassesFlag:
+    def test_mock_author_stall_dispatches_with_flag_off(
+        self, config: Config, monkeypatch
+    ) -> None:
+        assert config.pipeline.auto_dispatch_stalled is False
+        board = _board(
+            _mock_author_work("ma-work-1", test_state="passed"),
+            _review("ma-work-1", aid="ma-review-1", review_verdict="request-changes"),
+        )
+        detection, work = notify_mod.detect_stalled_pipeline(
+            config, board=board, merge_queue_items=[]
+        )[0]
+        assert detection.reason == "review_request_changes_no_fix"
+        assert work.type == "mock-author"
+
+        stub = MagicMock(return_value=[
+            LoopAction(
+                kind="fix_dispatched", assignment_id="ma-review-1",
+                detail="fix worker fix-9 dispatched to mac-mini (iteration 1/5)",
+            ),
+        ])
+        monkeypatch.setattr("coord.auto_loop.process_review_completion", stub)
+
+        action = notify_mod.dispatch_stalled_pipeline_action(detection, work, board, config)
+
+        assert action.kind == "fix_dispatch_attempted"
+        stub.assert_called_once()
+
+    def test_test_author_stall_dispatches_with_flag_off(
+        self, config: Config, monkeypatch
+    ) -> None:
+        """The scope is BOTH sealed-author types — test-author has the
+        identical hole (`coord/drive.py` `_die()`s on it too)."""
+        assert config.pipeline.auto_dispatch_stalled is False
+        board = _board(
+            replace(_mock_author_work("ta-work-1", test_state="passed"), type="test-author"),
+            _review("ta-work-1", aid="ta-review-1", review_verdict="request-changes"),
+        )
+        detection, work = notify_mod.detect_stalled_pipeline(
+            config, board=board, merge_queue_items=[]
+        )[0]
+        assert detection.reason == "review_request_changes_no_fix"
+        assert work.type == "test-author"
+
+        stub = MagicMock(return_value=[
+            LoopAction(
+                kind="fix_dispatched", assignment_id="ta-review-1",
+                detail="fix worker fix-9 dispatched to mac-mini (iteration 1/5)",
+            ),
+        ])
+        monkeypatch.setattr("coord.auto_loop.process_review_completion", stub)
+
+        action = notify_mod.dispatch_stalled_pipeline_action(detection, work, board, config)
+
+        assert action.kind == "fix_dispatch_attempted"
+        stub.assert_called_once()
+
+    def test_work_stall_still_disabled_with_flag_off(
+        self, config: Config, monkeypatch
+    ) -> None:
+        """Regression guard: a plain `work` row under the identical reason
+        stays gated behind the flag — `coord drive` owns that row and a
+        second dispatcher racing it would duplicate/clobber its fix."""
+        assert config.pipeline.auto_dispatch_stalled is False
+        board = _board(
+            _work("work-1", test_state="passed"),
+            _review("work-1", aid="review-1", review_verdict="request-changes"),
+        )
+        detection, work = notify_mod.detect_stalled_pipeline(
+            config, board=board, merge_queue_items=[]
+        )[0]
+        assert detection.reason == "review_request_changes_no_fix"
+        assert work.type == "work"
+
+        stub = MagicMock()
+        monkeypatch.setattr("coord.auto_loop.process_review_completion", stub)
+
+        action = notify_mod.dispatch_stalled_pipeline_action(detection, work, board, config)
+
+        assert action.kind == "disabled"
+        stub.assert_not_called()
+
+    def test_mock_author_stall_still_respects_live_session_guard(
+        self, config: Config, monkeypatch
+    ) -> None:
+        """The flag bypass must not skip the #602 live-session guard — an
+        interactive session on the same (repo, issue) still wins."""
+        assert config.pipeline.auto_dispatch_stalled is False
+        work = _mock_author_work("ma-work-2", test_state="passed")
+        review = _review("ma-work-2", aid="ma-review-2", review_verdict="request-changes")
+        live_session = Assignment(
+            machine_name="mac-mini", repo_name="vimcode", issue_number=602,
+            issue_title="interactive smoke", assignment_id="smoke-live",
+            status="running", type="smoke",
+        )
+        board = Board(active=[live_session], completed=[work, review])
+
+        detection, work_row = notify_mod.detect_stalled_pipeline(
+            config, board=board, merge_queue_items=[]
+        )[0]
+        assert detection.reason == "review_request_changes_no_fix"
+
+        stub = MagicMock()
+        monkeypatch.setattr("coord.auto_loop.process_review_completion", stub)
+
+        action = notify_mod.dispatch_stalled_pipeline_action(
+            detection, work_row, board, config
+        )
+
+        assert action.kind == "skipped_live_session"
+        stub.assert_not_called()
+
+    def test_mock_author_stall_still_respects_iteration_cap(
+        self, config: Config, monkeypatch
+    ) -> None:
+        """The flag bypass must not skip `process_review_completion`'s own
+        `max_review_iterations` cap — a `max_iterations` resolution stays
+        `no_action`, not a dispatch."""
+        assert config.pipeline.auto_dispatch_stalled is False
+        board = _board(
+            _mock_author_work("ma-work-3", test_state="passed"),
+            _review("ma-work-3", aid="ma-review-3", review_verdict="request-changes"),
+        )
+        detection, work = notify_mod.detect_stalled_pipeline(
+            config, board=board, merge_queue_items=[]
+        )[0]
+
+        stub = MagicMock(return_value=[
+            LoopAction(
+                kind="max_iterations", assignment_id="ma-review-3",
+                detail="max_review_iterations=5 reached",
+            ),
+        ])
+        monkeypatch.setattr("coord.auto_loop.process_review_completion", stub)
+
+        action = notify_mod.dispatch_stalled_pipeline_action(detection, work, board, config)
+
+        assert action.kind == "no_action"
+        assert action.kind not in notify_mod._STALLED_DISPATCH_KINDS
+        stub.assert_called_once()
+
+
 class TestLiveSessionGuard:
     def test_dispatch_skipped_when_live_session_active(
         self, config: Config, monkeypatch