code-coordinator 0.5.660__tar.gz → 0.5.661__tar.gz

{code_coordinator-0.5.660 → code_coordinator-0.5.661}/PKG-INFO

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

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

@@ -1,7 +1,7 @@
 {
-  "tag": "0.5.660",
+  "tag": "0.5.661",
   "distance": 0,
-  "node": "g84e0243c5811e3c81d1a5513d483f0637e3c0f74",
+  "node": "g1152ba357daaa2b42b64f3ba32ee103d459ff668",
   "dirty": false,
   "branch": "HEAD",
   "node_date": "2026-10-22"

{code_coordinator-0.5.660 → code_coordinator-0.5.661}/coord/commands/merge.py

@@ -2114,7 +2114,12 @@ def merge(
         # #1477: re-test any parked CONFLICT entry before resolving
         # --only — a branch repaired since the last tick should be eligible
         # for --only the moment it's clean, not only after a manual --drop.
+        # Keep the events so the --override-human-required check below can
+        # tell "already HUMAN_REQUIRED" apart from "just auto-cleared by this
+        # same reconcile pass" instead of treating the latter as a usage error.
+        _reconciled_assignment_ids = set()
         for _ev in mq.reconcile_conflict_entries(gh_ops):
+            _reconciled_assignment_ids.add(_ev.entry.assignment_id)
             click.echo(
                 f"  {_ev.entry.repo_name} #{_ev.entry.issue_number} "
                 f"({_ev.entry.branch}): {_ev.kind} — {_ev.message}"
@@ -2173,49 +2178,63 @@ def merge(
         # so it gets its own flag, its own validation, and its own audit
         # row, never bundled into --force-merge.
         if override_human_required:
+            _override_already_moot = False
             if only_entry.state != HUMAN_REQUIRED:
-                click.echo(
-                    "error: --override-human-required only applies to a "
-                    f"HUMAN_REQUIRED entry; {only_assignment!r} is in state "
-                    f"{only_entry.state!r}",
-                    err=True,
-                )
-                sys.exit(1)
-            if dry_run:
-                click.echo(
-                    "  --override-human-required: (dry run) would clear "
-                    f"HUMAN_REQUIRED on {only_assignment!r} — "
-                    f"{override_human_required!r}"
-                )
-            else:
-                from coord.audit import record_audit  # noqa: PLC0415
-
-                record_audit(
-                    tier="business",
-                    category="merge",
-                    event_type="human_required_override",
-                    actor="user",
-                    summary=(
-                        f"human_required override: {only_entry.repo_name}"
-                        f"#{only_entry.issue_number} ({only_assignment}) — "
-                        f"{override_human_required}"
-                    ),
-                    repo=only_entry.repo_name,
-                    issue=only_entry.issue_number,
-                    assignment_id=only_entry.assignment_id,
-                    details={"reason": override_human_required},
-                )
-                click.echo(
-                    "  --override-human-required: cleared HUMAN_REQUIRED on "
-                    f"{only_assignment!r} — {override_human_required!r} — "
-                    "requeued as PENDING"
-                )
-            # Reset in-memory state either way so the dry-run event stream
-            # below reflects what a real run would do (matching the review/
-            # smoke gate dry-run convention); actual persistence is still
-            # gated on `not dry_run` in the save block further down.
-            only_entry.state = PENDING
-            only_entry.error = None
+                if only_entry.assignment_id in _reconciled_assignment_ids:
+                    # The reconcile pass just above this already found the
+                    # PR mergeable again and cleared the latch itself — the
+                    # override the operator asked for is moot, not an error.
+                    _override_already_moot = True
+                    click.echo(
+                        "  --override-human-required: not needed — "
+                        f"{only_assignment!r} was already auto-cleared to "
+                        f"{only_entry.state!r} by the conflict reconcile pass"
+                    )
+                else:
+                    click.echo(
+                        "error: --override-human-required only applies to a "
+                        f"HUMAN_REQUIRED entry; {only_assignment!r} is in state "
+                        f"{only_entry.state!r}",
+                        err=True,
+                    )
+                    sys.exit(1)
+            if not _override_already_moot:
+                if dry_run:
+                    click.echo(
+                        "  --override-human-required: (dry run) would clear "
+                        f"HUMAN_REQUIRED on {only_assignment!r} — "
+                        f"{override_human_required!r}"
+                    )
+                else:
+                    from coord.audit import record_audit  # noqa: PLC0415
+
+                    record_audit(
+                        tier="business",
+                        category="merge",
+                        event_type="human_required_override",
+                        actor="user",
+                        summary=(
+                            f"human_required override: {only_entry.repo_name}"
+                            f"#{only_entry.issue_number} ({only_assignment}) — "
+                            f"{override_human_required}"
+                        ),
+                        repo=only_entry.repo_name,
+                        issue=only_entry.issue_number,
+                        assignment_id=only_entry.assignment_id,
+                        details={"reason": override_human_required},
+                    )
+                    click.echo(
+                        "  --override-human-required: cleared HUMAN_REQUIRED on "
+                        f"{only_assignment!r} — {override_human_required!r} — "
+                        "requeued as PENDING"
+                    )
+                # Reset in-memory state either way so the dry-run event
+                # stream below reflects what a real run would do (matching
+                # the review/smoke gate dry-run convention); actual
+                # persistence is still gated on `not dry_run` in the save
+                # block further down.
+                only_entry.state = PENDING
+                only_entry.error = None
         # #2157: MERGED is the one non-PENDING state that is not a failure.
         # An exit code reports whether the CALLER's postcondition holds, and
         # for `--only <aid>` that postcondition is "aid's branch is on the

{code_coordinator-0.5.660 → code_coordinator-0.5.661}/coord/merge_queue.py

@@ -5763,21 +5763,69 @@ def refresh_entry_assignment(
 
 # ── Stale-conflict reconciliation (#1477) ───────────────────────────────────
 
+# A HUMAN_REQUIRED entry's `error` is not always the pristine original
+# conflict message: `coord.reconcile`'s conflict-fix completion hook builds
+# several of its own escalation messages as `f"{existing_error}; ..."`,
+# prefixing a fresh explanation onto whatever was already there rather than
+# replacing it. `classify_conflict` only pattern-matches wording, so a
+# message carrying one of these prefixes can still contain a `_REBASEABLE_
+# SIGNALS` phrase from the ORIGINAL conflict text and classify as
+# "rebaseable" even though the actual latch reason has nothing to do with
+# mergeability (the branch's content already landed elsewhere, a worker was
+# killed by a usage-limit reset, a reword was refused as non-content-
+# preserving, or an escalation attempt itself could not be dispatched).
+# These phrases are the ones `reconcile_conflict_entries` must still
+# recognize and refuse to unpark, even when `classify_conflict` disagrees.
+_NON_MERGEABILITY_HUMAN_REQUIRED_SIGNALS = (
+    "not a real conflict",  # usage-limit kill — never was a conflict
+    "nothing to merge",  # already-upstream — content already landed elsewhere
+    "manual reword required",  # reword worker declined a non-content-preserving rewrite
+    "escalation could not be dispatched",  # ordinary conflict-fix escalation itself declined
+)
+
+
+def _is_non_mergeability_human_latch(error: str | None) -> bool:
+    """True when ``error`` carries a known non-mergeability escalation
+    phrase, even though it may also contain conflict wording from a
+    prefixed original message (see ``_NON_MERGEABILITY_HUMAN_REQUIRED_
+    SIGNALS`` above).
+    """
+    if not error:
+        return False
+    text = error.lower()
+    return any(sig in text for sig in _NON_MERGEABILITY_HUMAN_REQUIRED_SIGNALS)
+
+
 def reconcile_conflict_entries(gh_ops: "GhOps") -> list["MergeEvent"]:
-    """Re-test every ``CONFLICT`` entry's mergeability and clear stale verdicts.
+    """Re-test stale conflict verdicts (``CONFLICT``, and retry-cap-latched
+    ``HUMAN_REQUIRED``) against live mergeability and clear them when stale.
 
     A ``CONFLICT`` entry caches the ``gh pr merge`` failure message from
     whenever the queue last attempted it, and ``process()`` never looks at it
     again — it only ever iterates ``PENDING`` entries. When a conflict-fix
-    worker (#241) lands a rebase, or a human pushes a fix by hand, the branch
+    worker lands a rebase, or a human pushes a fix by hand, the branch
     becomes clean but the entry sits parked on the old verdict forever,
-    requiring the three-step manual incantation described in #1477
-    (``--drop`` → a bare re-enqueue → ``--only``) to notice.
-
-    This re-tests GitHub's own mergeability computation for every
-    ``CONFLICT`` entry that has an open PR and, when it now reports clean,
-    returns the entry to ``PENDING`` and clears the stored error so it
-    re-enters the ordinary merge flow on this tick — no manual archaeology.
+    requiring a manual ``--drop`` → re-enqueue → ``--only`` incantation to
+    notice.
+
+    The same staleness bites a ``HUMAN_REQUIRED`` entry escalated after a
+    conflict-fix retry-cap hit: if the branch was rebased or the conflict
+    resolved by hand afterwards (e.g. a develop merge that happened to land
+    after the latch), the cached error is now pure archaeology and nothing
+    else re-checks it — a clean, approved branch stays blocked until a
+    manual ``--override-human-required``. Eligibility here requires BOTH
+    that :func:`classify_conflict` reads the message as ``"rebaseable"``
+    AND that it does not carry one of the ``_NON_MERGEABILITY_HUMAN_
+    REQUIRED_SIGNALS`` phrases — a permission/protection latch
+    (``classify_conflict(...) == "human"``), and any latch whose actual
+    cause was never a mergeability question in the first place (content
+    already upstream, a usage-limit kill, a declined reword, a declined
+    escalation), are left untouched.
+
+    This re-tests GitHub's own mergeability computation for every eligible
+    entry that has an open PR and, when it now reports clean, returns the
+    entry to ``PENDING`` and clears the stored error so it re-enters the
+    ordinary merge flow on this tick — no manual archaeology.
 
     Fail-closed by design: an entry with no PR yet, or whose mergeability
     can't be determined (``gh`` error, or GitHub still computing it — both
@@ -5812,7 +5860,22 @@ def reconcile_conflict_entries(gh_ops: "GhOps") -> list["MergeEvent"]:
     events: list[MergeEvent] = []
     changed = False
     for entry in items:
-        if entry.state != CONFLICT or not entry.pr_number:
+        if not entry.pr_number:
+            continue
+        was_human_required = entry.state == HUMAN_REQUIRED
+        if was_human_required:
+            # Only a conflict-fix retry-cap latch is a mergeability
+            # question — a permission/protection latch, or a latch whose
+            # message merely contains leftover conflict wording from a
+            # prefixed original error but was actually caused by something
+            # re-checking `check_pr_mergeable` could never resolve, is left
+            # alone.
+            if (
+                classify_conflict(entry.error) != "rebaseable"
+                or _is_non_mergeability_human_latch(entry.error)
+            ):
+                continue
+        elif entry.state != CONFLICT:
             continue
         try:
             mergeable = gh_ops.check_pr_mergeable(entry.repo_github, entry.pr_number)
@@ -5835,9 +5898,10 @@ def reconcile_conflict_entries(gh_ops: "GhOps") -> list["MergeEvent"]:
         entry.state = PENDING
         entry.error = None
         changed = True
+        cleared_kind = "human_required latch" if was_human_required else "conflict"
         events.append(MergeEvent(
             entry, "reopened",
-            f"conflict cleared — PR #{entry.pr_number} ({entry.branch}) is "
+            f"{cleared_kind} cleared — PR #{entry.pr_number} ({entry.branch}) is "
             "mergeable again, returned to pending",
         ))
     if changed:

{code_coordinator-0.5.660 → code_coordinator-0.5.661}/tests/test_cli_merge.py

@@ -1132,6 +1132,49 @@ class TestMergeOverrideHumanRequired:
         ).fetchall()
         assert rows == []
 
+    def test_override_moot_when_reconcile_already_cleared_entry(
+        self, config_file: Path, coord_dir: Path, coord_db,
+    ) -> None:
+        """`--only`'s own stale-conflict reconcile pass (#1477) runs before
+        this validation and can itself unpark a HUMAN_REQUIRED retry-cap
+        latch the moment GitHub reports the PR mergeable again. That is not
+        a usage error — the override the operator asked for is simply no
+        longer needed — so it must not be reported as one, and must not
+        write a spurious `human_required_override` audit row for an
+        override that never actually applied."""
+        entry = mq.QueuedMerge(
+            assignment_id="h1", repo_name="api", repo_github="acme/api",
+            branch="worker/h1", target_branch="main", issue_number=1,
+            issue_title="t", state=mq.HUMAN_REQUIRED, pr_number=900,
+            error="gh pr merge 900 ... --rebase failed: not mergeable",
+        )
+        _seed_queue([entry])
+
+        def fake_merge(repo, number, method="rebase"):
+            return True, "ok"
+
+        with patch("coord.github_ops.check_pr_mergeable", return_value=True), \
+             patch("coord.github_ops.create_pr") as create, \
+             patch("coord.github_ops.get_pr_size", return_value=10), \
+             patch("coord.github_ops.merge_pr", side_effect=fake_merge):
+            result = CliRunner().invoke(
+                main,
+                [
+                    "merge", "--config", str(config_file),
+                    "--only", "h1",
+                    "--override-human-required", "no longer needed",
+                ],
+            )
+
+        assert result.exit_code == 0, result.output
+        assert "not needed" in result.output
+        assert "cleared HUMAN_REQUIRED" not in result.output
+
+        rows = coord_db.execute(
+            "SELECT * FROM audit_log WHERE event_type='human_required_override'"
+        ).fetchall()
+        assert rows == []
+
     def test_override_dry_run_does_not_persist_or_audit(
         self, config_file: Path, coord_dir: Path, coord_db,
     ) -> None:

{code_coordinator-0.5.660 → code_coordinator-0.5.661}/tests/test_epic_up_down_symlinked_config_1887.py

@@ -120,17 +120,46 @@ def _fake_coord_home(tmp_path: Path) -> Path:
     return home
 
 
+def _venv_pythonpath() -> str:
+    """site-packages (for PyYAML) and REPO_ROOT (for `coord`), as the block's
+    `PYBIN` subprocess sees them.
+
+    The real daemon host's ~/.coord-venv/bin/python is a venv interpreter that
+    finds `coord` and its deps in its own site-packages. `_fake_coord_home`
+    fakes that interpreter with a bare symlink to this test process's
+    executable -- but a symlink with no adjacent `pyvenv.cfg` is not a venv, so
+    the subprocess resolves its prefix to the base interpreter and cannot see
+    the test venv's site-packages (notably PyYAML, which `coord.config` imports
+    at module top). Python 3.13 made this prefix resolution stricter, so the
+    bare symlink no longer happens to import `yaml`. Hand the subprocess the
+    exact directories where `yaml` and `coord` live for this interpreter, which
+    stands in for the real venv having them installed."""
+    import coord
+    import yaml
+
+    return os.pathsep.join(
+        str(p)
+        for p in (
+            Path(yaml.__file__).resolve().parent.parent,  # site-packages
+            Path(coord.__file__).resolve().parent.parent,  # REPO_ROOT
+        )
+    )
+
+
 def _run_remote_block(body: str, home: Path, *args: str):
     import subprocess
 
     driver = f"set -euo pipefail\n{body}\n"
+    extra_path = _venv_pythonpath()
+    existing = os.environ.get("PYTHONPATH")
+    pythonpath = f"{extra_path}{os.pathsep}{existing}" if existing else extra_path
     return subprocess.run(
         [POSIX_BASH, "-c", driver, "bash", *args],
         capture_output=True,
         text=True,
         timeout=30,
         cwd=REPO_ROOT,
-        env={**os.environ, "HOME": str(home)},
+        env={**os.environ, "HOME": str(home), "PYTHONPATH": pythonpath},
         check=False,
     )
 

{code_coordinator-0.5.660 → code_coordinator-0.5.661}/tests/test_merge_queue.py

@@ -7235,7 +7235,10 @@ class TestReconcileConflictEntries:
         assert load_queue()[0].state == CONFLICT
 
     def test_only_touches_conflict_entries(self, coord_db) -> None:
-        """PENDING/MERGED/HUMAN_REQUIRED entries are never re-tested."""
+        """PENDING/MERGED entries, and a HUMAN_REQUIRED entry with no
+        conflict-shaped error (e.g. a permission/protection latch), are
+        never re-tested. A retry-cap-latched conflict IS re-tested — see
+        ``TestReconcileHumanRequiredConflictLatch`` below (#3750)."""
         pending = _q("p", state=PENDING, pr=200)
         merged = _q("m", state=MERGED, pr=201)
         human = _q("h", state=mq.HUMAN_REQUIRED, pr=202)
@@ -7274,6 +7277,163 @@ class TestReconcileConflictEntries:
         assert states == {"clean": PENDING, "broken": CONFLICT}
 
 
+class TestReconcileHumanRequiredConflictLatch:
+    """A HUMAN_REQUIRED entry escalated by the conflict-fix retry cap must
+    be re-tested against live mergeability exactly like a plain CONFLICT
+    entry, instead of staying latched forever once the branch is actually
+    clean again. Eligibility requires both a ``"rebaseable"``
+    classification AND the absence of a known non-mergeability escalation
+    phrase (``_NON_MERGEABILITY_HUMAN_REQUIRED_SIGNALS``) — several
+    HUMAN_REQUIRED escalations build their message as
+    ``f"{existing_error}; ..."``, so the original conflict wording can
+    survive into a message whose actual cause was never a mergeability
+    question at all."""
+
+    def test_unparks_human_required_conflict_latch_when_now_mergeable(self, coord_db) -> None:
+        entry = _q("a", state=mq.HUMAN_REQUIRED, pr=100)
+        entry.error = "Pull request #100 is not mergeable"
+        save_queue([entry])
+
+        gh = FakeGh(mergeable_results={100: True})
+        events = mq.reconcile_conflict_entries(gh)
+
+        assert len(events) == 1
+        assert events[0].kind == "reopened"
+        assert "human_required latch cleared" in events[0].message
+        reloaded = load_queue()[0]
+        assert reloaded.state == PENDING
+        assert reloaded.error is None
+
+    def test_leaves_human_required_conflict_latch_parked_when_still_conflicting(
+        self, coord_db,
+    ) -> None:
+        entry = _q("a", state=mq.HUMAN_REQUIRED, pr=100)
+        entry.error = "Pull request #100 is not mergeable"
+        save_queue([entry])
+
+        gh = FakeGh(mergeable_results={100: False})
+        events = mq.reconcile_conflict_entries(gh)
+
+        assert events == []
+        reloaded = load_queue()[0]
+        assert reloaded.state == mq.HUMAN_REQUIRED
+        assert reloaded.error == "Pull request #100 is not mergeable"
+
+    def test_leaves_permission_human_required_latch_untouched(self, coord_db) -> None:
+        """A permission/protection HUMAN_REQUIRED latch is not a
+        mergeability question — it must never be probed at all."""
+        entry = _q("a", state=mq.HUMAN_REQUIRED, pr=100)
+        entry.error = "GraphQL: protected branch rules violation"
+        save_queue([entry])
+
+        gh = FakeGh(mergeable_results={100: True})
+        events = mq.reconcile_conflict_entries(gh)
+
+        assert events == []
+        assert gh.mergeable_calls == []
+        reloaded = load_queue()[0]
+        assert reloaded.state == mq.HUMAN_REQUIRED
+        assert reloaded.error == "GraphQL: protected branch rules violation"
+
+    def test_leaves_already_upstream_latch_untouched_despite_conflict_wording(
+        self, coord_db,
+    ) -> None:
+        """quadraui #3462: the stale-rebase worker found the branch's
+        content already landed elsewhere — not a conflict at all — but the
+        escalation message is built as ``f"{existing_error}; ..."``, so the
+        ORIGINAL ``"is not mergeable"`` wording survives into it. That
+        prefix must not make the entry eligible for re-probing: GitHub will
+        happily read MERGEABLE for a no-op branch, and unparking here would
+        re-enter the merge flow for a PR the system already determined has
+        nothing to merge."""
+        entry = _q("a", state=mq.HUMAN_REQUIRED, pr=100)
+        entry.error = (
+            "Pull request #100 is not mergeable; stale-rebase worker "
+            "found: no unique commits. Branch content is already present "
+            "on main (landed via another change) — nothing to merge; "
+            "close the issue or `coord drive-queue remove`."
+        )
+        save_queue([entry])
+
+        gh = FakeGh(mergeable_results={100: True})
+        events = mq.reconcile_conflict_entries(gh)
+
+        assert events == []
+        assert gh.mergeable_calls == []
+        reloaded = load_queue()[0]
+        assert reloaded.state == mq.HUMAN_REQUIRED
+
+    def test_leaves_usage_limit_latch_untouched_despite_conflict_wording(
+        self, coord_db,
+    ) -> None:
+        """A conflict-fix worker killed by the account's usage limit never
+        resolved (or failed to resolve) anything — the original conflict
+        wording surviving in the prefixed message must not make this
+        eligible."""
+        entry = _q("a", state=mq.HUMAN_REQUIRED, pr=100)
+        entry.error = (
+            "Pull request #100 is not mergeable; conflict-fix worker was "
+            "killed by the account's 5-hour usage limit — not a real "
+            "conflict. Wait for the reset, then re-run `coord merge` to "
+            "retry unchanged."
+        )
+        save_queue([entry])
+
+        gh = FakeGh(mergeable_results={100: True})
+        events = mq.reconcile_conflict_entries(gh)
+
+        assert events == []
+        assert gh.mergeable_calls == []
+        reloaded = load_queue()[0]
+        assert reloaded.state == mq.HUMAN_REQUIRED
+
+    def test_leaves_reword_mismatch_latch_untouched_despite_conflict_wording(
+        self, coord_db,
+    ) -> None:
+        """A reword-commit worker's refusal to push a non-content-
+        preserving rewrite is not a mergeability question either."""
+        entry = _q("a", state=mq.HUMAN_REQUIRED, pr=100)
+        entry.error = (
+            "Pull request #100 is not mergeable; reword-commit worker "
+            "refused to push: a conflict marker appeared mid-rebase. "
+            "Manual reword required."
+        )
+        save_queue([entry])
+
+        gh = FakeGh(mergeable_results={100: True})
+        events = mq.reconcile_conflict_entries(gh)
+
+        assert events == []
+        assert gh.mergeable_calls == []
+        reloaded = load_queue()[0]
+        assert reloaded.state == mq.HUMAN_REQUIRED
+
+    def test_leaves_declined_escalation_latch_untouched_despite_conflict_wording(
+        self, coord_db,
+    ) -> None:
+        """quadraui #3444: when the ordinary conflict-fix escalation that
+        follows a stale-rebase mismatch itself couldn't be dispatched, the
+        resulting latch is about dispatch capacity, not live
+        mergeability."""
+        entry = _q("a", state=mq.HUMAN_REQUIRED, pr=100)
+        entry.error = (
+            "Pull request #100 is not mergeable; stale-rebase worker "
+            "refused to push: a conflict marker appeared. The rebase was "
+            "not content-preserving against the new base, and the "
+            "ordinary conflict-fix escalation could not be dispatched "
+            "either — manual resolution required."
+        )
+        save_queue([entry])
+
+        gh = FakeGh(mergeable_results={100: True})
+        events = mq.reconcile_conflict_entries(gh)
+
+        assert events == []
+        assert gh.mergeable_calls == []
+        reloaded = load_queue()[0]
+        assert reloaded.state == mq.HUMAN_REQUIRED
+
+
 class TestReconcileConflictEntriesRebaseRefusalGuard:
     """#1467: a `mergeable: MERGEABLE` verdict is not evidence that a
     *rebase* merge will succeed — GitHub reports a branch carrying a merge