code-coordinator 0.5.759__tar.gz → 0.5.760__tar.gz

{code_coordinator-0.5.759 → code_coordinator-0.5.760}/PKG-INFO

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

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

@@ -1,7 +1,7 @@
 {
-  "tag": "0.5.759",
+  "tag": "0.5.760",
   "distance": 0,
-  "node": "g8877e507364adbe8c3051ef031849fd96e87e159",
+  "node": "g110342595fbe069c4cb87b136ae89c3e3656fc3a",
   "dirty": false,
   "branch": "HEAD",
   "node_date": "2026-11-12"

{code_coordinator-0.5.759 → code_coordinator-0.5.760}/coord/decomposition_chat.py

@@ -46,6 +46,7 @@ from typing import TYPE_CHECKING, Any
 
 if TYPE_CHECKING:  # pragma: no cover - typing only
     from coord.config import Config
+    from coord.milestone_order import WorkOrderNode
     from coord.models import Assignment, Board, Machine, Repo, SplitProposal
     from coord.preflight_size import SplitVerification
 
@@ -1314,6 +1315,98 @@ def parse_size_triage_response(
     )
 
 
+def _repoint_queued_dependents_at_split(
+    *,
+    repo_name: str,
+    original_issue: int,
+    epic_number: int,
+    remapped_nodes: tuple["WorkOrderNode", ...],
+    origin: str,
+) -> None:
+    """Re-point every queued entry whose ``after=`` names *original_issue*
+    onto the split's sink children (#3984).
+
+    Without this, ``drive_queue._resolve_prereqs``'s ``live_prereq_
+    terminal`` recovery (#2602/#2850) reads a prerequisite a live re-check
+    finds CLOSED as satisfied, whatever the reason it closed — so a
+    dependent chained on the original would read it as "done" the instant
+    :func:`file_and_queue_split_proposal` closes it as superseded, and
+    launch before any split child has merged (the quadraui#2341 incident:
+    13 rows would have launched against code the split hadn't landed yet).
+
+    Walks the WHOLE drive queue, not just *repo_name*'s — an ``after=`` key
+    is fully-qualified (``repo#N``) and a dependent can live in a different
+    repo than the original. Every matching row is rewritten with the SAME
+    write path ``coord drive-queue add`` itself uses
+    (:func:`coord.state.enqueue_drive_queue`), carrying forward every
+    OTHER operator-declared field on that row untouched, then confirmed
+    with a readback before moving to the next row — an unconfirmed rewrite
+    is not a rewrite, same discipline the child-queuing loop above already
+    applies. A row's ``last_reason`` also records why its edges changed, so
+    ``coord drive-queue list`` doesn't just show a different ``after=``
+    with no explanation.
+
+    Raises (never swallows) on the first row that doesn't read back the new
+    ``after=`` — propagating straight out of
+    :func:`file_and_queue_split_proposal`, which calls this BEFORE closing
+    the original, so a raise here always aborts before that close.
+    """
+    from coord.drive_queue import entry_key, rewrite_after_for_split, sink_children
+    from coord.state import (
+        enqueue_drive_queue,
+        get_drive_queue_entry,
+        list_drive_queue,
+        update_drive_queue_entry,
+    )
+
+    sink_issue_numbers = sink_children(remapped_nodes)
+    original_key = entry_key(repo_name, original_issue)
+    sink_keys = [entry_key(repo_name, n) for n in sink_issue_numbers]
+
+    for row in list_drive_queue():
+        current_after = [str(a) for a in (row.get("after_json") or [])]
+        if original_key not in current_after:
+            continue
+        dep_repo = str(row.get("repo_name") or "")
+        dep_issue = int(row.get("issue_number") or 0)
+        new_after = rewrite_after_for_split(current_after, original_key, sink_keys)
+
+        enqueue_drive_queue(
+            dep_repo,
+            dep_issue,
+            machine=row.get("machine") or None,
+            after=new_after,
+            hold_after=bool(row.get("hold_after")),
+            hold_reason=str(row.get("hold_reason") or ""),
+            resume_when=str(row.get("resume_when") or ""),
+            hold_scope=str(row.get("hold_scope") or "entry"),
+            max_fix_rounds=row.get("max_fix_rounds"),
+            no_acceptance=bool(row.get("no_acceptance")),
+            plan_destructive=bool(row.get("plan_destructive")),
+        )
+        update_drive_queue_entry(
+            dep_repo,
+            dep_issue,
+            last_reason=(
+                f"re-pointed off superseded {original_key} onto #{epic_number}'s "
+                f"split children ({', '.join(sink_keys)}) by the {origin}"
+            ),
+        )
+
+        confirmed = get_drive_queue_entry(dep_repo, dep_issue)
+        confirmed_after = (
+            [str(a) for a in (confirmed.get("after_json") or [])]
+            if confirmed is not None
+            else None
+        )
+        if confirmed is None or sorted(confirmed_after) != sorted(new_after):
+            raise RuntimeError(
+                f"filed epic #{epic_number} but re-pointing queued dependent "
+                f"{dep_repo}#{dep_issue} off superseded {original_key} did not "
+                f"read back the new after= list"
+            )
+
+
 def file_and_queue_split_proposal(
     *,
     proposal: "SplitProposal",
@@ -1339,8 +1432,13 @@ def file_and_queue_split_proposal(
     ``proposal.chunks`` order, remap the placeholder work order onto the
     real numbers and splice it into the epic body, queue each child
     (confirming every queue write with a readback — an unconfirmed queue
-    insert is not a queued child), then close the original issue pointing
-    at the new epic — forcing past the "open children" guard (the
+    insert is not a queued child), re-point every ALREADY-queued entry
+    whose ``after=`` names the original onto the split's sink children
+    (:func:`_repoint_queued_dependents_at_split`, #3984 — otherwise
+    ``drive_queue._resolve_prereqs``'s ``live_prereq_terminal`` recovery
+    reads the original's close as "pre-req satisfied" and launches every
+    dependent before any child has landed), then close the original issue
+    pointing at the new epic — forcing past the "open children" guard (the
     original's own body is exactly the shape expected to trip it once it
     already carries a ``## Sub-issues``/``## Work order`` block, e.g. from
     a prior triage pass) and confirming the close itself with a readback,
@@ -1410,6 +1508,19 @@ def file_and_queue_split_proposal(
                 "did not read back from the drive queue"
             )
 
+    # #3984: before closing the original, re-point every dependent ALREADY
+    # queued against it onto the split's children — a failure here raises
+    # and propagates straight out of this function, same as every other
+    # step above, so the original is never closed with a dependent still
+    # pointing at it.
+    _repoint_queued_dependents_at_split(
+        repo_name=repo.name,
+        original_issue=proposal.issue_number,
+        epic_number=epic_number,
+        remapped_nodes=remapped_nodes,
+        origin=origin,
+    )
+
     # `force=True`: the original being split is likely to already carry a
     # `## Sub-issues`/`## Work order` block of its own (e.g. a prior triage
     # pass), which would otherwise trip `close_issue()`'s open-children

{code_coordinator-0.5.759 → code_coordinator-0.5.760}/coord/drive_queue.py

@@ -114,7 +114,7 @@ from coord.merge_queue import (
     is_ci_unreadable_reason,
     is_stale_smoke_reason,
 )
-from coord.milestone_order import TRACKING_ISSUE_LABEL
+from coord.milestone_order import TRACKING_ISSUE_LABEL, WorkOrderNode
 from coord.models import (
     CLOSES_ISSUE_TYPES,
     EPIC_DECOMPOSE_TYPE,
@@ -1650,6 +1650,51 @@ def parse_after_spec(raw: str | Iterable[str], default_repo: str) -> list[str]:
     return out
 
 
+def sink_children(nodes: Iterable[WorkOrderNode]) -> list[int]:
+    """The subset of a split's children nothing else in *nodes* depends on.
+
+    A split's own ``after=`` graph can fan out into more than one
+    independent chain (e.g. ``C1 -> C2`` alongside a parallel ``C3``) — this
+    is every chain's own tail, i.e. the split's full "everything landed"
+    frontier. :func:`coord.decomposition_chat.file_and_queue_split_proposal`
+    re-points a dependent chained on the SUPERSEDED original onto exactly
+    this set: a dependent re-pointed at only the last-filed child would
+    launch the moment that ONE chain lands, while a sibling chain is still
+    mid-flight (#3984).
+
+    Order follows *nodes*' own order, not issue-number order — filed issue
+    numbers need not increase in work-order position order.
+    """
+    nodes = list(nodes)
+    depended_on = {dep for node in nodes for dep in node.after}
+    return [node.issue_number for node in nodes if node.issue_number not in depended_on]
+
+
+def rewrite_after_for_split(
+    after: Sequence[str], original_key: str, sink_keys: Sequence[str]
+) -> list[str]:
+    """Drop *original_key* from *after* and append *sink_keys* in its place.
+
+    Every OTHER pre-req *after* already names (the ``X`` in ``after=O,X``)
+    is kept, untouched — a dependent chained on more than the superseded
+    original still waits on those too. De-duplicates, preserving
+    first-seen order, so a dependent that already names one of the sink
+    children (unusual, but not impossible) doesn't end up listing it
+    twice. Returns a list with the same keys and order as *after* — never
+    raises — when *original_key* isn't present; callers are expected to
+    check that themselves before deciding whether a rewrite happened.
+    """
+    kept = [key for key in after if key != original_key]
+    if len(kept) == len(after):
+        return kept
+    seen = set(kept)
+    for key in sink_keys:
+        if key not in seen:
+            seen.add(key)
+            kept.append(key)
+    return kept
+
+
 # ── the queue row ────────────────────────────────────────────────────────────
 
 

{code_coordinator-0.5.759 → code_coordinator-0.5.760}/tests/test_decomposition_chat.py

@@ -2231,6 +2231,139 @@ class TestFileAndQueueSplitProposal:
         mock_close_issue.assert_not_called()
 
 
+class TestRepointQueuedDependentsAtSplit:
+    """#3984: a dependent already queued with ``after=`` naming the issue
+    being split must be re-pointed at the split's SINK children before the
+    original closes — otherwise #2602/#2850's `live_prereq_terminal`
+    recovery reads the original's close as "pre-req satisfied" and the
+    dependent launches before any child has landed.
+
+    Exercises the real drive-queue read/write path (only `coord.github_ops`
+    is mocked — no real GitHub calls) so the acceptance shape is pinned
+    end to end: split O into `C1 -> C2` plus a parallel `C3`, with
+    dependents D1 (`after=O`) and D2 (`after=O,X`)."""
+
+    def _proposal(self) -> "decomposition_chat.SplitProposal":
+        from coord.models import SplitChunk, SplitProposal
+
+        return SplitProposal(
+            id=0, repo_name="api", issue_number=99, issue_title="A giant issue",
+            rationale="too big for one worker", chunks=[
+                SplitChunk(title="Part 1", scope="do part 1", files_likely=["a.py"]),
+                SplitChunk(title="Part 2", scope="do part 2", files_likely=["b.py"]),
+                SplitChunk(title="Part 3", scope="do part 3", files_likely=["c.py"]),
+            ],
+        )
+
+    def _verification(self) -> "decomposition_chat.SplitVerification":
+        from coord.milestone_order import WorkOrder, WorkOrderNode
+        from coord.preflight_size import SplitVerification
+
+        return SplitVerification(
+            ok=True, reason=None, epic_body="rationale text",
+            work_order=WorkOrder(nodes=(
+                WorkOrderNode(issue_number=1, after=()),
+                WorkOrderNode(issue_number=2, after=(1,)),
+                WorkOrderNode(issue_number=3, after=()),
+            )),
+        )
+
+    @patch("coord.github_ops.get_issue_state")
+    @patch("coord.github_ops.close_issue")
+    @patch("coord.github_ops.update_issue_body")
+    @patch("coord.github_ops.create_issue")
+    def test_dependents_repointed_at_sink_children_and_original_closed(
+        self, mock_create_issue, mock_update_body, mock_close_issue, mock_get_issue_state,
+    ) -> None:
+        from coord.drive_queue import entry_key
+        from coord.models import Repo
+        from coord.state import enqueue_drive_queue, list_drive_queue
+
+        mock_create_issue.side_effect = [
+            {"number": 500, "url": "https://x/500"},  # epic
+            {"number": 501, "url": "https://x/501"},  # C1
+            {"number": 502, "url": "https://x/502"},  # C2 (after C1)
+            {"number": 503, "url": "https://x/503"},  # C3
+        ]
+        mock_get_issue_state.return_value = "closed"
+        repo = Repo(name="api", github="acme/api")
+
+        original_key = entry_key("api", 99)
+        enqueue_drive_queue("api", 201, after=[original_key])  # D1: after=O
+        enqueue_drive_queue(
+            "other", 777, after=[original_key, "other#300"]
+        )  # D2: after=O,X (cross-repo dependent)
+
+        epic_number = decomposition_chat.file_and_queue_split_proposal(
+            proposal=self._proposal(), verification=self._verification(), repo=repo,
+        )
+        assert epic_number == 500
+
+        sink_keys = {entry_key("api", 502), entry_key("api", 503)}
+        rows = {(e["repo_name"], e["issue_number"]): e for e in list_drive_queue()}
+
+        d1 = rows[("api", 201)]
+        assert set(d1["after_json"]) == sink_keys
+        assert original_key not in d1["after_json"]
+        assert "99" in d1["last_reason"]
+
+        d2 = rows[("other", 777)]
+        assert set(d2["after_json"]) == sink_keys | {"other#300"}
+        assert original_key not in d2["after_json"]
+
+        # The original is still force-closed, after the re-point.
+        mock_close_issue.assert_called_once()
+
+    @patch("coord.github_ops.get_issue_state")
+    @patch("coord.github_ops.close_issue")
+    @patch("coord.github_ops.update_issue_body")
+    @patch("coord.github_ops.create_issue")
+    def test_repoint_failure_aborts_before_close_and_leaves_row_untouched(
+        self, mock_create_issue, mock_update_body, mock_close_issue, mock_get_issue_state,
+        monkeypatch,
+    ) -> None:
+        """A failed re-point write must abort BEFORE the original closes,
+        and the dependent's own row must be left exactly as it was — never
+        partially rewritten."""
+        import coord.state as state_mod
+        from coord.drive_queue import entry_key
+        from coord.models import Repo
+        from coord.state import enqueue_drive_queue, list_drive_queue
+
+        mock_create_issue.side_effect = [
+            {"number": 500, "url": "https://x/500"},
+            {"number": 501, "url": "https://x/501"},
+            {"number": 502, "url": "https://x/502"},
+            {"number": 503, "url": "https://x/503"},
+        ]
+        repo = Repo(name="api", github="acme/api")
+
+        original_key = entry_key("api", 99)
+        enqueue_drive_queue("api", 201, after=[original_key])
+
+        real_enqueue = state_mod.enqueue_drive_queue
+
+        def _boom(repo_name, issue_number, **kwargs):
+            after = kwargs.get("after")
+            if issue_number == 201 and after is not None and original_key not in after:
+                raise RuntimeError("boom: simulated drive-queue write failure")
+            return real_enqueue(repo_name, issue_number, **kwargs)
+
+        monkeypatch.setattr(state_mod, "enqueue_drive_queue", _boom)
+
+        with pytest.raises(RuntimeError, match="boom"):
+            decomposition_chat.file_and_queue_split_proposal(
+                proposal=self._proposal(), verification=self._verification(), repo=repo,
+            )
+
+        mock_close_issue.assert_not_called()
+        row = next(
+            e for e in list_drive_queue()
+            if e["repo_name"] == "api" and e["issue_number"] == 201
+        )
+        assert row["after_json"] == [original_key]
+
+
 class TestAutoSplitNeedsDecomposition:
     """`auto_split_needs_decomposition` files a needs-decomposition work
     leg's machine-readable split through the same verify + file + queue path

{code_coordinator-0.5.759 → code_coordinator-0.5.760}/tests/test_drive_queue.py

@@ -74,6 +74,8 @@ from coord.drive_queue import (
     plan_tick,
     remaining_fix_rounds,
     render_plan,
+    rewrite_after_for_split,
+    sink_children,
     summarize_drive_queue,
     total_fix_round_budget,
     unreachable_wait_alert,
@@ -388,6 +390,61 @@ def test_a_malformed_after_entry_raises_rather_than_being_dropped():
         parse_after_spec("not-an-issue", REPO)
 
 
+# ── split-supersede dependent re-pointing (#3984) ────────────────────────────
+
+
+def test_sink_children_excludes_a_node_something_else_depends_on():
+    """#3984: split into `C1 -> C2` plus a parallel `C3` — C1 is excluded
+    (C2 depends on it), C2 and C3 are each a chain's own tail."""
+    from coord.milestone_order import WorkOrderNode
+
+    nodes = (
+        WorkOrderNode(issue_number=501, after=()),
+        WorkOrderNode(issue_number=502, after=(501,)),
+        WorkOrderNode(issue_number=503, after=()),
+    )
+    assert sink_children(nodes) == [502, 503]
+
+
+def test_sink_children_of_a_single_linear_chain_is_just_the_tail():
+    from coord.milestone_order import WorkOrderNode
+
+    nodes = (
+        WorkOrderNode(issue_number=501, after=()),
+        WorkOrderNode(issue_number=502, after=(501,)),
+        WorkOrderNode(issue_number=503, after=(502,)),
+    )
+    assert sink_children(nodes) == [503]
+
+
+def test_rewrite_after_for_split_drops_original_and_appends_sinks():
+    """D1's `after=O` becomes `after=C2,C3` — the acceptance shape."""
+    assert rewrite_after_for_split(
+        ["repo#99"], "repo#99", ["repo#502", "repo#503"]
+    ) == ["repo#502", "repo#503"]
+
+
+def test_rewrite_after_for_split_keeps_other_prereqs_before_the_sinks():
+    """D2's `after=O,X` becomes `after=X,C2,C3` — the OTHER pre-req (`X`) is
+    kept, the superseded original is dropped, and the sink children are
+    appended after it, not spliced into O's old position."""
+    assert rewrite_after_for_split(
+        ["repo#99", "repo#300"], "repo#99", ["repo#502", "repo#503"]
+    ) == ["repo#300", "repo#502", "repo#503"]
+
+
+def test_rewrite_after_for_split_is_a_no_op_when_original_key_absent():
+    assert rewrite_after_for_split(
+        ["repo#300"], "repo#99", ["repo#502", "repo#503"]
+    ) == ["repo#300"]
+
+
+def test_rewrite_after_for_split_deduplicates_an_already_named_sink():
+    assert rewrite_after_for_split(
+        ["repo#99", "repo#502"], "repo#99", ["repo#502", "repo#503"]
+    ) == ["repo#502", "repo#503"]
+
+
 # ── cycle validation (the `add` gate) ────────────────────────────────────────