code-coordinator 0.5.234__tar.gz → 0.5.235__tar.gz

{code_coordinator-0.5.234 → code_coordinator-0.5.235}/PKG-INFO

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

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

@@ -1,7 +1,7 @@
 {
-  "tag": "0.5.234",
+  "tag": "0.5.235",
   "distance": 0,
-  "node": "g24d0c079b3a206f0037f3385f58eefdf567c593d",
+  "node": "g5e1480a48c81b0a8cba96e6b1a3f8efc68470379",
   "dirty": false,
   "branch": "HEAD",
   "node_date": "2026-08-22"

{code_coordinator-0.5.234 → code_coordinator-0.5.235}/coord/agent.py

@@ -1110,14 +1110,36 @@ def _pushed_commits_ahead(repo_path: Path, base: str, branch: str) -> int | None
 _ISSUE_REF_RE = re.compile(r"#(\d+)")
 
 
-def _foreign_issue_refs(subject: str, issue_number: int) -> frozenset[int]:
+def _foreign_issue_refs(
+    subject: str,
+    issue_number: int,
+    extra_allowed: frozenset[int] = frozenset(),
+) -> frozenset[int]:
     """Return the set of *foreign* issue numbers referenced in *subject* —
-    those that are not *issue_number*.  Empty if the subject doesn't reference
-    any foreign issue."""
+    those that are neither *issue_number* nor in *extra_allowed*.  Empty if
+    the subject doesn't reference any foreign issue.
+
+    *extra_allowed* (#2545): for a ``type="test-author"``/``"mock-author"``
+    merge entry, *issue_number* is the milestone's TRACKING issue (every JIT
+    slice for one milestone shares a single branch/PR — see
+    ``Assignment.for_issue_number``'s docstring), but the slice's own commit
+    correctly and necessarily cites its OWN child issue
+    (``test(ms-4): ... slice #132``). Without this, every such commit was
+    flagged FOREIGN on every single verify, regardless of whether the rebase
+    was actually clean. Callers resolve the slice's own issue number (e.g.
+    via ``coord.models.effective_issue_number``) and pass it here so a
+    reference to *either* the tracking issue or the resolved slice issue
+    counts as home, not foreign. Defaults to empty, preserving the original
+    all-blocking-except-``issue_number`` behaviour for ordinary ``work``
+    assignments.
+    """
     refs = {int(m) for m in _ISSUE_REF_RE.findall(subject)}
-    if not refs or issue_number in refs:
+    if not refs:
         return frozenset()
-    return frozenset(refs - {issue_number})
+    home = {issue_number} | extra_allowed
+    if refs & home:
+        return frozenset()
+    return frozenset(refs - home)
 
 
 def _resolve_base_ref(wt_path: Path, base: str) -> str | None:
@@ -1218,6 +1240,7 @@ def verify_merge_branch(
     *,
     base: str,
     issue_number: int,
+    extra_allowed_issue_numbers: frozenset[int] = frozenset(),
     closed_issue_numbers: frozenset[int] = frozenset(),
 ) -> MergeVerify:
     """Verify a ``--merge-of`` branch before its terminal ``done`` is recorded.
@@ -1233,10 +1256,17 @@ def verify_merge_branch(
     ``claude``, no PTY — so the gate runs as a fast local-only test fixture.
 
     Args:
+        extra_allowed_issue_numbers: Additional issue numbers, besides
+            *issue_number*, that a commit subject may legitimately reference
+            without being flagged foreign (#2545) — see
+            :func:`_foreign_issue_refs`'s ``extra_allowed`` for why a
+            ``test-author``/``mock-author`` merge entry needs this (its own
+            slice issue, not just the milestone's tracking issue).
         closed_issue_numbers: Issue numbers that are known to be closed/merged
             in the upstream repo.  When a commit's subject references *only*
-            issues in this set (and not ``issue_number``), it is downgraded
-            from a **blocking** foreign finding to an **advisory** one (#1279).
+            issues in this set (and not ``issue_number`` or
+            ``extra_allowed_issue_numbers``), it is downgraded from a
+            **blocking** foreign finding to an **advisory** one (#1279).
             The rationale: a commit referencing a *closed* issue cannot be
             live rebase-pollution — it is almost certainly a worker typo in the
             commit subject.  Pass the empty frozenset (default) to preserve the
@@ -1271,7 +1301,9 @@ def verify_merge_branch(
     foreign: list[tuple[str, str]] = []
     advisory_foreign: list[tuple[str, str]] = []
     for sha, subj in added:
-        foreign_refs = _foreign_issue_refs(subj, issue_number)
+        foreign_refs = _foreign_issue_refs(
+            subj, issue_number, extra_allowed=extra_allowed_issue_numbers
+        )
         if not foreign_refs:
             continue  # not flagged — own work or bare message
         # #1279: downgrade to advisory when ALL referenced foreign issues are
@@ -1312,6 +1344,17 @@ def resolve_closed_issue_numbers(
     Returns an empty frozenset immediately when *repo_github* is falsy or
     *foreign_commits* is empty, so callers can skip the second verify pass
     entirely (``if closed: ...``) without an extra branch.
+
+    Deliberately does **not** accept an ``extra_allowed_issue_numbers``
+    parameter to thread through to :func:`_foreign_issue_refs` (#2545
+    review): *foreign_commits* here is always the ``.foreign`` list a prior,
+    ``extra_allowed``-aware :func:`verify_merge_branch` pass already
+    produced, and ``_foreign_issue_refs`` treats any overlap with the "home"
+    set (``{issue_number} | extra_allowed``) as voiding a commit's foreign
+    status entirely — so no subject surviving into *foreign_commits* can
+    reference an ``extra_allowed`` issue in the first place. If a future
+    caller ever feeds this something other than a prior pass's ``.foreign``,
+    re-check this assumption before relying on it.
     """
     foreign_commits = list(foreign_commits)
     if not repo_github or not foreign_commits:

{code_coordinator-0.5.234 → code_coordinator-0.5.235}/coord/commands/dispatch_workers.py

@@ -3355,6 +3355,26 @@ def _dispatch_merge_of(
         )
         sys.exit(2)
 
+    # #2545: a `type="test-author"`/`"mock-author"` work row's `issue_number`
+    # (== `issue` above) is always the milestone's TRACKING issue, but its
+    # commit correctly cites the slice's OWN child issue — resolved via the
+    # canonical `coord.models.effective_issue_number` helper (built for
+    # exactly this tracking-vs-slice distinction, #1553) rather than reading
+    # `for_issue_number` directly, so this stays in sync with the other
+    # callers of that helper (e.g. `merge_queue._test_author_effective_
+    # issue_number`) instead of drifting as an independent copy. Without
+    # allowing the resolved issue too, the #604 FOREIGN check below flags
+    # every JIT slice's own, correctly-labeled commit on every single verify.
+    # Ordinary `work` assignments have no `for_issue_number`, so this
+    # resolves to `issue` itself — already in the "home" set, a harmless
+    # no-op.
+    from coord.models import effective_issue_number as _mg_effective_issue_number  # noqa: PLC0415
+
+    _mg_for_issue = _mg_effective_issue_number(work)
+    _mg_extra_allowed = (
+        frozenset({_mg_for_issue}) if _mg_for_issue and _mg_for_issue != issue else frozenset()
+    )
+
     resolved_model = model if model else cfg.models.default
     assignment_id = _uuid.uuid4().hex[:12]
     if _is_local:
@@ -3607,6 +3627,9 @@ def _dispatch_merge_of(
                 # #604: git truth overrides the agent's self-report on the
                 # merge path — a botched rebase records `blocked`, not `done`.
                 verify_merge=True,
+                # #2545: allow the JIT slice's own child issue, not just the
+                # tracking issue, in the FOREIGN check.
+                extra_allowed_issue_numbers=_mg_extra_allowed,
                 branch=work.branch,
             )
             _echo_merge_finalize(finalize_result, merge_target_branch)
@@ -3869,6 +3892,9 @@ def _dispatch_merge_of(
             exit_code=exit_code,
             started_at=started_at,
             verify_merge=True,
+            # #2545: allow the JIT slice's own child issue, not just the
+            # tracking issue, in the FOREIGN check.
+            extra_allowed_issue_numbers=_mg_extra_allowed,
         )
         _echo_merge_finalize(finalize_result, merge_target_branch)
         _mv = finalize_result.merge_verify

{code_coordinator-0.5.234 → code_coordinator-0.5.235}/coord/commands/merge.py

@@ -11,7 +11,7 @@ import click
 
 
 from coord.commands._common import _CONFIG_OPTION, _load_config
-from coord.models import WORK_LIKE_TYPES
+from coord.models import WORK_LIKE_TYPES, effective_issue_number
 
 
 def _machine_for_assignment(board, assignment_id: str | None) -> str | None:
@@ -726,10 +726,26 @@ def verify_merge(
                 err=True,
             )
             sys.exit(2)
+        extra_allowed: frozenset[int] = frozenset()
     else:
         repo_name = work.repo_name
         issue_num = int(work.issue_number)
         branch_display = work.branch or "(unknown)"
+        # #2545: a `type="test-author"`/`"mock-author"` merge entry's
+        # `issue_number` is always the milestone's TRACKING issue (every JIT
+        # slice for one milestone shares a branch/PR), but its commit
+        # correctly cites the slice's OWN child issue — resolved via the
+        # canonical `effective_issue_number` helper (built for exactly this
+        # tracking-vs-slice distinction, #1553) rather than reading
+        # `for_issue_number` directly, so this stays in sync with the other
+        # callers of that helper (e.g. `merge_queue._test_author_effective_
+        # issue_number`) instead of drifting as an independent copy. Ordinary
+        # `work` assignments have no `for_issue_number`, so this resolves to
+        # `issue_num` itself — already in the "home" set, a harmless no-op.
+        _for_issue = effective_issue_number(work)
+        extra_allowed = (
+            frozenset({_for_issue}) if _for_issue and _for_issue != issue_num else frozenset()
+        )
 
     repo_cfg = cfg.repo(repo_name)
     base = (repo_cfg.default_branch if repo_cfg else None) or "main"
@@ -747,14 +763,23 @@ def verify_merge(
     repo_github = repo_cfg.github if repo_cfg else None
     wt_path = Path(path_opt).expanduser() if path_opt else Path.cwd()
 
-    mv = verify_merge_branch(wt_path, base=base, issue_number=issue_num)
+    mv = verify_merge_branch(
+        wt_path,
+        base=base,
+        issue_number=issue_num,
+        extra_allowed_issue_numbers=extra_allowed,
+    )
     # #1279: only worth a `gh` round-trip when the cheap git-only pass above
     # actually found blocking foreign commits — corroborate against GitHub's
     # closed-issue state and re-verify with the downgrade signal populated.
     closed = resolve_closed_issue_numbers(repo_github, mv.foreign, issue_num)
     if closed:
         mv = verify_merge_branch(
-            wt_path, base=base, issue_number=issue_num, closed_issue_numbers=closed
+            wt_path,
+            base=base,
+            issue_number=issue_num,
+            extra_allowed_issue_numbers=extra_allowed,
+            closed_issue_numbers=closed,
         )
 
     click.echo(f"branch:        {branch_display}")

{code_coordinator-0.5.234 → code_coordinator-0.5.235}/coord/interactive.py

@@ -3057,6 +3057,7 @@ def finalize_interactive_exit(
     repo_path: str | None = None,
     artifact_paths: list[str] | None = None,
     verify_merge: bool = False,
+    extra_allowed_issue_numbers: frozenset[int] = frozenset(),
     ssh_target: str | None = None,
     branch: str | None = None,
     smoke_repo_path: str | None = None,
@@ -3116,6 +3117,12 @@ def finalize_interactive_exit(
     session, with no structured block, no transcript floor, and no fallback
     if that command never ran (#1351). ``None`` (every non-smoke caller)
     makes this an unconditional no-op.
+
+    *extra_allowed_issue_numbers* (#2545): forwarded to
+    :func:`coord.agent.verify_merge_branch`'s parameter of the same name —
+    additional issue numbers a merge-prep commit subject may legitimately
+    reference (besides *issue_number*) without tripping the #604 FOREIGN
+    check. Only meaningful when *verify_merge* is set; ignored otherwise.
     """
     _effective_patterns = list(artifact_paths or [])
 
@@ -3197,7 +3204,10 @@ def finalize_interactive_exit(
             )
 
             merge_verify = verify_merge_branch(
-                wt_v, base=base_branch, issue_number=issue_number
+                wt_v,
+                base=base_branch,
+                issue_number=issue_number,
+                extra_allowed_issue_numbers=extra_allowed_issue_numbers,
             )
             # #1279: corroborate blocking foreign commits against GitHub's
             # closed-issue state before deciding — a typo'd reference to an
@@ -3210,6 +3220,7 @@ def finalize_interactive_exit(
                     wt_v,
                     base=base_branch,
                     issue_number=issue_number,
+                    extra_allowed_issue_numbers=extra_allowed_issue_numbers,
                     closed_issue_numbers=closed,
                 )
             if not merge_verify.ok:
@@ -3915,6 +3926,7 @@ def _remote_verify_merge_branch(
     base: str,
     issue_number: int,
     timeout: float = 30.0,
+    extra_allowed_issue_numbers: frozenset[int] = frozenset(),
     closed_issue_numbers: frozenset[int] = frozenset(),
 ) -> MergeVerify:
     """Remote (over ssh) analogue of :func:`coord.agent.verify_merge_branch`
@@ -3935,6 +3947,11 @@ def _remote_verify_merge_branch(
     same conservative "unverifiable ⇒ not ok" fallback as the local function.
 
     Args:
+        extra_allowed_issue_numbers: Mirrors the same parameter in
+            :func:`coord.agent.verify_merge_branch` (#2545) — additional
+            issue numbers, besides *issue_number*, that a commit subject may
+            legitimately reference without being flagged foreign (a
+            ``test-author``/``mock-author`` slice's own child issue).
         closed_issue_numbers: Mirrors the same parameter in
             :func:`coord.agent.verify_merge_branch` — issue numbers known to
             be closed/merged.  Foreign-subject commits referencing only
@@ -3990,7 +4007,9 @@ def _remote_verify_merge_branch(
     foreign: list[tuple[str, str]] = []
     advisory_foreign: list[tuple[str, str]] = []
     for sha, subj in added:
-        foreign_refs = _foreign_issue_refs(subj, issue_number)
+        foreign_refs = _foreign_issue_refs(
+            subj, issue_number, extra_allowed=extra_allowed_issue_numbers
+        )
         if not foreign_refs:
             continue
         if closed_issue_numbers and foreign_refs.issubset(closed_issue_numbers):
@@ -4088,6 +4107,7 @@ def finalize_remote_interactive_exit(
     started_at: float | None = None,
     artifact_paths: list[str] | None = None,
     verify_merge: bool = False,
+    extra_allowed_issue_numbers: frozenset[int] = frozenset(),
 ) -> InteractiveFinalizeResult:
     """Remote (#486d) analog of :func:`finalize_interactive_exit` for a remote
     interactive FIX (and, since #1007, a remote ``--merge-of``).
@@ -4116,6 +4136,12 @@ def finalize_remote_interactive_exit(
     self-report, so a botched remote rebase is never silently accepted as
     ``done``.  This check runs FIRST, before the ``_assignment_already_recorded``
     fast path below — do NOT reorder it after that check.
+
+    ``extra_allowed_issue_numbers`` (#2545): mirrors the same parameter on
+    :func:`finalize_interactive_exit` — forwarded to
+    :func:`_remote_verify_merge_branch` so a ``test-author``/``mock-author``
+    slice's own child-issue commit doesn't trip the FOREIGN check just
+    because *issue_number* here is the milestone's tracking issue.
     """
     _effective_patterns = list(artifact_paths or [])
 
@@ -4130,6 +4156,7 @@ def finalize_remote_interactive_exit(
         merge_verify = _remote_verify_merge_branch(
             ssh_target, remote_worktree_sh,
             base=base_branch, issue_number=issue_number,
+            extra_allowed_issue_numbers=extra_allowed_issue_numbers,
         )
         # #1279: same corroboration as the local finalize path — re-verify
         # with the closed-issue downgrade signal only when the first (cheap,
@@ -4141,6 +4168,7 @@ def finalize_remote_interactive_exit(
             merge_verify = _remote_verify_merge_branch(
                 ssh_target, remote_worktree_sh,
                 base=base_branch, issue_number=issue_number,
+                extra_allowed_issue_numbers=extra_allowed_issue_numbers,
                 closed_issue_numbers=closed,
             )
         if not merge_verify.ok:

{code_coordinator-0.5.234 → code_coordinator-0.5.235}/tests/test_cli_assign_interactive_remote.py

@@ -1433,10 +1433,28 @@ class TestRemoteFixWorktreeCollision:
 # ── #1007: --merge-of on a REMOTE machine ─────────────────────────────────────
 
 
-def _seed_merge_board(work_id: str, branch: str) -> None:
-    """Seed a completed+approved work assignment for `--merge-of` tests."""
-    from coord.models import Assignment, Board, Repo
-    from coord.state import save_board
+def _seed_merge_board(
+    work_id: str,
+    branch: str,
+    *,
+    assignment_type: str = "work",
+    for_issue_number: int | None = None,
+) -> None:
+    """Seed a completed+approved work assignment for `--merge-of` tests.
+
+    *assignment_type* / *for_issue_number* (#2545): a ``type="test-author"``
+    JIT-slice work row carries its own child issue in ``for_issue_number``,
+    distinct from ``issue_number`` (which stays the milestone's tracking
+    issue) — see ``Assignment.for_issue_number``'s docstring.
+
+    Uses ``record_dispatched_assignment`` (not the whole-board
+    ``save_board``) because ``save_board``'s bulk UPSERT statement doesn't
+    include the ``for_issue_number`` column at all — only the single-row
+    dispatch writer does — so a plain ``Board(...); save_board(...)`` seed
+    would silently drop it and defeat any test that needs it set.
+    """
+    from coord.models import Assignment
+    from coord.state import get_connection, record_dispatched_assignment
 
     work = Assignment(
         machine_name="precision",
@@ -1444,19 +1462,20 @@ def _seed_merge_board(work_id: str, branch: str) -> None:
         issue_number=1,
         issue_title="Fix bug",
         assignment_id=work_id,
-        status="done",
+        status="running",
         branch=branch,
-        type="work",
+        type=assignment_type,
+        for_issue_number=for_issue_number,
         dispatched_at=0.0,
-        finished_at=1.0,
     )
-    board = Board(
-        repos=[Repo(name="api", github="acme/api", default_branch="main")],
-        machines=[],
-        active=[],
-        completed=[work],
-    )
-    save_board(board)
+    record_dispatched_assignment(assignment=work, repo_github="acme/api")
+    conn = get_connection()
+    with conn:
+        conn.execute(
+            "UPDATE assignments SET status='done', branch=?, finished_at=1.0 "
+            "WHERE assignment_id=?",
+            (branch, work_id),
+        )
 
 
 class TestRemoteMergeOf:
@@ -1539,6 +1558,47 @@ class TestRemoteMergeOf:
         assert captured_kwargs[0]["verify_merge"] is True
         assert captured_kwargs[0]["ssh_target"] == "precision.tailnet"
         assert captured_kwargs[0]["branch"] == "issue-1-fix-bug"
+        # #2545: an ordinary `type="work"` row has no `for_issue_number` —
+        # nothing extra to allow.
+        assert captured_kwargs[0]["extra_allowed_issue_numbers"] == frozenset()
+
+    def test_remote_merge_of_allows_test_author_slices_own_issue(
+        self, remote_config_file: Path, coord_dir: Path,
+    ) -> None:
+        """#2545: a `type="test-author"` merge entry's `issue_number` is the
+        milestone's TRACKING issue, but its own commit correctly cites the
+        JIT slice's child issue (`for_issue_number`). The remote finalize
+        call must thread that through as `extra_allowed_issue_numbers` so
+        the #604 FOREIGN check doesn't flag every slice's own commit."""
+        _seed_merge_board(
+            "work-mg2-ta", "issue-1-slice-132",
+            assignment_type="test-author", for_issue_number=132,
+        )
+
+        captured_kwargs: list[dict[str, Any]] = []
+
+        def _fake_finalize(**kwargs: Any) -> Any:
+            captured_kwargs.append(kwargs)
+            return _make_finalize_result(push_ok=True)
+
+        with patch("coord.github_ops.get_issue",
+                   return_value={"title": "Fix bug", "body": "b"}), \
+             patch("coord.interactive._launch_via_tmux", return_value=0), \
+             patch("coord.interactive.launch_human_attended_interactive") as mock_local, \
+             patch("coord.interactive.tmux_session_alive", return_value=False), \
+             patch("coord.interactive.finalize_remote_interactive_exit",
+                   side_effect=_fake_finalize):
+            result = CliRunner().invoke(
+                main,
+                ["assign", "precision", "api", "1",
+                 "--config", str(remote_config_file),
+                 "--interactive", "--merge-of", "work-mg2-ta"],
+            )
+
+        assert result.exit_code == 0, result.output
+        mock_local.assert_not_called()
+        assert len(captured_kwargs) == 1
+        assert captured_kwargs[0]["extra_allowed_issue_numbers"] == frozenset({132})
 
     def test_local_merge_of_still_uses_local_tty(
         self, config_file: Path, coord_dir: Path,
@@ -1572,6 +1632,45 @@ class TestRemoteMergeOf:
         mock_local.assert_called_once()
         mock_remote.assert_not_called()
 
+    def test_local_merge_of_allows_test_author_slices_own_issue(
+        self, config_file: Path, coord_dir: Path,
+    ) -> None:
+        """#2545 local counterpart: the LOCAL finalize call must also thread
+        the JIT slice's own child issue through as
+        `extra_allowed_issue_numbers`, not just the remote path."""
+        _seed_merge_board(
+            "work-mg3-ta", "issue-1-slice-130",
+            assignment_type="test-author", for_issue_number=130,
+        )
+
+        captured_kwargs: list[dict[str, Any]] = []
+
+        def _fake_finalize(**kwargs: Any) -> Any:
+            captured_kwargs.append(kwargs)
+            return _make_finalize_result(push_ok=True)
+
+        with patch("coord.github_ops.get_issue",
+                   return_value={"title": "Fix bug", "body": "b"}), \
+             patch("coord.agent.setup_interactive_worktree",
+                   return_value=(Path("/tmp/wt"), "issue-1-slice-130")), \
+             patch("coord.interactive.launch_human_attended_interactive",
+                   return_value=0), \
+             patch("coord.interactive._launch_via_tmux"), \
+             patch("coord.interactive.tmux_available", return_value=False), \
+             patch("coord.interactive.tmux_session_alive", return_value=False), \
+             patch("coord.interactive.finalize_interactive_exit",
+                   side_effect=_fake_finalize):
+            result = CliRunner().invoke(
+                main,
+                ["assign", _LOCAL_HOST, "api", "1",
+                 "--config", str(config_file),
+                 "--interactive", "--merge-of", "work-mg3-ta"],
+            )
+
+        assert result.exit_code == 0, result.output
+        assert len(captured_kwargs) == 1
+        assert captured_kwargs[0]["extra_allowed_issue_numbers"] == frozenset({130})
+
 
 # ── #1280: merge-prep prompt — FOREIGN decision procedure ────────────────────