code-coordinator 0.5.536__tar.gz → 0.5.538__tar.gz

{code_coordinator-0.5.536 → code_coordinator-0.5.538}/PKG-INFO

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

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

@@ -1,7 +1,7 @@
 {
-  "tag": "0.5.536",
+  "tag": "0.5.538",
   "distance": 0,
-  "node": "g88b4c49256bda59316741a2cfccb7ac352b3e665",
+  "node": "g497e677b9148b371539abe944ff11b260e6dc373",
   "dirty": false,
   "branch": "HEAD",
   "node_date": "2026-09-30"

{code_coordinator-0.5.536 → code_coordinator-0.5.538}/coord/commands/gate_a.py

@@ -137,17 +137,46 @@ def _fetch_contract(repo_cfg, config, milestone_number: int) -> str | None:
     number doesn't say whether it's a directory-discovered driver's slice
     (shared repo-root tree) or an entrypoint-linked driver's relocated one,
     so this checks each candidate :func:`coord.acceptance.
-    gate_a_contract_candidates` returns until one exists."""
+    gate_a_contract_candidates` returns until one exists.
+
+    Returns ``None`` only when every candidate genuinely 404'd — a
+    confirmed absence. Raises :class:`coord.github_ops.GhTransientError`
+    (unchanged) when a candidate's read failed because ``gh`` classified it
+    as a GitHub rate limit (:func:`coord.github_ops._classify_rate_limit`,
+    surfaced as :class:`coord.github_ops.GhRateLimitError`) rather than a
+    404: #2973's bug was exactly this distinction getting lost — a
+    rate-limited read was folded into the same ``except RuntimeError:
+    continue`` as a real 404, so "I could not tell" silently became "it
+    does not exist". A transient failure on ANY candidate makes the whole
+    read inconclusive (a later candidate 404'ing doesn't confirm the
+    transiently-failed one is absent too), so it takes priority over a
+    clean ``None`` even if a later candidate genuinely 404s.
+
+    Narrower than it may sound: only a rate limit is currently classified
+    this way — a plain non-zero ``gh`` exit that isn't a rate limit (a bad
+    token, a genuine network failure, ``gh`` missing) still raises a plain
+    ``RuntimeError``/:class:`coord.github_ops.GhError` and is still folded
+    into ``continue`` below, same as before this fix. Tracked as a
+    follow-up rather than widened here, since ``_is_transient_error``-style
+    reclassification of those cases is a broader, separately-reviewable
+    change to ``coord.github_ops._gh`` itself.
+    """
     from coord import github_ops  # noqa: PLC0415
     from coord.acceptance import gate_a_contract_candidates  # noqa: PLC0415
 
+    transient: github_ops.GhTransientError | None = None
     for path in gate_a_contract_candidates(config, repo_cfg.name, milestone_number):
         try:
             return github_ops.get_repo_file(
                 repo_cfg.github, path, branch=repo_cfg.default_branch,
             )
+        except github_ops.GhTransientError as e:
+            transient = transient or e
+            continue
         except RuntimeError:
             continue
+    if transient is not None:
+        raise transient
     return None
 
 
@@ -216,7 +245,27 @@ def gate_a(
         sys.exit(2)
     milestone_number = int(milestone_number)
 
-    contract_text = _fetch_contract(repo_cfg, cfg, milestone_number)
+    try:
+        contract_text = _fetch_contract(repo_cfg, cfg, milestone_number)
+    except github_ops.GhTransientError as e:
+        # #2973: a failed READ is a different claim than a confirmed
+        # ABSENCE — only the latter justifies telling the caller to
+        # dispatch `coord acceptance mock` (which, against a milestone
+        # that already has an approved contract, produces a duplicate/
+        # conflicting one). Mirror the issue-fetch path just above, which
+        # already reports this correctly: name the real cause and ask for
+        # a retry, print no remedy.
+        click.echo(
+            f"error: could not read the Gate-A contract for ms-{milestone_number} "
+            f"({repo}#{tracking_issue}): {e}",
+            err=True,
+        )
+        click.echo(
+            "  This is a failed read, not a confirmed absence — the contract "
+            "may well exist. Retry once the rate limit clears.",
+            err=True,
+        )
+        sys.exit(1)
     if contract_text is None:
         from coord.acceptance import gate_a_contract_candidates  # noqa: PLC0415
 

{code_coordinator-0.5.536 → code_coordinator-0.5.538}/coord/commands/lifecycle.py

@@ -428,7 +428,7 @@ def done(config_path: Path) -> None:
             pass
 
     all_assignments = list(board.active) + list(board.completed)
-    session_usage = build_session_usage(all_assignments, started_at=started_at)
+    session_usage = build_session_usage(all_assignments, started_at=started_at, cfg=cfg)
     total_cost = session_usage.total_cost_usd
 
     click.echo("")

{code_coordinator-0.5.536 → code_coordinator-0.5.538}/coord/commands/status.py

@@ -980,7 +980,7 @@ def status(config_path: Path, machine_filter: str | None, no_reconcile: bool, ti
                 pass
 
         all_assignments = list(board.active) + list(board.completed)
-        session_usage = build_session_usage(all_assignments, started_at=started_at)
+        session_usage = build_session_usage(all_assignments, started_at=started_at, cfg=cfg)
         burn_line = format_burn_rate_line(session_usage)
         if burn_line:
             click.echo("")
@@ -1103,7 +1103,7 @@ def status(config_path: Path, machine_filter: str | None, no_reconcile: bool, ti
         machine_by_aid = {
             a.assignment_id: a.machine_name for a in rows if a.assignment_id
         }
-        usage = build_session_usage(rows, remote_by_id=agent_completed or None)
+        usage = build_session_usage(rows, remote_by_id=agent_completed or None, cfg=cfg)
         for au in usage.assignments:
             # #3376 review round 2: `cost_unknown` means no local log AND no
             # remote entry. That is the ghost-dispatch signal ONLY if this
@@ -2992,6 +2992,14 @@ def usage(
             pass
 
     # Optionally fetch remote cost data for assignments without local logs.
+    # #2305: cfg is only loaded here (not unconditionally) — the bare
+    # `coord usage` view has always worked with no coordinator.yml present
+    # at all (see TestUsageCommandBareViewHonorsWindowFlags), and that must
+    # stay true. When it IS loaded (here, or by --remote below), it's
+    # threaded into build_session_usage() so a tier-named provider (e.g.
+    # "oc-mid") resolves correctly instead of degrading to ClaudeProvider
+    # log parsing.
+    cfg: "Config | None" = None
     remote_by_id: dict[str, dict] = {}
     if remote and all_assignments:
         cfg = _load_config(config_path)
@@ -3027,6 +3035,7 @@ def usage(
         all_assignments,
         remote_by_id=remote_by_id if remote_by_id else None,
         started_at=started_at,
+        cfg=cfg,
     )
     click.echo(format_usage_report(session, window_label=window_label))
 

{code_coordinator-0.5.536 → code_coordinator-0.5.538}/coord/failure_class.py

@@ -79,6 +79,7 @@ from coord.worker_events import (
 )
 
 if TYPE_CHECKING:
+    from coord.config import Config
     from coord.providers.base import Provider
 
 # ── the two classes ─────────────────────────────────────────────────────────
@@ -461,6 +462,7 @@ def classify_log(
     tail_bytes: int = 65536,
     provider_name: str | None = None,
     provider: "Provider | None" = None,
+    cfg: "Config | None" = None,
 ) -> FailureClassification:
     """Classify a worker's terminal state from its log.
 
@@ -484,6 +486,14 @@ def classify_log(
     an escape hatch for tests to pass an already-constructed provider
     directly, bypassing name resolution.
 
+    *cfg* (#2305): the coordinator's :class:`~coord.config.Config`, passed
+    straight through to :func:`coord.providers.get_provider` so a
+    tier-named ``providers.definitions`` entry (e.g. ``oc-mid``) resolves to
+    its real backend instead of silently degrading to
+    :class:`~coord.providers.claude.ClaudeProvider` — *provider_name* alone
+    only ever matches the built-in type names. ``None`` (the default)
+    preserves pre-#2305 behaviour.
+
     #1710 NOTE — a documented, narrow behaviour difference from the
     pre-#1710 implementation: that version additionally scanned the raw
     ``result`` event's ``error`` and bare ``subtype`` fields (via
@@ -509,7 +519,7 @@ def classify_log(
 
     if provider is None:
         from coord.providers import get_provider  # noqa: PLC0415
-        provider = get_provider(provider_name)
+        provider = get_provider(provider_name, cfg=cfg)
     summary = provider.parse_log(log_path, tail_bytes=tail_bytes)
 
     classification = classify_failure(

{code_coordinator-0.5.536 → code_coordinator-0.5.538}/coord/milestone_dispatch.py

@@ -197,6 +197,11 @@ def is_milestone_complete(ctx: MilestoneContext) -> bool:
 
 # (repo_github, path, branch) -> True if the file exists at that ref.
 # Injected so tests never hit `gh` — mirrors ``coord.claim``'s BranchLookup.
+#
+# #2973: may also raise ``coord.github_ops.GhTransientError`` — a failed
+# read (auth, network, a GitHub rate limit) is a different claim than a
+# confirmed 404, and callers (``gate_a_status``) must not fold the two
+# together the way the pre-#2973 default implementation did.
 GateAFileExists = Callable[[str, str, str], bool]
 
 
@@ -206,6 +211,11 @@ def _default_gate_a_file_exists(repo_github: str, path: str, branch: str) -> boo
     try:
         github_ops.get_repo_file(repo_github, path, branch=branch)
         return True
+    except github_ops.GhTransientError:
+        # #2973: a rate-limited (or otherwise transient) read is NOT a
+        # confirmed absence — let it propagate so `gate_a_status` can tell
+        # the two apart, instead of silently becoming `False` here.
+        raise
     except RuntimeError:
         return False
 
@@ -235,17 +245,42 @@ def gate_a_status(
     checking only the legacy repo-root path and reporting a false "Gate A
     not satisfied" for a milestone whose contract already exists, just
     somewhere else.
+
+    #2973: a candidate whose read *fails* (auth, network, a GitHub rate
+    limit — :class:`coord.github_ops.GhTransientError`) is a different claim
+    than a candidate that genuinely 404s, and only the latter justifies the
+    "run `coord acceptance mock`" remedy below — that remedy dispatches a
+    duplicate mock-author against a milestone that may already have an
+    approved contract. Mirrors :func:`coord.commands.gate_a._fetch_contract`:
+    a confirmed existence on ANY candidate wins outright (even after an
+    earlier candidate's transient failure), but a transient failure on any
+    checked candidate makes the whole read inconclusive when nothing else
+    confirms existence — reported distinctly, with no dispatch-a-mock-author
+    remedy attached.
     """
     if not config.acceptance.has_driver(repo_cfg.name):
         return None
 
+    from coord import github_ops  # noqa: PLC0415
     from coord.acceptance import gate_a_contract_candidates  # noqa: PLC0415
 
     candidates = gate_a_contract_candidates(config, repo_cfg.name, milestone_number)
     check = file_exists or _default_gate_a_file_exists
+    transient: github_ops.GhTransientError | None = None
     for path in candidates:
-        if check(repo_cfg.github, path, repo_cfg.default_branch):
-            return None
+        try:
+            if check(repo_cfg.github, path, repo_cfg.default_branch):
+                return None
+        except github_ops.GhTransientError as e:
+            transient = transient or e
+            continue
+    if transient is not None:
+        return (
+            f"Gate A undetermined: could not read {repo_cfg.name}'s Gate-A "
+            f"contract on {repo_cfg.default_branch!r} ({transient}). This is "
+            "a failed read, not a confirmed absence — the contract may well "
+            "exist. Retry once the rate limit clears."
+        )
     named = " or ".join(repr(p) for p in candidates)
     return (
         f"Gate A not satisfied: {named} does not exist yet on "
@@ -257,6 +292,17 @@ def gate_a_status(
 
 # (repo_github, path, branch) -> file content, or None if it doesn't exist.
 # Injected so tests never hit `gh` — mirrors GateAFileExists above.
+#
+# #2973: may also raise ``coord.github_ops.GhTransientError`` — same reason
+# as ``GateAFileExists`` above. ``gate_a_signoff_status`` and
+# ``issue_oracle_ready`` both build a ``GateAFileExists`` closure on top of
+# this fetch (memoised, so the existence probe and the content read share
+# one call), so this must propagate the same distinction they'd otherwise
+# lose. Callers that only want *content*, never existence — the manifest/
+# exempt reads in ``_fetch_manifest_data`` and the contract-hashing loop in
+# ``gate_a_signoff`` — catch it locally and keep degrading to ``None``,
+# their pre-#2973 behaviour: those reads are advisory/best-effort, not the
+# gate whose misreporting #2973 is about.
 ManifestFetch = Callable[[str, str, str], "str | None"]
 
 
@@ -265,6 +311,8 @@ def _default_fetch_repo_file(repo_github: str, path: str, branch: str) -> str |
 
     try:
         return github_ops.get_repo_file(repo_github, path, branch=branch)
+    except github_ops.GhTransientError:
+        raise
     except RuntimeError:
         return None
 
@@ -313,6 +361,7 @@ def _fetch_manifest_data(
     legacy manifest and/or fragment file; a milestone's data lives under
     exactly one, so the first root that produces anything wins.
     """
+    from coord import github_ops  # noqa: PLC0415
     from coord.acceptance import (  # noqa: PLC0415
         ACCEPTANCE_DIRNAME,
         MANIFEST_FRAGMENTS_DIRNAME,
@@ -326,7 +375,14 @@ def _fetch_manifest_data(
     def _fetch_one(dir_path: str, filename_stem: str) -> "tuple[ManifestData, bool]":
         for ext in (".yml", ".yaml", ".json"):
             path = f"{dir_path}/{filename_stem}{ext}"
-            content = fetch(repo_github, path, branch)
+            try:
+                content = fetch(repo_github, path, branch)
+            except github_ops.GhTransientError:
+                # #2973: this is an advisory manifest/exempt read, not the
+                # contract-existence gate — a transient GitHub error here
+                # degrades to "no manifest data yet" exactly like a genuine
+                # 404 always has, rather than crashing dispatch.
+                content = None
             if content is None:
                 continue
             try:
@@ -433,11 +489,23 @@ def gate_a_signoff(
     for the common single-candidate case).
     """
     from coord import gate_a as gate_a_mod  # noqa: PLC0415
+    from coord import github_ops  # noqa: PLC0415
     from coord.acceptance import gate_a_contract_candidates  # noqa: PLC0415
 
     contract_text: str | None = None
     for path in gate_a_contract_candidates(config, repo_cfg.name, milestone_number):
-        contract_text = fetch(repo_cfg.github, path, repo_cfg.default_branch)
+        try:
+            contract_text = fetch(repo_cfg.github, path, repo_cfg.default_branch)
+        except github_ops.GhTransientError:
+            # #2973: by the time this runs, `gate_a_status` has already
+            # confirmed SOME candidate exists (that's the precondition every
+            # caller of this checks first) — a transient failure re-reading
+            # a candidate here (this loop re-walks the same list, and a
+            # not-yet-memoised path can still hit a fresh rate limit) just
+            # means this particular candidate isn't the hashable one; keep
+            # walking rather than letting the read crash the signoff check.
+            contract_text = None
+            continue
         if contract_text is not None:
             break
     return gate_a_mod.evaluate(

{code_coordinator-0.5.536 → code_coordinator-0.5.538}/coord/progress.py

@@ -26,6 +26,7 @@ from pathlib import Path
 from typing import TYPE_CHECKING
 
 if TYPE_CHECKING:
+    from coord.config import Config
     from coord.providers.base import Provider
 
 
@@ -118,6 +119,7 @@ def parse_progress(
     *,
     provider_name: str | None = None,
     provider: "Provider | None" = None,
+    cfg: "Config | None" = None,
 ) -> WorkerProgress:
     """Parse progress from a worker log.
 
@@ -137,6 +139,15 @@ def parse_progress(
             precedence over *provider_name*. Mainly for tests that want to
             exercise a specific (e.g. fake, non-claude) provider without
             wiring up a full :class:`~coord.config.Config`.
+        cfg: The coordinator's :class:`~coord.config.Config`, when the caller
+            has one in scope. #2305: without this, ``provider_name`` only
+            ever resolves against the built-in provider *types*
+            (``claude``/``claude-pty``/``opencode``) — a **tier-named**
+            ``providers.definitions`` entry (e.g. ``oc-mid``) silently
+            degrades to :class:`~coord.providers.claude.ClaudeProvider`.
+            Passed straight through to :func:`coord.providers.get_provider`;
+            ``None`` (the default) preserves the pre-#2305 built-ins-only
+            resolution, so existing callers are unaffected.
     """
     from coord.worker_events import detect_anomalies, is_stream_json
 
@@ -147,7 +158,7 @@ def parse_progress(
     if is_stream_json(p):
         if provider is None:
             from coord.providers import get_provider  # noqa: PLC0415
-            provider = get_provider(provider_name)
+            provider = get_provider(provider_name, cfg=cfg)
         summary = provider.parse_log(p, tail_bytes=tail_bytes)
         progress = WorkerProgress()
         # Synthesise a single rolling "update" line so coord status keeps

{code_coordinator-0.5.536 → code_coordinator-0.5.538}/coord/usage.py

@@ -27,6 +27,7 @@ from coord.models import Assignment
 from coord.state import COORD_DIR
 
 if TYPE_CHECKING:
+    from coord.config import Config
     from coord.providers.base import Provider
 
 _log = logging.getLogger(__name__)
@@ -155,6 +156,7 @@ def parse_usage_from_log(
     *,
     provider_name: str | None = None,
     provider: "Provider | None" = None,
+    cfg: "Config | None" = None,
 ) -> AssignmentUsage | None:
     """Parse an :class:`AssignmentUsage` from a worker log file.
 
@@ -172,6 +174,14 @@ def parse_usage_from_log(
     behaviour byte-for-byte for every caller that doesn't pass it. *provider*
     is an escape hatch to pass an already-constructed provider directly
     (tests; bypasses name resolution).
+
+    *cfg* (#2305): the coordinator's :class:`~coord.config.Config`, passed
+    straight through to :func:`coord.providers.get_provider` so a
+    **tier-named** ``providers.definitions`` entry (e.g. ``oc-mid``) resolves
+    to its real backend instead of silently degrading to
+    :class:`~coord.providers.claude.ClaudeProvider` — *provider_name* alone
+    only ever matches the built-in type names. ``None`` (the default)
+    preserves pre-#2305 behaviour.
     """
     from coord.worker_events import is_stream_json
 
@@ -179,7 +189,7 @@ def parse_usage_from_log(
         return None
     if provider is None:
         from coord.providers import get_provider  # noqa: PLC0415
-        provider = get_provider(provider_name)
+        provider = get_provider(provider_name, cfg=cfg)
     if not is_stream_json(log_path):
         # #1710: a provider that claims it reports cost but whose log isn't
         # stream-json shaped gets NO cost/token data here — that mismatch is
@@ -221,6 +231,7 @@ def _assignment_to_usage(
     *,
     logs_dir: Path | None = None,
     remote_data: dict | None = None,
+    cfg: "Config | None" = None,
 ) -> AssignmentUsage:
     """Build an :class:`AssignmentUsage` for *a*.
 
@@ -229,6 +240,12 @@ def _assignment_to_usage(
 
     *remote_data* is a dict from the agent's ``list_assignments()`` response
     (e.g. ``{"cost_so_far": 0.12, "model_used": "claude-sonnet-4-6", ...}``).
+
+    *cfg* (#2305): threaded through to both the local-log parse and the
+    "neither local nor remote" ``get_provider`` fallback below, so a
+    tier-named provider (e.g. ``oc-mid``) resolves to its real backend
+    rather than :class:`~coord.providers.claude.ClaudeProvider`. ``None``
+    (the default) preserves pre-#2305 behaviour.
     """
     _logs_dir = logs_dir if logs_dir is not None else LOGS_DIR
     from coord.models import effective_issue_number  # noqa: PLC0415
@@ -252,7 +269,7 @@ def _assignment_to_usage(
         # #1710: thread the assignment's resolved provider name through so
         # the parse uses the right provider's parse_log() rather than always
         # assuming claude.
-        parsed = parse_usage_from_log(log_path, provider_name=a.provider_name)
+        parsed = parse_usage_from_log(log_path, provider_name=a.provider_name, cfg=cfg)
         if parsed is not None:
             usage.model = parsed.model or a.model
             usage.total_cost_usd = parsed.total_cost_usd
@@ -283,7 +300,7 @@ def _assignment_to_usage(
     if a.assignment_id:
         from coord.providers import get_provider  # noqa: PLC0415
 
-        provider = get_provider(a.provider_name)
+        provider = get_provider(a.provider_name, cfg=cfg)
         if provider.capabilities().cost_reporting:
             usage.cost_unknown = True
 
@@ -298,6 +315,7 @@ def collect_usage(
     *,
     logs_dir: Path | None = None,
     remote_by_id: dict[str, dict] | None = None,
+    cfg: "Config | None" = None,
 ) -> list[AssignmentUsage]:
     """Collect :class:`AssignmentUsage` for every assignment on the board.
 
@@ -305,13 +323,21 @@ def collect_usage(
     whose logs live on a remote machine.  Pass ``None`` (the default) to skip
     remote lookups entirely — the result will still be correct for any
     assignment whose log is available locally.
+
+    *cfg* (#2305): the coordinator's :class:`~coord.config.Config`, when the
+    caller has one — threaded to :func:`_assignment_to_usage` so a
+    tier-named ``providers.definitions`` entry resolves correctly rather
+    than degrading to :class:`~coord.providers.claude.ClaudeProvider`.
+    ``None`` (the default) preserves pre-#2305 behaviour.
     """
     result: list[AssignmentUsage] = []
     for a in board_assignments:
         if not a.assignment_id:
             continue
         remote = (remote_by_id or {}).get(a.assignment_id)
-        result.append(_assignment_to_usage(a, logs_dir=logs_dir, remote_data=remote))
+        result.append(
+            _assignment_to_usage(a, logs_dir=logs_dir, remote_data=remote, cfg=cfg)
+        )
     return result
 
 
@@ -321,12 +347,16 @@ def build_session_usage(
     logs_dir: Path | None = None,
     remote_by_id: dict[str, dict] | None = None,
     started_at: float | None = None,
+    cfg: "Config | None" = None,
 ) -> SessionUsage:
     """Build a :class:`SessionUsage` from the current board.
 
     *started_at* should come from ``session.json["started_at"]`` (parsed to
     a Unix timestamp).  If not provided we fall back to the oldest
     ``dispatched_at`` among the assignments.
+
+    *cfg* (#2305): passed straight through to :func:`collect_usage` — see
+    its docstring.
     """
     if started_at is None:
         # Derive from oldest dispatch time on the board.
@@ -341,6 +371,7 @@ def build_session_usage(
         board_assignments,
         logs_dir=logs_dir,
         remote_by_id=remote_by_id,
+        cfg=cfg,
     )
     return SessionUsage(started_at=started_at, assignments=assignments)
 

{code_coordinator-0.5.536 → code_coordinator-0.5.538}/tests/test_cli_gate_a.py

@@ -209,6 +209,40 @@ class TestGateACommand:
         assert result.exit_code == 1
         assert "coord acceptance mock" in result.output
 
+    def test_a_rate_limited_read_is_not_reported_as_a_missing_contract(
+        self, config_file: Path, coord_db
+    ) -> None:
+        """#2973: a failed contents-API read (GitHub secondary rate limit)
+        must not be folded into the same "does not exist" outcome as a
+        genuine 404 — the file was on `main` the whole time; only the read
+        failed. Reporting it as absent recommends `coord acceptance mock`,
+        which against an already-approved milestone dispatches a duplicate
+        mock-author."""
+        from coord.github_ops import GhRateLimitError
+
+        def _repo_file(repo: str, path: str, branch: str | None = None) -> str:
+            raise GhRateLimitError(
+                "gh api repos/acme/api/contents/tests/acceptance/ms-37/"
+                "contract.md?ref=main failed: API rate limit exceeded for "
+                "user ID 12345",
+                secondary=True,
+            )
+
+        with patch(
+            "coord.github_ops.get_issue",
+            return_value={"title": "ms-37 epic", "milestone": {"number": 37}, "labels": []},
+        ), patch("coord.github_ops.get_repo_file", side_effect=_repo_file):
+            result = CliRunner().invoke(
+                main,
+                ["gate-a", "--approved", "api", "900", "--config", str(config_file)],
+            )
+
+        assert result.exit_code == 1
+        assert "does not exist" not in result.output
+        assert "coord acceptance mock" not in result.output
+        assert "rate limit" in result.output.lower()
+        assert "retry" in result.output.lower()
+
     def test_unknown_repo_exits_two(self, config_file: Path, coord_db) -> None:
         result = _run(config_file, ["--approved", "nope", "900"])
         assert result.exit_code == 2

{code_coordinator-0.5.536 → code_coordinator-0.5.538}/tests/test_cli_status_provider.py

@@ -17,13 +17,18 @@ stays uncluttered — only a non-default backend earns the tag.
 
 from __future__ import annotations
 
+import logging
+from pathlib import Path
+
 import coord.network as network_mod
+import pytest
 from click.testing import CliRunner
 
 from coord.commands.status import status as status_cmd
 from coord.models import Assignment, Board
 from coord.network import MachineStatus, StatusResult
 from coord.state import save_board
+from tests.conftest import VALID_CONFIG
 
 
 def _work(
@@ -188,3 +193,46 @@ def test_busy_line_omits_provider_when_absent(valid_config_path, monkeypatch) ->
     )
     assert result.exit_code == 0, result.output
     assert "provider=" not in result.output, result.output
+
+
+# ── #2305: tier-named providers.definitions must resolve, not degrade ──────
+
+
+@pytest.fixture
+def tier_provider_config_path(tmp_path: Path) -> Path:
+    """`valid_config_path` plus a tier-named `providers.definitions` entry —
+    the real fleet shape #2305 is about (`oc-mid` etc.), not a builtin
+    provider *type* name."""
+    p = tmp_path / "coordinator.yml"
+    p.write_text(
+        VALID_CONFIG
+        + "\nproviders:\n"
+        "  definitions:\n"
+        "    oc-mid:\n"
+        "      type: opencode\n"
+    )
+    return p
+
+
+def test_status_resolves_tier_named_provider_without_warning(
+    tier_provider_config_path, monkeypatch, coord_db, caplog: pytest.LogCaptureFixture,
+) -> None:
+    """#2305 acceptance criterion: `coord status` against a board holding a
+    tier-named assignment (`oc-mid`, not a built-in `claude`/`claude-pty`/
+    `opencode` type name) must resolve the assignment's own provider
+    definition — no `get_provider: unknown provider_name` warning — because
+    `build_session_usage()` (feeding the burn-rate line) is now handed
+    `cfg`, which carries `providers.definitions`."""
+    save_board(Board(completed=[_work("w1", provider_name="oc-mid")]))
+    monkeypatch.setattr(network_mod, "check_all", lambda *a, **k: [])
+    runner = CliRunner()
+    with caplog.at_level(logging.WARNING, logger="coord.providers"):
+        result = runner.invoke(
+            status_cmd,
+            ["--config", str(tier_provider_config_path)],
+            catch_exceptions=False,
+        )
+    assert result.exit_code == 0, result.output
+    assert not any(
+        "unknown provider_name" in r.message for r in caplog.records
+    ), [r.message for r in caplog.records]