code-coordinator 0.5.220__tar.gz → 0.5.221__tar.gz

{code_coordinator-0.5.220 → code_coordinator-0.5.221}/PKG-INFO

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

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

@@ -1,7 +1,7 @@
 {
-  "tag": "0.5.220",
+  "tag": "0.5.221",
   "distance": 0,
-  "node": "g3b354927ade8c4466bfcb6981c100e1c23f7c41c",
+  "node": "g27baf026f5785418120546b37450a2213ff910ab",
   "dirty": false,
   "branch": "HEAD",
   "node_date": "2026-08-22"

{code_coordinator-0.5.220 → code_coordinator-0.5.221}/coord/agent.py

@@ -1076,6 +1076,37 @@ def _commits_ahead(wt_path: Path, base: str) -> int | None:
     return None
 
 
+def _pushed_commits_ahead(repo_path: Path, base: str, branch: str) -> int | None:
+    """Commits ``origin/<branch>`` is ahead of *base*, checked from *repo_path*.
+
+    #2552: used by ``_reap``'s post-cleanup recheck, run AFTER
+    ``_cleanup_worktree`` has possibly already torn the worktree down — so,
+    unlike :func:`_commits_ahead`, this never touches the (possibly gone)
+    worktree directory. It reads from *repo_path* instead, which stays valid
+    for the whole reap: branch refs (including ``refs/remotes/origin/*``)
+    live in the shared ``.git`` directory, not per-worktree.
+
+    Deliberately compares against the REMOTE-tracking ref ``origin/<branch>``
+    rather than the local branch ref. A commit that only exists locally on
+    this one agent (the push in ``_rescue_uncommitted_work`` can fail, same
+    as any push) isn't yet something Test/Review/Merge — which all operate
+    against GitHub — can act on, so it must not flip a status that implies
+    "ready for the pipeline". Returns ``None`` when the remote ref can't be
+    resolved at all (no ``origin`` configured, or the push never landed) —
+    callers should treat that exactly like :func:`_commits_ahead`'s ``None``:
+    unknown, don't act on it.
+    """
+    for base_ref in (f"origin/{base}", base):
+        try:
+            raw = _git(
+                repo_path, "rev-list", "--count", f"{base_ref}..origin/{branch}"
+            )
+            return int(raw.strip())
+        except (_GitError, ValueError):
+            continue
+    return None
+
+
 _ISSUE_REF_RE = re.compile(r"#(\d+)")
 
 
@@ -8903,6 +8934,52 @@ class AgentServer:
         if assignment is not None:
             self._cleanup_worktree(assignment)
 
+        # #2552: `_cleanup_worktree` above may have just rescued a dirty
+        # worktree into a WIP commit and pushed it (`_rescue_uncommitted_
+        # work`) — AFTER the "0 commits ahead" status decision earlier in
+        # this method already ran. That decision (ADVISORY's `zero_commit_
+        # reason`, or REFUSED_POLICY's `policy_refusal_reason`) was computed
+        # from a branch that was genuinely empty at the moment of judgement;
+        # a rescue that landed a real, pushed commit on it makes the verdict
+        # stale by construction — reporting "nothing was authored" about a
+        # branch that, four log lines later, carries the worker's actual
+        # output. Recompute from `repo_path` (not the worktree, which may
+        # already be gone) whether the rescue's push actually reached
+        # origin, and correct the status when it did. Only ADVISORY/
+        # REFUSED_POLICY are ever reachable here (both are set exclusively
+        # in the `_ahead == 0` branch above, itself gated on `spec.type in
+        # _ZERO_COMMIT_TYPES`) — DONE, FAILED-for-other-reasons, CANCELLED
+        # etc. are untouched.
+        if (
+            assignment is not None
+            and assignment.status in (ADVISORY, REFUSED_POLICY)
+            and assignment.dirty_worktree_reason is not None
+        ):
+            _rescue_branch = assignment.branch or assignment.spec.target_branch
+            if _rescue_branch:
+                _rescue_repo_path = Path(assignment.spec.repo_path).expanduser()
+                _rescue_base = assignment.spec.branch or "main"
+                _post_ahead = _pushed_commits_ahead(
+                    _rescue_repo_path, _rescue_base, _rescue_branch
+                )
+                if _post_ahead is not None and _post_ahead > 0:
+                    _prior_status = assignment.status
+                    with self._lock:
+                        _live = self._assignments.get(assignment_id)
+                        if _live is not None and _live.status == _prior_status:
+                            _live.status = DONE
+                        if assignment is not _live:
+                            assignment.status = DONE
+                    self._persist()
+                    self._log_line(
+                        assignment,
+                        "# reap: post-cleanup recheck — "
+                        f"{_post_ahead} commit(s) pushed to origin/"
+                        f"{_rescue_branch} ahead of {_rescue_base} after "
+                        f"rescue (was {_prior_status!r}); status corrected "
+                        "to done (#2552)",
+                    )
+
     def _prune_completed_history(self) -> None:
         """Drop oldest terminal assignments over _COMPLETED_HISTORY_CAP (#452).
 

{code_coordinator-0.5.220 → code_coordinator-0.5.221}/coord/test_author.py

@@ -579,6 +579,36 @@ def dispatch_test_author(
                 "work, open a fresh branch by hand — do not retry as-is."
             )
 
+    # #2552: a retried JIT dispatch re-derives this SAME branch for the same
+    # (tracking_issue, issue_number) pair, and `_setup_worktree` already
+    # resumes from `origin/<branch>` at the git level whenever it exists —
+    # the #389/#460 continuation-branch logic checks out the remote tip
+    # instead of branching fresh. So a retried worker's worktree is NOT
+    # empty when the branch already carries real commits (e.g. a #1394
+    # WIP-rescue commit left behind by a killed prior attempt) — but the
+    # briefing built above reads identically whether the branch is fresh or
+    # already has content, so nothing told the worker to check what's
+    # already there before writing more, and a worker that doesn't think to
+    # `git log` first can end up re-authoring over its own prior output.
+    # `branch_commits_ahead` asks GitHub directly (no local checkout
+    # required — the coordinator dispatching this may not have one); `None`
+    # (lookup failed) is left silent rather than asserted either way, same
+    # fail-quiet posture as every other best-effort GitHub read in this
+    # function.
+    _resume_ahead = github_ops.branch_commits_ahead(
+        repo_cfg.github, repo_cfg.default_branch or "main", branch
+    )
+    if _resume_ahead:
+        briefing += (
+            "\n\n---\nRESUMING: this branch already has "
+            f"{_resume_ahead} commit(s) on it ahead of "
+            f"{repo_cfg.default_branch or 'main'} — likely unfinished or "
+            "unverified work from an interrupted prior session (possibly a "
+            "coordinator WIP-rescue commit — see #1394). Run `git log` and "
+            "read what's already there FIRST. Continue/complete/verify it "
+            "rather than re-authoring from scratch (#2552)."
+        )
+
     deny_commands = test_author_deny_commands(config, repo_name)
 
     # #2549: this was the only dispatcher on the fleet that never sent

{code_coordinator-0.5.220 → code_coordinator-0.5.221}/tests/test_agent.py

@@ -3938,6 +3938,99 @@ def test_reap_review_type_gets_no_stash_diagnostic(tmp_path: Path) -> None:
     server.shutdown()
 
 
+def _init_repo_with_remote(path: Path) -> Path:
+    """Like `_init_repo`, but with a real (local, bare) `origin` configured
+    and `main` already pushed.
+
+    #2552's post-cleanup recheck (`AgentServer._pushed_commits_ahead`)
+    deliberately reads the REMOTE-tracking ref (`origin/<branch>`), not the
+    local branch — a rescue commit that never reached origin must not flip
+    status. `_init_repo` (no remote) can't exercise that path at all, since
+    `origin/<branch>` never exists there.
+    """
+    remote = path.parent / f"{path.name}-remote.git"
+    subprocess.run(
+        ["git", "init", "--bare", "-b", "main", str(remote)],
+        check=True, capture_output=True,
+    )
+    _init_repo(path)
+    subprocess.run(
+        ["git", "remote", "add", "origin", str(remote)],
+        cwd=str(path), check=True, capture_output=True,
+    )
+    subprocess.run(
+        ["git", "push", "-u", "origin", "main"],
+        cwd=str(path), check=True, capture_output=True,
+    )
+    return path
+
+
+def test_reap_status_reflects_post_rescue_branch_state(tmp_path: Path) -> None:
+    """#2552: a rescued WIP commit that reaches origin must correct the
+    pre-cleanup zero-commit verdict instead of leaving it standing.
+
+    Reported bug: `_reap` measures "0 commits ahead of main" (true at that
+    instant, since the worker left a tracked-file edit uncommitted) and sets
+    ADVISORY with `zero_commit_reason` — BEFORE `_cleanup_worktree` runs.
+    Cleanup then rescues the dirty worktree into a `WIP [coord-rescue]`
+    commit and pushes it (`_rescue_uncommitted_work`), landing a real commit
+    on the very branch the ADVISORY verdict was judged empty one step
+    earlier. Nothing ever revisited the verdict, so a successful #1394
+    rescue was always scored as "nothing was authored".
+
+    Drives the real `_reap` path end to end (`assign()`/`wait_for()`,
+    exactly like the neighboring stash-diagnostic tests above) rather than
+    re-implementing the ordering inline, so a regression in the actual
+    `_reap`/`_cleanup_worktree` sequence is what this test would catch.
+    """
+    repo = _init_repo_with_remote(tmp_path / "repo")
+    server = _server(
+        tmp_path,
+        argv=["/bin/sh", "-c", "echo dirty >> README; exit 0"],
+        repo_path=repo,
+    )
+
+    a = server.assign(_spec(repo))
+    final = server.wait_for(a.id, timeout=15)
+
+    assert final.status == DONE
+    assert final.dirty_worktree_reason is not None
+    assert "coord-rescue" in final.dirty_worktree_reason
+    assert "UNVERIFIED" in final.dirty_worktree_reason
+    server.shutdown()
+
+
+def test_reap_stays_advisory_when_rescue_commit_never_reaches_origin(
+    tmp_path: Path,
+) -> None:
+    """#2552 control: a rescue commit that stays LOCAL ONLY must NOT flip
+    status to done.
+
+    Same dirty-worktree shape as the test above, but the repo has no
+    `origin` at all — the WIP-rescue push has nothing to push to, so the
+    commit only ever exists on this one agent. Test/Review/Merge all operate
+    against GitHub; a branch nobody but this agent can see is not "ready for
+    the pipeline", so the post-cleanup recheck must leave the pre-existing
+    ADVISORY verdict alone (the `dirty_worktree_reason` still records that
+    real work exists — see `_record_dirty_worktree` — just not that it is
+    live anywhere the pipeline can consume it).
+    """
+    repo = _init_repo(tmp_path / "repo")  # no `origin` remote configured
+    server = _server(
+        tmp_path,
+        argv=["/bin/sh", "-c", "echo dirty >> README; exit 0"],
+        repo_path=repo,
+    )
+
+    a = server.assign(_spec(repo))
+    final = server.wait_for(a.id, timeout=15)
+
+    assert final.status == ADVISORY
+    assert final.dirty_worktree_reason is not None
+    assert "coord-rescue" in final.dirty_worktree_reason
+    server.shutdown()
+
+
 def test_sanitize_branch_replaces_slashes(tmp_path: Path) -> None:
     """_sanitize_branch should replace slashes with dashes."""
     from coord.agent import _sanitize_branch

{code_coordinator-0.5.220 → code_coordinator-0.5.221}/tests/test_test_author.py

@@ -77,6 +77,20 @@ def _pr_not_merged(monkeypatch):
     monkeypatch.setattr("coord.test_author.github_ops.pr_is_merged", lambda *a, **k: False)
 
 
+@pytest.fixture(autouse=True)
+def _no_resume_ahead(monkeypatch):
+    """#2552: default the resume-detection GitHub read (does the target
+    branch already carry commits from a prior/interrupted attempt?) to "0
+    commits ahead" so the existing happy-path tests below — which don't
+    care about this check — don't shell out to a real ``gh`` subprocess via
+    ``coord.github_ops.branch_commits_ahead``. Tests exercising the resume
+    note itself re-patch it to opt in, same convention as ``_pr_not_merged``
+    above."""
+    monkeypatch.setattr(
+        "coord.test_author.github_ops.branch_commits_ahead", lambda *a, **k: 0
+    )
+
+
 # ── pick_test_author_machine ────────────────────────────────────────────────
 
 
@@ -676,6 +690,60 @@ class TestDispatchTestAuthor:
         fake_client.post.assert_called_once()
         record_mock.assert_called_once()
 
+    def test_branch_with_prior_commits_gets_resume_note_in_briefing(self) -> None:
+        """#2552: a retry/continuation dispatch for a slice branch that
+        already carries commits (e.g. a #1394 WIP-rescue commit left by a
+        killed prior attempt) must tell the worker to look before writing —
+        `_setup_worktree` already resumes the worktree from that branch at
+        the git level, but nothing said so in the briefing text itself."""
+        cfg = _config([_machine("laptop", ["coord-tui"])], driver=self._driver())
+        fake_client = MagicMock()
+        fake_resp = MagicMock()
+        fake_resp.json.return_value = {"id": "abc123"}
+        fake_client.post.return_value = fake_resp
+
+        with patch("coord.test_author.fetch_milestone_context", return_value=self._ctx()), \
+             patch(
+                 "coord.test_author.github_ops.get_issue",
+                 return_value={"title": "Add foo", "body": "Body text"},
+             ), \
+             patch(
+                 "coord.test_author.github_ops.branch_commits_ahead", return_value=3,
+             ) as ahead_mock, \
+             patch("coord.state.record_dispatched_assignment"):
+            dispatch_test_author(
+                "coord-tui", 947, cfg, issue_number=101, http_client=fake_client,
+            )
+
+        payload = fake_client.post.call_args.kwargs["json"]
+        assert "RESUMING" in payload["briefing"]
+        assert "3 commit(s)" in payload["briefing"]
+        assert "#1394" in payload["briefing"]
+        target_branch = payload["target_branch"]
+        ahead_mock.assert_called_once_with("acme/coord-tui", "main", target_branch)
+
+    def test_fresh_branch_gets_no_resume_note_in_briefing(self) -> None:
+        """The common case (a genuinely fresh slice branch, 0 commits ahead)
+        must NOT get the resume note — it would be actively misleading."""
+        cfg = _config([_machine("laptop", ["coord-tui"])], driver=self._driver())
+        fake_client = MagicMock()
+        fake_resp = MagicMock()
+        fake_resp.json.return_value = {"id": "abc123"}
+        fake_client.post.return_value = fake_resp
+
+        with patch("coord.test_author.fetch_milestone_context", return_value=self._ctx()), \
+             patch(
+                 "coord.test_author.github_ops.get_issue",
+                 return_value={"title": "Add foo", "body": "Body text"},
+             ), \
+             patch("coord.state.record_dispatched_assignment"):
+            dispatch_test_author(
+                "coord-tui", 947, cfg, issue_number=101, http_client=fake_client,
+            )
+
+        payload = fake_client.post.call_args.kwargs["json"]
+        assert "RESUMING" not in payload["briefing"]
+
     def test_repo_deny_commands_merged(self) -> None:
         cfg = _config(
             [_machine("laptop", ["coord-tui"])],