code-coordinator 0.5.142__tar.gz → 0.5.145__tar.gz

{code_coordinator-0.5.142 → code_coordinator-0.5.145}/PKG-INFO

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

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

@@ -1,7 +1,7 @@
 {
-  "tag": "0.5.142",
+  "tag": "0.5.145",
   "distance": 0,
-  "node": "gf633cd59c13444ede9e9471099a848d9bd3587f4",
+  "node": "g2c4967683cf16fc253e1af6018babca87d6eb43a",
   "dirty": false,
   "branch": "HEAD",
   "node_date": "2026-08-18"

{code_coordinator-0.5.142 → code_coordinator-0.5.145}/coord/ci_github.py

@@ -129,6 +129,13 @@ class GitHubCi:
     _jobs_cache: dict[tuple[str, str], tuple[float, list[JobRun]]] = field(
         default_factory=dict
     )
+    # #2388: repo -> (fetched_at, required context names or None). Keyed by
+    # repo alone, same reasoning as `_workflow_cache` — required contexts are
+    # a branch-protection property of the repo's default branch, not of any
+    # particular PR.
+    _required_contexts_cache: dict[str, tuple[float, frozenset[str] | None]] = field(
+        default_factory=dict
+    )
 
     @property
     def is_available(self) -> bool:
@@ -360,7 +367,7 @@ class GitHubCi:
             return [_unreadable_check(repo, number, str(e))]
         if not isinstance(raw, list):
             return [_unreadable_check(repo, number, "gh pr checks returned non-list JSON")]
-        return [
+        checks = [
             CheckRun(
                 name=str(entry.get("name", "")),
                 status=_status_from_bucket(str(entry.get("bucket", ""))),
@@ -373,6 +380,32 @@ class GitHubCi:
             for entry in raw
             if isinstance(entry, dict)
         ]
+        # #2388: narrow to what branch protection actually REQUIRES, when
+        # that's determinable — a repo can report far more `gh pr checks`
+        # entries than GitHub's own required list (this repo: 9 reported, 5
+        # required), and every merge-gate predicate downstream of this
+        # method (`failed_checks`, `in_flight_checks`, `checks_are_stale`)
+        # otherwise waits on advisory jobs GitHub itself doesn't. A hung
+        # advisory job (e.g. an unconditional Playwright/Chromium install
+        # with no timeout) would then block `coord merge` indefinitely even
+        # though the PR is already `MERGEABLE`. `_required_contexts` returns
+        # `None` (never filters) when it can't determine the required list
+        # — #1525's bias: unknown reads as "wait on everything reported",
+        # not as a free pass to stop waiting on something that might matter.
+        required = self._required_contexts(repo)
+        if required:
+            checks = [c for c in checks if c.name in required]
+        return checks
+
+    def _required_contexts(self, repo: str) -> frozenset[str] | None:
+        now = time.time()
+        cached = self._required_contexts_cache.get(repo)
+        if cached is not None and (now - cached[0]) < self.cache_ttl:
+            return cached[1]
+        contexts = github_ops.get_required_status_check_contexts(repo)
+        result = frozenset(contexts) if contexts else None
+        self._required_contexts_cache[repo] = (now, result)
+        return result
 
 
 def _unreadable_check(repo: str, number: int, detail: str) -> CheckRun:

{code_coordinator-0.5.142 → code_coordinator-0.5.145}/coord/config.py

@@ -946,7 +946,7 @@ class PipelineConfig:
     worker that gives up on a **semantic** conflict (it emits the
     ``coord:conflict=semantic`` marker on its ``STUCK:`` line) gets ONE
     second attempt from a stronger model
-    (``semantic_conflict_model``, default ``"fable"``) before the merge
+    (``semantic_conflict_model``, default ``"opus"``) before the merge
     entry is parked ``HUMAN_REQUIRED``.  **Defaults to ``False``** — this
     ships dark until it earns trust on real conflicts.  The escalated
     attempt consumes the existing one-per-entry conflict-fix retry cap, so
@@ -986,7 +986,7 @@ class PipelineConfig:
     escalate_fix_model: bool = True
     # #1291 — DEFAULT OFF. See the class docstring.
     escalate_semantic_conflicts: bool = False
-    semantic_conflict_model: str = "fable"
+    semantic_conflict_model: str = "opus"
     # #1478 — DEFAULT OFF. See the class docstring.
     auto_dispatch_stalled: bool = False
     attention_thresholds: dict[str, float] = field(

{code_coordinator-0.5.142 → code_coordinator-0.5.145}/coord/github_ops.py

@@ -1540,6 +1540,46 @@ def get_repo_workflow_count(repo: str) -> int:
     return data["total_count"]
 
 
+def get_required_status_check_contexts(repo: str) -> list[str] | None:
+    """Required status-check context names for *repo*'s default branch (#2388).
+
+    Backs the merge gate's "don't wait on an advisory check" filter — a repo
+    can report many more `gh pr checks` entries than GitHub's own branch
+    protection actually requires (this repo: 9 reported, 5 required), and a
+    slow/hung advisory job (an unconditional Playwright/Chromium install
+    step, say) has no business blocking `coord merge` when GitHub itself
+    already considers the PR mergeable.
+
+    Returns ``None`` — never an empty list treated as "nothing required" —
+    when the default branch has no protection configured, or any read
+    step fails (auth, rate-limit, malformed response, `gh` missing). #1525's
+    bias applies here too: "couldn't determine what's required" must read as
+    "don't filter, wait on everything reported", not as a free pass to stop
+    waiting on checks that might in fact be required. Only an actually
+    non-empty ``required_status_checks.contexts`` list narrows the gate.
+    """
+    try:
+        repo_data = _gh_json("api", f"repos/{repo}", default=None)
+        if not isinstance(repo_data, dict):
+            return None
+        default_branch = repo_data.get("default_branch")
+        if not isinstance(default_branch, str) or not default_branch:
+            return None
+        protection = _gh_json(
+            "api", f"repos/{repo}/branches/{default_branch}/protection",
+            default=None,
+        )
+    except (FileNotFoundError, subprocess.TimeoutExpired, RuntimeError):
+        return None
+    if not isinstance(protection, dict):
+        return None
+    contexts = protection.get("required_status_checks", {})
+    contexts = contexts.get("contexts") if isinstance(contexts, dict) else None
+    if not isinstance(contexts, list) or not contexts:
+        return None
+    return [str(c) for c in contexts]
+
+
 def get_pr_checks(repo: str, number: int) -> list[dict]:
     """Return ``gh pr checks``' raw check-run list for PR *number*.
 

{code_coordinator-0.5.142 → code_coordinator-0.5.145}/coord/merge_queue.py

@@ -1588,6 +1588,43 @@ def _ci_unreadable_reason(failed: "list[CheckRun]") -> str | None:
     )
 
 
+# #2380: a bare check-list FETCH failure (`_ci_unreadable_reason`, above) has
+# TWO readings, exactly like `checks == []` already does (#1877): "GitHub is
+# genuinely unreachable right now" (real, self-healing — keep retrying), and
+# "this PR is DIRTY/CONFLICTING against its base, so GitHub can never build a
+# merge ref for it and `gh pr checks` has nothing to read" (definitive,
+# self-*never*-healing — no amount of retrying a CI read produces CI that
+# will never run). The two are indistinguishable from the check list alone;
+# GitHub's own `mergeable` field is the one thing that tells them apart, and
+# — unlike CI — it is always computable, conflict or not.
+def _pr_reports_conflicting(gh_ops, repo: str | None, number: int | None) -> bool:
+    """True only when GitHub's live ``mergeable`` field reads ``CONFLICTING``
+    for PR *number* — definitive, readable evidence a CI-unreadable park can
+    never resolve on its own (#2380).
+
+    Duck-typed the same way the sibling #1877 checks-absent conflict probe
+    (a few lines above each of this function's call sites) already is:
+    ``gh_ops`` on the board/plan read path may be a :class:`~coord.gate_
+    snapshot.GateSnapshot` with no ``check_pr_mergeable`` at all (#1336
+    Invariant 1 — no third-party I/O there), and any of "no probe available",
+    "the probe raised", or a ``True``/``None`` verdict (cleanly mergeable, or
+    GitHub still computing it) must read as "not confirmed conflicting" —
+    never as false evidence of one. This is intentionally narrower than the
+    design's "``mergeable == CONFLICTING`` or ``mergeStateStatus == DIRTY``"
+    framing: :func:`coord.github_ops.check_pr_mergeable` already reads GitHub's
+    ``mergeable`` field, which is exactly ``CONFLICTING`` whenever
+    ``mergeStateStatus`` would read ``DIRTY`` — one probe, one `gh` call,
+    same readable-and-definitive signal either way.
+    """
+    probe = getattr(gh_ops, "check_pr_mergeable", None)
+    if probe is None or not repo or number is None:
+        return False
+    try:
+        return probe(repo, number) is False
+    except Exception:  # noqa: BLE001 — inconclusive, not a confirmed conflict
+        return False
+
+
 def _ci_infra_reason(
     ci: "CiStore", repo: str, number: int, failed: "list[CheckRun]"
 ) -> str | None:
@@ -3820,21 +3857,36 @@ def _entry_gate_status(
             # `process()`'s own live reading.
             unreadable_reason = _ci_unreadable_reason(failed)
             if unreadable_reason is not None:
-                return PLAN_BLOCKED, unreadable_reason
-            summary = ", ".join(f"{c.name} ({c.conclusion})" for c in failed)
-            return PLAN_BLOCKED, f"CI failed: {summary}"
-        pending = in_flight_checks(checks)
-        if pending:
-            summary = ", ".join(c.name for c in pending)
-            return PLAN_BLOCKED, f"{CI_PENDING_PREFIX} {summary}"
-        if checks and _ci_checks_are_stale(
-            checks, gh_ops, entry.repo_github, entry.target_branch, smoke
-        ):
-            return (
-                PLAN_BLOCKED,
-                f"{CI_STALE_PREFIX} checks predate the current base — "
-                "re-run CI (`coord merge --revalidate`) before merging",
-            )
+                # #2380: a fetch failure this uniform (EVERY failing check is
+                # the synthetic unreadable stand-in) is ALSO exactly what a
+                # DIRTY/CONFLICTING PR produces — see
+                # :func:`_pr_reports_conflicting`'s docstring. Same "don't
+                # block, mirror `process()`, let the real conflict surface"
+                # response as the #1877 checks-absent case immediately above
+                # — deliberately NOT falling into the `pending`/staleness
+                # checks below, which assume (per `_ci_checks_are_stale`'s
+                # own docstring) a *non-empty, no-failed-entries* check list;
+                # this one is neither.
+                if not _pr_reports_conflicting(
+                    gh_ops, entry.repo_github, entry.pr_number
+                ):
+                    return PLAN_BLOCKED, unreadable_reason
+            else:
+                summary = ", ".join(f"{c.name} ({c.conclusion})" for c in failed)
+                return PLAN_BLOCKED, f"CI failed: {summary}"
+        else:
+            pending = in_flight_checks(checks)
+            if pending:
+                summary = ", ".join(c.name for c in pending)
+                return PLAN_BLOCKED, f"{CI_PENDING_PREFIX} {summary}"
+            if checks and _ci_checks_are_stale(
+                checks, gh_ops, entry.repo_github, entry.target_branch, smoke
+            ):
+                return (
+                    PLAN_BLOCKED,
+                    f"{CI_STALE_PREFIX} checks predate the current base — "
+                    "re-run CI (`coord merge --revalidate`) before merging",
+                )
     if gh_ops is not None and entry.pr_number:
         try:
             commit_messages = gh_ops.get_pr_commit_messages(
@@ -5176,6 +5228,25 @@ def process(
                             # checked first, mirroring the live path's
                             # ordering — see `_ci_unreadable_reason`.
                             unreadable_reason = _ci_unreadable_reason(failed)
+                            # #2380: mirror the real path's straight-to-
+                            # conflict routing — see the identical check a
+                            # few lines above (#1877) and the live path's own
+                            # `_pr_reports_conflicting` branch. Preview-only:
+                            # never mutates `entry.state`, same as every
+                            # other branch in this dry-run block.
+                            if unreadable_reason is not None and _pr_reports_conflicting(
+                                gh_ops, entry.repo_github, entry.pr_number
+                            ):
+                                events.append(MergeEvent(
+                                    entry, "conflict",
+                                    f"(dry run) {entry.branch} conflicts "
+                                    f"with {entry.target_branch} and its CI "
+                                    "check-list fetch fails for the same "
+                                    "reason — a real run would route to the "
+                                    "#241 conflict-fix path rather than park "
+                                    "on an unreadable CI retry (#2380)",
+                                ))
+                                continue
                             infra_reason = None if unreadable_reason else _ci_infra_reason(
                                 ci, entry.repo_github, entry.pr_number, failed
                             )
@@ -5528,6 +5599,39 @@ def process(
                     # to evaluate unconditionally, every time.
                     unreadable_reason = _ci_unreadable_reason(failed)
                     if unreadable_reason is not None:
+                        # #2380: a check-list fetch failure this uniform
+                        # (EVERY failing check is the synthetic unreadable
+                        # stand-in) is ALSO exactly what GitHub reports for a
+                        # DIRTY/CONFLICTING PR — it can never build a merge
+                        # ref, so `gh pr checks` has nothing to read either.
+                        # `_pr_reports_conflicting` tells the two apart the
+                        # same way the #1877 checks-absent branch above does:
+                        # GitHub's own `mergeable` field, definitive and
+                        # always computable, conflict or not. When it reads
+                        # CONFLICTING, retrying the CI read can never
+                        # succeed — route STRAIGHT to the same `conflict`
+                        # event / `_dispatch_conflict_fixes` path a readable
+                        # CONFLICT merge-queue status already triggers
+                        # (#1474/#241), instead of parking behind a read that
+                        # will never resolve.
+                        if _pr_reports_conflicting(
+                            gh_ops, entry.repo_github, entry.pr_number
+                        ):
+                            msg = (
+                                f"merge conflict: GitHub reports PR "
+                                f"#{entry.pr_number} ({entry.branch}) as "
+                                f"CONFLICTING against {entry.target_branch} "
+                                "— no CI ever ran because GitHub cannot "
+                                "build a merge ref for a conflicting PR, so "
+                                "the check-list fetch failure was never a "
+                                "transient GitHub outage (#2380). Rebase "
+                                f"the branch onto {entry.target_branch} and "
+                                "resolve."
+                            )
+                            entry.state = CONFLICT
+                            entry.error = msg
+                            events.append(MergeEvent(entry, "conflict", msg))
+                            continue  # #292: skip, don't halt the group
                         if entry.ci_unreadable_reruns < MAX_CI_UNREADABLE_RERUNS:
                             entry.ci_unreadable_reruns += 1
                             _log.info(

{code_coordinator-0.5.142 → code_coordinator-0.5.145}/tests/test_ci_store.py

@@ -31,6 +31,24 @@ from coord.ci_store import (
 )
 
 
+# Captured before the autouse fixture below ever patches it, so a test that
+# needs the REAL caching/lookup behavior can restore it for just itself.
+_REAL_REQUIRED_CONTEXTS = GitHubCi._required_contexts
+
+
+@pytest.fixture(autouse=True)
+def _no_required_contexts_filter(monkeypatch):
+    """#2388: default every `GitHubCi` in this file to "couldn't determine
+    required contexts, don't filter" — every test below that mocks raw
+    `gh` subprocess calls does so with an exact expected call sequence, and
+    the required-contexts lookup (a repo lookup + a branch-protection
+    lookup) would otherwise insert two extra calls into that sequence for
+    tests that never intended to exercise it. `TestGitHubCiRequiredContexts`
+    below overrides this directly to exercise the real filtering path.
+    """
+    monkeypatch.setattr(GitHubCi, "_required_contexts", lambda self, repo: None)
+
+
 # ── NoOpCi ───────────────────────────────────────────────────────────────────
 
 class TestNoOpCi:
@@ -770,6 +788,74 @@ class TestGitHubCiExpectsChecks:
         assert fn.call_count == 2
 
 
+class TestGitHubCiRequiredContexts:
+    """#2388: `list_checks_for_pr` narrows to branch-protection-required
+    contexts when they're determinable, so an advisory job (e.g. a hung,
+    unconditional Playwright/Chromium install with no timeout) can't block
+    the merge gate on its own — GitHub itself doesn't wait on it either."""
+
+    def test_narrows_to_required_contexts_when_known(self) -> None:
+        payload = json.dumps([
+            {"name": "test (3.12)", "state": "SUCCESS", "bucket": "pass",
+             "link": "", "startedAt": "", "completedAt": ""},
+            {"name": "acceptance", "state": "PENDING", "bucket": "pending",
+             "link": "", "startedAt": "", "completedAt": ""},
+        ])
+        store = GitHubCi()
+        with (
+            patch("coord.ci_github.subprocess.run", return_value=_gh_result(payload)),
+            patch.object(
+                GitHubCi, "_required_contexts",
+                lambda self, repo: frozenset({"test (3.12)"}),
+            ),
+        ):
+            checks = store.list_checks_for_pr("acme/api", 42)
+        assert [c.name for c in checks] == ["test (3.12)"]
+        # The gate no longer sees the advisory `acceptance` check at all —
+        # a hung advisory job can't make this read as in-flight.
+        assert in_flight_checks(checks) == []
+
+    def test_does_not_filter_when_required_contexts_unknown(self) -> None:
+        """No branch protection configured / unreadable — #1525's bias:
+        unknown must read as "wait on everything reported", not as license
+        to stop waiting on something that might in fact be required."""
+        payload = json.dumps([
+            {"name": "test (3.12)", "state": "SUCCESS", "bucket": "pass",
+             "link": "", "startedAt": "", "completedAt": ""},
+            {"name": "acceptance", "state": "PENDING", "bucket": "pending",
+             "link": "", "startedAt": "", "completedAt": ""},
+        ])
+        store = GitHubCi()
+        with patch("coord.ci_github.subprocess.run", return_value=_gh_result(payload)):
+            checks = store.list_checks_for_pr("acme/api", 42)  # fixture default: None
+        assert {c.name for c in checks} == {"test (3.12)", "acceptance"}
+        assert len(in_flight_checks(checks)) == 1
+
+    def test_required_contexts_cached_per_repo(self, monkeypatch) -> None:
+        monkeypatch.setattr(GitHubCi, "_required_contexts", _REAL_REQUIRED_CONTEXTS)
+        store = GitHubCi(cache_ttl=60.0)
+        with patch(
+            "coord.github_ops.get_required_status_check_contexts",
+            return_value=["test (3.12)"],
+        ) as fn:
+            store._required_contexts("acme/api")
+            store._required_contexts("acme/api")
+        assert fn.call_count == 1
+
+    def test_empty_required_list_reads_as_unknown_not_nothing_required(
+        self, monkeypatch,
+    ) -> None:
+        """An empty `contexts` list from the API (protection configured but
+        zero required checks — an unusual but real repo state) must not be
+        read as "filter everything out". Only a non-empty list narrows."""
+        monkeypatch.setattr(GitHubCi, "_required_contexts", _REAL_REQUIRED_CONTEXTS)
+        store = GitHubCi()
+        with patch(
+            "coord.github_ops.get_required_status_check_contexts", return_value=[],
+        ):
+            assert store._required_contexts("acme/api") is None
+
+
 class TestGitHubCiRerunForPr:
     """#1851: the remedy side — re-running a PR's CI via `gh run rerun`."""
 

{code_coordinator-0.5.142 → code_coordinator-0.5.145}/tests/test_cli_drive_queue.py

@@ -1724,17 +1724,29 @@ def live_ci_backend(monkeypatch):
     """Fake the live `ci_store`/`github_ops` seam #2182's re-check calls.
 
     Patches `coord.ci_store.build_ci_store` (what constructs the live
-    backend) and the two `coord.github_ops` functions the CI gate reaches
+    backend) and the three `coord.github_ops` functions the CI gate reaches
     for once the checks themselves resolve (`get_branch_commit_timestamp`
     for the #1851 staleness check, `get_pr_commit_messages` for the #1318
-    epic-closing-keyword gate) — the same seams `tests/test_board_read_
-    path.py` fakes for the equivalent `/board`-side gate. Returns a setter,
-    `live_ci_backend(checks)`.
+    epic-closing-keyword gate, and `check_pr_mergeable` for the #1877 /
+    #2380 "is this PR actually CONFLICTING?" disambiguation) — the same
+    seams `tests/test_board_read_path.py` fakes for the equivalent
+    `/board`-side gate. Returns a setter, `live_ci_backend(checks,
+    mergeable=...)`.
+
+    `mergeable` defaults to `None` — GitHub's own "still computing /
+    unknown" verdict, which every gate treats as inconclusive, so the
+    default leaves the pre-#2380 reading of every scenario here untouched.
+    Pass `mergeable=False` for the #2380 case (a DIRTY/CONFLICTING PR,
+    whose `gh pr checks` fetch fails because GitHub can never build a merge
+    ref for it). Faking it matters beyond convenience: `launches`
+    monkeypatches `subprocess.run` process-wide, so an unfaked probe would
+    (a) really shell out to `gh` from a unit test and (b) land in
+    `launches` as a phantom extra "launch".
     """
     import coord.ci_store as ci_store_module
     import coord.github_ops as github_ops
 
-    state: dict = {"checks": []}
+    state: dict = {"checks": [], "mergeable": None}
     monkeypatch.setattr(
         ci_store_module, "build_ci_store", lambda t: _FakeLiveCi(state)
     )
@@ -1744,9 +1756,13 @@ def live_ci_backend(monkeypatch):
         github_ops, "get_branch_commit_timestamp", lambda repo, branch: 1.0
     )
     monkeypatch.setattr(github_ops, "get_pr_commit_messages", lambda repo, n: [])
+    monkeypatch.setattr(
+        github_ops, "check_pr_mergeable", lambda repo, n: state["mergeable"]
+    )
 
-    def _set(checks: list) -> None:
+    def _set(checks: list, *, mergeable: bool | None = None) -> None:
         state["checks"] = checks
+        state["mergeable"] = mergeable
 
     return _set
 
@@ -1885,6 +1901,40 @@ def test_a_parked_entrys_reason_is_corrected_when_github_is_unreachable(
     assert queued(2159)["state"] == "running"
 
 
+def test_a_parked_entry_whose_pr_is_confirmed_conflicting_stops_waiting_on_ci(
+    cli_no_gates, seed, launches, coord_db, live_ci_backend,
+):
+    """#2380 at the drive-queue tick: the SAME unreadable check list as the
+    #2347 test above, but GitHub's `mergeable` field reads CONFLICTING.
+
+    That combination is not a transient outage and never becomes readable
+    on its own — GitHub cannot build a merge ref for a conflicting PR, so
+    `gh pr checks` has nothing to read, forever. Parking on "retry the CI
+    read" therefore wedges the entry until the 45-minute ceiling, every
+    ceiling, with zero forward progress (the live incident: claude-
+    coordinator#2375 / PR #2379 parked 6x). The live re-check must stop
+    treating it as still-blocked-on-CI and let the entry move again, so the
+    merge path can route it to the #241 conflict-fix dispatch.
+    """
+    _park_with_pr(cli_no_gates, seed, coord_db)
+    assert queued(2159)["state"] == "parked"
+    assert len(launches) == 1, launches
+
+    from coord.ci_github import _unreadable_check
+    live_ci_backend(
+        [_unreadable_check(REPO, 2159, "HTTP 503: No server is currently available")],
+        mergeable=False,
+    )
+
+    result = cli_no_gates("tick")
+    assert result.exit_code == 0, result.output
+    entry = queued(2159)
+    assert entry["state"] != "parked", entry  # no longer wedged on a dead read
+    from coord.merge_queue import is_ci_unreadable_reason
+    assert not is_ci_unreadable_reason(entry["last_reason"] or ""), entry
+    assert "parked" not in cli_no_gates("status").output
+
+
 def test_a_live_ready_wins_even_over_a_stale_cached_plan_reading(
     cli_no_gates, seed, launches, coord_db, live_ci_backend, board_merge_plan,
 ):

{code_coordinator-0.5.142 → code_coordinator-0.5.145}/tests/test_conflict_fix_semantic.py

@@ -463,7 +463,7 @@ def _patched_dispatch(client: _FakeClient):
 class TestConfigFlag:
     def test_defaults_off(self) -> None:
         assert PipelineConfig().escalate_semantic_conflicts is False
-        assert PipelineConfig().semantic_conflict_model == "fable"
+        assert PipelineConfig().semantic_conflict_model == "opus"
 
     def test_parsed_from_yaml(self, tmp_path) -> None:
         from coord.config import load