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

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

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

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

{code_coordinator-0.5.308 → 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.308 → 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.308 → 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.308 → code_coordinator-0.5.310}/coord/milestone_chat.py

@@ -57,15 +57,28 @@ def pick_milestone_chat_machine(cfg: Config, repo: str) -> Machine | None:
     return pick_refinement_machine(cfg, repo)
 
 
-def _fetch_milestone_issues(slug: str, milestone_number: int) -> list[dict]:
+def _fetch_milestone_issues(
+    slug: str,
+    milestone_number: int,
+    *,
+    max_body_chars: int | None = MAX_ISSUE_BODY_CHARS,
+) -> list[dict]:
     """Best-effort fetch of open issues under *milestone_number*.
 
-    Returns a list of ``{"number", "title", "body"}`` dicts (bodies
-    truncated to ``MAX_ISSUE_BODY_CHARS`` so cohort/dependency inference has
-    signal without blowing the prompt budget), capped at ``MAX_ISSUES``.
-    Returns an empty list on any failure so the seed briefing still works
-    without issue context — the operator can still chat, just with less to
-    go on.
+    Returns a list of ``{"number", "title", "body"}`` dicts, capped at
+    ``MAX_ISSUES``. Returns an empty list on any failure so the seed
+    briefing still works without issue context — the operator can still
+    chat, just with less to go on.
+
+    *max_body_chars* defaults to ``MAX_ISSUE_BODY_CHARS`` (bodies truncated
+    so cohort/dependency inference has signal without blowing the prompt
+    budget) — that trade is right for *this* module's job, a chat session
+    inferring dependencies from a digest. It is wrong for a caller whose
+    entire output is derived from the body text itself: #2969 found Gate A's
+    mock-author (`coord/mock_author.py`) reusing this same cap, silently
+    handing it 36-82% of each issue's spec and leaving it to notice and flag
+    the gap in its own contract. Pass ``max_body_chars=None`` for callers
+    like that, where a body must arrive in full or not at all.
     """
     try:
         issues = github_ops.get_open_issues(slug)
@@ -78,8 +91,8 @@ def _fetch_milestone_issues(slug: str, milestone_number: int) -> list[dict]:
     out: list[dict] = []
     for issue in under_milestone[:MAX_ISSUES]:
         body = (issue.get("body") or "").strip()
-        if len(body) > MAX_ISSUE_BODY_CHARS:
-            body = body[:MAX_ISSUE_BODY_CHARS] + "\n...(truncated)"
+        if max_body_chars is not None and len(body) > max_body_chars:
+            body = body[:max_body_chars] + "\n...(truncated)"
         out.append({
             "number": issue.get("number"),
             "title": issue.get("title") or "",

{code_coordinator-0.5.308 → code_coordinator-0.5.310}/coord/mock_author.py

@@ -323,7 +323,13 @@ def dispatch_acceptance_mock(
             required_gates=list(config.pipeline.default_gates),
         )
     else:
-        issues = _fetch_milestone_issues(repo_cfg.github, milestone_number)
+        # #2969: Gate A's contract IS the spec — anything truncated here
+        # becomes silent guesswork in `contract.md`. Unlike milestone-chat's
+        # own cohort/dependency-inference use of this fetcher, hand the
+        # mock-author every body in full (no `max_body_chars` cap).
+        issues = _fetch_milestone_issues(
+            repo_cfg.github, milestone_number, max_body_chars=None
+        )
 
         briefing = build_mock_author_briefing(
             repo_slug=repo_cfg.github,

{code_coordinator-0.5.308 → 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.308 → 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

{code_coordinator-0.5.308 → code_coordinator-0.5.310}/tests/test_milestone_chat.py

@@ -223,6 +223,18 @@ def test_fetch_milestone_issues_returns_empty_on_failure():
     assert out == []
 
 
+def test_fetch_milestone_issues_max_body_chars_none_disables_truncation():
+    """#2969: Gate A's mock-author passes `max_body_chars=None` so it sees
+    every issue body in full — the cap below is this module's own default,
+    not a hard-coded floor other callers are stuck with."""
+    long_body = "x" * (milestone_chat.MAX_ISSUE_BODY_CHARS + 500)
+    issues = [{"number": 1, "title": "T", "body": long_body, "milestone": {"number": 9}}]
+    with patch("coord.github_ops.get_open_issues", return_value=issues):
+        out = milestone_chat._fetch_milestone_issues("acme/api", 9, max_body_chars=None)
+    assert out[0]["body"] == long_body
+    assert "(truncated)" not in out[0]["body"]
+
+
 # ── pick_milestone_chat_machine ──────────────────────────────────────────────
 
 

{code_coordinator-0.5.308 → code_coordinator-0.5.310}/tests/test_mock_author.py

@@ -352,6 +352,39 @@ def test_dispatch_success_records_assignment(tmp_path):
     mock_record.assert_called_once()
 
 
+def test_dispatch_briefs_full_issue_bodies_uncapped(tmp_path):
+    """#2969: Gate A's contract is authored straight from these bodies —
+    reusing milestone_chat's 1500-char cohort-inference cap here silently
+    fed the mock-author 36-82% of each issue's spec. The dispatched
+    briefing must carry every body in full, past that cap."""
+    from coord.models import Board
+
+    long_body = "y" * (2000) + " END-OF-BODY-MARKER"
+    cfg = _cfg_with_driver(tmp_path)
+    issue_data = {
+        "number": 100, "title": "Milestone tracker", "body": "",
+        "milestone": {"number": 9, "title": "Q3"},
+    }
+    open_issues = [
+        {
+            "number": 5, "title": "Child", "body": long_body,
+            "milestone": {"number": 9},
+        },
+    ]
+    with patch("coord.github_ops.get_issue", return_value=issue_data), \
+         patch("coord.github_ops.get_open_issues", return_value=open_issues), \
+         patch("coord.board_service.read_board", return_value=Board()), \
+         patch("coord.dispatch.dispatch_with_retry", return_value={"id": "asg-xyz"}) as mock_dispatch, \
+         patch("coord.dispatch.post_briefing"), \
+         patch("coord.state.record_dispatched"):
+        mock_author.dispatch_acceptance_mock("api", 100, cfg)
+
+    proposal = mock_dispatch.call_args[0][0]
+    assert len(long_body) > 1500  # sanity: this reproduces only past the old cap
+    assert long_body in proposal.briefing
+    assert "(truncated)" not in proposal.briefing
+
+
 # ── build_mock_author_amend_briefing / --amend dispatch (#1315) ─────────────