code-coordinator 0.5.128__tar.gz → 0.5.129__tar.gz

{code_coordinator-0.5.128 → code_coordinator-0.5.129}/PKG-INFO

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

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

@@ -1,7 +1,7 @@
 {
-  "tag": "0.5.128",
+  "tag": "0.5.129",
   "distance": 0,
-  "node": "gdb3e5a50ffe1a0bb743d2cc2f791188761858441",
+  "node": "g35ed648ce7ee944d0c954c511918f971ef413bef",
   "dirty": false,
   "branch": "HEAD",
   "node_date": "2026-08-17"

{code_coordinator-0.5.128 → code_coordinator-0.5.129}/coord/commands/milestone.py

@@ -3,10 +3,11 @@
 
 Thin CLI glue around ``coord/milestone_order.py`` (the pure DAG/frontier
 parser) and ``coord/milestone_dispatch.py`` (Phase 1's machine-picking +
-dispatch): fetches the tracking issue + milestone membership + issue
-terminal state from GitHub via ``coord.milestone_dispatch.
-fetch_milestone_context`` (shared by both subcommands so they see identical
-inputs), then hands that data to the pure functions and prints the result.
+dispatch, and #2335's work-order -> drive-queue translation): fetches the
+tracking issue + milestone membership + issue terminal state from GitHub via
+``coord.milestone_dispatch.fetch_milestone_context`` (shared by both
+subcommands so they see identical inputs), then hands that data to the pure
+functions and prints the result.
 """
 
 from __future__ import annotations
@@ -21,7 +22,6 @@ import httpx
 from coord.commands._common import _CONFIG_OPTION, _load_config
 from coord.milestone_dispatch import (
     DispatchOutcome,
-    MachinePick,
     MilestoneDispatchError,
     dispatch_entry,
     fetch_milestone_context,
@@ -29,6 +29,7 @@ from coord.milestone_dispatch import (
     is_milestone_complete,
     pick_machine,
     plan_dispatch,
+    plan_queue,
 )
 from coord.milestone_order import (
     TRACKING_ISSUE_LABEL,
@@ -859,11 +860,6 @@ def milestone_order_cmd(repo: str, tracking_issue: int, config_path: Path) -> No
             click.echo(f"  #{b.issue_number}: {b.reason}")
 
 
-def _echo_pick(pick: MachinePick) -> None:
-    suffix = f"  (group {pick.entry.group})" if pick.entry.group else ""
-    click.echo(f"  #{pick.entry.issue_number} -> {pick.machine.name}{suffix}")
-
-
 def _echo_outcome(outcome: DispatchOutcome) -> None:
     if outcome.ok:
         click.echo(
@@ -883,13 +879,18 @@ def _echo_outcome(outcome: DispatchOutcome) -> None:
 @milestone_group.command(
     "dispatch",
     help=(
-        "Promote a milestone into the pipeline: dispatch its ready frontier "
-        "in parallel (up to idle/capable machines), then keep draining it as "
-        "declared-order dependencies complete. REPO is the local repo name "
-        "from coordinator.yml; TRACKING_ISSUE is the GH issue number of the "
-        "tracking issue (its body holds the `## Work order` block). This is "
-        "the single explicit approval for the whole declared work order — "
-        "it does not expand scope beyond what `## Work order` lists."
+        "Promote a milestone into the pipeline: derive the dependency order "
+        "from the `## Work order` DAG and queue every still-open issue into "
+        "the drive-queue (`coord drive-queue add --after ...`) in that order "
+        "(#2335) — the DQ-4 tick then launches each issue as its pre-reqs "
+        "land, with #2247 file-overlap prediction, durable board-backed "
+        "state, and `coord drive-queue list/status` observability. `--next` "
+        "keeps the lighter direct single-dispatch path. REPO is the local "
+        "repo name from coordinator.yml; TRACKING_ISSUE is the GH issue "
+        "number of the tracking issue (its body holds the `## Work order` "
+        "block). This is the single explicit approval for the whole declared "
+        "work order — it does not expand scope beyond what `## Work order` "
+        "lists."
     ),
 )
 @click.argument("repo")
@@ -902,8 +903,9 @@ def _echo_outcome(outcome: DispatchOutcome) -> None:
     "--next", "next_", is_flag=True,
     help=(
         "Single-pick mode: show up to 3 ready-frontier items and dispatch "
-        "only the one you choose. Lighter-weight than draining the whole "
-        "milestone — does not register for daemon auto-drain."
+        "only the one you choose — directly, not via the drive-queue. "
+        "Lighter-weight than bulk mode's whole-DAG drive-queue enqueue "
+        "(#2335)."
     ),
 )
 @click.option(
@@ -1003,14 +1005,15 @@ def milestone_dispatch_cmd(
         click.echo(f"#{tracking_issue}: no `## Work order` block found")
         return
 
-    board = board_service.read_board()
-    plan = plan_dispatch(ctx.work_order, board, cfg, repo_entry, ctx.terminal_issues)
-
     click.echo(
         f"Work order for #{tracking_issue} (milestone #{ctx.milestone_number}):"
     )
 
     if next_:
+        board = board_service.read_board()
+        plan = plan_dispatch(
+            ctx.work_order, board, cfg, repo_entry, ctx.terminal_issues
+        )
         if not plan.to_dispatch:
             click.echo("No ready frontier item can dispatch right now.")
             if plan.skipped:
@@ -1075,54 +1078,93 @@ def milestone_dispatch_cmd(
             sys.exit(1)
         return
 
-    # Bulk mode: dispatch the entire current ready frontier.
-    click.echo("Will dispatch now:")
-    if plan.to_dispatch:
-        for pick in plan.to_dispatch:
-            _echo_pick(pick)
-    else:
-        click.echo("  (none)")
-
-    if plan.skipped:
-        click.echo()
-        click.echo("Ready but no idle machine:")
-        for s in plan.skipped:
-            click.echo(f"  #{s.entry.issue_number}: {s.reason}")
+    # Bulk mode (#2335): queue the whole declared work order into the
+    # drive-queue rather than dispatching the ready frontier directly. Before
+    # #2335 this path called `dispatch_entry` per frontier pick and registered
+    # the milestone for daemon auto-drain — bypassing the drive-queue
+    # entirely: no #2247 overlap prediction, no durable queue entry surviving
+    # a coordinator restart, nothing in `coord drive-queue list/status`. The
+    # queue's `after=` edges now carry the DAG, so the DQ-4 tick launches each
+    # issue as its pre-reqs land; that also makes `register_milestone_drain`
+    # redundant here (the queue IS the durable drain, and registering would
+    # have the daemon's direct-dispatch drain racing it).
+    queue_plan = plan_queue(ctx.work_order, ctx.terminal_issues, repo_entry.name)
+
+    if not queue_plan:
+        click.echo("Nothing to queue — every work-order node is already closed.")
+        return
 
-    if plan.waiting:
-        click.echo()
-        click.echo("Waiting:")
-        for b in plan.waiting:
-            click.echo(f"  #{b.issue_number}: {b.reason}")
+    click.echo("Will queue (drive-queue), in dependency order:")
+    for qe in queue_plan:
+        bits = []
+        if qe.group:
+            bits.append(f"group {qe.group}")
+        if qe.after:
+            bits.append("after " + ", ".join(qe.after))
+        suffix = f"  ({'; '.join(bits)})" if bits else ""
+        click.echo(f"  #{qe.issue_number}{suffix}")
 
     if dry_run:
         click.echo()
-        click.echo("(dry run — not dispatched)")
+        click.echo("(dry run — nothing queued)")
         return
 
-    if not plan.to_dispatch:
-        click.echo()
-        click.echo("Nothing to dispatch right now.")
-        return
+    # Reuse `coord drive-queue add`'s own helpers so a milestone enqueue is
+    # byte-identical to N manual `add` calls: same pre-write validation, same
+    # #2247 overlap prediction (auto-`after` edges recorded to the audit log),
+    # same upsert semantics for an issue already queued.
+    from coord.commands.drive_queue import (  # noqa: PLC0415
+        _applicable_auto_after,
+        _predict_overlap,
+        _record_overlap_prediction,
+    )
+    from coord.drive_queue import (  # noqa: PLC0415
+        QueueError,
+        entries_from_rows,
+        entry_key,
+        validate_enqueue,
+    )
+    from coord.state import enqueue_drive_queue, list_drive_queue  # noqa: PLC0415
 
     click.echo()
     failures = 0
-    for pick in plan.to_dispatch:
-        outcome = dispatch_entry(pick, repo_entry, cfg, board, tracking_issue=tracking_issue)
-        _echo_outcome(outcome)
-        if not outcome.ok:
+    queued = 0
+    for qe in queue_plan:
+        # Re-read per entry so each add validates (and overlap-predicts)
+        # against the queue as its just-added siblings left it.
+        existing = entries_from_rows(list_drive_queue())
+        after = list(qe.after)
+        key = entry_key(repo_entry.name, qe.issue_number)
+        try:
+            validate_enqueue(existing, repo_entry.name, qe.issue_number, after)
+        except QueueError as exc:
+            click.echo(f"  {key}: not queued: {exc}", err=True)
             failures += 1
+            continue
+        prediction = _predict_overlap(
+            config_path, repo_entry.name, qe.issue_number, existing
+        )
+        auto_after = _applicable_auto_after(
+            existing, repo_entry.name, qe.issue_number, after, prediction
+        )
+        after = [*after, *auto_after]
+        enqueue_drive_queue(repo_entry.name, qe.issue_number, after=after)
+        if auto_after:
+            _record_overlap_prediction(
+                repo_entry.name, qe.issue_number, prediction, auto_after
+            )
+        suffix = f" after {', '.join(after)}" if after else ""
+        overlap_note = f"\n     {prediction.reason}" if auto_after else ""
+        click.echo(f"  queued {key}{suffix}{overlap_note}")
+        queued += 1
 
-    if not is_milestone_complete(ctx):
-        from coord.state import register_milestone_drain
-
-        register_milestone_drain(repo_name=repo_entry.name, tracking_issue=tracking_issue)
+    if queued:
         click.echo()
         click.echo(
-            f"Milestone #{tracking_issue} registered for daemon auto-drain "
-            "(requires `milestone.auto_dispatch: true` in coordinator.yml + a "
-            "daemon restart to activate; `coord milestone dispatch` still "
-            "works as a manual re-drain either way)."
+            f"{queued} issue(s) queued — `coord drive-queue tick` (the DQ-4 "
+            "timer, or run it manually) launches them in dependency order; "
+            "`coord drive-queue list` shows the queue. Entries are durable "
+            "across coordinator restarts."
         )
 
     if failures:

{code_coordinator-0.5.128 → code_coordinator-0.5.129}/coord/milestone_dispatch.py

@@ -16,7 +16,10 @@ not an LLM judgment call like ``coord.brain.propose``.
 Three call sites share this module:
 
 - ``coord milestone dispatch`` (``coord/commands/milestone.py``) — the
-  one-shot CLI dispatch (bulk or ``--next`` single-pick).
+  ``--next`` single-pick still dispatches directly through
+  :func:`plan_dispatch`/:func:`dispatch_entry`; bulk mode instead derives
+  drive-queue enqueues from the work order via :func:`plan_queue` (#2335),
+  so the DQ-4 tick owns the actual launches.
 - The daemon's auto-drain tick (``coord.serve_app._milestone_drain_tick``,
   opt-in via ``coordinator.yml`` ``milestone.auto_dispatch``) — re-runs the
   same fetch → plan → dispatch sequence for milestones registered via a
@@ -38,6 +41,7 @@ from coord.milestone_order import (
     FrontierEntry,
     WorkOrder,
     WorkOrderError,
+    WorkOrderNode,
     parse_work_order,
     ready_frontier,
     validate_milestone_membership,
@@ -64,6 +68,8 @@ __all__ = [
     "NoMachineAvailable",
     "MilestonePlan",
     "plan_dispatch",
+    "QueuePlanEntry",
+    "plan_queue",
     "DispatchOutcome",
     "dispatch_entry",
     "is_milestone_complete",
@@ -684,6 +690,74 @@ def plan_dispatch(
     )
 
 
+@dataclass(frozen=True)
+class QueuePlanEntry:
+    """One drive-queue enqueue derived from a work-order node (#2335)."""
+
+    issue_number: int
+    #: Fully-qualified pre-req keys (``"repo#N"``) for the drive-queue's
+    #: ``after=`` edge list — the node's declared ``{after: #N}`` targets,
+    #: minus any that are already terminal (closed issues never enter the
+    #: queue, so an edge at one would read as unsatisfiable to the tick's
+    #: ``_resolve_prereqs`` rather than as "already done").
+    after: tuple[str, ...] = ()
+    group: str | None = None
+
+
+def plan_queue(
+    work_order: WorkOrder,
+    terminal_issues: frozenset[int] | set[int],
+    repo_name: str,
+) -> tuple[QueuePlanEntry, ...]:
+    """Translate the work order's DAG into drive-queue enqueues (#2335).
+
+    Pure — no GitHub, no board, no side effects. One entry per non-terminal
+    node, in dependency order: a stable topological sort seeded by declared
+    order, so independent nodes keep the operator's declared sequence while a
+    node declared *before* its own pre-req still queues after it (queue
+    position is the tick's tie-break among eligible entries; the ``after``
+    edges are what actually gate launches).
+
+    Each entry's ``after`` carries the node's declared ``{after: #N}`` edges
+    as fully-qualified ``repo#N`` keys — the same format ``coord drive-queue
+    add --after`` parses — filtered to pre-reqs that are still open.
+    :func:`~coord.milestone_order.parse_work_order` already refused cycles,
+    self-edges, and edges to undeclared nodes, so the sort always terminates;
+    the defensive tail below only fires on inputs constructed outside it.
+    """
+    from coord.drive_queue import entry_key  # noqa: PLC0415
+
+    terminal = set(terminal_issues)
+    remaining: dict[int, WorkOrderNode] = {
+        n.issue_number: n for n in work_order.nodes if n.issue_number not in terminal
+    }
+    open_set = set(remaining)
+    placed: set[int] = set()
+    ordered: list[WorkOrderNode] = []
+    while remaining:
+        progressed = False
+        for number, node in list(remaining.items()):
+            if any(d in open_set and d not in placed for d in node.after):
+                continue
+            ordered.append(node)
+            placed.add(number)
+            del remaining[number]
+            progressed = True
+        if not progressed:  # cycle — unreachable via parse_work_order; see above
+            ordered.extend(remaining.values())
+            break
+    return tuple(
+        QueuePlanEntry(
+            issue_number=n.issue_number,
+            after=tuple(
+                entry_key(repo_name, d) for d in n.after if d not in terminal
+            ),
+            group=n.group,
+        )
+        for n in ordered
+    )
+
+
 @dataclass(frozen=True)
 class DispatchOutcome:
     """The result of one :func:`dispatch_entry` call."""

{code_coordinator-0.5.128 → code_coordinator-0.5.129}/coord/serve_app.py

@@ -1283,8 +1283,11 @@ def _milestone_drain_tick(config: Config) -> list:
 
     Called by ``_tick_loop`` when ``milestone.auto_dispatch: true`` is set in
     ``coordinator.yml`` (default-off). For each ``(repo_name, tracking_issue)``
-    registered via a non-dry-run ``coord milestone dispatch`` (``coord.state.
-    register_milestone_drain``), re-fetches the tracking issue, recomputes the
+    registered via ``coord.state.register_milestone_drain`` (historically the
+    non-dry-run ``coord milestone dispatch`` bulk path — since #2335 that
+    path enqueues the work order into the drive-queue instead and registers
+    nothing, so only pre-#2335 registrations feed this tick), re-fetches the
+    tracking issue, recomputes the
     ready frontier (:func:`coord.milestone_dispatch.plan_dispatch`), and
     dispatches any newly-unblocked entries — the same mechanism a manual
     ``coord milestone dispatch`` uses, so a fix that lands and merges for one

{code_coordinator-0.5.128 → code_coordinator-0.5.129}/docs/ARCHITECTURE.md

@@ -167,7 +167,7 @@ The auto-loop above sequences a *single* issue. For work that spans many issues,
 
 Layering is deliberate: `evaluate_gate(gate, probes)` is **pure** (gate name + a `GateProbes` value in, one `GateStep` out — no board, no GitHub, no clock), so every edge in the machine is decided in exactly one place and any edge is testable without I/O; `probe_milestone()` is the I/O half and reuses the *existing* readers (`milestone_dispatch.gate_a_status`, `gate_b.latest_gate_b_verdict`) so the gate walk and the manual CLI can never disagree about whether a gate is satisfied. `work` is the only state with a side effect, and it delegates to `plan_dispatch` + `dispatch_entry` rather than adding a second dispatch path. Every other edge is currently an explicit, logged **hold** — the machine reports why it cannot advance and stays put. There is no silent fall-through anywhere in the module; that is the failure mode that produced the 240-minute advisory spin in the per-issue driver.
 
-**`drive` vs. `milestone.auto_dispatch` — mutually exclusive per milestone, gate driving wins.** `milestone.auto_dispatch` gates the *legacy standalone drain* (`_milestone_drain_tick`): a milestone registered by `coord milestone dispatch` whose frontier the daemon re-drains with no gate walk around it. A milestone with a gate record is driven by `_milestone_gate_tick` instead, which owns the drain as its `work` state — so `_milestone_drain_tick` **skips** any `(repo_name, tracking_issue)` that has a gate record. Without that exclusion a milestone parked at Gate A could still have its frontier dispatched by the independently-gated drain path. Gate driving is consequently its own per-milestone opt-in (`coord milestone drive`) and `_milestone_gate_tick` is *not* behind the global flag — hiding it there would make `drive` silently no-op.
+**`drive` vs. `milestone.auto_dispatch` — mutually exclusive per milestone, gate driving wins.** `milestone.auto_dispatch` gates the *legacy standalone drain* (`_milestone_drain_tick`): a milestone registered by a pre-#2335 `coord milestone dispatch` whose frontier the daemon re-drains with no gate walk around it. (Since #2335 the bulk `coord milestone dispatch` path enqueues the whole `## Work order` DAG into the drive-queue — `after=` edges carry the dependencies, the DQ-4 tick launches, and nothing new registers for this drain.) A milestone with a gate record is driven by `_milestone_gate_tick` instead, which owns the drain as its `work` state — so `_milestone_drain_tick` **skips** any `(repo_name, tracking_issue)` that has a gate record. Without that exclusion a milestone parked at Gate A could still have its frontier dispatched by the independently-gated drain path. Gate driving is consequently its own per-milestone opt-in (`coord milestone drive`) and `_milestone_gate_tick` is *not* behind the global flag — hiding it there would make `drive` silently no-op.
 
 **Exactly one overseer, structurally (#1930).** The gate tick is the sole owner of a gate-controlled milestone's `work` drain. `coord milestone drive` only ever writes/re-persists the `GateRecord` — it never calls `apply_step` or dispatches, so running it twice (any operator, any machine) is inert, not a race. `coord milestone dispatch`, the manual non-gate CLI, now refuses outright against a milestone with a gate record — before #1930 it had no way to know one existed and would dispatch the same frontier the gate tick's `work` state owns, the same "two gates disagreeing about whether work may start" shape #1870 fixed for the drive queue, reached from an operator's keyboard instead of a second host's timer.
 

{code_coordinator-0.5.128 → code_coordinator-0.5.129}/tests/test_cli_milestone_dispatch.py

@@ -104,8 +104,10 @@ class TestMilestoneDispatchValidation:
 
 
 class TestMilestoneDispatchDryRun:
-    def test_cohort_dispatches_now_and_gated_node_waits(self, config_file: Path) -> None:
-        """#769 acceptance criteria (first half)."""
+    def test_dry_run_shows_queue_plan_with_after_edges(self, config_file: Path) -> None:
+        """#2335: bulk dry-run previews the drive-queue enqueue plan — the
+        whole DAG, with the gated node's `after` edges spelled out — and
+        writes/dispatches nothing."""
         open_issues = [
             {"number": 762, "milestone": {"number": 9}},
             {"number": 763, "milestone": {"number": 9}},
@@ -122,17 +124,18 @@ class TestMilestoneDispatchDryRun:
         assert result.exit_code == 0, result.output
         disp.assert_not_called()
 
-        will_dispatch = result.output.split("Will dispatch now:")[1].split("Waiting:")[0]
-        assert "#762" in will_dispatch
-        assert "#763" in will_dispatch
-        waiting_section = result.output.split("Waiting:")[1]
-        assert "#765" in waiting_section
-        assert "waiting on #762, #763" in waiting_section
+        plan_section = result.output.split("Will queue (drive-queue), in dependency order:")[1]
+        assert "#762" in plan_section
+        assert "#763" in plan_section
+        assert "#765  (after api#762, api#763)" in plan_section
         assert "dry run" in result.output
+        # Nothing written — the dry run leaves the queue untouched.
+        assert state_mod.list_drive_queue() == []
 
-    def test_cohort_merging_unblocks_gated_node(self, config_file: Path) -> None:
-        """#769 acceptance criteria (second half): simulate #762/#763 merged ->
-        #765 enters the ready frontier."""
+    def test_terminal_prereqs_are_dropped_from_after_edges(self, config_file: Path) -> None:
+        """#2335: #762/#763 already closed -> only #765 queues, with no
+        `after` edges (a closed issue never enters the queue, so an edge at
+        it would read as unsatisfiable to the tick)."""
         open_issues = [{"number": 765, "milestone": {"number": 9}}]
 
         def get_issue(repo, number):
@@ -149,9 +152,10 @@ class TestMilestoneDispatchDryRun:
         assert result.exit_code == 0, result.output
         disp.assert_not_called()
 
-        will_dispatch = result.output.split("Will dispatch now:")[1]
-        assert "#765" in will_dispatch
-        assert "Waiting:" not in result.output
+        plan_section = result.output.split("Will queue (drive-queue), in dependency order:")[1]
+        assert "#765" in plan_section
+        assert "after" not in plan_section
+        assert "#762" not in plan_section
 
     def test_no_work_order_block_reports_and_exits_zero(self, config_file: Path) -> None:
         def get_issue_no_block(repo, number):
@@ -170,7 +174,12 @@ class TestMilestoneDispatchDryRun:
 
 
 class TestMilestoneDispatchBulk:
-    def test_dispatches_ready_frontier_and_registers_drain(self, config_file: Path) -> None:
+    def test_enqueues_whole_dag_into_drive_queue(self, config_file: Path) -> None:
+        """#2335: bulk mode queues every open work-order node into the
+        drive-queue with `after=` edges carrying the DAG — it never calls
+        `coord.dispatch.dispatch` directly, and it no longer registers the
+        milestone for the daemon's direct-dispatch auto-drain (the queue IS
+        the durable drain)."""
         open_issues = [
             {"number": 762, "milestone": {"number": 9}},
             {"number": 763, "milestone": {"number": 9}},
@@ -179,36 +188,69 @@ class TestMilestoneDispatchBulk:
         with patch("coord.github_ops.get_issue", side_effect=_get_issue), \
              patch("coord.github_ops.get_open_issues", return_value=open_issues), \
              patch("coord.board_service.read_board", return_value=Board()), \
-             patch("coord.dispatch.dispatch", side_effect=[{"id": "a1"}, {"id": "a2"}]) as disp, \
-             patch("coord.github_ops.post_issue_comment"), \
-             patch("coord.github_ops.check_branch_exists", return_value=False):
+             patch("coord.dispatch.dispatch") as disp:
             result = CliRunner().invoke(
                 main,
                 ["milestone", "dispatch", "api", "100", "--config", str(config_file)],
             )
         assert result.exit_code == 0, result.output
-        assert disp.call_count == 2
-        assert "a1" in result.output
-        assert "a2" in result.output
+        disp.assert_not_called()
+
+        rows = state_mod.list_drive_queue()
+        assert [(r["repo_name"], r["issue_number"]) for r in rows] == [
+            ("api", 762), ("api", 763), ("api", 765),
+        ]
+        by_issue = {r["issue_number"]: r for r in rows}
+        assert by_issue[762]["after_json"] == []
+        assert by_issue[763]["after_json"] == []
+        assert by_issue[765]["after_json"] == ["api#762", "api#763"]
+
+        assert "queued api#762" in result.output
+        assert "queued api#765 after api#762, api#763" in result.output
+        assert "3 issue(s) queued" in result.output
+        assert "coord drive-queue tick" in result.output
+
+        # No direct dispatch happened, so nothing was recorded as dispatched
+        # and no daemon auto-drain registration is needed or wanted.
+        assert state_mod.load_dispatched() == []
+        assert state_mod.list_milestone_drains() == []
+        assert "registered for daemon auto-drain" not in result.output
 
-        # Both cohort issues fanned out to distinct machines.
-        machine_names = {c.args[0].machine_name for c in disp.call_args_list}
-        assert machine_names == {"laptop", "server"}
+    def test_dependent_declared_first_still_queues_after_its_prereq(
+        self, config_file: Path
+    ) -> None:
+        """#2335: declared order is not necessarily topological — a node
+        declared before its own pre-req still queues after it, so queue
+        positions read in dependency order."""
+        body = "## Work order\n- [ ] #765  {after: #762}\n- [ ] #762\n"
+        open_issues = [
+            {"number": 762, "milestone": {"number": 9}},
+            {"number": 765, "milestone": {"number": 9}},
+        ]
 
-        records = state_mod.load_dispatched()
-        assert len(records) == 2
+        def get_issue(repo, number):
+            return _get_issue(repo, number, bodies={100: body})
+
+        with patch("coord.github_ops.get_issue", side_effect=get_issue), \
+             patch("coord.github_ops.get_open_issues", return_value=open_issues), \
+             patch("coord.board_service.read_board", return_value=Board()), \
+             patch("coord.dispatch.dispatch") as disp:
+            result = CliRunner().invoke(
+                main,
+                ["milestone", "dispatch", "api", "100", "--config", str(config_file)],
+            )
+        assert result.exit_code == 0, result.output
+        disp.assert_not_called()
 
-        # #765 still open (not terminal) -> the milestone registers for
-        # daemon auto-drain.
-        drains = state_mod.list_milestone_drains()
-        assert drains == [{"repo_name": "api", "tracking_issue": 100}]
-        assert "registered for daemon auto-drain" in result.output
+        rows = state_mod.list_drive_queue()
+        assert [r["issue_number"] for r in rows] == [762, 765]
+        assert rows[1]["after_json"] == ["api#762"]
 
-    def test_already_complete_milestone_dispatches_nothing_and_does_not_register(
+    def test_already_complete_milestone_queues_nothing_and_does_not_register(
         self, config_file: Path
     ) -> None:
-        """Every node already terminal at fetch time -> empty ready frontier,
-        nothing dispatched, no daemon auto-drain registration needed."""
+        """Every node already terminal at fetch time -> nothing to queue,
+        nothing dispatched, no daemon auto-drain registration."""
         body = "## Work order\n- [ ] #762\n"
         open_issues: list[dict] = []
 
@@ -225,7 +267,8 @@ class TestMilestoneDispatchBulk:
             )
         assert result.exit_code == 0, result.output
         disp.assert_not_called()
-        assert "Nothing to dispatch right now." in result.output
+        assert "Nothing to queue" in result.output
+        assert state_mod.list_drive_queue() == []
         assert state_mod.list_milestone_drains() == []
 
 
@@ -429,9 +472,9 @@ class TestMilestoneDispatchGateA:
             )
         assert result.exit_code == 0, result.output
         assert "Gate A" not in result.output
-        will_dispatch = result.output.split("Will dispatch now:")[1].split("Waiting:")[0]
-        assert "#762" in will_dispatch
-        assert "#763" in will_dispatch
+        plan_section = result.output.split("Will queue (drive-queue), in dependency order:")[1]
+        assert "#762" in plan_section
+        assert "#763" in plan_section
 
     def test_repo_without_acceptance_driver_is_unaffected(self, config_file: Path) -> None:
         """No `acceptance.drivers` entry for this repo -> Gate A is a no-op,

{code_coordinator-0.5.128 → code_coordinator-0.5.129}/tests/test_milestone_dispatch.py

@@ -27,6 +27,7 @@ from coord.milestone_dispatch import (
     issue_oracle_ready,
     pick_machine,
     plan_dispatch,
+    plan_queue,
 )
 from coord.milestone_order import WorkOrder, WorkOrderNode
 from coord.models import Assignment, Board, Machine, Repo
@@ -168,6 +169,46 @@ class TestPlanDispatch:
         assert plan.waiting == ()
 
 
+# ── plan_queue (#2335) ───────────────────────────────────────────────────────
+
+
+class TestPlanQueue:
+    def test_whole_dag_in_declared_order_with_qualified_after_keys(self) -> None:
+        plan = plan_queue(WORK_ORDER, terminal_issues=set(), repo_name="api")
+        assert [q.issue_number for q in plan] == [762, 763, 765]
+        assert plan[0].after == ()
+        assert plan[0].group == "A"
+        assert plan[1].after == ()
+        assert plan[2].after == ("api#762", "api#763")
+        assert plan[2].group is None
+
+    def test_terminal_nodes_are_dropped_and_their_edges_filtered(self) -> None:
+        plan = plan_queue(WORK_ORDER, terminal_issues={762}, repo_name="api")
+        assert [q.issue_number for q in plan] == [763, 765]
+        # The closed pre-req never enters the queue, so its edge is dropped;
+        # the still-open one is kept.
+        assert plan[1].after == ("api#763",)
+
+    def test_all_terminal_yields_empty_plan(self) -> None:
+        plan = plan_queue(WORK_ORDER, terminal_issues={762, 763, 765}, repo_name="api")
+        assert plan == ()
+
+    def test_dependent_declared_before_prereq_sorts_topologically(self) -> None:
+        order = WorkOrder(
+            nodes=(WorkOrderNode(765, after=(762,)), WorkOrderNode(762))
+        )
+        plan = plan_queue(order, terminal_issues=set(), repo_name="api")
+        assert [q.issue_number for q in plan] == [762, 765]
+        assert plan[1].after == ("api#762",)
+
+    def test_independent_nodes_keep_declared_order(self) -> None:
+        order = WorkOrder(
+            nodes=(WorkOrderNode(3), WorkOrderNode(1), WorkOrderNode(2))
+        )
+        plan = plan_queue(order, terminal_issues=set(), repo_name="api")
+        assert [q.issue_number for q in plan] == [3, 1, 2]
+
+
 # ── is_milestone_complete ────────────────────────────────────────────────────