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

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

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

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

{code_coordinator-0.5.69 → code_coordinator-0.5.71}/coord/agent.py

@@ -1118,6 +1118,7 @@ def _worker_subprocess_env(
     prefix: str | None = None,
     base_prefix: str | None = None,
     cwd: "str | Path | None" = None,
+    assignment_id: str | None = None,
 ) -> dict[str, str]:
     """Environment for worker `claude -p` subprocesses, with the agent's own
     venv removed (#402).
@@ -1150,6 +1151,21 @@ def _worker_subprocess_env(
     ``provider.env()`` on top of this result may still override ``PWD``
     deliberately; that ordering is preserved since we only set it here, not
     after.
+
+    #2217: ``assignment_id``, when given, is written to
+    ``COORD_ASSIGNMENT_ID``. The headless worker prompt (built in
+    ``review.py`` and elsewhere) tells every worker that if this variable is
+    set it should call ``coord report-result --assignment
+    "$COORD_ASSIGNMENT_ID" ...`` directly as the *authoritative* verdict
+    path, with the transcript-parsed ``END_REVIEW`` block as a fallback only.
+    Before this, nothing in the headless ``claude -p`` dispatch lane (this
+    function is the only place that lane's subprocess environment is built)
+    ever set the variable, so that "primary" path was dead on arrival for
+    every headless review — the fragile transcript parse was silently the
+    *only* path, not a backup. Both spawn call sites below pass
+    ``assignment_id=assignment.id`` so it's set for every worker type (review,
+    smoke, work), matching what ``coord/commands/review.py`` already reads as
+    its ``--assignment`` default.
     """
     env = dict(os.environ if base_env is None else base_env)
     pfx = sys.prefix if prefix is None else prefix
@@ -1172,6 +1188,9 @@ def _worker_subprocess_env(
     if cwd is not None:
         env["PWD"] = str(cwd)
 
+    if assignment_id is not None:
+        env["COORD_ASSIGNMENT_ID"] = assignment_id
+
     return env
 
 
@@ -6494,7 +6513,7 @@ class AgentServer:
         # daemon happened to start in — worktree confinement for those
         # providers must not depend on `bash_wrap_spawn` recomputing PWD as
         # a side effect (see `_maybe_bash_wrap`).
-        _spawn_env = _worker_subprocess_env(cwd=repo_path)
+        _spawn_env = _worker_subprocess_env(cwd=repo_path, assignment_id=assignment.id)
         # #1402: shared per-repo cargo target dir (see coord.cargo_cache).
         # Must stay in sync with the PTY path in ``_spawn_pty``.
         _spawn_env.update(
@@ -6668,7 +6687,7 @@ class AgentServer:
             # docstring above), so unlike the headless path it never got an
             # incidental PWD correction — confinement here must not depend
             # on a provider trusting $PWD over getcwd() by accident.
-            env = _worker_subprocess_env(cwd=repo_path)
+            env = _worker_subprocess_env(cwd=repo_path, assignment_id=assignment.id)
             env.setdefault("TERM", "xterm-256color")
             # #1402: point cargo at this machine's shared per-repo target dir
             # so the build cache survives worktree cleanup and is reused by

{code_coordinator-0.5.69 → 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.69 → code_coordinator-0.5.71}/tests/test_agent.py

@@ -146,6 +146,36 @@ def test_worker_env_no_cwd_leaves_pwd_untouched() -> None:
     assert env["PWD"] == "/whatever"
 
 
+def test_worker_env_sets_coord_assignment_id() -> None:
+    """#2217: the headless worker prompt (review.py) tells every worker that
+    if $COORD_ASSIGNMENT_ID is set, it must report its verdict straight to
+    the coordinator board via `coord report-result` as the *authoritative*
+    path — with the transcript-parsed END_REVIEW block as a fallback only.
+    Nothing set the variable for the headless `claude -p` dispatch lane, so
+    that "primary" instruction was dead on arrival for every review and the
+    fragile transcript parse was silently the only path. Both `_spawn` call
+    sites must pass assignment_id= so this is set for every worker type."""
+    env = _worker_subprocess_env(
+        {"PATH": "/usr/bin"},
+        prefix="/usr",
+        base_prefix="/usr",
+        assignment_id="abc123",
+    )
+    assert env["COORD_ASSIGNMENT_ID"] == "abc123"
+
+
+def test_worker_env_no_assignment_id_leaves_var_unset() -> None:
+    """When assignment_id isn't passed, COORD_ASSIGNMENT_ID must not appear
+    at all (not even empty) — callers that don't have an assignment yet
+    (e.g. standalone helper use) shouldn't leak a stale/empty value."""
+    env = _worker_subprocess_env(
+        {"PATH": "/usr/bin"},
+        prefix="/usr",
+        base_prefix="/usr",
+    )
+    assert "COORD_ASSIGNMENT_ID" not in env
+
+
 def test_health_reports_machine(tmp_path: Path) -> None:
     server = _server(tmp_path)
     h = server.health()
@@ -431,6 +461,40 @@ def test_spawn_sets_pwd_to_worktree_bash_wrap_enabled(tmp_path: Path) -> None:
     server.shutdown()
 
 
+def test_spawn_sets_coord_assignment_id(tmp_path: Path) -> None:
+    """#2217: the headless `_spawn` path must set COORD_ASSIGNMENT_ID to the
+    assignment's own id — this is the variable the review prompt tells every
+    worker to use for `coord report-result --assignment "$COORD_ASSIGNMENT_ID"
+    ...`, the "authoritative" primary verdict path. Before #2217 nothing set
+    it anywhere in this dispatch lane, so that instruction was silently
+    unreachable for every headless review; only the fragile transcript-parsed
+    END_REVIEW fallback ever ran. This test must fail against pre-#2217 code.
+    """
+    import coord.agent as agent_mod
+
+    repo = _init_repo(tmp_path / "repo")
+    server = _server(tmp_path, repo_path=repo)
+
+    captured_env: list[dict[str, str]] = []
+    real_popen = agent_mod.subprocess.Popen
+
+    def recording_popen(spawn_argv, *args, **kwargs):
+        if kwargs.get("start_new_session"):
+            captured_env.append(dict(kwargs.get("env") or {}))
+        return real_popen(spawn_argv, *args, **kwargs)
+
+    agent_mod.subprocess.Popen = recording_popen  # type: ignore[assignment]
+    try:
+        a = server.assign(_spec(repo, type="review"))
+        final = server.wait_for(a.id)
+    finally:
+        agent_mod.subprocess.Popen = real_popen  # type: ignore[assignment]
+
+    assert captured_env, "Popen was not called"
+    assert captured_env[0]["COORD_ASSIGNMENT_ID"] == final.id == a.id
+    server.shutdown()
+
+
 def test_pty_spawn_sets_pwd_to_repo_path(tmp_path: Path) -> None:
     """#1783: the PTY spawn path (_spawn_pty) gets the same explicit-PWD
     treatment as the headless path.

{code_coordinator-0.5.69 → 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)