code-coordinator 0.5.70__tar.gz → 0.5.71__tar.gz

{code_coordinator-0.5.70 → code_coordinator-0.5.71}/PKG-INFO

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

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

@@ -1,7 +1,7 @@
 {
-  "tag": "0.5.70",
+  "tag": "0.5.71",
   "distance": 0,
-  "node": "g522a9f215942bd8d54b0906c6f672934c636ad73",
+  "node": "g61fe32cffef6c91f2bf3f8b2535b211f0c81996c",
   "dirty": false,
   "branch": "HEAD",
   "node_date": "2026-08-14"

{code_coordinator-0.5.70 → code_coordinator-0.5.71}/coord/drive.py

@@ -413,6 +413,10 @@ class AcceptanceGateChecker(Protocol):
         issue_labels: tuple[str, ...],
     ) -> bool: ...
 
+    def has_authored_slice(
+        self, repo_name: str, milestone_number: int, issue_number: int,
+    ) -> bool: ...
+
 
 @dataclass
 class GitHubAcceptanceGateChecker:
@@ -478,6 +482,35 @@ class GitHubAcceptanceGateChecker:
         )
         return readiness.exempt
 
+    def has_authored_slice(
+        self, repo_name: str, milestone_number: int, issue_number: int,
+    ) -> bool:
+        """#2061: the AUTHORITATIVE answer to "has this issue's JIT slice
+        landed?" — the manifest on the repo's default branch, read via the
+        identical ``test_ids_for_issue`` check the #1138 hard gate
+        (:func:`coord.milestone_dispatch.issue_oracle_ready`) already
+        performs, exposed here as ``OracleReadiness.has_slice``.
+
+        :func:`_decide_acceptance_author` calls this — instead of trusting
+        the `type="test-author"` assignment row alone — at every point
+        where the row is about to be read as "nothing was authored": no
+        row yet, or a terminal (``failed``/``cancelled``/``advisory``/
+        ``done``) status with no branch commits. The assignment row is a
+        PROXY for this question; it can be stale (a drive that died
+        mid-run, a retry, or a #2020-mangled row) while an EARLIER attempt
+        already merged the slice. The manifest cannot lie about that: if
+        the slice is there, it landed, whatever the row says.
+        """
+        from coord.milestone_dispatch import issue_oracle_ready  # noqa: PLC0415
+
+        repo_cfg = self.config.repo(repo_name)
+        if repo_cfg is None:
+            return False
+        readiness = issue_oracle_ready(
+            repo_cfg, self.config, milestone_number, issue_number,
+        )
+        return readiness.has_slice
+
 
 @dataclass(frozen=True)
 class OracleDecision:
@@ -623,11 +656,47 @@ def _decide_acceptance_author(
     Landing that last step is what :func:`_decide_acceptance_landing` does,
     with the same bounded ``coord merge --only <aid>`` call
     :func:`_decide_merge` already makes for the work row.
+
+    **#2061 — the assignment row is a proxy, the manifest is the answer.**
+    Every branch below that would otherwise treat "no row" or "a terminal
+    row with no branch commits" as "nothing was authored" first asks
+    :func:`_slice_already_landed`, which reads the manifest on the repo's
+    default branch — the same ``test_ids_for_issue`` check the #1138 hard
+    gate performs. A drive retry re-dispatches this gate without knowing
+    whether an EARLIER attempt already merged the slice; the second author
+    then correctly does nothing (``DONE`` with zero commits, or a stale
+    row that never even started) and, pre-#2061, that correct no-op was
+    read as a terminal failure — killing a run whose slice was already
+    landed and whose real work was ready to dispatch (coord-portal#13).
     """
     aid = state.acceptance_author_aid
     status = state.acceptance_author_status
 
+    def _slice_already_landed() -> bool:
+        """#2061: the `type="test-author"` row above is a PROXY for "has
+        this issue's slice landed?" — a drive that died mid-run, a retry,
+        or a #2020-mangled row can leave it pointing at nothing (or at a
+        genuine failure) while an EARLIER attempt already merged the slice
+        from a previous run. Ask the AUTHORITATIVE question — the manifest
+        on the default branch, via :meth:`AcceptanceGateChecker.
+        has_authored_slice` — whenever the row is about to be read as
+        "nothing was authored": right before dispatching a fresh author,
+        and right before declaring a terminal, commit-less row a failure.
+        Never consulted for "" / "running" (still authoring — the slice
+        cannot be on the default branch yet) or "merged" (already the
+        strongest signal there is), so this costs one extra fetch at a
+        decision point, not one per poll tick.
+        """
+        return gate_checker.has_authored_slice(
+            state.repo, state.milestone_number, state.issue,
+        )
+
     if not aid:
+        # #2061: a retry (or a drive resuming after this run's own board
+        # row went missing/stale) must not re-dispatch an author for a
+        # slice that already landed from an earlier attempt.
+        if _slice_already_landed():
+            return None
         command = [
             "acceptance", "author", state.repo, str(oracle.tracking_issue),
             "--issue", str(state.issue),
@@ -671,6 +740,12 @@ def _decide_acceptance_author(
         return None
 
     if status == "failed":
+        # #2061: this row's FAILED status describes what happened to THIS
+        # author, not whether the issue's slice exists — a retry's row can
+        # fail (or simply be stale) while an earlier attempt already merged
+        # the slice it was about to re-author.
+        if _slice_already_landed():
+            return None
         return _die(
             f"acceptance author {aid} failed — inspect: coord log {aid} "
             f"--machine {state.acceptance_author_machine or machine}\n"
@@ -679,6 +754,8 @@ def _decide_acceptance_author(
         )
 
     if status == "cancelled":
+        if _slice_already_landed():
+            return None
         return _die(
             f"acceptance author {aid} was cancelled — re-dispatch by hand: "
             f"coord acceptance author {state.repo} {oracle.tracking_issue} "
@@ -700,6 +777,11 @@ def _decide_acceptance_author(
         branch = state.acceptance_author_branch
         probe = replace(state, work_branch=branch) if branch else state
         if not branch or not verifier.branch_has_commits(probe):
+            # #2061: a commit-less ADVISORY row IS what an earlier-landed
+            # slice's stale/retried author row looks like — check the
+            # manifest before declaring failure.
+            if _slice_already_landed():
+                return None
             return _die(
                 f"acceptance author {aid} exited ADVISORY with no commits on "
                 "its branch — nothing was authored, so there is no slice to "
@@ -741,6 +823,13 @@ def _decide_acceptance_author(
         branch = state.acceptance_author_branch
         probe = replace(state, work_branch=branch) if branch else state
         if not branch or not verifier.branch_has_commits(probe):
+            # #2061 (coord-portal#13): a re-dispatched author that lands in
+            # a world where the slice is ALREADY on the default branch
+            # correctly does nothing — DONE with zero commits — and that is
+            # not a failure to re-diagnose, it's the terminal case this
+            # whole gate exists to detect. Check the manifest before dying.
+            if _slice_already_landed():
+                return None
             branch_display = repr(branch) if branch else "(none)"
             return _die(
                 f"acceptance author {aid} exited DONE, but its branch "

{code_coordinator-0.5.70 → code_coordinator-0.5.71}/tests/test_drive.py

@@ -455,14 +455,17 @@ class FakeGateChecker:
         for_path: str | None = None,
         for_path_error: Exception | None = None,
         exempt: bool = False,
+        landed: bool = False,
     ) -> None:
         self._exists = exists
         self._for_path = for_path
         self._for_path_error = for_path_error
         self._exempt = exempt
+        self._landed = landed
         self.calls: list[tuple[str, int]] = []
         self.for_path_calls: list[tuple[str, int]] = []
         self.exempt_calls: list[tuple[str, int, int, tuple[str, ...]]] = []
+        self.landed_calls: list[tuple[str, int, int]] = []
 
     def contract_exists(self, repo_name: str, milestone_number: int) -> bool:
         self.calls.append((repo_name, milestone_number))
@@ -484,6 +487,12 @@ class FakeGateChecker:
         self.exempt_calls.append((repo_name, milestone_number, issue_number, issue_labels))
         return self._exempt
 
+    def has_authored_slice(
+        self, repo_name: str, milestone_number: int, issue_number: int,
+    ) -> bool:
+        self.landed_calls.append((repo_name, milestone_number, issue_number))
+        return self._landed
+
 
 def oracle_state(**kw) -> IssueState:
     base = dict(milestone_number=38, milestone_tracking_issue=1120)
@@ -607,6 +616,17 @@ def test_the_default_gate_checker_is_issue_exempt_reuses_the_1138_hard_gate():
     assert "issue_oracle_ready" in src
 
 
+def test_the_default_gate_checker_has_authored_slice_reuses_the_1138_hard_gate():
+    """#2061: "has the slice landed?" must be answered from the SAME
+    manifest-vs-default-branch read the #1138 hard gate performs
+    (`issue_oracle_ready`'s `has_slice`), not a fresh re-derivation that
+    could drift from it."""
+    import inspect
+
+    src = inspect.getsource(GitHubAcceptanceGateChecker.has_authored_slice)
+    assert "issue_oracle_ready" in src
+
+
 def test_the_default_gate_checker_reuses_gate_a_status_not_a_reimplementation():
     """#1453: must not drift from tui's gate_a_contract_exists_for /
     coord.milestone_dispatch.gate_a_status — both keyed on
@@ -758,13 +778,34 @@ def test_oracle_active_authors_the_slice_before_dispatching_work():
     )
 
 
+def test_oracle_active_skips_dispatching_a_new_author_when_the_slice_already_landed():
+    """#2061 (coord-portal#13): a retry must not re-author a slice that
+    already merged from an earlier attempt — ask the manifest, not just
+    the (possibly missing/stale) assignment row, before dispatching."""
+    oracle = OracleDecision(True, "ORACLE DRIVE", tracking_issue=1120)
+    checker = FakeGateChecker(landed=True)
+    action = step(oracle_state(), oracle=oracle, gate_checker=checker)
+    assert action.kind == RUN
+    assert action.command == (
+        "assign", "precision", REPO, "1392",
+        "--driven-by", f"drive:{REPO}#1392",
+    )
+    assert checker.landed_calls == [(REPO, 38, 1392)]
+
+
 def test_oracle_active_waits_while_the_slice_is_still_authoring():
     oracle = OracleDecision(True, "ORACLE DRIVE", tracking_issue=1120)
+    checker = FakeGateChecker()
     action = step(
         state(acceptance_author_aid="ta1", acceptance_author_status="running"),
         oracle=oracle,
+        gate_checker=checker,
     )
     assert action.kind == WAIT
+    # #2061: "still authoring" never needs the authoritative manifest read —
+    # the slice cannot possibly be on the default branch yet, so this must
+    # not pay a GitHub fetch on every poll tick.
+    assert checker.landed_calls == []
 
 
 def test_oracle_active_dispatches_work_once_the_slice_has_merged():
@@ -792,6 +833,24 @@ def test_oracle_active_is_terminal_when_the_slice_authoring_fails():
     assert "--no-acceptance" in action.message
 
 
+def test_oracle_active_failed_row_is_not_terminal_when_the_slice_already_landed():
+    """#2061: a FAILED row describes what happened to THIS author, not
+    whether the issue's slice exists — a stale/retried row can fail (or
+    just be wrong) while an earlier attempt already merged the slice."""
+    oracle = OracleDecision(True, "ORACLE DRIVE", tracking_issue=1120)
+    checker = FakeGateChecker(landed=True)
+    action = step(
+        oracle_state(acceptance_author_aid="ta1", acceptance_author_status="failed"),
+        oracle=oracle,
+        gate_checker=checker,
+    )
+    assert action.kind == RUN
+    assert action.command == (
+        "assign", "precision", REPO, "1392",
+        "--driven-by", f"drive:{REPO}#1392",
+    )
+
+
 def test_oracle_active_is_terminal_when_the_slice_authoring_is_cancelled():
     oracle = OracleDecision(True, "ORACLE DRIVE", tracking_issue=1120)
     action = step(
@@ -803,6 +862,21 @@ def test_oracle_active_is_terminal_when_the_slice_authoring_is_cancelled():
     assert "cancelled" in action.message
 
 
+def test_oracle_active_cancelled_row_is_not_terminal_when_the_slice_already_landed():
+    oracle = OracleDecision(True, "ORACLE DRIVE", tracking_issue=1120)
+    checker = FakeGateChecker(landed=True)
+    action = step(
+        oracle_state(acceptance_author_aid="ta1", acceptance_author_status="cancelled"),
+        oracle=oracle,
+        gate_checker=checker,
+    )
+    assert action.kind == RUN
+    assert action.command == (
+        "assign", "precision", REPO, "1392",
+        "--driven-by", f"drive:{REPO}#1392",
+    )
+
+
 def test_oracle_active_still_honours_do_plan_after_the_slice_has_landed():
     oracle = OracleDecision(True, "ORACLE DRIVE", tracking_issue=1120)
     action = step(
@@ -881,6 +955,30 @@ def test_oracle_active_advisory_with_no_commits_is_terminal():
     assert "no commits" in action.message
 
 
+def test_oracle_active_advisory_with_no_commits_is_not_terminal_when_the_slice_already_landed():
+    """#2061: a commit-less ADVISORY row is exactly what a stale/retried
+    author's row looks like when an earlier attempt already merged the
+    slice — check the manifest before declaring failure."""
+    oracle = OracleDecision(True, "ORACLE DRIVE", tracking_issue=1120)
+    verifier = FakeVerifier(has_commits=False)
+    checker = FakeGateChecker(landed=True)
+    action = step(
+        oracle_state(
+            acceptance_author_aid="ta1",
+            acceptance_author_status="advisory",
+            acceptance_author_branch="",
+        ),
+        oracle=oracle,
+        verifier=verifier,
+        gate_checker=checker,
+    )
+    assert action.kind == RUN
+    assert action.command == (
+        "assign", "precision", REPO, "1392",
+        "--driven-by", f"drive:{REPO}#1392",
+    )
+
+
 def test_oracle_active_advisory_with_commits_requires_accept_advisory():
     """The #1357 false-positive shape — real commits, downgraded to
     advisory anyway — must not be treated as "still landing"; it needs the
@@ -966,6 +1064,33 @@ def test_oracle_active_done_with_no_commits_is_terminal():
     assert "ta1" in action.message
 
 
+def test_oracle_active_done_with_no_commits_is_not_terminal_when_the_slice_already_landed():
+    """#2061 (coord-portal#13): the exact observed shape — a re-dispatched
+    author lands in a world where the slice is already merged from an
+    earlier attempt, correctly does nothing (DONE, zero commits), and
+    drive must read that as "already done", not re-diagnose it as a
+    failure and block the queue entry."""
+    oracle = OracleDecision(True, "ORACLE DRIVE", tracking_issue=1120)
+    verifier = FakeVerifier(has_commits=False)
+    checker = FakeGateChecker(landed=True)
+    action = step(
+        oracle_state(
+            acceptance_author_aid="ta1",
+            acceptance_author_status="done",
+            acceptance_author_branch="test-author-ms-38-slice-1124",
+        ),
+        oracle=oracle,
+        verifier=verifier,
+        gate_checker=checker,
+    )
+    assert action.kind == RUN
+    assert action.command == (
+        "assign", "precision", REPO, "1392",
+        "--driven-by", f"drive:{REPO}#1392",
+    )
+    assert checker.landed_calls == [(REPO, 38, 1392)]
+
+
 def test_oracle_active_done_with_no_branch_is_terminal():
     oracle = OracleDecision(True, "ORACLE DRIVE", tracking_issue=1120)
     verifier = FakeVerifier(has_commits=False)