code-coordinator 0.5.309__tar.gz → 0.5.310__tar.gz

{code_coordinator-0.5.309 → code_coordinator-0.5.310}/PKG-INFO

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

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

@@ -1,7 +1,7 @@
 {
-  "tag": "0.5.309",
+  "tag": "0.5.310",
   "distance": 0,
-  "node": "g64b7ec99fe4514edb4d20e26f811aca2f270a47b",
+  "node": "ga706a8d9e5cc804e73c38968328d2a67cd807eca",
   "dirty": false,
   "branch": "HEAD",
   "node_date": "2026-08-30"

{code_coordinator-0.5.309 → code_coordinator-0.5.310}/coord/commands/dispatch.py

@@ -1172,6 +1172,28 @@ def assign(
     # Fetch the issue title from GitHub
     try:
         issue_data = github_ops.get_issue(repo_cfg.github, issue)
+    except github_ops.GhRateLimitError as e:
+        if e.from_cache:
+            # #2977: `_gh`'s pre-call guard refused this WITHOUT ever making
+            # a network call — a shared rate-limit backoff
+            # (`coord.github_throttle`) was already known active. That is
+            # categorically different from a real failure: nothing about
+            # this dispatch attempt was wrong, and the exact moment it would
+            # succeed is already known. Exit `EX_TEMPFAIL` (not the generic
+            # `1` below) and embed that moment in the message itself — see
+            # `github_ops.format_throttle_skip_reason` — so
+            # `coord/drive_queue.py`'s tick can park this launch without
+            # spending one of its two attempts, instead of treating a
+            # skipped call as indistinguishable from a genuine dispatch
+            # failure (the `coord-portal#161` incident this closes).
+            click.echo(
+                f"error: could not fetch issue #{issue}: "
+                f"{github_ops.format_throttle_skip_reason(e)}",
+                err=True,
+            )
+            sys.exit(github_ops.EX_TEMPFAIL)
+        click.echo(f"error: could not fetch issue #{issue}: {e}", err=True)
+        sys.exit(1)
     except RuntimeError as e:
         click.echo(f"error: could not fetch issue #{issue}: {e}", err=True)
         sys.exit(1)

{code_coordinator-0.5.309 → code_coordinator-0.5.310}/coord/drive_queue.py

@@ -91,6 +91,7 @@ from typing import Any, Iterable, Mapping, Sequence
 
 from coord.drive_state import TERMINAL_STATUSES, WORK_LIKE
 from coord.gate_a import is_gate_a_refusal_reason
+from coord.github_ops import is_throttle_skip_reason, parse_throttle_skip_until
 from coord.issues_sync_status import STALENESS_WARN_SECONDS as ISSUE_CACHE_STALE_CEILING_S
 from coord.merge_queue import (
     PLAN_READY,
@@ -3425,6 +3426,42 @@ def _reconcile_running(
             None,
         )
 
+    # #2977: `coord assign` exited because `_gh`'s pre-call guard found a
+    # shared GitHub rate-limit backoff already active and skipped the call
+    # entirely (`GhRateLimitError(from_cache=True)`) — no `gh` call was ever
+    # attempted for this launch. That is neither a permanent refusal (the
+    # `is_policy_refusal_reason`/`is_gate_a_refusal_reason` shapes above —
+    # nothing about the ISSUE was rejected) nor a genuine dispatch failure
+    # (the generic `_dispatch_produced_nothing` note below, which would
+    # spend an attempt): it is a fleet-wide, known-duration condition this
+    # entry had nothing to do with. Parks WITHOUT spending an attempt
+    # (`Reconcile.updates` carries no `attempts` key, same as every other
+    # park above) — the wall-clock `until=` timestamp
+    # `github_ops.format_throttle_skip_reason` embedded in `own_reason` is
+    # what lets `plan_tick`'s parked-entry sweep resume it the moment the
+    # backoff clears, with no live re-check and no operator action, unlike
+    # the gate_a/policy parks just above which need one.
+    if own_reason and is_throttle_skip_reason(own_reason):
+        reason = (
+            f"{own_reason} — parking without spending an attempt; the queue "
+            "resumes it automatically once the backoff clears, no operator "
+            "needed (#2977)"
+        )
+        return (
+            Reconcile(
+                entry.key,
+                "parked",
+                reason,
+                occupies=False,
+                updates={
+                    "state": STATE_PARKED,
+                    "last_reason": reason,
+                    "session_name": None,
+                },
+            ),
+            None,
+        )
+
     permanent: tuple[str, str] | None = None
     if own_reason and (exit_refused or {}).get(entry.key):
         permanent = (
@@ -5008,6 +5045,59 @@ def plan_tick(
         # clears it (`coord drive-queue remove`, same as `blocked`).
         if is_policy_refusal_reason(entry.last_reason):
             continue
+        # #2977: a throttle-skip park (`github_ops.is_throttle_skip_reason`)
+        # carries its OWN known wall-clock expiry (`until=<epoch>`, embedded
+        # by `github_ops.format_throttle_skip_reason` at park time) — unlike
+        # the CI-park default below, which needs a live re-check because it
+        # has no way to know in advance when checks will report, this park
+        # can resume on a plain clock comparison, no I/O at all. `now is
+        # None` (a pure-logic caller with no clock) degrades to "never
+        # resume this tick", same posture #1794's grace window uses for the
+        # same input. An unparseable `until` (should not happen for text
+        # this module itself wrote) or a wait that has run well past
+        # `PARK_STALE_SECONDS` — far longer than any real backoff
+        # (`coord.github_throttle.MAX_BACKOFF_S` is 900s) — resumes anyway
+        # rather than parking indefinitely on a reading nothing can refresh,
+        # the same finite-wait guarantee #2158 already gives the CI park.
+        if is_throttle_skip_reason(entry.last_reason):
+            if now is None:
+                continue
+            until = parse_throttle_skip_until(entry.last_reason)
+            age = now - entry.reason_at if entry.reason_at is not None else None
+            cleared = until is not None and now >= until
+            stale = until is None or (age is not None and age > PARK_STALE_SECONDS)
+            if not cleared and not stale:
+                continue
+            reason = (
+                (
+                    f"the GitHub rate-limit backoff that parked {entry.key} "
+                    "has cleared — resuming without spending an attempt "
+                    "(#2977)"
+                )
+                if cleared
+                else (
+                    f"{entry.last_reason} — this throttle-skip park has run "
+                    f"{PARK_STALE_SECONDS / 60:.0f}m+ with no refreshable "
+                    "expiry left to trust — resuming rather than parking "
+                    "indefinitely (#2977)"
+                )
+            )
+            reconciles.append(
+                Reconcile(
+                    entry.key,
+                    "resumed",
+                    reason,
+                    occupies=False,
+                    updates={
+                        "state": STATE_WAITING,
+                        "attempts": 0,
+                        "last_reason": reason,
+                    },
+                )
+            )
+            states[entry.key] = STATE_WAITING
+            effective_attempts[entry.key] = 0
+            continue
         if park_expired is not None:
             # Deliberately does NOT claim CI has reported — nothing here knows
             # that. It says only that the reading this park rests on has no

{code_coordinator-0.5.309 → code_coordinator-0.5.310}/coord/github_ops.py

@@ -100,6 +100,108 @@ class GhRateLimitError(GhTransientError):
         self.from_cache = from_cache
 
 
+# ── #2977: coord-assign-side signal for a throttle-SKIPPED gh call ─────────
+#
+# `_gh`'s pre-call guard above raises `GhRateLimitError(from_cache=True)`
+# WITHOUT ever making a network call, whenever a shared backoff
+# (:mod:`coord.github_throttle`) is already known active — see that raise's
+# own comment. Before this, that distinction was lost the moment it crossed
+# the `coord assign` subprocess boundary: the caller (`coord/drive.py`)
+# just saw a bare non-zero exit and folded it into the same generic "drive
+# died" bucket as a real infrastructure failure, so `coord/drive_queue.py`'s
+# tick spent one of the entry's two launch attempts on a call that never
+# even reached GitHub (the 2026-08-30 `coord-portal#161` incident this
+# closes — see the issue for the full trace).
+#
+# `EX_TEMPFAIL` is the conventional (sysexits.h) code for "temporary
+# failure, retry later" — used by :mod:`coord.commands.dispatch`'s `assign`
+# command to give this ONE failure shape a distinct exit status. That is
+# necessary but not sufficient for `coord/drive_queue.py`'s pure tick logic
+# to act on: the exit code alone carries no expiry, and by the time a
+# `drive_exited` audit row is read back the file that raised the original
+# `GhRateLimitError` is long gone, so there is nothing left to re-consult.
+# `format_throttle_skip_reason` instead embeds everything the tick needs —
+# the marker, and an absolute `until=<epoch>` wall-clock timestamp — directly
+# in the human-readable reason text that already survives the subprocess
+# boundary unmodified (`coord.drive.Driver._spawn` captures the child's
+# stdout+stderr verbatim into `_last_run_output`, which flows straight into
+# the `drive_exited` audit summary `coord/commands/drive_queue.py`'s
+# `_fetch_exit_reasons` reads back as `own_reason` — no protocol change
+# needed on that path at all). `is_throttle_skip_reason`/
+# `parse_throttle_skip_until` are `coord/drive_queue.py`'s read side: pure
+# text parsing, no I/O, so `_reconcile_running`'s park (and its wall-clock
+# resume, no live re-check needed) stay exactly as pure as every other
+# branch in that module.
+THROTTLE_SKIP_MARKER = "[gh-throttle-skipped #2977]"
+
+#: The conventional sysexits.h "temporary failure, please try again" code —
+#: distinct from every other exit status `coord assign` uses (see
+#: `coord.drive.EXIT_DISPATCH_REFUSED`/`EXIT_DEAD_END` for the other two
+#: exit codes a downstream reader must be able to tell apart from "died").
+EX_TEMPFAIL = 75
+
+_THROTTLE_SKIP_UNTIL_RE = re.compile(r"until=([0-9]+(?:\.[0-9]+)?)")
+
+
+def format_throttle_skip_reason(exc: GhRateLimitError, *, now: float | None = None) -> str:
+    """Canonical, parseable text for a ``coord assign`` refusal caused by a
+    throttle-SKIPPED ``gh`` call (``exc.from_cache`` — see
+    :class:`GhRateLimitError`'s docstring).  Wraps ``str(exc)`` (already
+    carries the reason/status/request-id `_gh` recovered) with
+    :data:`THROTTLE_SKIP_MARKER` and an absolute ``until=`` epoch timestamp
+    that :func:`parse_throttle_skip_until` recovers later, with no clock of
+    its own and no access to :mod:`coord.github_throttle` needed.
+
+    ``exc.retry_after_s`` is "seconds remaining AT THE MOMENT ``_gh`` raised"
+    — a value that goes stale the instant it's read back, which is exactly
+    why an absolute timestamp is embedded here (computed once, at the one
+    point in this whole path that has both a fresh clock and the exception)
+    rather than a duration re-derived downstream. Falls back to
+    :data:`coord.github_throttle.DEFAULT_BACKOFF_S` when ``retry_after_s``
+    is ``None`` (the pre-call guard's own fallback wording already reads
+    "GitHub's guidance" in that case, so this mirrors it rather than
+    inventing a shorter window with no evidence behind it).
+    """
+    now = now if now is not None else time.time()
+    retry_after = (
+        exc.retry_after_s if exc.retry_after_s is not None else github_throttle.DEFAULT_BACKOFF_S
+    )
+    until = now + max(0.0, retry_after)
+    return (
+        f"{THROTTLE_SKIP_MARKER} {exc} — no gh call was made for this launch "
+        f"attempt, so it should not spend one (#2977); until={until:.3f}"
+    )
+
+
+def is_throttle_skip_reason(text: str | None) -> bool:
+    """``True`` when *text* is (or contains) a :func:`format_throttle_skip_reason`
+    result — the same marker-based convention as
+    ``coord.models.is_policy_refusal_reason``/``coord.gate_a.
+    is_gate_a_refusal_reason``, so ``coord/drive_queue.py`` can recognise this
+    park from plain reason text with no I/O.
+    """
+    return bool(text) and THROTTLE_SKIP_MARKER in text
+
+
+def parse_throttle_skip_until(text: str | None) -> float | None:
+    """The absolute epoch ``until=`` timestamp embedded by
+    :func:`format_throttle_skip_reason`, or ``None`` when *text* doesn't
+    carry the marker at all, or carries it without a parseable timestamp
+    (defensive — should not happen for text this module itself wrote, but a
+    hand-edited row or a future format change must degrade to "unknown",
+    never a wrong resume time).
+    """
+    if not is_throttle_skip_reason(text):
+        return None
+    m = _THROTTLE_SKIP_UNTIL_RE.search(text)
+    if not m:
+        return None
+    try:
+        return float(m.group(1))
+    except ValueError:
+        return None
+
+
 class GhTooOldForJsonChecks(GhError):
     """Raised when the installed ``gh`` doesn't support ``gh pr checks --json``
     *at all* (#1564 Addendum 2), as opposed to supporting ``--json`` but

{code_coordinator-0.5.309 → code_coordinator-0.5.310}/tests/test_cli_assign.py

@@ -495,6 +495,68 @@ class TestAssignDispatch:
         assert result.exit_code == 1
         assert "could not fetch issue" in result.output
 
+    def test_issue_fetch_throttle_skip_exits_distinctly(
+        self, config_file: Path, coord_dir: Path
+    ) -> None:
+        """#2977: a `GhRateLimitError(from_cache=True)` — `_gh`'s pre-call
+        guard skipped this `gh issue view` call WITHOUT making a network
+        call because a shared rate-limit backoff was already known active
+        — is a categorically different failure from an ordinary fetch error
+        (the generic `RuntimeError` case just above, still exit `1`). It
+        must exit `github_ops.EX_TEMPFAIL`, and the printed message must
+        carry `THROTTLE_SKIP_MARKER` plus an absolute `until=` timestamp, so
+        `coord drive-queue`'s tick (`coord/drive_queue.py`'s
+        `is_throttle_skip_reason`/`parse_throttle_skip_until`) can park this
+        launch without spending one of its two attempts instead of treating
+        it like a genuine dispatch failure (the `coord-portal#161`
+        incident)."""
+        from coord.github_ops import EX_TEMPFAIL, GhRateLimitError, THROTTLE_SKIP_MARKER
+
+        with patch(
+            "coord.github_ops.get_issue",
+            side_effect=GhRateLimitError(
+                "gh issue view 999 --repo acme/api --json ... skipped: GitHub "
+                "secondary_rate_limit backoff active for 59s more "
+                "(status=403, request_id=abc123)",
+                status_code=403, request_id="abc123", retry_after_s=59.0,
+                secondary=True, from_cache=True,
+            ),
+        ):
+            result = CliRunner().invoke(
+                main,
+                ["assign", "laptop", "api", "999", "--config", str(config_file)],
+            )
+        assert result.exit_code == EX_TEMPFAIL
+        assert result.exit_code != 1
+        assert "could not fetch issue" in result.output
+        assert THROTTLE_SKIP_MARKER in result.output
+        assert "until=" in result.output
+
+    def test_issue_fetch_real_rate_limit_hit_keeps_the_generic_exit(
+        self, config_file: Path, coord_dir: Path
+    ) -> None:
+        """The counterpart: a `GhRateLimitError` from an ACTUAL network call
+        (`from_cache=False`) is a genuine observation, not a skip — it must
+        keep exiting the generic `1` the `RuntimeError` case above does, not
+        `EX_TEMPFAIL`, so it is never mistaken for the zero-attempt-cost
+        skip class this issue fixes."""
+        from coord.github_ops import GhRateLimitError
+
+        with patch(
+            "coord.github_ops.get_issue",
+            side_effect=GhRateLimitError(
+                "gh issue view 999 --repo acme/api --json ... failed: API "
+                "rate limit exceeded",
+                status_code=403, retry_after_s=60.0, from_cache=False,
+            ),
+        ):
+            result = CliRunner().invoke(
+                main,
+                ["assign", "laptop", "api", "999", "--config", str(config_file)],
+            )
+        assert result.exit_code == 1
+        assert "could not fetch issue" in result.output
+
     def test_briefing_post_failure_is_nonfatal(
         self, config_file: Path, coord_dir: Path
     ) -> None:

{code_coordinator-0.5.309 → code_coordinator-0.5.310}/tests/test_drive_queue.py

@@ -2852,6 +2852,165 @@ def test_a_policy_refusal_still_reconciles_to_done_if_it_lands_by_hand():
     assert reconcile.updates["state"] == STATE_DONE
 
 
+# ═══════════════════════════════════════════════════════════════════════════
+# #2977: a throttle-SKIPPED `gh` call — `_gh`'s pre-call guard found a shared
+# GitHub rate-limit backoff (coord.github_throttle) already active and
+# raised `GhRateLimitError(from_cache=True)` WITHOUT ever making a network
+# call — must not be charged like a real dispatch failure. It parks (like
+# Gate-A/policy above) rather than blocking, spends no attempt, AND —
+# unlike Gate-A/policy, which wait on an external verdict — resumes itself
+# the instant the embedded wall-clock `until=` timestamp passes, no live
+# re-check and no operator action needed. coord-portal#161, 2026-08-30: two
+# such skips in a row parked the keystone of a 9-entry milestone.
+# ═══════════════════════════════════════════════════════════════════════════
+
+
+def _throttle_skip_reason(*, now: float, retry_after_s: float = 59.0) -> str:
+    """A realistic `own_reason` string for a `running` entry whose launch
+    died on a throttle-skipped `coord assign` — i.e. exactly what
+    `coord/commands/drive_queue.py`'s `_fetch_exit_reasons` would read back
+    from the `drive_exited` audit row once `coord.drive.Driver._spawn`
+    folds the child's stderr (built by `coord/commands/dispatch.py`'s
+    `assign` command from `github_ops.format_throttle_skip_reason`) into
+    the summary — see this module's own #2977 comment for the full chain.
+    """
+    from coord.github_ops import GhRateLimitError, format_throttle_skip_reason
+
+    exc = GhRateLimitError(
+        "gh issue view 161 --repo JDonaghy/coord-portal --json "
+        "number,title,body,state,milestone,labels skipped: GitHub "
+        "secondary_rate_limit backoff active for "
+        f"{retry_after_s:.0f}s more (status=403, "
+        "request_id=A654:2496C0:1E674B6:66A49BB:6A94A599)",
+        status_code=403,
+        request_id="A654:2496C0:1E674B6:66A49BB:6A94A599",
+        retry_after_s=retry_after_s,
+        secondary=True,
+        from_cache=True,
+    )
+    skip_reason = format_throttle_skip_reason(exc, now=now)
+    return (
+        f"drive exited for {REPO}#161 (exit_code=75): coord assign precision "
+        f"{REPO} 161 --driven-by drive:{REPO}#161 exited 75\n   output: "
+        f"error: could not fetch issue #161: {skip_reason}"
+    )
+
+
+def test_format_and_parse_throttle_skip_reason_round_trip():
+    """The seam `coord/drive_queue.py` actually depends on: the marker and
+    the absolute `until=` timestamp `format_throttle_skip_reason` embeds
+    must survive being read back by `is_throttle_skip_reason`/
+    `parse_throttle_skip_until` with no clock and no I/O."""
+    from coord.github_ops import (
+        GhRateLimitError,
+        format_throttle_skip_reason,
+        is_throttle_skip_reason,
+        parse_throttle_skip_until,
+    )
+
+    exc = GhRateLimitError(
+        "gh ... skipped: GitHub secondary_rate_limit backoff active for "
+        "10s more (status=403, request_id=abc)",
+        retry_after_s=10.0, secondary=True, from_cache=True,
+    )
+    reason = format_throttle_skip_reason(exc, now=NOW)
+    assert is_throttle_skip_reason(reason)
+    assert parse_throttle_skip_until(reason) == pytest.approx(NOW + 10.0)
+    assert not is_throttle_skip_reason("an ordinary death, nothing to do with gh")
+    assert parse_throttle_skip_until("an ordinary death") is None
+
+
+def test_a_throttle_skipped_gh_call_parks_without_spending_an_attempt():
+    reason = _throttle_skip_reason(now=NOW)
+    entries = [entry(161, position=3, state=STATE_RUNNING, attempts=0)]
+    plan = plan_tick(
+        entries, board(), capacity=1, now=NOW,
+        exit_reasons={entry_key(REPO, 161): reason},
+    )
+    reconcile = plan.reconciles[0]
+    assert reconcile.outcome == "parked"
+    assert reconcile.updates["state"] == STATE_PARKED
+    assert "attempts" not in reconcile.updates
+    assert plan.blocked == ()  # NOT terminal `blocked`
+    assert plan.launch is None
+
+
+def test_a_throttle_skipped_gh_call_deep_into_the_attempt_budget_still_spends_none():
+    reason = _throttle_skip_reason(now=NOW)
+    entries = [entry(161, state=STATE_RUNNING, attempts=DEFAULT_MAX_ATTEMPTS - 1)]
+    plan = plan_tick(
+        entries, board(), capacity=1, now=NOW,
+        exit_reasons={entry_key(REPO, 161): reason},
+    )
+    assert plan.reconciles[0].outcome == "parked"  # not "exhausted"
+    assert plan.blocked == ()
+
+
+def test_a_parked_throttle_skip_stays_parked_before_the_backoff_clears():
+    reason = _throttle_skip_reason(now=NOW, retry_after_s=120.0)
+    entries = [
+        entry(161, position=3, state="parked", attempts=0,
+              last_reason=reason, reason_at=NOW)
+    ]
+    plan = plan_tick(entries, board(), capacity=1, now=NOW + 30.0)
+    assert plan.reconciles == ()  # still parked — backoff has not cleared yet
+    assert plan.launch is None
+
+
+def test_a_parked_throttle_skip_resumes_the_instant_the_backoff_clears():
+    """The acceptance criterion: no operator action, no `remove`+`add` — the
+    entry wakes itself exactly when `Backoff.until` passes."""
+    reason = _throttle_skip_reason(now=NOW, retry_after_s=59.0)
+    entries = [
+        entry(161, position=3, state="parked", attempts=1,
+              last_reason=reason, reason_at=NOW)
+    ]
+    plan = plan_tick(entries, board(), capacity=1, now=NOW + 60.0)
+    reconcile = plan.reconciles[0]
+    assert reconcile.outcome == "resumed"
+    assert reconcile.updates["state"] == STATE_WAITING
+    assert reconcile.updates["attempts"] == 0
+
+
+def test_a_parked_throttle_skip_with_no_clock_never_resumes():
+    """`now=None` (a pure-logic caller) must never guess a resume — same
+    fail-closed posture #1794's grace window uses for the same input."""
+    reason = _throttle_skip_reason(now=NOW, retry_after_s=1.0)
+    entries = [
+        entry(161, position=3, state="parked", attempts=0, last_reason=reason)
+    ]
+    plan = plan_tick(entries, board(), capacity=1)
+    assert plan.reconciles == ()
+
+
+def test_a_parked_throttle_skip_with_unparseable_until_resumes_past_the_2158_ceiling():
+    """Defensive: text carrying the marker with no parseable `until=` (a
+    hand-edited row, or a future format change) must still be FINITE — never
+    a silent infinite park — bounded by the same `PARK_STALE_SECONDS`
+    ceiling #2158 already gives the CI park."""
+    from coord.github_ops import THROTTLE_SKIP_MARKER
+
+    reason = f"drive exited: {THROTTLE_SKIP_MARKER} gh skipped, no until recorded"
+    entries = [
+        entry(161, position=3, state="parked", attempts=0,
+              last_reason=reason, reason_at=NOW - PARK_STALE_SECONDS - 60)
+    ]
+    plan = plan_tick(entries, board(), capacity=1, now=NOW)
+    reconcile = plan.reconciles[0]
+    assert reconcile.outcome == "resumed"
+    assert reconcile.updates["state"] == STATE_WAITING
+
+
+def test_a_throttle_skip_still_reconciles_to_done_if_it_lands_by_hand():
+    reason = _throttle_skip_reason(now=NOW)
+    entries = [entry(161, position=3, state="parked", attempts=0,
+                      last_reason=reason)]
+    plan = plan_tick(entries, board(merged=(161,)), capacity=1)
+    reconcile = plan.reconciles[0]
+    assert reconcile.outcome == "done"
+    assert reconcile.updates["state"] == STATE_DONE
+
+
 # ═══════════════════════════════════════════════════════════════════════════
 # #2850: a drive that exits 0 having MERGED must reconcile straight to
 # `done`, never `retry` — before this fix, `own_reason` carried the drive's