code-coordinator 0.5.495__tar.gz → 0.5.497__tar.gz

{code_coordinator-0.5.495 → code_coordinator-0.5.497}/PKG-INFO

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

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

@@ -613,6 +613,7 @@ tests/test_drive_machine_fault.py
 tests/test_drive_queue.py
 tests/test_drive_queue_blocked_rendering.py
 tests/test_drive_queue_launch_argv.py
+tests/test_drive_queue_max_parallel_config.py
 tests/test_drive_queue_max_parallel_per_repo_config.py
 tests/test_drive_queue_roll_pending.py
 tests/test_drive_queue_self_cordon_escalation.py

{code_coordinator-0.5.495 → code_coordinator-0.5.497}/code_coordinator.egg-info/scm_file_list.json

@@ -639,6 +639,7 @@
     "tests/test_drive_queue.py",
     "tests/test_drive_queue_blocked_rendering.py",
     "tests/test_drive_queue_launch_argv.py",
+    "tests/test_drive_queue_max_parallel_config.py",
     "tests/test_drive_queue_max_parallel_per_repo_config.py",
     "tests/test_drive_queue_roll_pending.py",
     "tests/test_drive_queue_self_cordon_escalation.py",

code_coordinator-0.5.497/code_coordinator.egg-info/scm_version.json

@@ -0,0 +1,8 @@
+{
+  "tag": "0.5.497",
+  "distance": 0,
+  "node": "gd05a81b74292333679389936cf7cdb3edea6fd12",
+  "dirty": false,
+  "branch": "HEAD",
+  "node_date": "2026-09-19"
+}

{code_coordinator-0.5.495 → code_coordinator-0.5.497}/coord/commands/drive_queue.py

@@ -35,7 +35,7 @@ import socket
 import subprocess
 import time
 from pathlib import Path
-from typing import TYPE_CHECKING, Any, Mapping
+from typing import TYPE_CHECKING, Any, Mapping, Sequence
 
 import click
 
@@ -46,6 +46,7 @@ from coord.drive_queue import (
     APPLY_APPLIED,
     APPLY_FAILED,
     DEFAULT_MAX_ATTEMPTS,
+    DEFAULT_MAX_PARALLEL,
     DEFAULT_MAX_PARALLEL_PER_REPO,
     HOLD_FIRED,
     HOLD_RELEASED,
@@ -77,6 +78,7 @@ from coord.drive_queue import (
     add_preflight_notice,
     apply_gate_status,
     build_board_view,
+    default_max_parallel,
     detect_unreachable_waits,
     diagnose_blocked_after,
     effective_max_fix_rounds,
@@ -109,6 +111,7 @@ from coord.overlap_predict import (
     EVENT_SCORED,
     OUTCOME_UNKNOWN,
     SOURCE_DECLARED,
+    Overlap,
     Prediction,
     classify_outcome,
     collect_candidate_files,
@@ -116,6 +119,7 @@ from coord.overlap_predict import (
     fanout_warnings,
     inflight_footprints,
     malformed_files_warning,
+    overlap_would_run_before,
     parse_declared_files,
     predict_overlap,
     predictions_from_audit,
@@ -463,12 +467,38 @@ def drive_queue_add(
     malformed_note = ""
     auto_after: list[str] = []
     rejected_after: list[str] = []
+    # #3395 rule 2: overlaps against an already-queued, not-yet-dispatched
+    # entry that THIS add is positioning ahead of — the edge for those goes
+    # on the INCUMBENT (`entry --after this add`), applied further down once
+    # this add's own row exists, never on `after` above (that would chain
+    # this add behind an entry it is about to run in front of).
+    reverse_candidates: list[tuple[QueueEntry, Overlap]] = []
+    reverse_rejected: list[str] = []
     if not no_predict_overlap:
         prediction, staleness_note, malformed_note = _predict_overlap(
             config_path, repo, issue, existing_entries
         )
+        effective_position = _resolve_effective_new_position(position, previous)
+        forward_keys, all_reverse = _partition_overlap_after(
+            existing_entries,
+            effective_position,
+            prediction,
+            previous_position=previous.position if previous is not None else None,
+        )
+        # #2603's --reject-after is the same narrower escape hatch for a
+        # REVERSED edge too — it names the OTHER entry's key either way, so
+        # an operator does not need to know which direction rule 2 picked to
+        # veto it.
+        reverse_candidates = [
+            (entry, overlap) for entry, overlap in all_reverse
+            if entry.key not in reject_after
+        ]
+        reverse_rejected = [
+            entry.key for entry, _overlap in all_reverse if entry.key in reject_after
+        ]
         candidate_after = _applicable_auto_after(
-            existing_entries, repo, issue, after, prediction
+            existing_entries, repo, issue, after, prediction,
+            candidate_keys=forward_keys,
         )
         # #2603: --reject-after is the narrower escape hatch — it drops only
         # the named edge(s) from what actually gets applied, never the whole
@@ -491,6 +521,18 @@ def drive_queue_add(
         no_acceptance=no_acceptance,
         plan_destructive=plan_destructive,
     )
+    # #3395: apply the REVERSED edges rule 2 selected — writing to the
+    # INCUMBENT entry's own row, now that this add's row exists to name as
+    # its `--after`. Must run after the write above: it names `entry_key
+    # (repo, issue)` as a pre-req, and while nothing here checks the row for
+    # existence, doing this first keeps the audit trail (both events land in
+    # enqueue order, not out of order relative to `queued ...`) intuitive to
+    # read back.
+    reverse_applied: list[tuple[QueueEntry, Overlap]] = []
+    if reverse_candidates:
+        reverse_applied = _apply_reversed_overlap_after(
+            existing_entries, entry_key(repo, issue), after, reverse_candidates,
+        )
     # #2839: queueing a drive is a strictly STRONGER statement than "send to
     # Pipeline" (`coord track`), so it must never leave the issue in a
     # weaker label state — apply the same `coord` + `status:ready` labels
@@ -540,13 +582,22 @@ def drive_queue_add(
     # --reject-after confirmation above: an author who wrote a declaration
     # that never took must not see output byte-identical to "declared
     # nothing".
+    # #3395: plus, for every REVERSED edge rule 2 applied, a line naming the
+    # INCUMBENT entry and why the direction is flipped from #2247's usual
+    # "ordered --after" reading — an unexplained edge on a row OTHER than
+    # the one this `add` named is exactly the kind of surprise an operator
+    # needs the reason for immediately, not by going and reading that row's
+    # own `last_reason` separately.
     overlap_notes: list[str] = []
     if auto_after:
         overlap_notes.append(prediction.reason)
         overlap_notes.extend(_declared_overlap_age_notes(prediction, auto_after))
-    if rejected_after:
+    for entry, overlap in reverse_applied:
+        overlap_notes.append(_reverse_overlap_reason(entry_key(repo, issue), overlap))
+    all_rejected = [*rejected_after, *reverse_rejected]
+    if all_rejected:
         overlap_notes.append(
-            "rejected via --reject-after (not applied): " + ", ".join(rejected_after)
+            "rejected via --reject-after (not applied): " + ", ".join(all_rejected)
         )
     overlap_notes.extend(fanout_warnings(prediction))
     if malformed_note:
@@ -923,6 +974,8 @@ def _applicable_auto_after(
     issue: int,
     after: list[str],
     prediction: Prediction,
+    *,
+    candidate_keys: Sequence[str] | None = None,
 ) -> list[str]:
     """The predicted pre-reqs that are actually safe to add.
 
@@ -931,9 +984,20 @@ def _applicable_auto_after(
     dropped if it would self-edge or close a cycle — the opposite posture to
     `validate_enqueue`'s treatment of an operator-declared `--after`, which is
     a typo worth reporting.
+
+    #3395: *candidate_keys* narrows which of `prediction.after_keys` this
+    call even considers — `None` (the default, unused by `drive_queue_add`'s
+    own call today but kept for a caller that wants pre-#3395 behaviour, or
+    a future direct test) keeps the pre-#3395 behaviour of trying all of
+    them. `drive_queue_add` passes the FORWARD subset only:
+    `_partition_overlap_after` has already routed the REVERSED ones (a
+    newcomer positioned ahead of an overlapping, not-yet-dispatched entry) to
+    `_apply_reversed_overlap_after` instead, and chaining this entry after
+    them TOO would apply rule 2's edge twice, in both directions.
     """
+    keys = prediction.after_keys if candidate_keys is None else tuple(candidate_keys)
     applied: list[str] = []
-    for candidate_key in prediction.after_keys:
+    for candidate_key in keys:
         if candidate_key in after or candidate_key in applied:
             continue
         try:
@@ -946,6 +1010,226 @@ def _applicable_auto_after(
     return applied
 
 
+def _resolve_effective_new_position(
+    position: int | None, previous: QueueEntry | None,
+) -> int | None:
+    """#3395: the position this `add` actually leaves the entry at, for
+    :func:`coord.overlap_predict.overlap_would_run_before` to compare against.
+
+    An explicit ``--position`` wins outright. Otherwise, re-adding an
+    already-queued entry keeps its CURRENT position — `enqueue_drive_queue`
+    never moves a row unless `position` is given — so that position is what
+    the entry will actually run at. A brand-new entry with no `--position`
+    appends at the tail (``None``, `overlap_would_run_before`'s own "never
+    ahead of anything" case) — there is no meaningful position yet.
+    """
+    if position is not None:
+        return position
+    if previous is not None:
+        return previous.position
+    return None
+
+
+def _partition_overlap_after(
+    existing_entries: list[QueueEntry],
+    effective_position: int | None,
+    prediction: Prediction,
+    *,
+    previous_position: int | None = None,
+) -> tuple[list[str], list[tuple[QueueEntry, Overlap]]]:
+    """#3395 rule 2: split predicted overlaps by which direction the
+    ``--after`` edge belongs in.
+
+    FORWARD (returned as plain keys, same shape `_applicable_auto_after`
+    always took) is correct whenever the other side either is already
+    running (`[branch]` — it started before this `add` regardless of queue
+    position) or is queued but will still dispatch no earlier than this
+    newcomer. REVERSE (returned paired with the other side's own
+    `QueueEntry`, since applying it means writing to THAT row, not this one)
+    is the case the issue is about: a `[declared]` overlap against an entry
+    that is still queued but is about to be pushed BEHIND this newcomer in
+    dispatch order. Chaining the newcomer after it there would force the
+    newcomer to run last despite the operator's own `--position`, while the
+    incumbent — now scheduled first — would carry no edge stopping it from
+    colliding with the newcomer's fresher files.
+
+    An overlap naming a key with no matching `QueueEntry` (the declared
+    footprint disappeared between prediction and this call — a `remove` race,
+    vanishingly rare) falls back to FORWARD: the safe, pre-#3395 default.
+
+    ``previous_position`` is the target's OWN position before this call —
+    `None` for a brand-new entry, the row's current position when this
+    `add` is REPOSITIONING an already-queued entry. Passed straight through
+    to `overlap_would_run_before`, which needs it to account for
+    `_move_drive_queue_entry_local`'s remove-then-reinsert shift: without
+    it, the direction decision compares `other`'s stale pre-removal
+    position and can pick the REVERSE edge when FORWARD is actually correct
+    (or vice versa) — see that function's docstring for the full case
+    analysis.
+    """
+    entries_by_key = {e.key: e for e in existing_entries}
+    forward: list[str] = []
+    reverse: list[tuple[QueueEntry, Overlap]] = []
+    for overlap in prediction.overlaps:
+        other = entries_by_key.get(overlap.key)
+        if (
+            overlap.source == SOURCE_DECLARED
+            and other is not None
+            and overlap_would_run_before(
+                effective_position,
+                other.position,
+                previous_position=previous_position,
+            )
+        ):
+            reverse.append((other, overlap))
+        else:
+            forward.append(overlap.key)
+    return forward, reverse
+
+
+def _apply_reversed_overlap_after(
+    existing_entries: list[QueueEntry],
+    new_key: str,
+    new_key_after: Sequence[str],
+    reverse_candidates: list[tuple[QueueEntry, Overlap]],
+) -> list[tuple[QueueEntry, Overlap]]:
+    """#3395: apply the REVERSED edges `_partition_overlap_after` identified
+    — chain each incumbent entry ``--after`` the newcomer, since the
+    newcomer is the one that will actually dispatch first.
+
+    Same fail-safe posture as `_applicable_auto_after`: a would-be cycle is
+    silently dropped rather than failing this `add` (an INFERRED edge must
+    never be able to refuse an operator's own `--position`), and an edge that
+    already exists on the incumbent is left alone (no redundant write).
+    Every OTHER operator-declared field on the incumbent's row (`machine`,
+    the hold gate, `max_fix_rounds`, ...) is carried through unchanged —
+    `enqueue_drive_queue` fully replaces those columns on every call, so
+    omitting one here would silently clear it off a row this `add` was never
+    asked to touch.
+
+    ``new_key_after`` is the newcomer's OWN final ``--after`` list from this
+    same `add` (operator-declared plus rule 1's forward auto-chains). The
+    cycle check below builds its own edge graph rather than reusing
+    `validate_enqueue` directly, because `existing_entries` is the pre-write
+    snapshot: it never contains the newcomer's row (a brand-new entry) and,
+    on a reposition, contains only its STALE pre-`add` edges — so a
+    `validate_enqueue` call scoped to just the incumbent's candidate edge
+    cannot see the newcomer's own outgoing edges and would miss a two-node
+    cycle this single `add` invocation introduces (rule 1 chains the
+    newcomer after an overlapping incumbent, rule 2 separately wants that
+    same incumbent chained after the newcomer). Including `new_key_after` as
+    the newcomer's node in the graph here closes that gap; the tick's own
+    full-graph `find_cycle` would otherwise be the only thing to catch it,
+    after the fact.
+    """
+    from coord.state import enqueue_drive_queue  # noqa: PLC0415
+
+    applied: list[tuple[QueueEntry, Overlap]] = []
+    base_edges: dict[str, list[str]] = {
+        e.key: list(e.after) for e in existing_entries if e.key != new_key
+    }
+    base_edges[new_key] = [str(a) for a in new_key_after]
+    for entry, overlap in reverse_candidates:
+        if new_key in entry.after:
+            applied.append((entry, overlap))
+            continue
+        new_after = [*entry.after, new_key]
+        trial_edges = dict(base_edges)
+        trial_edges[entry.key] = new_after
+        if find_cycle(trial_edges) is not None:
+            continue
+        enqueue_drive_queue(
+            entry.repo,
+            entry.issue,
+            machine=entry.machine or None,
+            after=new_after,
+            position=None,
+            hold_after=entry.hold_after,
+            hold_reason=entry.hold_reason,
+            resume_when=entry.resume_when,
+            hold_scope=entry.hold_scope,
+            max_fix_rounds=entry.max_fix_rounds,
+            no_acceptance=entry.no_acceptance,
+            plan_destructive=entry.plan_destructive,
+        )
+        applied.append((entry, overlap))
+        _record_reverse_overlap_prediction(entry.repo, entry.issue, new_key, overlap)
+    return applied
+
+
+def _reverse_overlap_reason(new_key: str, overlap: Overlap) -> str:
+    """#3395: the one sentence shared by `add`'s stdout, the audit summary,
+    and the INCUMBENT's own `last_reason` for a REVERSED edge — so all three
+    surfaces agree on why a row this `add` never named got a new `after=`.
+    """
+    return (
+        "predicted file overlap (#2247) — ordered "
+        + overlap.describe_reversed(new_key)
+        + " (#3395: this add was positioned ahead of an existing queued entry)"
+    )
+
+
+def _record_reverse_overlap_prediction(
+    repo: str, issue: int, new_key: str, overlap: Overlap,
+) -> None:
+    """#3395: the audit + `last_reason` twin of `_record_overlap_prediction`
+    for a REVERSED edge — recorded against *repo*/*issue*, the INCUMBENT
+    entry that actually got the new `after=` write, not the entry `add` was
+    called for. Mirrors `_record_overlap_prediction`'s two sinks (a durable
+    audit row, plus the `last_reason` column an operator reading `coord
+    drive-queue list` sees immediately) for the same reason: a `last_reason`
+    the next tick attempt will overwrite is not durable, so the claim also
+    needs a permanent home to be scored later.
+
+    Kept as its own event rather than reusing `Prediction.audit_details()`
+    verbatim: that payload's `after` list and `predicted_files` are framed
+    from the CANDIDATE's point of view (`_predict_overlap` computed them
+    that way), and reusing it here unedited would misrepresent whose files
+    were actually being ordered against whose.
+    """
+    reason = _reverse_overlap_reason(new_key, overlap)
+    details = {
+        "predicted_files": list(overlap.files),
+        "overlaps": [
+            {
+                "key": new_key,
+                "source": overlap.source,
+                "branch": overlap.branch,
+                "head_sha": overlap.head_sha,
+                "synced_at": overlap.synced_at,
+                "liveness_checked": overlap.liveness_checked,
+                "files": list(overlap.files),
+            }
+        ],
+        "after": [new_key],
+        # #3395: the one field with no forward-edge equivalent — lets a later
+        # reader (a human, `overlap-report`) tell this row's `after=` was
+        # rule 2's reversal, not an ordinary same-direction prediction.
+        "reversed": True,
+    }
+    try:
+        from coord.audit import record_audit  # noqa: PLC0415
+
+        record_audit(
+            tier="business",
+            category=AUDIT_CATEGORY,
+            event_type=EVENT_PREDICTED,
+            actor="drive-queue",
+            summary=reason,
+            repo=repo,
+            issue=issue,
+            details=details,
+        )
+    except Exception:  # noqa: BLE001 — recording must never fail the enqueue
+        pass
+    try:
+        from coord.state import update_drive_queue_entry  # noqa: PLC0415
+
+        update_drive_queue_entry(repo, issue, last_reason=reason)
+    except Exception:  # noqa: BLE001 — same
+        pass
+
+
 def _record_overlap_prediction(
     repo: str, issue: int, prediction: Prediction, applied: list[str],
 ) -> None:
@@ -5248,12 +5532,25 @@ def _blocked_escalation_command(entry: QueueEntry | None, key: str, reason: str)
 @click.option(
     "--max-parallel",
     type=int,
-    default=1,
-    show_default=True,
+    default=None,
     help=(
-        "Concurrency ceiling. Capacity is counted from BOARD state, not from a "
-        "session count, so a drive whose observer hit its deadline (#1660) "
-        "still occupies a slot."
+        "Global concurrency ceiling. Capacity is counted from BOARD state, "
+        "not from a session count, so a drive whose observer hit its "
+        "deadline (#1660) still occupies a slot. Omit this flag to use "
+        "pipeline.max_parallel from coordinator.yml (or, absent that, a "
+        "derivation from the fleet's own shape — repo count times the "
+        "resolved --max-parallel-per-repo, clamped to "
+        "concurrency.max_workers, see coord.drive_queue."
+        "default_max_parallel; falling back further, if the config itself "
+        f"can't be read, to {DEFAULT_MAX_PARALLEL}, #3388) — passing it "
+        "explicitly always wins over both. #3388: a hardcoded constant here "
+        "(coord-drive-queue.service used to pin --max-parallel 4) silently "
+        "starves every repo but the first couple once "
+        "--max-parallel-per-repo can exceed 1 — prefer the config setting "
+        "over a systemd drop-in for the same reason #2573 gives for "
+        "--max-parallel-per-repo: a drop-in has to restate the packaged "
+        "unit's whole ExecStart= to change just this flag, and that copy "
+        "silently drifts from the packaged unit's other flags over time."
     ),
 )
 @click.option(
@@ -5301,7 +5598,7 @@ def _blocked_escalation_command(entry: QueueEntry | None, key: str, reason: str)
 )
 @_CONFIG_OPTION
 def drive_queue_tick(
-    max_parallel: int,
+    max_parallel: int | None,
     max_parallel_per_repo: int | None,
     dry_run: bool,
     reconcile_only: bool,
@@ -5338,6 +5635,20 @@ def drive_queue_tick(
     reverted #2314's pinned-venv `ExecStart=` right back to a
     worker-overwritable path as an unnoticed side effect).
 
+    #3388: `--max-parallel` resolves the SAME way, one level up — the flag on
+    THIS invocation, when given; else `pipeline.max_parallel` from
+    `coordinator.yml`; else `coord.drive_queue.default_max_parallel`'s
+    derivation from the fleet's own shape (repo count times the
+    ALREADY-RESOLVED `--max-parallel-per-repo` above, clamped to
+    `concurrency.max_workers`); else, only if the config itself could not be
+    read at all, `coord.drive_queue.DEFAULT_MAX_PARALLEL` (1). A hardcoded
+    `--max-parallel` on the deployed systemd unit is exactly the failure mode
+    this closes: #2012 set it to the repo count when `--max-parallel-per-repo`
+    always defaulted to 1, #2057 raised it once by hand for a fifth repo, and
+    neither update survived #2573 letting the per-repo ceiling exceed 1 — two
+    repos alone then reach a stale global ceiling and starve every other repo
+    in the fleet, forever, however deep their own queues are.
+
     `--max-parallel 0` (or `--reconcile-only`, the readable spelling of the
     same thing — #2110) reconciles every `running` entry against the board and
     then stops: no capacity walk, no deferrals, no queue-level alert, no
@@ -5369,24 +5680,37 @@ def drive_queue_tick(
     from coord.filelock import FileLock, LockBusy, drive_queue_lock_path  # noqa: PLC0415
     from coord.state import list_drive_queue, update_drive_queue_entry  # noqa: PLC0415
 
-    if max_parallel < 0:
-        raise click.ClickException(
-            "--max-parallel must be at least 0 (0 = reconcile-only, launch "
-            "nothing this run — see --reconcile-only)"
-        )
+    # Loaded at most once, shared by both ceilings' config-default resolution
+    # below (#3388's `max_parallel` derivation needs the same config
+    # `max_parallel_per_repo` already reads, plus `repos`/`concurrency`) —
+    # `None` on the documented fail-open path, same posture as every other
+    # best-effort config read on this path (an unreadable config must never
+    # abort the tick).
+    _resolved_config: Config | None = None
+    _config_load_attempted = False
+
+    def _config_for_defaults() -> Config | None:
+        nonlocal _resolved_config, _config_load_attempted
+        if not _config_load_attempted:
+            _config_load_attempted = True
+            try:
+                from coord.commands._common import _load_config  # noqa: PLC0415
+
+                _resolved_config = _load_config(config_path)
+            except Exception:  # noqa: BLE001 — an unreadable config must not abort the tick
+                _resolved_config = None
+        return _resolved_config
 
     # #2573: an explicit `--max-parallel-per-repo` always wins; otherwise
     # fall back to the fleet-wide `pipeline.max_parallel_per_repo` in
     # coordinator.yml, and only then to the hardcoded default. Resolved
-    # BEFORE validation below so a bad value from either source is caught
-    # the same way regardless of which one supplied it.
+    # BEFORE `--max-parallel` (#3388's derivation multiplies BY this
+    # already-resolved value) and before validation below, so a bad value
+    # from either source is caught the same way regardless of which one
+    # supplied it.
     if max_parallel_per_repo is None:
-        try:
-            from coord.commands._common import _load_config  # noqa: PLC0415
-
-            config_default = _load_config(config_path).pipeline.max_parallel_per_repo
-        except Exception:  # noqa: BLE001 — an unreadable config must not abort the tick
-            config_default = None
+        _cfg = _config_for_defaults()
+        config_default = None if _cfg is None else _cfg.pipeline.max_parallel_per_repo
         max_parallel_per_repo = (
             DEFAULT_MAX_PARALLEL_PER_REPO if config_default is None else config_default
         )
@@ -5396,6 +5720,35 @@ def drive_queue_tick(
             "--max-parallel-per-repo must be 0 (no per-repo ceiling) or more"
         )
 
+    # #3388: an explicit `--max-parallel` always wins; otherwise
+    # `pipeline.max_parallel` from coordinator.yml; otherwise derive it from
+    # the fleet's own shape (repo count * the per-repo ceiling just resolved
+    # above, clamped to the fleet's real worker capacity) rather than fall
+    # back to a hand-maintained constant that goes stale the moment either
+    # side changes — see `coord.drive_queue.default_max_parallel`. Only when
+    # the config itself could not be read at all (so neither the fleet
+    # default nor the fleet shape is known) does this fall back to the
+    # hardcoded `DEFAULT_MAX_PARALLEL`.
+    if max_parallel is None:
+        _cfg = _config_for_defaults()
+        config_max_parallel = None if _cfg is None else _cfg.pipeline.max_parallel
+        if config_max_parallel is not None:
+            max_parallel = config_max_parallel
+        elif _cfg is not None:
+            max_parallel = default_max_parallel(
+                repo_count=len(_cfg.repos),
+                max_parallel_per_repo=max_parallel_per_repo,
+                max_workers_cap=_cfg.concurrency.max_workers,
+            )
+        else:
+            max_parallel = DEFAULT_MAX_PARALLEL
+
+    if max_parallel < 0:
+        raise click.ClickException(
+            "--max-parallel must be at least 0 (0 = reconcile-only, launch "
+            "nothing this run — see --reconcile-only)"
+        )
+
     # #2110: `--reconcile-only` and `--max-parallel 0` are the same request —
     # one flag is a mnemonic for the other rather than a second code path, so
     # there is exactly one way this behaves, not two that could drift apart.

{code_coordinator-0.5.495 → code_coordinator-0.5.497}/coord/config.py

@@ -1232,6 +1232,21 @@ class PipelineConfig:
     :data:`_DEFAULT_STALL_THRESHOLDS` for the shape and the evidence behind
     its two seeded entries, and :meth:`stall_threshold_secs` for how a type
     absent from the table falls back to the drive's flat ``--stall`` value.
+
+    ``max_parallel`` (#3388) is the fleet-wide default for ``coord
+    drive-queue tick``'s GLOBAL concurrency ceiling (``--max-parallel``) —
+    the sibling of ``max_parallel_per_repo`` above, added for the same
+    reason: a systemd unit's hardcoded ``--max-parallel 4`` encoded a fact
+    about the fleet (repo count times per-repo ceiling) that nobody revisited
+    when either side changed, and two repos alone starved the other twelve
+    once ``max_parallel_per_repo`` could exceed 1 (#2012, #2057, #2573).
+    ``None`` (the default) leaves the ceiling at
+    ``coord.drive_queue.default_max_parallel``'s derivation — ``repo_count *
+    max_parallel_per_repo``, clamped to ``concurrency.max_workers`` — rather
+    than a hand-maintained constant. An explicit ``coord drive-queue tick
+    --max-parallel N`` on the command line always wins over this, exactly
+    mirroring ``max_parallel_per_repo``'s own resolution order — see
+    ``coord.commands.drive_queue.drive_queue_tick``.
     """
 
     default_gates: list[str] = field(default_factory=lambda: ["test", "review", "merge"])
@@ -1267,6 +1282,9 @@ class PipelineConfig:
     stall_thresholds: dict[str, float] = field(
         default_factory=lambda: dict(_DEFAULT_STALL_THRESHOLDS)
     )
+    # #3388 — None means "derive from the fleet shape", see
+    # coord.drive_queue.default_max_parallel. See the class docstring.
+    max_parallel: int | None = None
 
     def attention_threshold_for(
         self,
@@ -3641,6 +3659,17 @@ def _parse_pipeline(raw: Any) -> PipelineConfig:
             )
         cfg.max_parallel_per_repo = value
 
+    if "max_parallel" in raw:
+        value = raw["max_parallel"]
+        if value is not None and (
+            not isinstance(value, int) or isinstance(value, bool) or value < 0
+        ):
+            raise ConfigError(
+                "pipeline.max_parallel must be a non-negative integer or "
+                "null (0 = reconcile-only, launch nothing)"
+            )
+        cfg.max_parallel = value
+
     if "stall_thresholds" in raw:
         value = raw["stall_thresholds"]
         if not isinstance(value, dict):