code-coordinator 0.5.120__tar.gz → 0.5.121__tar.gz

{code_coordinator-0.5.120 → code_coordinator-0.5.121}/PKG-INFO

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

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

@@ -1,7 +1,7 @@
 {
-  "tag": "0.5.120",
+  "tag": "0.5.121",
   "distance": 0,
-  "node": "g73a6cc8774d10c7a9a405ba25bd93f772ff445ab",
+  "node": "gfcdd7f8f7839bc92680284bc0e829ec126748357",
   "dirty": false,
   "branch": "HEAD",
   "node_date": "2026-08-17"

{code_coordinator-0.5.120 → code_coordinator-0.5.121}/coord/acceptance.py

@@ -361,7 +361,34 @@ def load_manifest(acceptance_root: Path) -> dict[str, int]:
     return mapping
 
 
-def load_expected_red(acceptance_root: Path) -> dict[str, int]:
+def _driver_kind_for_manifest_dir(ms_dir: Path) -> str | None:
+    """Best-effort LOCAL driver-kind lookup for one ``ms-NN``/``issue-NN``
+    acceptance directory, via its ``mocks/`` file extensions
+    (:data:`MOCK_EXT_TO_DRIVER_KIND`) — the filesystem counterpart of
+    :func:`resolve_for_path`'s GitHub-backed lookup, for callers that
+    already have a local checkout and don't want a network round trip.
+
+    Returns ``None`` (unknown) rather than guessing when ``mocks/`` is
+    absent, empty, or its files imply more than one kind — callers MUST
+    treat ``None`` as "don't exclude", never as "safe to skip": this feeds
+    a hard-failure check (:func:`load_expected_red`), and silently
+    dropping a manifest because its kind couldn't be determined would hide
+    the exact class of bug that check exists to catch.
+    """
+    mocks_dir = ms_dir / "mocks"
+    if not mocks_dir.is_dir():
+        return None
+    kinds = {
+        MOCK_EXT_TO_DRIVER_KIND[p.suffix]
+        for p in mocks_dir.iterdir()
+        if p.suffix in MOCK_EXT_TO_DRIVER_KIND
+    }
+    return next(iter(kinds)) if len(kinds) == 1 else None
+
+
+def load_expected_red(
+    acceptance_root: Path, *, driver_kind: str | None = None
+) -> dict[str, int]:
     """Merge every ``ms-NN/manifest.(yml|json)``'s ``expected_red:`` block
     under *acceptance_root* into one ``{test_id: issue_number}`` mapping
     (#2164) — the flat shape :func:`apply_expected_red` and the ``coord
@@ -369,9 +396,28 @@ def load_expected_red(acceptance_root: Path) -> dict[str, int]:
 
     Mirrors :func:`load_manifest`'s merge/empty-dict/last-writer-wins
     conventions exactly, just reading ``expected_red`` instead of ``tests``.
+
+    *driver_kind* (#2339): when given, a manifest whose own directory
+    resolves (via :func:`_driver_kind_for_manifest_dir`) to a DIFFERENT
+    driver kind is skipped entirely. A repo routes different milestones to
+    different drivers (``coord/**`` -> cli-pytest, ``tui/**`` ->
+    tui-tuidriver, ...), but a single ``coord acceptance run --for-path X
+    --all`` invocation only ever executes ONE of them — before this
+    parameter existed, the merged registry always spanned every driver, so
+    every milestone's ``expected_red`` ids that belonged to a DIFFERENT
+    driver than the one actually running were reported as
+    ``missing_expected_red_ids`` (a hard, un-waivable CI failure) on every
+    single run, for every repo with more than one routed driver kind, the
+    moment two milestones used different drivers. A directory whose kind
+    can't be determined (see above) is always included, matching the
+    unfiltered (``driver_kind=None``) behaviour this defaults to.
     """
     mapping: dict[str, int] = {}
     for path in _manifest_paths(acceptance_root):
+        if driver_kind is not None:
+            resolved = _driver_kind_for_manifest_dir(path.parent)
+            if resolved is not None and resolved != driver_kind:
+                continue
         try:
             data = parse_manifest_text(path.read_text(), source=str(path))
         except OSError as e:

{code_coordinator-0.5.120 → code_coordinator-0.5.121}/coord/commands/acceptance.py

@@ -301,7 +301,16 @@ def acceptance_run(
         )
 
     if ci_mode:
-        expected_red = load_expected_red(cwd / ACCEPTANCE_DIRNAME)
+        # #2339: scope the expected_red registry to milestones this run's
+        # OWN driver could actually produce results for — a routed repo's
+        # `--all --ci` used to merge every milestone's expected_red
+        # regardless of which driver `--for-path` resolved, so every OTHER
+        # driver's ids always came back `missing_expected_red_ids` (a hard
+        # CI failure) the moment the repo had more than one driver kind in
+        # use. See coord.acceptance.load_expected_red's docstring.
+        expected_red = load_expected_red(
+            cwd / ACCEPTANCE_DIRNAME, driver_kind=driver_cfg.kind,
+        )
         verdict = apply_expected_red(verdict, set(expected_red))
         click.echo(json.dumps(verdict, indent=2))
         hard_failure = expected_red_failure_summary(verdict)

{code_coordinator-0.5.120 → code_coordinator-0.5.121}/tests/test_acceptance.py

@@ -271,6 +271,51 @@ class TestLoadExpectedRed:
         (root / "ms11" / "manifest.yml").write_text("tests:\n  a: 554\n")
         assert load_expected_red(root) == {}
 
+    def test_driver_kind_excludes_a_different_driver_milestone(
+        self, tmp_path: Path
+    ) -> None:
+        # #2339: a repo routing coord/** -> cli-pytest and tui/** ->
+        # tui-tuidriver must not merge a tui-tuidriver milestone's
+        # expected_red into a cli-pytest run's registry (or vice versa) —
+        # the other driver can never produce those test-ids, so an unscoped
+        # merge always reported them `missing_expected_red_ids`, a hard CI
+        # failure on every run of every OTHER driver the moment two
+        # milestones used different drivers.
+        root = tmp_path / "tests" / "acceptance"
+        ms_tui = root / "ms65"
+        ms_tui.mkdir(parents=True)
+        (ms_tui / "manifest.yml").write_text("expected_red:\n  2282:\n    - board_tabs_2282::a\n")
+        (ms_tui / "mocks").mkdir()
+        (ms_tui / "mocks" / "board.screen").write_text("mock")
+
+        ms_cli = root / "ms37"
+        ms_cli.mkdir(parents=True)
+        (ms_cli / "manifest.yml").write_text("expected_red:\n  1118:\n    - test_x\n")
+        (ms_cli / "mocks").mkdir()
+        (ms_cli / "mocks" / "usage.out").write_text("mock")
+
+        assert load_expected_red(root, driver_kind="cli-pytest") == {"test_x": 1118}
+        assert load_expected_red(root, driver_kind="tui-tuidriver") == {
+            "board_tabs_2282::a": 2282
+        }
+        # Unfiltered (default) behaviour is unchanged — everything merges.
+        assert load_expected_red(root) == {"board_tabs_2282::a": 2282, "test_x": 1118}
+
+    def test_driver_kind_includes_a_milestone_with_no_mocks_dir(
+        self, tmp_path: Path
+    ) -> None:
+        # A directory whose driver can't be determined (no mocks/, mixed
+        # kinds, ...) must never be silently dropped — "unknown" is not
+        # "safe to skip" for a hard-failure check.
+        root = tmp_path / "tests" / "acceptance"
+        (root / "issue-9").mkdir(parents=True)
+        (root / "issue-9" / "manifest.yml").write_text(
+            "expected_red:\n  9:\n    - bare_bug_test\n"
+        )
+        assert load_expected_red(root, driver_kind="web-playwright") == {
+            "bare_bug_test": 9
+        }
+
 
 class TestApplyExpectedRed:
     def test_no_expected_red_ids_is_a_no_op(self) -> None: