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

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

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

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

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

{code_coordinator-0.5.536 → code_coordinator-0.5.537}/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.537}/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.537}/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.537}/tests/test_milestone_dispatch.py

@@ -450,6 +450,33 @@ class TestGateAStatus:
             reason = gate_a_status(repo, cfg, 9)
         assert reason is None
 
+    def test_rate_limited_read_is_not_reported_as_a_missing_contract(self) -> None:
+        """#2973: `coord milestone dispatch`/`coord milestone gate-b` echo
+        this reason verbatim to a human. A rate-limited read must not be
+        folded into "does not exist" — that outcome recommends `coord
+        acceptance mock`, which against a milestone that already has an
+        approved contract dispatches a duplicate mock-author."""
+        from coord.github_ops import GhRateLimitError
+
+        cfg = self._cfg(with_driver=True)
+        repo = cfg.repo("api")
+        with patch(
+            "coord.github_ops.get_repo_file",
+            side_effect=GhRateLimitError(
+                "gh api repos/acme/api/contents/tests/acceptance/ms-9/"
+                "contract.md?ref=main failed: API rate limit exceeded for "
+                "user ID 12345",
+                secondary=True,
+            ),
+        ):
+            reason = gate_a_status(repo, cfg, 9)
+        assert reason is not None
+        assert "does not exist" not in reason
+        assert "coord acceptance mock" not in reason
+        assert "rate limit" in reason.lower()
+        assert "retry" in reason.lower()
+
+
 
 class TestGateAStatusRelocatedSlices:
     """#2896: a repo with an entrypoint-linked route (the relocated
@@ -510,6 +537,53 @@ class TestGateAStatusRelocatedSlices:
         assert "tests/acceptance/ms-65/contract.md" in reason
         assert "tui/tests/acceptance/ms-65/contract.md" in reason
 
+    def test_a_later_candidate_confirming_existence_wins_over_an_earlier_rate_limit(
+        self,
+    ) -> None:
+        """#2973: mirrors `coord.commands.gate_a._fetch_contract`'s
+        precedence rule — a confirmed existence on ANY candidate wins
+        outright, even after an earlier candidate's transient failure. Only
+        when NOTHING confirms existence does the earlier transient failure
+        make the whole read inconclusive (see the next test)."""
+        from coord.github_ops import GhTransientError
+
+        cfg = self._cfg()
+        repo = cfg.repo("claude-coordinator")
+        calls: list[str] = []
+
+        def _check(repo_github: str, path: str, branch: str) -> bool:
+            calls.append(path)
+            if len(calls) == 1:
+                raise GhTransientError("secondary_rate_limit backoff active")
+            return True
+
+        assert gate_a_status(repo, cfg, 65, file_exists=_check) is None
+        assert len(calls) == 2
+
+    def test_an_unresolved_transient_failure_is_reported_distinctly_from_a_404(
+        self,
+    ) -> None:
+        """#2973: the first candidate's read fails transiently, the second
+        genuinely 404s — the transient failure must still win (it's
+        inconclusive, not a confirmed absence), and the block reason must
+        say so rather than recommending `coord acceptance mock`."""
+        from coord.github_ops import GhTransientError
+
+        cfg = self._cfg()
+        repo = cfg.repo("claude-coordinator")
+
+        def _check(repo_github: str, path: str, branch: str) -> bool:
+            if path == "tests/acceptance/ms-65/contract.md":
+                raise GhTransientError("secondary_rate_limit backoff active")
+            return False
+
+        reason = gate_a_status(repo, cfg, 65, file_exists=_check)
+        assert reason is not None
+        assert "does not exist" not in reason
+        assert "coord acceptance mock" not in reason
+        assert "rate limit" in reason.lower() or "secondary_rate_limit" in reason
+        assert "retry" in reason.lower()
+
 
 # ── issue_oracle_ready (#1138, docs/ORACLE_LOOP.md issue-level gate) ─────────
 
@@ -928,6 +1002,55 @@ class TestIssueOracleReady:
             "acme/api", "tests/acceptance/ms-37/manifest.yml", branch="main",
         )
 
+    def test_rate_limited_default_file_exists_fails_open_without_crashing(self) -> None:
+        """#2973: `issue_oracle_ready`'s own docstring says a Gate-A-not-yet-
+        satisfied outcome (confirmed 404 OR now, inconclusive) is a no-op —
+        dispatch proceeds as if this gate doesn't apply, rather than firing
+        a confusing refusal before the contract even exists. A rate-limited
+        existence read must reach that same no-op WITHOUT raising through
+        `issue_oracle_ready` — this is `coord.dispatch.
+        enforce_oracle_readiness`'s hard gate on every Work dispatch, so an
+        uncaught exception here would turn one rate-limited read into a
+        fleet-wide dispatch outage, exactly the failure mode this module's
+        fail-soft design exists to avoid."""
+        from coord.github_ops import GhRateLimitError
+
+        cfg = _oracle_cfg()
+        repo = cfg.repo("api")
+        with patch(
+            "coord.github_ops.get_repo_file",
+            side_effect=GhRateLimitError("secondary_rate_limit backoff active"),
+        ):
+            readiness = issue_oracle_ready(repo, cfg, 37, 1118)
+        assert readiness.applies is False
+        assert readiness.reason is None
+
+    def test_manifest_read_transient_error_degrades_to_no_slice_without_crashing(
+        self,
+    ) -> None:
+        """#2973: once Gate A's existence check has passed, a *separate*
+        transient failure reading the (advisory) manifest/exempt data must
+        still degrade to "no slice authored yet" — the pre-existing
+        fail-soft behaviour for a genuine 404 — rather than propagating as
+        an uncaught exception."""
+        from coord.github_ops import GhTransientError
+
+        cfg = _oracle_cfg()
+        repo = cfg.repo("api")
+
+        def _fetch(repo_github: str, path: str, branch: str) -> str | None:
+            if path.endswith("contract.md"):
+                return CONTRACT
+            raise GhTransientError("secondary_rate_limit backoff active")
+
+        readiness = issue_oracle_ready(
+            repo, cfg, 37, 1118,
+            file_exists=lambda *a: True, fetch_manifest=_fetch,
+            fetch_gate_a_approval=_approval(),
+        )
+        assert readiness.applies is True
+        assert readiness.has_slice is False
+
 
 class TestIssueOracleReadyRelocatedSlices:
     """#2896: ms-65's contract/manifest live under
@@ -992,6 +1115,39 @@ class TestIssueOracleReadyRelocatedSlices:
         assert readiness.has_slice is False
         assert readiness.reason is not None
 
+    def test_transient_failure_on_one_candidate_does_not_crash_the_signoff_read(
+        self,
+    ) -> None:
+        """#2973: the legacy repo-root candidate rate-limits, the relocated
+        candidate is the real one and has content — `gate_a_status` already
+        passes on the relocated candidate (see
+        `TestGateAStatusRelocatedSlices`); `gate_a_signoff`'s own content
+        read must likewise keep walking past the transient failure rather
+        than raising through `issue_oracle_ready`."""
+        from coord.github_ops import GhTransientError
+
+        cfg = self._cfg()
+        repo = cfg.repo("claude-coordinator")
+        mapping = {
+            "tui/tests/acceptance/ms-65/contract.md": CONTRACT,
+            "tui/tests/acceptance/ms-65/manifest.yml": "tests:\n  ms65::a: 2282\n",
+        }
+
+        def fetch(repo_github: str, path: str, branch: str) -> str | None:
+            if path == "tests/acceptance/ms-65/contract.md":
+                raise GhTransientError("secondary_rate_limit backoff active")
+            return mapping.get(path)
+
+        readiness = issue_oracle_ready(
+            repo, cfg, 65, 2282,
+            fetch_manifest=fetch,
+            fetch_gate_a_approval=_approval(repo_name="claude-coordinator", milestone=65),
+        )
+        assert readiness.applies is True
+        assert readiness.has_slice is True
+        assert readiness.reason is None
+        assert readiness.gate_a_state == "approved"
+
 
 # ── fetch_milestone_context ──────────────────────────────────────────────────