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

{code_coordinator-0.5.126 → code_coordinator-0.5.129}/CLAUDE.md

@@ -261,6 +261,7 @@ reviewer can stop reading here.
 - [`docs/GRAPHIFY_SETUP.md`](docs/GRAPHIFY_SETUP.md) — installing the knowledge graph on a new machine (four layers, all of which fail *silently*).
 - [`docs/EPHEMERAL_WORKERS.md`](docs/EPHEMERAL_WORKERS.md) — on-demand Azure worker VMs per epic. **The tailnet ACL is the security boundary** — `agent_app.py` has no authentication.
 - [`docs/MAC_MINI.md`](docs/MAC_MINI.md) — adding a Mac mini; sizing, provisioning, and what non-macOS work routes there. The port itself is [`docs/CROSS_PLATFORM.md`](docs/CROSS_PLATFORM.md) (milestone #39).
+- [`docs/WSL_WINDOWS_WORKER.md`](docs/WSL_WINDOWS_WORKER.md) — using a Tailscale-connected WSL2 box as the Windows worker for quadraui/vimcode's Win-GUI ports. Not the coord-itself Windows port.
 - [`docs/FORGE_MIGRATION.md`](docs/FORGE_MIGRATION.md) — surviving a forge outage (cheap) versus leaving a forge (expensive); milestone #58 / epic #1902.
 
 **Two deploy facts that bite most often:**

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: code-coordinator
-Version: 0.5.126
+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.126 → 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.126
+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.126 → code_coordinator-0.5.129}/code_coordinator.egg-info/SOURCES.txt

@@ -389,6 +389,7 @@ docs/SECOND_BACKEND.md
 docs/STORE_SERVICE.md
 docs/TEST_FIRST_BUG_LANE.md
 docs/WEB_CONTROL_CENTER.md
+docs/WSL_WINDOWS_WORKER.md
 docs/mocks/web/README.md
 docs/mocks/web/_tokens.css
 docs/mocks/web/issue-detail.html
@@ -827,6 +828,7 @@ tui/src/app/audit.rs
 tui/src/app/chat.rs
 tui/src/app/data.rs
 tui/src/app/dialogs.rs
+tui/src/app/doc_tabs.rs
 tui/src/app/drive.rs
 tui/src/app/drive_queue.rs
 tui/src/app/escalation.rs

{code_coordinator-0.5.126 → code_coordinator-0.5.129}/code_coordinator.egg-info/scm_file_list.json

@@ -367,6 +367,7 @@
     "docs/STORE_SERVICE.md",
     "docs/TEST_FIRST_BUG_LANE.md",
     "docs/WEB_CONTROL_CENTER.md",
+    "docs/WSL_WINDOWS_WORKER.md",
     "docs/mocks/web/README.md",
     "docs/mocks/web/_tokens.css",
     "docs/mocks/web/issue-detail.html",
@@ -803,6 +804,7 @@
     "tui/src/app/chat.rs",
     "tui/src/app/data.rs",
     "tui/src/app/dialogs.rs",
+    "tui/src/app/doc_tabs.rs",
     "tui/src/app/drive.rs",
     "tui/src/app/drive_queue.rs",
     "tui/src/app/escalation.rs",

{code_coordinator-0.5.126 → code_coordinator-0.5.129}/code_coordinator.egg-info/scm_version.json

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

{code_coordinator-0.5.126 → code_coordinator-0.5.129}/coord/commands/acceptance.py

@@ -420,6 +420,37 @@ def _acceptance_worktree_path(repo_name: str, issue_number: int) -> Path:
     return COORD_DIR / "acceptance-worktrees" / f"{repo_name}-{issue_number}"
 
 
+def _acceptance_worktree_lock_path(repo_name: str, issue_number: int) -> Path:
+    """The ``flock`` guarding :func:`_acceptance_worktree_path` (#2352).
+
+    That path is deliberately ONE per ``(repo, issue)``, reused across every
+    SHA/round for that issue (same incremental-build rationale as `coord
+    test`'s #561) — but nothing serialised *access* to it. Two concurrent
+    ``coord acceptance record`` calls for the same issue (an orphaned drive
+    process — #1660 — racing a fresh queue relaunch, or a by-hand re-run
+    overlapping an in-flight one) each did an unconditional ``git worktree
+    remove --force`` + ``add --force`` on the SAME directory: the second
+    invocation's remove ripped the tree out from under the first's
+    in-flight build/test, mid-compile. The corrupted build then printed
+    ordinary-looking compiler errors and exited non-zero having run zero
+    tests — indistinguishable from a genuinely red suite to
+    ``_scoped_verdict``, so it landed on the board as a real
+    ``acceptance_state=failed`` and burned a drive's fix-round budget on a
+    PR that was never actually broken.
+
+    A sibling ``.lock`` file next to the worktree directory itself (not one
+    global lock for the whole ``acceptance-worktrees/`` tree) so unrelated
+    ``(repo, issue)`` pairs never wait on each other.
+
+    Derived from :func:`_acceptance_worktree_path` (module-level lookup, so
+    a test monkeypatching that name — e.g. to redirect it under
+    ``tmp_path`` — redirects this lock alongside it) rather than
+    re-deriving ``COORD_DIR`` independently, which would silently drift the
+    two apart the moment either one's path scheme changes."""
+    wt_path = _acceptance_worktree_path(repo_name, issue_number)
+    return wt_path.with_name(wt_path.name + ".lock")
+
+
 def _remove_acceptance_worktree(repo_dir: Path, wt_path: Path) -> None:
     if not wt_path.exists():
         return
@@ -819,6 +850,7 @@ def _acceptance_record_local(
     config_path: Path,
     route_path: str | None = None,
 ) -> None:
+    from coord.filelock import FileLock  # noqa: PLC0415
     from coord.test_orchestrator import find_local_repo_path  # noqa: PLC0415
 
     cfg = _load_config(config_path)
@@ -835,119 +867,140 @@ def _acceptance_record_local(
         sys.exit(1)
 
     wt_path = _acceptance_worktree_path(repo, issue_number)
-    click.echo(
-        f"Fetching origin and preparing acceptance worktree at {sha!r} "
-        f"(base checkout {repo_dir} stays untouched)..."
-    )
-    try:
-        subprocess.run(
-            ["git", "fetch", "origin", "--prune"], cwd=str(repo_dir),
-            check=True, capture_output=True, text=True,
-        )
-    except subprocess.CalledProcessError as e:
-        click.echo(f"error: git fetch failed: {e.stderr.strip()}", err=True)
-        sys.exit(1)
 
-    _remove_acceptance_worktree(repo_dir, wt_path)
-    wt_path.parent.mkdir(parents=True, exist_ok=True)
-    res = subprocess.run(
-        ["git", "worktree", "add", "--force", "--detach", str(wt_path), sha],
-        cwd=str(repo_dir), capture_output=True, text=True,
-    )
-    if res.returncode != 0:
+    # #2352: everything from here down touches the ONE worktree this
+    # (repo, issue) reuses across every SHA/round — remove+add it, build in
+    # it, read its results. A second concurrent `coord acceptance record`
+    # for the same issue (an orphaned drive racing a fresh queue relaunch,
+    # or a by-hand re-run overlapping an in-flight one — see
+    # _acceptance_worktree_lock_path's docstring) must never interleave
+    # with this, or its `git worktree remove --force` clobbers whatever the
+    # first invocation is mid-build on. Blocking (not fail-fast) is
+    # deliberate: `flock` is released by the kernel even if the holder is
+    # killed, so there is no stale-lock deadlock risk to trade away, and
+    # blocking needs no change to `_decide_acceptance_gate`'s error
+    # handling — the second invocation just waits its turn and then records
+    # its own (correct) verdict, same as if it had been dispatched later.
+    with FileLock(_acceptance_worktree_lock_path(repo, issue_number)):
         click.echo(
-            f"error: could not create acceptance worktree at {sha!r}: "
-            f"{res.stderr.strip()}",
-            err=True,
+            f"Fetching origin and preparing acceptance worktree at {sha!r} "
+            f"(base checkout {repo_dir} stays untouched)..."
         )
-        sys.exit(1)
-
-    # #1125 review finding 2: resolve `{ms}` from the issue's manifest-mapped
-    # ms-NN dir (the worktree just checked out at `sha`) before running —
-    # same fail-soft-to-None rationale as `acceptance_run` above.
-    ms: str | None = None
-    try:
-        ms = ms_dir_for_issue(wt_path / ACCEPTANCE_DIRNAME, issue_number)
-    except Exception:  # noqa: BLE001
-        ms = None
+        try:
+            subprocess.run(
+                ["git", "fetch", "origin", "--prune"], cwd=str(repo_dir),
+                check=True, capture_output=True, text=True,
+            )
+        except subprocess.CalledProcessError as e:
+            click.echo(f"error: git fetch failed: {e.stderr.strip()}", err=True)
+            sys.exit(1)
 
-    try:
-        result = run_driver(
-            driver_cfg.kind, driver_cfg.run, cwd=str(wt_path), ms=ms,
-            setup_command=driver_cfg.setup,
-        )
-    except DriverError as e:
-        click.echo(f"error: {e}", err=True)
         _remove_acceptance_worktree(repo_dir, wt_path)
-        sys.exit(1)
-
-    # #944 review: _scoped_verdict exits(1) internally for a manifest that
-    # hasn't been authored yet / has no slice for this issue — a
-    # configuration error, not a real (kept-for-inspection) test failure, so
-    # the throwaway worktree must still be cleaned up on the way out.
-    try:
-        verdict = _scoped_verdict(
-            result.tests, wt_path / ACCEPTANCE_DIRNAME, issue_number,
-            entrypoint=driver_cfg.entrypoint,
+        wt_path.parent.mkdir(parents=True, exist_ok=True)
+        res = subprocess.run(
+            ["git", "worktree", "add", "--force", "--detach", str(wt_path), sha],
+            cwd=str(repo_dir), capture_output=True, text=True,
         )
-    except SystemExit:
-        _remove_acceptance_worktree(repo_dir, wt_path)
-        raise
+        if res.returncode != 0:
+            click.echo(
+                f"error: could not create acceptance worktree at {sha!r}: "
+                f"{res.stderr.strip()}",
+                err=True,
+            )
+            sys.exit(1)
 
-    from coord.board_service import read_board  # noqa: PLC0415
-    from coord.diagnose import stage_assignments  # noqa: PLC0415
+        # #1125 review finding 2: resolve `{ms}` from the issue's
+        # manifest-mapped ms-NN dir (the worktree just checked out at
+        # `sha`) before running — same fail-soft-to-None rationale as
+        # `acceptance_run` above.
+        ms: str | None = None
+        try:
+            ms = ms_dir_for_issue(wt_path / ACCEPTANCE_DIRNAME, issue_number)
+        except Exception:  # noqa: BLE001
+            ms = None
 
-    board = read_board()
-    work_rows = stage_assignments(board, repo, issue_number, "work")
-    if not work_rows:
-        click.echo(
-            f"error: no work assignment found for {repo} #{issue_number}; "
-            "cannot record verdict",
-            err=True,
-        )
-        # Same rationale: a lookup error, not a failing-verdict "kept for
-        # inspection" case — don't leak the worktree.
-        _remove_acceptance_worktree(repo_dir, wt_path)
-        sys.exit(1)
-    assignment_id = work_rows[0].assignment_id
-
-    from coord.state import record_acceptance_verdict  # noqa: PLC0415
-
-    acceptance_state = "passed" if verdict["green"] else "failed"
-    reason = failure_summary(verdict) or None
-    record_acceptance_verdict(
-        assignment_id=assignment_id,
-        acceptance_state=acceptance_state,
-        acceptance_reason=reason,
-        acceptance_sha=sha,
-        # #932: per-test counts so the Acceptance box can show partial
-        # progress ("3/7 acceptance green") instead of a bare verdict.
-        acceptance_total=verdict["total"],
-        acceptance_passed=verdict["passed"],
-    )
+        try:
+            result = run_driver(
+                driver_cfg.kind, driver_cfg.run, cwd=str(wt_path), ms=ms,
+                setup_command=driver_cfg.setup,
+            )
+        except DriverError as e:
+            click.echo(f"error: {e}", err=True)
+            _remove_acceptance_worktree(repo_dir, wt_path)
+            sys.exit(1)
 
-    click.echo(json.dumps(verdict, indent=2))
-    click.echo(f"\nAcceptance {acceptance_state.upper()} for {repo} #{issue_number} @ {sha}")
-
-    if acceptance_state == "passed":
-        # #2164 review: clearing expected_red here (before Test/Review/the
-        # actual merge to the default branch have happened) was the bug —
-        # it could reopen "red default branch" for reasons unrelated to
-        # whatever CI run next observed this issue's still-unmerged fix.
-        # The clear now happens in `coord.merge_queue.process`, right after
-        # this SHA's PR actually merges — see
-        # `coord.acceptance.clear_expected_red_via_pr`'s docstring. Nothing
-        # to do here beyond pointing the operator at how to check.
-        if ms is not None:
+        # #944 review: _scoped_verdict exits(1) internally for a manifest
+        # that hasn't been authored yet / has no slice for this issue — a
+        # configuration error, not a real (kept-for-inspection) test
+        # failure, so the throwaway worktree must still be cleaned up on
+        # the way out.
+        try:
+            verdict = _scoped_verdict(
+                result.tests, wt_path / ACCEPTANCE_DIRNAME, issue_number,
+                entrypoint=driver_cfg.entrypoint,
+            )
+        except SystemExit:
+            _remove_acceptance_worktree(repo_dir, wt_path)
+            raise
+
+        from coord.board_service import read_board  # noqa: PLC0415
+        from coord.diagnose import stage_assignments  # noqa: PLC0415
+
+        board = read_board()
+        work_rows = stage_assignments(board, repo, issue_number, "work")
+        if not work_rows:
             click.echo(
-                f"  note: any expected_red entries for #{issue_number} clear "
-                f"automatically once its fix merges — see `coord acceptance "
-                f"expected-red {repo}` to check current state."
+                f"error: no work assignment found for {repo} #{issue_number}; "
+                "cannot record verdict",
+                err=True,
             )
-        _remove_acceptance_worktree(repo_dir, wt_path)
-    else:
-        click.echo(f"  worktree kept for inspection: {wt_path}")
-        sys.exit(1)
+            # Same rationale: a lookup error, not a failing-verdict "kept
+            # for inspection" case — don't leak the worktree.
+            _remove_acceptance_worktree(repo_dir, wt_path)
+            sys.exit(1)
+        assignment_id = work_rows[0].assignment_id
+
+        from coord.state import record_acceptance_verdict  # noqa: PLC0415
+
+        acceptance_state = "passed" if verdict["green"] else "failed"
+        reason = failure_summary(verdict) or None
+        record_acceptance_verdict(
+            assignment_id=assignment_id,
+            acceptance_state=acceptance_state,
+            acceptance_reason=reason,
+            acceptance_sha=sha,
+            # #932: per-test counts so the Acceptance box can show partial
+            # progress ("3/7 acceptance green") instead of a bare verdict.
+            acceptance_total=verdict["total"],
+            acceptance_passed=verdict["passed"],
+        )
+
+        click.echo(json.dumps(verdict, indent=2))
+        click.echo(
+            f"\nAcceptance {acceptance_state.upper()} for {repo} #{issue_number} @ {sha}"
+        )
+
+        if acceptance_state == "passed":
+            # #2164 review: clearing expected_red here (before
+            # Test/Review/the actual merge to the default branch have
+            # happened) was the bug — it could reopen "red default branch"
+            # for reasons unrelated to whatever CI run next observed this
+            # issue's still-unmerged fix. The clear now happens in
+            # `coord.merge_queue.process`, right after this SHA's PR
+            # actually merges — see
+            # `coord.acceptance.clear_expected_red_via_pr`'s docstring.
+            # Nothing to do here beyond pointing the operator at how to
+            # check.
+            if ms is not None:
+                click.echo(
+                    f"  note: any expected_red entries for #{issue_number} clear "
+                    f"automatically once its fix merges — see `coord acceptance "
+                    f"expected-red {repo}` to check current state."
+                )
+            _remove_acceptance_worktree(repo_dir, wt_path)
+        else:
+            click.echo(f"  worktree kept for inspection: {wt_path}")
+            sys.exit(1)
 
 
 def _stall_push_wip_snapshot(cwd: Path) -> str:

{code_coordinator-0.5.126 → 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: