code-coordinator 0.5.508__tar.gz → 0.5.509__tar.gz

{code_coordinator-0.5.508 → code_coordinator-0.5.509}/PKG-INFO

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

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

@@ -788,6 +788,7 @@ tests/test_repo_add.py
 tests/test_repo_dormancy.py
 tests/test_repo_edit_2220.py
 tests/test_repo_graph_fleet_2237.py
+tests/test_repo_max_parallel_3423.py
 tests/test_repo_onboard_2220.py
 tests/test_report_result_push.py
 tests/test_reports.py

{code_coordinator-0.5.508 → code_coordinator-0.5.509}/code_coordinator.egg-info/scm_file_list.json

@@ -814,6 +814,7 @@
     "tests/test_repo_dormancy.py",
     "tests/test_repo_edit_2220.py",
     "tests/test_repo_graph_fleet_2237.py",
+    "tests/test_repo_max_parallel_3423.py",
     "tests/test_repo_onboard_2220.py",
     "tests/test_report_result_push.py",
     "tests/test_reports.py",

{code_coordinator-0.5.508 → code_coordinator-0.5.509}/code_coordinator.egg-info/scm_version.json

@@ -1,7 +1,7 @@
 {
-  "tag": "0.5.508",
+  "tag": "0.5.509",
   "distance": 0,
-  "node": "g8afe10d6337d6c249497f95932b1a6acd5596222",
+  "node": "gace3f38afa44e85a17064892c36412cab13d0d34",
   "dirty": false,
   "branch": "HEAD",
   "node_date": "2026-09-20"

{code_coordinator-0.5.508 → code_coordinator-0.5.509}/coord/commands/drive_queue.py

@@ -101,8 +101,10 @@ from coord.drive_queue import (
     plan_tick,
     remaining_fix_rounds,
     render_plan,
+    effective_repo_capacities,
     resolve_max_parallel,
     resolve_max_parallel_per_repo,
+    resolve_repo_ceilings,
     total_fix_round_budget,
     unreachable_wait_alert,
     validate_apply_gate,
@@ -6226,25 +6228,45 @@ def drive_queue_tick(
     _config_max_parallel_per_repo = (
         None if _cfg is None else _cfg.pipeline.max_parallel_per_repo
     )
-    _shadow_warning = flag_shadows_config_warning(
-        flag_name="max-parallel-per-repo",
-        override_value=max_parallel_per_repo,
-        config_key="pipeline.max_parallel_per_repo",
-        config_value=_config_max_parallel_per_repo,
-    )
-    if _shadow_warning:
-        click.echo(_shadow_warning)
-    max_parallel_per_repo = resolve_max_parallel_per_repo(
+    _flag_max_parallel_per_repo = max_parallel_per_repo
+    _per_repo_resolution = resolve_max_parallel_per_repo(
         override_value=max_parallel_per_repo,
         override_source="--max-parallel-per-repo flag",
         config_value=_config_max_parallel_per_repo,
-    ).value
+    )
+    max_parallel_per_repo = _per_repo_resolution.value
 
     if max_parallel_per_repo < 0:
         raise click.ClickException(
             "--max-parallel-per-repo must be 0 (no per-repo ceiling) or more"
         )
 
+    # #3423: each repo's OWN ceiling (`repos[].max_parallel`), layered on the
+    # fleet-wide answer just resolved. Only the repos that actually DIFFER
+    # are carried into the tick, so a fleet with no overrides produces the
+    # identical `TickPlan` (and identical `render_plan` output) it did
+    # before. `resolve_repo_ceilings` is the SAME function `coord config
+    # --effective` reports through, for the same reason as the two ceilings
+    # above: one resolution order, not two that could drift (#2085).
+    _repo_ceilings = resolve_repo_ceilings(
+        {} if _cfg is None else {r.name: r.max_parallel for r in _cfg.repos},
+        fleet=_per_repo_resolution,
+    )
+    repo_max_parallel = effective_repo_capacities(
+        _repo_ceilings, fleet_value=max_parallel_per_repo
+    )
+    # Emitted after the per-repo table exists so the #3408 warning can name
+    # the repos whose own ceiling beats the flag anyway (#3423).
+    _shadow_warning = flag_shadows_config_warning(
+        flag_name="max-parallel-per-repo",
+        override_value=_flag_max_parallel_per_repo,
+        config_key="pipeline.max_parallel_per_repo",
+        config_value=_config_max_parallel_per_repo,
+        overridden_repos=sorted(repo_max_parallel),
+    )
+    if _shadow_warning:
+        click.echo(_shadow_warning)
+
     # #3388/#3408: 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
@@ -6272,6 +6294,11 @@ def drive_queue_tick(
         max_parallel_per_repo=max_parallel_per_repo,
         max_workers_cap=0 if _cfg is None else _cfg.concurrency.max_workers,
         config_readable=_cfg is not None,
+        # #3423: the derivation must sum the per-repo ceilings, not multiply
+        # by the fleet default — raising one repo to 2 without widening the
+        # global ceiling to match re-creates exactly the starvation #3388
+        # was opened for.
+        repo_overrides=repo_max_parallel,
     ).value
 
     if max_parallel < 0:
@@ -6522,6 +6549,7 @@ def drive_queue_tick(
             board,
             effective_capacity,
             max_parallel_per_repo=max_parallel_per_repo,
+            repo_max_parallel=repo_max_parallel,
             probes=probes,
             now=now,
             local_host=_local_host_id(),

{code_coordinator-0.5.508 → code_coordinator-0.5.509}/coord/commands/setup.py

@@ -20,6 +20,8 @@ from coord.commands._common import _CONFIG_OPTION, _load_config
 import json
 
 if TYPE_CHECKING:  # pragma: no cover — typing only
+    from collections.abc import Mapping
+
     from coord.config import Config
     from coord.drive_queue import CeilingResolution
 
@@ -183,10 +185,12 @@ def _print_effective_concurrency(
     machine's own installed systemd unit, if any.
     """
     from coord.drive_queue import (  # noqa: PLC0415
+        effective_repo_capacities,
         flag_shadows_config_warning,
         read_systemd_max_parallel_flags,
         resolve_max_parallel,
         resolve_max_parallel_per_repo,
+        resolve_repo_ceilings,
     )
 
     systemd_flags = read_systemd_max_parallel_flags()
@@ -202,11 +206,26 @@ def _print_effective_concurrency(
         override_source=per_repo_source,
         config_value=cfg.pipeline.max_parallel_per_repo,
     )
+    # #3423: each repo's own `repos[].max_parallel`, layered on the
+    # fleet-wide answer above. Reported per repo below — a single
+    # `max_parallel_per_repo` line stopped being the whole truth the moment
+    # one repo could disagree with it, and "which ceiling actually applies
+    # to MY repo" is the same question #3408 was opened to answer.
+    repo_resolutions = resolve_repo_ceilings(
+        {r.name: r.max_parallel for r in cfg.repos}, fleet=per_repo_resolution
+    )
+    repo_overrides = effective_repo_capacities(
+        repo_resolutions, fleet_value=per_repo_resolution.value
+    )
     per_repo_warning = flag_shadows_config_warning(
         flag_name="max-parallel-per-repo",
         override_value=per_repo_override,
         config_key="pipeline.max_parallel_per_repo",
         config_value=cfg.pipeline.max_parallel_per_repo,
+        # #3423: computed after the per-repo table above so the warning can
+        # name the repos that beat the flag — "always wins" would otherwise
+        # be contradicted by the very next line this function prints.
+        overridden_repos=sorted(repo_overrides),
     )
 
     max_parallel_override = sim_max_parallel
@@ -222,6 +241,7 @@ def _print_effective_concurrency(
         repo_count=len(cfg.repos),
         max_parallel_per_repo=per_repo_resolution.value,
         max_workers_cap=cfg.concurrency.max_workers,
+        repo_overrides=repo_overrides,
     )
     global_warning = flag_shadows_config_warning(
         flag_name="max-parallel",
@@ -239,16 +259,26 @@ def _print_effective_concurrency(
     _echo_ceiling(per_repo_resolution)
     if per_repo_warning:
         click.echo(f"  {per_repo_warning}")
+    # #3423: only the repos that actually override the fleet default are
+    # listed. Printing all fourteen would bury the two that differ, which is
+    # the opposite of what this report is for.
+    for name in sorted(repo_overrides):
+        _echo_ceiling(repo_resolutions[name], indent="    ")
     click.echo(
         f"  {'concurrency.max_workers':<24} {cfg.concurrency.max_workers}"
         "  <- coordinator.yml concurrency.max_workers"
     )
     click.echo("")
-    click.echo(_effective_usage_line(cfg, global_resolution, per_repo_resolution))
+    click.echo(
+        _effective_usage_line(
+            cfg, global_resolution, per_repo_resolution, repo_overrides
+        )
+    )
 
 
-def _echo_ceiling(resolution: "CeilingResolution") -> None:
-    line = f"  {resolution.name:<24} {resolution.value}  <- {resolution.source}"
+def _echo_ceiling(resolution: "CeilingResolution", *, indent: str = "  ") -> None:
+    width = 26 - len(indent)
+    line = f"{indent}{resolution.name:<{width}} {resolution.value}  <- {resolution.source}"
     if resolution.losing:
         losers = ", ".join(f"{name}: {value}" for name, value in resolution.losing)
         line += f"  (losing: {losers})"
@@ -259,6 +289,7 @@ def _effective_usage_line(
     cfg: "Config",
     global_resolution: "CeilingResolution",
     per_repo_resolution: "CeilingResolution",
+    repo_overrides: "Mapping[str, int] | None" = None,
 ) -> str:
     """Current in-flight usage against the two resolved ceilings above
     (#3408 acceptance: "a queue at its global ceiling reports N/N rather
@@ -291,8 +322,11 @@ def _effective_usage_line(
         return f"in flight  unavailable ({exc})"
 
     line = f"in flight  {occupied}/{global_resolution.value} global"
+    # #3423: count each repo against ITS OWN ceiling — against the fleet
+    # default, an overridden repo reports "2/1" and reads as a bug.
+    overrides = repo_overrides or {}
     per_repo_bits = " · ".join(
-        f"{repo} {count}/{per_repo_resolution.value}"
+        f"{repo} {count}/{overrides.get(repo, per_repo_resolution.value)}"
         for repo, count in sorted(repo_occupied.items())
     )
     if per_repo_bits:

{code_coordinator-0.5.508 → code_coordinator-0.5.509}/coord/config.py

@@ -2536,6 +2536,7 @@ _KNOWN_REPO_KEYS = frozenset(
         "uat_live_preview",
         "uat_checks",
         "requires",
+        "max_parallel",
     }
 )
 
@@ -2831,6 +2832,28 @@ def _parse_repos(raw: Any) -> tuple[list[Repo], list[str]]:
         if not isinstance(requires, list) or not all(isinstance(r, str) for r in requires):
             raise ConfigError(f"repos[{i}].requires must be a list of strings")
 
+        # #3423: max_parallel — THIS repo's own drive-queue concurrency
+        # ceiling, overriding the fleet-wide `pipeline.max_parallel_per_repo`.
+        # Absent (None) means "no opinion", i.e. exactly the pre-#3423
+        # behaviour for that repo. See `Repo.max_parallel`'s docstring for
+        # why this one override outranks an explicit CLI/systemd flag, and
+        # `coord.drive_queue.resolve_repo_max_parallel` for the resolution.
+        # `bool` is rejected explicitly: YAML's `max_parallel: true` parses
+        # as a bool, which `isinstance(x, int)` would otherwise wave through
+        # as 1 — a silently-wrong ceiling rather than a config error.
+        repo_max_parallel = entry.get("max_parallel")
+        if repo_max_parallel is not None:
+            if isinstance(repo_max_parallel, bool) or not isinstance(repo_max_parallel, int):
+                raise ConfigError(
+                    f"repos[{i}].max_parallel must be an integer "
+                    "(omit the key entirely to use pipeline.max_parallel_per_repo)"
+                )
+            if repo_max_parallel < 0:
+                raise ConfigError(
+                    f"repos[{i}].max_parallel must be 0 (no per-repo ceiling "
+                    "for this repo) or more"
+                )
+
         repos.append(
             Repo(
                 name=name,
@@ -2853,6 +2876,7 @@ def _parse_repos(raw: Any) -> tuple[list[Repo], list[str]]:
                 uat_live_preview=uat_live_preview_raw,
                 uat_checks=uat_checks,
                 requires=list(requires),
+                max_parallel=repo_max_parallel,
             )
         )
     return repos, warnings