code-coordinator 0.5.203__tar.gz → 0.5.204__tar.gz

{code_coordinator-0.5.203 → code_coordinator-0.5.204}/PKG-INFO

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

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

@@ -1,7 +1,7 @@
 {
-  "tag": "0.5.203",
+  "tag": "0.5.204",
   "distance": 0,
-  "node": "gdac58130113c138d2461927553c0e5039233000e",
+  "node": "g471c14e8906b4f0ebf43a5b08365c101a0b02156",
   "dirty": false,
   "branch": "HEAD",
   "node_date": "2026-08-21"

{code_coordinator-0.5.203 → code_coordinator-0.5.204}/coord/merge_queue.py

@@ -4981,6 +4981,119 @@ def _maybe_clear_expected_red(entry: QueuedMerge, board, gh_ops: GhOps) -> Merge
     return MergeEvent(entry, event_type, msg)
 
 
+def _maybe_push_design_round(
+    entry: QueuedMerge, config, gh_ops: GhOps
+) -> "MergeEvent | None":
+    """PDR-3 (#2508): right after a `type="mock-author"` (Gate A) PR has
+    actually merged into ``entry.target_branch``, push its rendered mock
+    bundle + contract to the portal as a design round — the epic-#2506
+    bridge's third leg, wiring PDR-1's link (``coord portal link``,
+    #2507) and PDR-2's upload route (coord-portal#120) into the one signal
+    ``coord/merge_queue.py`` already fires for any assignment type: a real
+    merge.
+
+    Returns ``None`` for every "nothing to do" reason — not a `mock-author`
+    entry, no ``portal:`` block configured, the tracking issue isn't under
+    a milestone, or (the common case pre-#2508) the milestone has no portal
+    link on file. That last one is the fail-open posture
+    ``coord.portal_bridge``'s module docstring already states for the rest
+    of this bridge: "a portal outage must never block a merge or a
+    dispatch" applies just as much to "there's simply no portal submission
+    for this milestone yet" — until an operator runs ``coord portal link``,
+    this is silently, correctly, a no-op. Every other failure (can't fetch
+    the tracking issue, can't collect the bundle, upload/enqueue rejected)
+    degrades to a ``design_round_push_failed`` event rather than raising —
+    called from ``process()`` inside its own try/except, same discipline as
+    :func:`_maybe_clear_expected_red` right above it, but belt-and-braces
+    here too since this reaches out to two different externals (GitHub's
+    Contents API and the portal itself).
+    """
+    if entry.assignment_type != "mock-author":
+        return None
+    portal_cfg = getattr(config, "portal", None)
+    if portal_cfg is None or not portal_cfg.enabled:
+        return None
+
+    # #1467-style optional probe: `get_issue` isn't part of the GhOps
+    # Protocol proper (most stubs in tests never need it), so a stub that
+    # doesn't implement it degrades to "nothing to do" rather than an
+    # AttributeError — mirrors `branch_has_merge_commit`'s optional-probe
+    # pattern used for the rebase→squash fallback above.
+    get_issue = getattr(gh_ops, "get_issue", None)
+    if get_issue is None:
+        return None
+    try:
+        issue_data = get_issue(entry.repo_github, entry.issue_number)
+    except Exception as e:  # noqa: BLE001 — best-effort, see docstring
+        return MergeEvent(
+            entry, "design_round_push_failed",
+            f"could not fetch tracking issue #{entry.issue_number}: {e}",
+        )
+    milestone = (issue_data or {}).get("milestone") or {}
+    milestone_number = milestone.get("number")
+    if milestone_number is None:
+        # A "mock-author" entry not scoped to a milestone at all (shouldn't
+        # happen via `coord acceptance mock`, which always resolves one —
+        # but this hook must survive a hand-dispatched entry that skips it).
+        return None
+
+    from coord import portal_store  # noqa: PLC0415
+
+    link = portal_store.get_milestone_link(
+        repo_name=entry.repo_name, milestone_number=milestone_number
+    )
+    if link is None:
+        # PDR-1: no `coord portal link` recorded for this milestone yet —
+        # the whole point of the fail-open posture (see docstring above).
+        return None
+
+    from coord.mock_author import build_design_round, collect_mock_bundle_files  # noqa: PLC0415
+    from coord.portal_bridge import PortalBridgeError, client_from_config  # noqa: PLC0415
+    from coord.portal_sync import PortalSyncError, enqueue_design_round  # noqa: PLC0415
+
+    client = client_from_config(portal_cfg)
+    if client is None:
+        return None
+
+    try:
+        files = collect_mock_bundle_files(
+            entry.repo_github, milestone_number, entry.target_branch
+        )
+    except Exception as e:  # noqa: BLE001 — best-effort, see docstring
+        return MergeEvent(
+            entry, "design_round_push_failed",
+            f"could not collect mock bundle: {e}",
+        )
+    if not files:
+        return MergeEvent(
+            entry, "design_round_push_skipped",
+            f"no rendered mock bundle found on {entry.target_branch} for "
+            f"ms-{milestone_number} — nothing to push",
+        )
+
+    try:
+        bundle_key = client.upload_bundle(link.submission_id, files)
+    except PortalBridgeError as e:
+        return MergeEvent(entry, "design_round_push_failed", f"bundle upload failed: {e}")
+
+    design_round = build_design_round(
+        milestone_title=milestone.get("title") or f"ms-{milestone_number}",
+        tracking_issue_title=issue_data.get("title") or "",
+        tracking_issue_body=issue_data.get("body") or "",
+        bundle_key=bundle_key,
+    )
+    try:
+        row = enqueue_design_round(link.submission_id, design_round)
+    except PortalSyncError as e:
+        return MergeEvent(entry, "design_round_push_failed", f"enqueue failed: {e}")
+
+    return MergeEvent(
+        entry, "design_round_queued",
+        f"queued design round for portal submission {link.submission_id} "
+        f"(seq={row.seq}, bundle_key={bundle_key})",
+    )
+
+
 def process(
     items: list[QueuedMerge],
     gh_ops: GhOps,
@@ -6205,6 +6318,20 @@ def process(
                     clear_event = MergeEvent(entry, "expected_red_clear_failed", str(e))
                 if clear_event is not None:
                     events.append(clear_event)
+                # PDR-3 (#2508): a merged Gate-A (`type="mock-author"`)
+                # branch auto-pushes a design round to the portal, if (and
+                # only if) its milestone has a portal link on file. Best
+                # effort, same as the expected_red clear above — a portal
+                # outage, or simply no `coord portal link` recorded, must
+                # never undo a real merge.
+                try:
+                    design_round_event = _maybe_push_design_round(entry, config, gh_ops)
+                except Exception as e:  # noqa: BLE001 — bookkeeping, never undoes a real merge
+                    design_round_event = MergeEvent(
+                        entry, "design_round_push_failed", str(e)
+                    )
+                if design_round_event is not None:
+                    events.append(design_round_event)
                 continue
             entry.state = CONFLICT
             entry.error = msg

{code_coordinator-0.5.203 → code_coordinator-0.5.204}/coord/mock_author.py

@@ -25,10 +25,18 @@ TYPES``) and the matching exemption from the acceptance-dir auto-forbid in
 Work → Test → Review → Merge pipeline as any other branch (`required_gates`
 is the repo's normal `default_gates`) — Gate A produces a normal reviewed
 commit, not a special-cased one.
+
+**PDR-3 (#2508):** :func:`collect_mock_bundle_files` and
+:func:`build_design_round` are the other end of Gate A's output — read back
+off a merged mock-author branch and reshaped into a portal design round by
+``coord.merge_queue``'s post-merge hook, so a Gate-A merge auto-pushes a
+design round to any milestone with a portal link (`coord portal link`,
+PDR-1/#2507) instead of that link sitting unread.
 """
 from __future__ import annotations
 
 import uuid
+from typing import Any
 
 import httpx
 
@@ -332,3 +340,97 @@ def dispatch_acceptance_mock(
         pass
 
     return assignment_id, machine.name
+
+
+# ── PDR-3 (#2508): reading a merged Gate-A branch back into a design round ──
+
+
+def collect_mock_bundle_files(
+    repo_github: str, milestone_number: int, branch: str
+) -> dict[str, str]:
+    """Read a rendered Gate-A bundle off *branch* (post-merge) via the
+    GitHub Contents API — no local checkout, the same "gh-only wire layer"
+    posture the merge queue's other post-merge reads already use (see e.g.
+    ``coord.acceptance.clear_expected_red_via_pr``'s docstring).
+
+    Returns a ``{relative_path: content}`` mapping — ``"contract.md"`` plus
+    every ``mocks/*.html`` fixture under
+    ``tests/acceptance/ms-<milestone_number>/`` — ready to hand straight to
+    :meth:`coord.portal_bridge.PortalBridgeClient.upload_bundle`. Empty
+    when the directory doesn't exist on *branch* (Gate A hasn't merged
+    anything there yet, or the repo's acceptance driver renders to a
+    different mock glob than ``*.html``) — callers treat that as "nothing
+    to push", not an error.
+    """
+    ms_dir = f"tests/acceptance/{ms_dirname(milestone_number)}"
+    files: dict[str, str] = {}
+    if github_ops.repo_file_exists(repo_github, f"{ms_dir}/contract.md", branch):
+        files["contract.md"] = github_ops.get_repo_file(
+            repo_github, f"{ms_dir}/contract.md", branch
+        )
+    try:
+        mock_names = github_ops.list_repo_dir(repo_github, f"{ms_dir}/mocks", branch)
+    except RuntimeError:
+        # No `mocks/` dir on this branch at all — same "nothing to push"
+        # case list_repo_dir already returns [] for a missing path; the
+        # explicit catch is only for a `gh` error shaped differently.
+        mock_names = []
+    for name in mock_names:
+        if name.endswith(".html"):
+            files[f"mocks/{name}"] = github_ops.get_repo_file(
+                repo_github, f"{ms_dir}/mocks/{name}", branch
+            )
+    return files
+
+
+def build_design_round(
+    *,
+    milestone_title: str,
+    tracking_issue_title: str,
+    tracking_issue_body: str,
+    bundle_key: str,
+    round_number: int = 1,
+) -> dict[str, Any]:
+    """Build the D1 metadata half of a design round from the same inputs
+    `coord milestone chat`'s steward already reads: the tracking issue's
+    title/body (source of the plain-language ``outcome_definition``) and its
+    ``## Work order`` block (source of the ``decomposition``).
+
+    *bundle_key* is the R2 object key
+    :meth:`coord.portal_bridge.PortalBridgeClient.upload_bundle` returned
+    for this round's rendered mock bundle + contract — see that method's
+    docstring and :func:`coord.portal_sync.enqueue_design_round`'s for why
+    the bundle itself is never inlined into this payload.
+
+    A missing/malformed ``## Work order`` block degrades to an empty
+    ``decomposition`` rather than raising — a milestone that hasn't written
+    one yet (or has a stale one that fails validation) should still get a
+    design round pushed with whatever plain-language description its
+    tracking issue carries; the portal shows a design round with no listed
+    decomposition just fine.
+    """
+    from coord.milestone_order import WorkOrderError, parse_work_order  # noqa: PLC0415
+
+    try:
+        work_order = parse_work_order(tracking_issue_body)
+    except WorkOrderError:
+        work_order = None
+    decomposition = [
+        {
+            "issue_number": node.issue_number,
+            "group": node.group,
+            "after": list(node.after),
+        }
+        for node in (work_order.nodes if work_order is not None else ())
+    ]
+    outcome_definition = (
+        tracking_issue_body.strip()
+        or tracking_issue_title.strip()
+        or milestone_title
+    )
+    return {
+        "round": round_number,
+        "outcome_definition": outcome_definition,
+        "decomposition": decomposition,
+        "bundle_key": bundle_key,
+    }

{code_coordinator-0.5.203 → code_coordinator-0.5.204}/coord/portal_bridge.py

@@ -3,9 +3,12 @@
 **The gap this closes.** coord-portal has offered ``POST /api/bridge/push``
 since ms-1, and the entire ms-3 mail pipeline (``docs/CUSTOMER_PORTAL.md``) is
 live and waiting downstream of a queued outbox row — but nothing on this side
-has ever called it. This module is that client: a thin wrapper over the three
-bridge routes (``push``, ``pull``, ``heartbeat``), matching the wire contract
-coord-portal's ``src/bridge/*`` and ``src/routes/bridge.ts`` define.
+has ever called it. This module is that client: a thin wrapper over
+coord-portal's bridge routes (``push``, ``pull``, ``heartbeat``, and — as of
+PDR-3/#2508 — ``upload``), matching the wire contract coord-portal's
+``src/bridge/*`` and ``src/routes/bridge.ts`` define. ``upload`` is the one
+route that carries a bundle's raw content rather than D1 metadata — see
+:meth:`PortalBridgeClient.upload_bundle`.
 
 **What this module deliberately does NOT do**, per #2179's own framing —
 those are separate, harder design questions and belong to follow-up issues:
@@ -319,6 +322,45 @@ class PortalBridgeClient:
         except ValueError as exc:
             raise PortalBridgeError(f"GET /api/bridge/pull: non-JSON response: {exc}") from exc
 
+    def upload_bundle(self, submission_id: str, files: dict[str, str]) -> str:
+        """``POST /api/bridge/upload`` — store a design round's rendered
+        mock bundle + contract in the portal's R2 (coord-portal#120, PDR-2).
+
+        Deliberately a fourth route, not folded into :meth:`push`: the
+        three ``/api/bridge/*`` routes this module otherwise speaks
+        (``push``/``pull``/``heartbeat``) carry only D1 metadata —
+        :func:`coord.portal_sync.enqueue_design_round`'s own docstring
+        already says the mock bundle itself "is not uploaded here". This is
+        that upload, kept separate so a bundle (arbitrarily large HTML) is
+        never accidentally routed through :data:`MAX_PUSH_UPDATES`-bounded
+        ``push`` batching.
+
+        *files* maps a path relative to the bundle root — e.g.
+        ``"contract.md"``, ``"mocks/index.html"`` — to its text content; see
+        :func:`coord.mock_author.collect_mock_bundle_files`, which builds
+        exactly this mapping by reading a merged Gate-A branch back off
+        GitHub. Returns the R2 object key the portal assigns the bundle —
+        callers thread that straight into the ``design_round`` payload
+        :func:`coord.portal_sync.enqueue_design_round` queues, so the
+        customer's browser has something to fetch. Raises
+        :class:`PortalBridgeError` the same way every other method here
+        does: a transport failure, a 401, a 4xx/5xx, or a response with no
+        usable ``bundle_key``.
+        """
+        if not files:
+            raise PortalBridgeError("upload_bundle() got an empty files mapping")
+        data = self._post(
+            "/api/bridge/upload",
+            {"submission_id": submission_id, "files": files},
+        )
+        bundle_key = data.get("bundle_key")
+        if not isinstance(bundle_key, str) or not bundle_key:
+            raise PortalBridgeError(
+                f"POST /api/bridge/upload: response had no 'bundle_key' "
+                f"string: {data!r}"
+            )
+        return bundle_key
+
 
 def _utcnow_iso() -> str:
     return (

{code_coordinator-0.5.203 → code_coordinator-0.5.204}/coord/portal_sync.py

@@ -177,11 +177,16 @@ def enqueue_design_round(
 ) -> portal_store.OutboxRow:
     """Queue a design round (the D1 metadata half) for *submission_id*.
 
-    The mock bundle itself is an R2 object and is **not** uploaded here: the
-    portal's upload route is not part of the three bridge routes this side
-    speaks (:mod:`coord.portal_bridge`), so *design_round* is expected to
-    already carry whatever reference the customer's browser will follow. What
-    this function guarantees is the ordering — see :func:`enqueue_status`.
+    The mock bundle itself is an R2 object and is **not** uploaded here:
+    that goes through :meth:`coord.portal_bridge.PortalBridgeClient.
+    upload_bundle` (coord-portal#120, PDR-2) — a separate call from the
+    three ``push``/``pull``/``heartbeat`` D1-metadata routes this queue
+    drains — so *design_round* is expected to already carry whatever
+    reference (the returned bundle key) the customer's browser will follow.
+    The auto-push caller (:mod:`coord.merge_queue`'s post-merge hook,
+    PDR-3/#2508) uploads first and passes the resulting key through
+    :func:`coord.mock_author.build_design_round`. What this function
+    guarantees is the ordering — see :func:`enqueue_status`.
     """
     if not isinstance(design_round, dict) or not design_round:
         raise PortalSyncError("design_round payload must be a non-empty mapping")

{code_coordinator-0.5.203 → code_coordinator-0.5.204}/tests/test_merge_queue.py

@@ -1493,6 +1493,206 @@ class TestExpectedRedClearOnMerge:
         assert "coord acceptance expected-red api --clear --issue 1" in events[-1].message
 
 
+class _StubResponse:
+    """Minimal `httpx.Response` stand-in — mirrors `test_portal_bridge.py`'s
+    `_Response`, needed here too since `_maybe_push_design_round` (PDR-3,
+    #2508) drives a real `PortalBridgeClient` over `httpx.post`."""
+
+    def __init__(self, status_code=200, json_body=None, text="") -> None:
+        self.status_code = status_code
+        self._json_body = json_body
+        self.text = text or (str(json_body) if json_body is not None else "")
+
+    def json(self):
+        if self._json_body is None:
+            raise ValueError("no body")
+        return self._json_body
+
+
+@dataclass
+class _MockAuthorGh(FakeGh):
+    """FakeGh + `get_issue` — the one extra surface
+    `_maybe_push_design_round` (PDR-3, #2508) needs to resolve a
+    `type="mock-author"` entry's milestone. Not part of `GhOps` proper (see
+    `_maybe_push_design_round`'s optional-probe docstring), so every other
+    `FakeGh`-based test in this file is unaffected."""
+
+    issue_milestone_number: int | None = 9
+    issue_title: str = "Q3 push"
+    issue_body: str = "Ship the thing."
+
+    def get_issue(self, repo: str, issue_number: int) -> dict:
+        milestone = (
+            {"number": self.issue_milestone_number, "title": "Q3 push"}
+            if self.issue_milestone_number is not None
+            else None
+        )
+        return {"title": self.issue_title, "body": self.issue_body, "milestone": milestone}
+
+
+class TestDesignRoundPushOnMerge:
+    """PDR-3 (#2508): a merged `type="mock-author"` (Gate A) PR auto-pushes
+    a design round to the portal — but only for a milestone with a portal
+    link on file (`coord portal link`, PDR-1/#2507). No link, no portal
+    config, or a GhOps stub that can't even resolve the tracking issue all
+    degrade to a no-op, matching `coord.portal_bridge`'s fail-open posture
+    for the rest of this bridge ("a portal outage must never block a
+    merge")."""
+
+    @staticmethod
+    def _board(completed=None):
+        from coord.models import Board
+        return Board(active=[], completed=list(completed or []))
+
+    @staticmethod
+    def _config(*, portal_enabled: bool = True):
+        """A minimal config-like object carrying only what
+        `_maybe_push_design_round` and the ordinary merge-gate defaults
+        read — same "build the smallest _Cfg that satisfies the gate
+        reads" pattern `TestReviewGate._config` uses just above."""
+        from coord.config import PortalConfig
+
+        @dataclass
+        class _Cfg:
+            portal: PortalConfig = field(default_factory=PortalConfig)
+
+        cfg = _Cfg()
+        cfg.portal = PortalConfig(
+            enabled=portal_enabled,
+            base_url="https://intake.example.com",
+            bridge_client_id="id-123",
+            bridge_client_secret="secret-456",
+        )
+        return cfg
+
+    def _link(self, submission_id: str = "sub_1", milestone_number: int = 9) -> None:
+        from coord import portal_store
+        portal_store.link_milestone(
+            repo_name="api", milestone_number=milestone_number, submission_id=submission_id,
+        )
+
+    def test_no_op_when_portal_not_configured(self) -> None:
+        self._link()
+        events = process(
+            [_q("w1", size=10, assignment_type="mock-author")], _MockAuthorGh(),
+            config=None, board=self._board(),
+        )
+        assert not [e for e in events if e.kind.startswith("design_round")]
+
+    def test_no_op_when_portal_disabled(self) -> None:
+        self._link()
+        cfg = self._config(portal_enabled=False)
+        events = process(
+            [_q("w1", size=10, assignment_type="mock-author")], _MockAuthorGh(),
+            config=cfg, board=self._board(),
+        )
+        assert not [e for e in events if e.kind.startswith("design_round")]
+
+    def test_no_op_when_milestone_has_no_portal_link(self) -> None:
+        # No `_link()` call — milestone 9 is never linked.
+        cfg = self._config()
+        events = process(
+            [_q("w1", size=10, assignment_type="mock-author")], _MockAuthorGh(),
+            config=cfg, board=self._board(),
+        )
+        assert not [e for e in events if e.kind.startswith("design_round")]
+        assert events[-1].kind == "merged"  # the ordinary "left open" event still fires
+
+    def test_no_op_for_a_plain_work_entry(self) -> None:
+        """Only `type="mock-author"` triggers this hook — a normal `work`
+        merge must never attempt a portal push."""
+        self._link()
+        cfg = self._config()
+        events = process(
+            [_q("w1", size=10, assignment_type="work")], _MockAuthorGh(),
+            config=cfg, board=self._board(),
+        )
+        assert not [e for e in events if e.kind.startswith("design_round")]
+
+    def test_gh_ops_lacking_get_issue_degrades_to_a_noop(self) -> None:
+        """An ordinary `FakeGh` (no `get_issue`) must not crash — same
+        optional-probe convention `branch_has_merge_commit` already uses."""
+        self._link()
+        cfg = self._config()
+        events = process(
+            [_q("w1", size=10, assignment_type="mock-author")], FakeGh(),
+            config=cfg, board=self._board(),
+        )
+        assert not [e for e in events if e.kind.startswith("design_round")]
+
+    def test_pushes_a_design_round_when_linked(self, monkeypatch) -> None:
+        self._link(submission_id="sub_1", milestone_number=9)
+        cfg = self._config()
+
+        monkeypatch.setattr(
+            "coord.mock_author.collect_mock_bundle_files",
+            lambda repo_github, milestone_number, branch: {"contract.md": "# contract"},
+        )
+        seen_upload = {}
+
+        def _post(url, json=None, headers=None, timeout=None):
+            seen_upload["url"] = url
+            seen_upload["json"] = json
+            return _StubResponse(200, {"bundle_key": "bundles/sub_1/r1.tar"})
+
+        monkeypatch.setattr("httpx.post", _post)
+
+        events = process(
+            [_q("w1", size=10, assignment_type="mock-author")], _MockAuthorGh(),
+            config=cfg, board=self._board(),
+        )
+
+        assert events[-1].kind == "design_round_queued"
+        assert "sub_1" in events[-1].message
+        assert seen_upload["url"] == "https://intake.example.com/api/bridge/upload"
+        assert seen_upload["json"]["submission_id"] == "sub_1"
+        assert seen_upload["json"]["files"] == {"contract.md": "# contract"}
+
+        from coord import portal_store
+        rows = portal_store.outbox_for_submission("sub_1")
+        assert len(rows) == 1
+        assert rows[0].kind == "design_round"
+        assert rows[0].fields["design_round"]["bundle_key"] == "bundles/sub_1/r1.tar"
+        assert "Ship the thing." in rows[0].fields["design_round"]["outcome_definition"]
+
+    def test_no_bundle_files_yields_a_skip_event(self, monkeypatch) -> None:
+        self._link()
+        cfg = self._config()
+        monkeypatch.setattr(
+            "coord.mock_author.collect_mock_bundle_files",
+            lambda repo_github, milestone_number, branch: {},
+        )
+
+        events = process(
+            [_q("w1", size=10, assignment_type="mock-author")], _MockAuthorGh(),
+            config=cfg, board=self._board(),
+        )
+
+        assert events[-1].kind == "design_round_push_skipped"
+
+    def test_upload_failure_degrades_to_a_failed_event_not_an_exception(
+        self, monkeypatch,
+    ) -> None:
+        self._link()
+        cfg = self._config()
+        monkeypatch.setattr(
+            "coord.mock_author.collect_mock_bundle_files",
+            lambda repo_github, milestone_number, branch: {"contract.md": "# contract"},
+        )
+        monkeypatch.setattr(
+            "httpx.post", lambda *a, **k: _StubResponse(401, {}, text="unauthorized"),
+        )
+
+        events = process(
+            [_q("w1", size=10, assignment_type="mock-author")], _MockAuthorGh(),
+            config=cfg, board=self._board(),
+        )
+
+        assert events[-1].kind == "design_round_push_failed"
+        # The merge itself still went through — this hook never undoes it.
+        assert any(e.kind == "merged" for e in events)
+
+
 class _TestAuthorGateGh(FakeGh):
     """#2191: FakeGh + the API-only manifest/issue-state surface
     `coord.acceptance.missing_expected_red_warning` needs. Defaults to a