code-coordinator 0.5.561__tar.gz → 0.5.562__tar.gz

{code_coordinator-0.5.561 → code_coordinator-0.5.562}/PKG-INFO

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

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

@@ -1,7 +1,7 @@
 {
-  "tag": "0.5.561",
+  "tag": "0.5.562",
   "distance": 0,
-  "node": "g719f616d563fc6b94375e7381da2f4b6bc6c833d",
+  "node": "g4c48decab602ab760461ff8d55ddd5db5baccd46",
   "dirty": false,
   "branch": "HEAD",
   "node_date": "2026-10-02"

{code_coordinator-0.5.561 → code_coordinator-0.5.562}/coord/acceptance.py

@@ -877,6 +877,66 @@ def oracle_loop_contract_block(
     if ms_dir is None:
         return ""
 
+    return _render_oracle_contract_block(
+        repo_name, issue_number, ms_dir, acceptance_dirname, exempt=exempt,
+    )
+
+
+def oracle_loop_contract_block_for_slice(
+    repo_name: str,
+    issue_number: int,
+    *,
+    has_slice: bool,
+    exempt: bool,
+    ms_dir: str,
+    acceptance_dirname: str = ACCEPTANCE_DIRNAME,
+) -> str:
+    """(#2166) The exact same worker-briefing contract text
+    :func:`oracle_loop_contract_block` renders, but driven by an already-
+    resolved verdict (*has_slice*/*exempt*/*ms_dir*/*acceptance_dirname*)
+    instead of scanning a local checkout for one.
+
+    Exists so :func:`coord.dispatch.dispatch` can build the briefing block
+    from the EXACT SAME read :func:`coord.milestone_dispatch.
+    issue_oracle_ready` already did for the #1138 hard gate (default
+    branch, over ``gh``, one memoised fetch seam) rather than a second,
+    independent local-checkout scan that can silently disagree with it —
+    the #2166 split-brain: a dispatching host whose base checkout lagged
+    the default branch by a few commits had this (the old
+    ``oracle_loop_contract_block(Path, ...)`` call) come back ``""`` while
+    the gate, reading the default branch directly, had already let the
+    issue through — so the worker got dispatched with no oracle contract
+    at all, silently.
+
+    Returns ``""`` when *ms_dir* is empty (the gate never resolved a
+    milestone for this issue — ``OracleReadiness.applies`` was ``False``)
+    or neither *has_slice* nor *exempt* is set (no contract to point at
+    yet). Callers that have a full ``OracleReadiness`` in hand should pass
+    its ``has_slice``/``exempt``/``ms_dir``/``acceptance_dirname`` fields
+    straight through.
+    """
+    if not ms_dir or not (has_slice or exempt):
+        return ""
+    return _render_oracle_contract_block(
+        repo_name, issue_number, ms_dir, acceptance_dirname, exempt=exempt,
+    )
+
+
+def _render_oracle_contract_block(
+    repo_name: str,
+    issue_number: int,
+    ms_dir: str,
+    acceptance_dirname: str,
+    *,
+    exempt: bool,
+) -> str:
+    """Shared template for :func:`oracle_loop_contract_block` (local-
+    checkout scan) and :func:`oracle_loop_contract_block_for_slice`
+    (gate-verdict-driven, #2166) — ONE rendering so the text a worker sees
+    can never drift between the two slice-presence sources, even though
+    which SOURCE decided "there is a slice" differs between the two
+    callers.
+    """
     dirname = acceptance_dirname.rstrip("/") if acceptance_dirname else ACCEPTANCE_DIRNAME
     contract_path = f"{dirname}/{ms_dir}/contract.md"
     mocks_dir = f"{dirname}/{ms_dir}/mocks"

{code_coordinator-0.5.561 → code_coordinator-0.5.562}/coord/dispatch.py

@@ -12,6 +12,8 @@ import httpx
 if TYPE_CHECKING:
     from datetime import datetime
 
+    from coord.milestone_dispatch import OracleReadiness
+
 from coord import github_ops
 from coord.comments import (
     format_advisory,
@@ -112,7 +114,7 @@ class DispatchRefused(ValueError):
 
 def enforce_oracle_readiness(
     *, proposal_type: str, repo: Repo | None, config: Config, issue_number: int,
-) -> None:
+) -> "OracleReadiness | None":
     """#1138: hard-gate a ``type="work"`` dispatch on the issue-level oracle
     gate (:func:`coord.milestone_dispatch.issue_oracle_ready`) — refuses an
     issue that belongs to an oracle-opted-in milestone (Gate A already
@@ -147,11 +149,23 @@ def enforce_oracle_readiness(
     hard stop would turn a GitHub hiccup into a fleet-wide outage for every
     oracle-configured repo, which is a worse failure mode than the gap
     #1138 closes.
+
+    Returns the :class:`coord.milestone_dispatch.OracleReadiness` verdict
+    it computed (``None`` for every cheap-no-op / fail-open case above) —
+    (#2166) so ``dispatch()`` can build the worker-briefing oracle-loop
+    contract block from THIS SAME verdict instead of re-deriving "does a
+    slice exist" via a second, independent read. Before this, the gate
+    read the default branch over ``gh`` while the briefing separately
+    scanned the dispatching host's local base checkout for a manifest —
+    two sources that silently disagreed whenever that checkout lagged
+    (#2166's split-brain). One call, reused for both the pass/fail
+    decision and the text the worker sees, makes that disagreement
+    structurally impossible rather than merely rare.
     """
     if proposal_type != "work" or repo is None:
-        return
+        return None
     if not config.acceptance.has_driver(repo.name):
-        return
+        return None
 
     from coord import github_ops  # noqa: PLC0415
     from coord.milestone_dispatch import issue_oracle_ready  # noqa: PLC0415
@@ -159,7 +173,7 @@ def enforce_oracle_readiness(
     try:
         issue_data = github_ops.get_issue(repo.github, issue_number)
     except RuntimeError:
-        return
+        return None
 
     milestone_number = (issue_data.get("milestone") or {}).get("number")
     issue_labels = [lbl.get("name", "") for lbl in (issue_data.get("labels") or [])]
@@ -169,6 +183,7 @@ def enforce_oracle_readiness(
     )
     if readiness.reason is not None:
         raise DispatchRefused(readiness.reason)
+    return readiness
 
 
 def enforce_epic_dispatch_guard(
@@ -784,7 +799,11 @@ def dispatch(
     # a driver kind this install doesn't implement. Placed early / before
     # the TOS gate below so a refusal never depends on provider resolution
     # succeeding first.
-    enforce_oracle_readiness(
+    #
+    # #2166: the returned verdict is reused below to build the worker-
+    # briefing oracle-loop contract block — the SAME read this gate just
+    # used, not a second independent one — so the two can never disagree.
+    oracle_readiness = enforce_oracle_readiness(
         proposal_type=proposal.type, repo=repo, config=config,
         issue_number=proposal.issue_number,
     )
@@ -994,44 +1013,64 @@ def dispatch(
     # a milestone-level flag, so "driver configured for this repo" is the
     # signal, mirroring the tests/acceptance/ auto-seal above) AND this issue
     # already has an authored slice, OR (#3212) is exempted from one —
-    # oracle_loop_contract_block covers both and returns "" only when neither
-    # applies (e.g. before Gate A/#931 has run for it at all). An exemption
-    # waives the automated gate, not the design contract the milestone's
-    # mocks define, so the worker still needs the pointer — see
-    # oracle_loop_contract_block's docstring for the exempted-issue variant.
+    # oracle_loop_contract_block_for_slice covers both and returns "" only
+    # when neither applies (e.g. before Gate A/#931 has run for it at all).
+    # An exemption waives the automated gate, not the design contract the
+    # milestone's mocks define, so the worker still needs the pointer — see
+    # oracle_loop_contract_block_for_slice's docstring for the exempted-issue
+    # variant.
+    #
+    # #2166: this used to re-derive "does a slice exist" by scanning the
+    # dispatching HOST's local base checkout (`repo_root / search_root`) —
+    # a second, independent read from the #1138 gate above, which reads the
+    # default branch over `gh`. A stale base checkout (nothing refreshes it
+    # automatically — see docs/ORACLE_LOOP.md) made the two disagree: the
+    # gate let a dispatch through because the slice existed on the default
+    # branch, while this scan came back `""` because the local clone hadn't
+    # pulled it yet, silently sending the worker with no oracle contract at
+    # all. Now this builds the block from `oracle_readiness` — the EXACT
+    # verdict the gate above already computed — so there is only one read
+    # and the two can never diverge again.
     briefing_text = proposal.briefing
     if proposal.type == "work" and proposal.issue_number:
-        from pathlib import Path  # noqa: PLC0415
-
         from coord.state import issue_context_block  # noqa: PLC0415
 
         oracle_contract = ""
         if config.acceptance.has_driver(proposal.repo_name):
-            from coord.acceptance import oracle_loop_contract_block  # noqa: PLC0415
-
-            # #2896: the issue's slice may live under the shared repo-root
-            # tree (a directory-discovered driver, e.g. ms-37's cli-pytest
-            # suite) OR under an entrypoint-linked driver's own sibling
-            # `acceptance/` dir (e.g. ms-65's tui-tuidriver suite, relocated
-            # out of the repo root) — this dispatch call has no single path
-            # in hand to pick a route ahead of time (proposal.issue_number
-            # alone doesn't say which), so it tries every search root this
-            # repo declares and uses whichever one actually has the slice.
-            # A local checkout scan (no `gh`), so trying more than one root
-            # costs nothing but a stat/read against a directory that
-            # usually doesn't exist.
-            repo_root = Path(repo_path).expanduser()
-            for search_root in config.acceptance.acceptance_search_roots(
-                proposal.repo_name
-            ):
-                oracle_contract = oracle_loop_contract_block(
-                    repo_root / search_root,
+            from coord.acceptance import (  # noqa: PLC0415
+                oracle_loop_contract_block_for_slice,
+            )
+
+            if oracle_readiness is not None and oracle_readiness.applies:
+                oracle_contract = oracle_loop_contract_block_for_slice(
                     proposal.repo_name,
                     proposal.issue_number,
-                    acceptance_dirname=search_root,
+                    has_slice=oracle_readiness.has_slice,
+                    exempt=oracle_readiness.exempt,
+                    ms_dir=oracle_readiness.ms_dir,
+                    acceptance_dirname=oracle_readiness.acceptance_dirname,
                 )
-                if oracle_contract:
-                    break
+                # #2166 acceptance criterion: a gate must be able to fail,
+                # and unconfirmed success is a defect — if the gate's own
+                # verdict says there's a slice (or an exemption) to point
+                # at, rendering the block must not silently come back
+                # empty. That combination can only mean a bug in the
+                # renderer above, not "no slice yet" (which `applies`/
+                # `has_slice`/`exempt` already ruled out) — refuse loudly
+                # rather than dispatch a worker with a hollow briefing.
+                if (
+                    oracle_readiness.has_slice or oracle_readiness.exempt
+                ) and not oracle_contract:
+                    raise DispatchRefused(
+                        f"#2166: internal inconsistency building the "
+                        f"oracle-loop briefing for {proposal.repo_name}#"
+                        f"{proposal.issue_number} — the gate found a "
+                        "slice/exemption (ms_dir="
+                        f"{oracle_readiness.ms_dir!r}) but rendering the "
+                        "contract block came back empty. Refusing rather "
+                        "than dispatching a worker with no oracle "
+                        "contract."
+                    )
 
         # #1720: dispatch-time file-overlap fence — the union of file
         # footprints of every OTHER currently-running work-like assignment

{code_coordinator-0.5.561 → code_coordinator-0.5.562}/coord/milestone_dispatch.py

@@ -433,6 +433,7 @@ def _fetch_manifest_data(
     *,
     issue_number: int | None = None,
     roots: Iterable[str] | None = None,
+    root_out: "list[str] | None" = None,
 ):
     """*milestone_number*'s manifest data via *fetch* (a raw-content GitHub
     fetch, no local checkout, no directory listing) — the legacy single-file
@@ -468,6 +469,16 @@ def _fetch_manifest_data(
     unchanged from before #2896. Tries each root until one actually has a
     legacy manifest and/or fragment file; a milestone's data lives under
     exactly one, so the first root that produces anything wins.
+
+    *root_out* (#2166), when given, has the matched root dir appended —
+    the SAME root this data actually came from — so a caller rendering the
+    worker-briefing contract block (which needs to name a repo-relative
+    dirname in the text, e.g. ``tests/acceptance/ms-37/contract.md``) can
+    do so without a second, independent search. Appends the first
+    candidate root (or the legacy single-root default) when nothing
+    matched, mirroring the fall-through return below — there is no "right"
+    root to name for a slice that doesn't exist, so the caller must check
+    ``has_slice``/``exempt`` before trusting this for message text.
     """
     from coord import github_ops  # noqa: PLC0415
     from coord.acceptance import (  # noqa: PLC0415
@@ -511,6 +522,8 @@ def _fetch_manifest_data(
         legacy, legacy_found = _fetch_one(f"{root_dir}/{ms_dir}", "manifest")
         if issue_number is None:
             if legacy_found:
+                if root_out is not None:
+                    root_out.append(root_dir)
                 return legacy
             continue
         fragment, fragment_found = _fetch_one(
@@ -518,10 +531,14 @@ def _fetch_manifest_data(
             str(issue_number),
         )
         if legacy_found or fragment_found:
+            if root_out is not None:
+                root_out.append(root_dir)
             return merge_manifest_data(legacy, fragment)
 
     # No root produced anything — degrade to empty data, same as the old
     # single-root "not found" behaviour.
+    if root_out is not None:
+        root_out.append(search_roots[0])
     return legacy if issue_number is None else merge_manifest_data(legacy, fragment)
 
 
@@ -714,6 +731,19 @@ class OracleReadiness:
     #: gate doesn't apply. ``"approved"``/``"exempt"`` are the only values
     #: that let ``reason`` be ``None``.
     gate_a_state: str = ""
+    #: (#2166) The milestone this readiness verdict was computed against,
+    #: and the ``ms-NN`` directory name / repo-relative acceptance-root
+    #: dirname the slice (or exemption) it found actually lives under —
+    #: set whenever ``applies`` is ``True``. Exists so a caller that needs
+    #: to RENDER the worker-briefing contract block
+    #: (:func:`coord.acceptance.oracle_loop_contract_block_for_slice`) can
+    #: do so from THIS SAME verdict instead of re-deriving "does a slice
+    #: exist" from a second, independent read (previously a scan of the
+    #: dispatching host's local checkout, #2166's split-brain) — one
+    #: fetch, one source of truth, per #2096 "one question, one answer".
+    milestone_number: int | None = None
+    ms_dir: str = ""
+    acceptance_dirname: str = ""
 
 
 def _gate_a_exempt_trade_off_note(
@@ -857,14 +887,27 @@ def issue_oracle_ready(
     from coord.acceptance import test_ids_for_issue  # noqa: PLC0415
     from coord.acceptance_drivers import SUPPORTED_KINDS  # noqa: PLC0415
 
+    # #2166: capture WHICH search root this issue's manifest data actually
+    # came from, so the verdict below can carry enough to let a caller
+    # render the worker-briefing contract block from THIS read — the same
+    # `gh`-fetched-from-the-default-branch source the gate itself just
+    # used — instead of a second, independent local-checkout scan that can
+    # silently disagree with it (the #2166 split-brain).
+    matched_roots: list[str] = []
     manifest = _fetch_manifest_data(
         repo_cfg.github, milestone_number, repo_cfg.default_branch, fetch,
         issue_number=issue_number,
         roots=config.acceptance.acceptance_search_roots(repo_cfg.name),
+        root_out=matched_roots,
     )
     has_slice = bool(test_ids_for_issue(manifest.tests, issue_number))
     exempt = issue_number in manifest.exempt or "oracle:exempt" in set(issue_labels)
 
+    from coord.acceptance import ACCEPTANCE_DIRNAME, ms_dirname  # noqa: PLC0415
+
+    ms_dir = ms_dirname(milestone_number)
+    acceptance_dirname = matched_roots[0] if matched_roots else ACCEPTANCE_DIRNAME
+
     entry = config.acceptance.drivers.get(repo_cfg.name)
     unsupported = _unsupported_driver_kinds(entry) if entry is not None else ()
 
@@ -887,13 +930,16 @@ def issue_oracle_ready(
         return OracleReadiness(
             applies=True, exempt=exempt, has_slice=has_slice,
             unsupported_kinds=unsupported, reason=signoff.reason,
-            gate_a_state=signoff.state,
+            gate_a_state=signoff.state, milestone_number=milestone_number,
+            ms_dir=ms_dir, acceptance_dirname=acceptance_dirname,
         )
 
     if exempt:
         return OracleReadiness(
             applies=True, exempt=True, has_slice=has_slice,
             unsupported_kinds=unsupported, gate_a_state=signoff.state,
+            milestone_number=milestone_number, ms_dir=ms_dir,
+            acceptance_dirname=acceptance_dirname,
         )
 
     reason: str | None = None
@@ -920,7 +966,8 @@ def issue_oracle_ready(
     return OracleReadiness(
         applies=True, exempt=False, has_slice=has_slice,
         unsupported_kinds=unsupported, reason=reason,
-        gate_a_state=signoff.state,
+        gate_a_state=signoff.state, milestone_number=milestone_number,
+        ms_dir=ms_dir, acceptance_dirname=acceptance_dirname,
     )
 
 

{code_coordinator-0.5.561 → code_coordinator-0.5.562}/tests/test_acceptance.py

@@ -48,6 +48,7 @@ from coord.acceptance import (
     ms_dir_for_exempt_issue,
     ms_dir_for_issue,
     oracle_loop_contract_block,
+    oracle_loop_contract_block_for_slice,
     oracle_loop_contract_reviewer_note,
     parse_manifest_text,
     resolve_for_path,
@@ -1467,6 +1468,63 @@ class TestOracleLoopContractBlock:
         assert "`tests/acceptance/" not in block
 
 
+class TestOracleLoopContractBlockForSlice:
+    """(#2166) :func:`oracle_loop_contract_block_for_slice` renders the
+    exact same text :func:`oracle_loop_contract_block` does, but from an
+    already-resolved verdict (no local checkout) — the version
+    `coord.dispatch.dispatch` now uses so the worker-briefing block can
+    never drift from the #1138 gate's own read."""
+
+    def test_empty_when_ms_dir_missing(self) -> None:
+        # OracleReadiness.applies == False (e.g. no milestone) -> ms_dir
+        # is "" -> nothing to render, same as oracle_loop_contract_block's
+        # "no manifest found" case.
+        assert oracle_loop_contract_block_for_slice(
+            "api", 945, has_slice=False, exempt=False, ms_dir="",
+        ) == ""
+
+    def test_empty_when_neither_slice_nor_exempt(self) -> None:
+        # A milestone resolved (ms_dir set) but this issue has no slice and
+        # isn't exempted — the #1138 gate's own "no acceptance slice yet"
+        # refusal covers this case; nothing to point the worker at.
+        assert oracle_loop_contract_block_for_slice(
+            "api", 945, has_slice=False, exempt=False, ms_dir="ms-25",
+        ) == ""
+
+    def test_renders_same_text_as_the_local_checkout_scan(
+        self, tmp_path: Path,
+    ) -> None:
+        root = tmp_path / "tests" / "acceptance"
+        (root / "ms25").mkdir(parents=True)
+        (root / "ms25" / "manifest.yml").write_text("tests:\n  ms25::a: 945\n")
+        from_disk = oracle_loop_contract_block(root, "api", 945)
+        from_verdict = oracle_loop_contract_block_for_slice(
+            "api", 945, has_slice=True, exempt=False, ms_dir="ms25",
+            acceptance_dirname=ACCEPTANCE_DIRNAME,
+        )
+        assert from_disk == from_verdict
+        assert "coord acceptance run --repo api --issue 945" in from_verdict
+
+    def test_renders_the_exempt_variant(self) -> None:
+        block = oracle_loop_contract_block_for_slice(
+            "api", 1125, has_slice=False, exempt=True, ms_dir="ms-37",
+            acceptance_dirname="tests/acceptance",
+        )
+        assert "(exempted issue, #3212)" in block
+        assert "tests/acceptance/ms-37/contract.md" in block
+        # The exempted variant deliberately drops the "run coord
+        # acceptance run" instruction (there is no slice of its own).
+        assert "coord acceptance run" not in block
+
+    def test_acceptance_dirname_names_a_relocated_slice(self) -> None:
+        block = oracle_loop_contract_block_for_slice(
+            "coord-tui", 2282, has_slice=True, exempt=False, ms_dir="ms-65",
+            acceptance_dirname="tui/tests/acceptance/",
+        )
+        assert "tui/tests/acceptance/ms-65/contract.md" in block
+        assert "`tests/acceptance/" not in block
+
+
 class TestMsDirForExemptIssue:
     """#3212: sibling to ms_dir_for_issue, but for an issue named in a
     manifest's `exempt:` list rather than one with a test mapping."""