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

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

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

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

{code_coordinator-0.5.560 → 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.560 → code_coordinator-0.5.562}/coord/ci_store.py

@@ -733,7 +733,7 @@ def is_verdictless_job(check: CheckRun, job: JobRun | None) -> bool:
 
 
 def checks_are_stale(checks: list[CheckRun], base_commit_time: float | None) -> bool:
-    """True when a **green** *checks* result predates *base_commit_time* (#1851).
+    """True when *checks* predate *base_commit_time* (#1851).
 
     GitHub attaches ``pull_request`` check runs to the PR's *head* SHA and
     re-runs them on head ``synchronize`` — never on base movement — so a
@@ -742,10 +742,17 @@ def checks_are_stale(checks: list[CheckRun], base_commit_time: float | None) ->
     what matters is what the base looked like when the run *began*, not when
     it finished.
 
-    Callers should apply :func:`failed_checks`/:func:`in_flight_checks`
-    first — this function assumes *checks* is the all-passing remainder and
-    doesn't re-derive that itself, so it never contradicts "CI failed"/"CI
-    running" with a third, competing reading of the same checks. An empty
+    Originally written for the caller's all-**passing** remainder — apply
+    :func:`failed_checks`/:func:`in_flight_checks` first and pass what's
+    left, so this never contradicts "CI failed"/"CI running" with a third,
+    competing reading of the same checks. #1986 also calls this with the
+    FAILED remainder instead (``coord.merge_queue``'s ``checks_failed``
+    path): the comparison itself never inspects ``conclusion``, only
+    ``started_at``, so "did this run predate the base?" is the identical
+    question either way — there is no second notion of CI staleness for the
+    red case, only a second caller asking the same one (#2096: one question,
+    one answer). Which verdict a stale run carries decides what the caller's
+    message says; it never decides whether the merge blocks. An empty
     *checks* list (nothing to compare) reads as not-stale; the caller's own
     "no checks" handling covers that case — see :meth:`CiStore.expects_checks`
     and ``coord.merge_queue``'s ``checks_absent`` gate (#1904), which now

{code_coordinator-0.5.560 → 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.560 → code_coordinator-0.5.562}/coord/merge_queue.py

@@ -2770,9 +2770,19 @@ def _ci_checks_are_stale(
     *,
     fail_closed: bool = True,
 ) -> bool:
-    """True when *checks* — already confirmed by the caller to have no
-    failed/in-flight entries — are stale relative to *target_branch*'s
-    current base (#1851).
+    """True when *checks* are stale relative to *target_branch*'s current
+    base (#1851).
+
+    Originally written for the caller's all-PASSING remainder (no
+    failed/in-flight entries) — the ``checks_stale`` path below. #1986 reuses
+    it unchanged for the FAILED remainder too: the underlying comparison
+    (``started_at`` vs. the base's current commit time, via
+    :func:`coord.ci_store.checks_are_stale`) never reads ``conclusion``, so
+    "did this run see the base's current tip?" has exactly one answer
+    regardless of which way the run concluded (#2096: one question, one
+    answer). A stale FAILING check still blocks the merge either way — this
+    only changes whether the refusal names the staleness, never the
+    pass/fail verdict itself.
 
     GitHub does not re-run ``pull_request`` workflows on a base-only move
     (only on head ``synchronize``), so a green check can silently outlive the
@@ -2906,6 +2916,50 @@ def ci_stale_reason(
     )
 
 
+def checks_failed_stale_suffix(
+    failed: "list[CheckRun]",
+    gh_ops: "GhOps | None",
+    repo_github: str | None,
+    target_branch: str | None,
+) -> str:
+    """Clause appended to a ``checks failed: ...`` refusal when the failing
+    run(s) predate *target_branch*'s current base (#1986).
+
+    Hit while merging #1895: a `windows` check was red for `ModuleNotFoundError:
+    No module named 'fcntl'` — a bug #1156 had already fixed on `main` 33
+    commits before this branch's base. The gate reported it as a bare,
+    current-looking failure, inviting either pointless debugging of a defect
+    that no longer exists, or a `--force-merge` reasoned on "it's probably
+    just flaky" — neither of which an operator should have to guess at when
+    the gate already has the evidence.
+
+    #1851/:func:`ci_stale_reason` already answers "did this run see the
+    base's current tip?" for a stale PASSING check; this is the exact same
+    question for a FAILING one, so it reuses :func:`ci_staleness_note` for
+    the anchor wording rather than inventing a second rendering of "predates
+    the base" (#2096: one question, one answer). Callers decide staleness
+    first via :func:`_ci_checks_are_stale` — this never makes that call
+    itself, only renders the clause once asked to.
+
+    Returns ``""`` when the anchors can't be read — the same unreadable case
+    :func:`ci_staleness_note` itself falls back on — so the caller's plain
+    ``checks failed: ...`` message prints unchanged rather than asserting
+    staleness evidence this can't actually produce. Either way the refusal
+    still BLOCKS: this only ever adds provenance to an existing block, never
+    removes or downgrades it.
+    """
+    note = ci_staleness_note(failed, gh_ops, repo_github, target_branch)
+    if not note:
+        return ""
+    branch = target_branch or "the target branch"
+    return (
+        " — but that run predates the current base" + note + " — rebase "
+        f"onto {branch} and push (`git push --force-with-lease`) and let CI "
+        "re-run before trusting this result; a CI re-run against the same "
+        "base cannot see a moved base"
+    )
+
+
 # #1826: `--force-merge` still overrides the CI gate, but the override must
 # never be SILENT — the same posture `epic_closing_keyword_in_commit_forced`
 # already takes for the #1318 gate. A waived stale-CI merge is precisely the
@@ -7649,11 +7703,26 @@ def process(
                             summary = ", ".join(
                                 f"{c.name} ({c.conclusion})" for c in failed
                             )
-                            msg = (
-                                unreadable_reason
-                                or infra_reason
-                                or f"checks failed: {summary}"
-                            )
+                            if unreadable_reason:
+                                msg = unreadable_reason
+                            elif infra_reason:
+                                msg = infra_reason
+                            else:
+                                # #1986: preview the same staleness
+                                # provenance the live path now adds to a
+                                # bare `checks failed: ...` — see
+                                # `checks_failed_stale_suffix`'s docstring.
+                                # Preview-only: never mutates, just shows
+                                # what a real attempt would compute.
+                                msg = f"checks failed: {summary}"
+                                if _ci_checks_are_stale(
+                                    failed, gh_ops, entry.repo_github,
+                                    entry.target_branch, _smoke,
+                                ):
+                                    msg += checks_failed_stale_suffix(
+                                        failed, gh_ops, entry.repo_github,
+                                        entry.target_branch,
+                                    )
                             events.append(MergeEvent(
                                 entry, "checks_failed",
                                 f"(dry run) would be blocked: {msg}",
@@ -8283,6 +8352,20 @@ def process(
                         # this already-confirmed streak as a flake.
                         entry.ci_flaky_pending = ""
                     msg = f"checks failed: {summary}"
+                    # #1986: a RED check can be exactly as stale as a GREEN
+                    # one (#1851) — it just looks like a current defect
+                    # instead of an obvious re-test candidate, which is what
+                    # invites either pointless debugging of a bug already
+                    # fixed on the current base, or a wrong `--force-merge`.
+                    # Reports provenance only; the entry still blocks either
+                    # way (see `checks_failed_stale_suffix`'s docstring).
+                    if _ci_checks_are_stale(
+                        failed, gh_ops, entry.repo_github, entry.target_branch,
+                        smoke,
+                    ):
+                        msg += checks_failed_stale_suffix(
+                            failed, gh_ops, entry.repo_github, entry.target_branch,
+                        )
                     entry.error = msg
                     events.append(MergeEvent(entry, "checks_failed", msg))
                     continue  # #292: skip, don't halt the group

{code_coordinator-0.5.560 → 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.560 → code_coordinator-0.5.562}/tests/conftest.py

@@ -1304,3 +1304,33 @@ def _no_frozen_coord_dir_constants():
     _scrub_lazy_coord_dir_constants()
     yield
     _scrub_lazy_coord_dir_constants()
+
+
+@pytest.fixture(autouse=True)
+def _non_wsl_host_by_default(monkeypatch):
+    """#3532: ``coord.win_native_bridge.is_wsl_host`` detects the REAL host
+    it's running on (``WSL_DISTRO_NAME``/``/proc/version``) — fine for
+    production, but it means every ``win-native`` acceptance-driver test
+    that doesn't scripts its own ``run_native_spec``/bridge fake implicitly
+    assumed "whatever machine runs this test suite is not WSL". That held
+    for every machine except dell64 (a genuine WSL2 host with a working
+    Windows-side Python, #3519): there, ``is_wsl_host()`` legitimately
+    returns ``True`` and ``coord.acceptance_drivers._run_win_native`` takes
+    the real WSL->Windows bridge path instead of the scripted fake these
+    tests set up on ``coord.win_native_driver.run_native_spec`` — a
+    baseline-red latch (#3386), not a test bug in the assertions themselves.
+
+    Forcing the DEFAULT to non-WSL here, once, is the same "one question,
+    one answer" posture as this file's other ``_no_real_*``/``_no_live_*``
+    fixtures: every test in the suite gets a hermetic answer to "is this
+    host WSL" regardless of which machine actually runs it. A test that
+    means to exercise the WSL/bridge branch (``TestRunDriverWinNativeWslBridge``
+    in ``tests/test_acceptance_drivers.py``) monkeypatches
+    ``win_native_bridge.is_wsl_host`` back to ``True`` itself, inside the
+    test body — that call reuses this same function-scoped ``monkeypatch``
+    fixture and so simply wins (last ``setattr`` on the same attribute),
+    no ordering trick needed.
+    """
+    import coord.win_native_bridge as win_native_bridge
+
+    monkeypatch.setattr(win_native_bridge, "is_wsl_host", lambda: False)

{code_coordinator-0.5.560 → 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."""