code-coordinator 0.5.523__tar.gz → 0.5.524__tar.gz

{code_coordinator-0.5.523 → code_coordinator-0.5.524}/PKG-INFO

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

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

@@ -1,7 +1,7 @@
 {
-  "tag": "0.5.523",
+  "tag": "0.5.524",
   "distance": 0,
-  "node": "geeb81f140eb64e517c8fde27adf71ba0186f28da",
+  "node": "g0e924a9e07fea9e3ea943a45cd49b370575ca40c",
   "dirty": false,
   "branch": "HEAD",
   "node_date": "2026-09-27"

{code_coordinator-0.5.523 → code_coordinator-0.5.524}/coord/config.py

@@ -307,12 +307,34 @@ class SmokeTestsConfig:
     `default_command` is the shell command the smoke agent runs (e.g.
     `make smoke` or `pytest tests/smoke`). Per-repo overrides flow through
     `Repo.test_command` already; this is the fallback when none is set.
+
+    `native_execution_capabilities` (#3455) lists which bare capabilities
+    (e.g. `"windows"`) merely mean "some machine can build/cross-compile
+    for this" and do NOT by themselves prove a Test leg runs on that OS
+    natively. `dell64` declared `windows` while its coord agent ran inside
+    WSL (Linux); a #[cfg(target_os = "windows")] test compiled out and the
+    Test stage reported `pass` for a failure GitHub's `windows-latest`
+    runner caught every time (quadraui#1077). A machine must ALSO declare
+    `coord.config.native_execution_capability(cap)` (e.g. `windows-native`)
+    to certify it runs *that* capability's suite natively — see
+    `coord.smoke.unverified_native_capabilities`, consulted at THREE points
+    so the gap can't be closed by prompt-cooperation alone: routing
+    (`coord.smoke.rank_smoke_machines` prefers a native-verified candidate
+    over a bare one when both exist), dispatch (the briefing tells the
+    worker to caveat its own marker), and verdict-recording
+    (`coord.notify._record_smoke_verdict`'s PASS branches independently
+    recompute this and record `test_confirmation="native_unverified"`
+    regardless of what the worker's marker text says). Defaults to
+    `["windows"]`, the one capability the incident this exists for actually
+    involved; add more here (e.g. a future `"macos"` cross-build path)
+    without any code change.
     """
 
     auto_queue: bool = False
     default_command: str | None = None
     timeout_seconds: int = 600
     capability_rules: list[SmokeRule] = field(default_factory=list)
+    native_execution_capabilities: list[str] = field(default_factory=lambda: ["windows"])
 
 
 @dataclass
@@ -1904,6 +1926,25 @@ def provider_capability(provider_type: str) -> str:
     return f"provider:{provider_type}"
 
 
+def native_execution_capability(capability: str) -> str:
+    """The ``capabilities:`` string a machine must ALSO declare, alongside
+    *capability* itself, to certify it runs *capability*'s tests on a
+    genuinely native host rather than merely building/cross-compiling for
+    it (#3455).
+
+    ``native_execution_capability("windows") == "windows-native"``. Same
+    config-only-declaration shape as :func:`provider_capability` — a
+    machine that lists ``windows`` in ``capabilities:`` can build for
+    Windows (a WSL/Linux agent satisfies that today), but only one that
+    ALSO lists ``windows-native`` has told the coordinator its Test-stage
+    runs actually execute there. Single source of truth for the naming
+    convention: `coord.smoke.unverified_native_capabilities` is the only
+    caller, so the two can never disagree about the string (#2096, "one
+    question, one answer").
+    """
+    return f"{capability}-native"
+
+
 def model_plausible_for_provider_type(model: str, provider_type: str) -> bool:
     """Namespace-shape sanity check: could *model* plausibly belong to
     *provider_type* (#1798)?
@@ -3498,6 +3539,14 @@ def _parse_smoke_tests(raw: Any) -> SmokeTestsConfig:
             raise ConfigError("smoke_tests.timeout_seconds must be a positive integer")
         cfg.timeout_seconds = value
 
+    if "native_execution_capabilities" in raw:
+        value = raw["native_execution_capabilities"]
+        if not isinstance(value, list) or not all(isinstance(c, str) for c in value):
+            raise ConfigError(
+                "smoke_tests.native_execution_capabilities must be a list of strings"
+            )
+        cfg.native_execution_capabilities = value
+
     rules_raw = raw.get("capability_rules", []) or []
     if not isinstance(rules_raw, list):
         raise ConfigError("smoke_tests.capability_rules must be a list")

{code_coordinator-0.5.523 → code_coordinator-0.5.524}/coord/confirm_test.py

@@ -314,8 +314,21 @@ INCONCLUSIVE_KINDS = frozenset({
 # * ``TEST_CONFIRMATION_BASELINE_RED`` — `ConfirmationResult.baseline_red`
 #   (#2170): the suite failed identically on the merge-base, so nothing was
 #   learned about the BRANCH specifically, but a real run did happen.
+# * ``TEST_CONFIRMATION_NATIVE_UNVERIFIED`` (#3455) — the claimed pass ran on
+#   a machine that declares only the bare/build side of a capability this
+#   leg required (`coord.smoke.SmokeTestsConfig.native_execution_
+#   capabilities`, e.g. `"windows"`), not the paired `coord.config.
+#   native_execution_capability` proof it runs that suite on genuinely native
+#   hardware — a WSL-hosted `windows` machine being the canonical case
+#   (`dell64` / quadraui#1077). Distinct from `UNCONFIRMED`: a confirmation
+#   run may well have executed and even agreed with the claim, but "agreed"
+#   here still means "on a non-native host", so platform-conditional code the
+#   real target OS would exercise never ran anywhere in this leg. Recorded
+#   by `coord.notify._record_smoke_verdict`'s PASS branches regardless of
+#   what the worker's own `SMOKE:` marker text says — see `coord.smoke.
+#   native_unverified_for_verdict`.
 #
-# ``None`` (the column default) is a fifth, implicit state: no confirmation
+# ``None`` (the column default) is a sixth, implicit state: no confirmation
 # question was ever asked about this write at all — a headless smoke
 # FAILURE, a human `coord test --passed` write that has not yet been reaped
 # by a notify pass, a mute-leg park, ``TEST_STATE_BLOCKED``, ... None of
@@ -326,6 +339,7 @@ TEST_CONFIRMATION_CONFIRMED = "confirmed"
 TEST_CONFIRMATION_UNCONFIRMED = "unconfirmed"
 TEST_CONFIRMATION_REFUTED = "refuted"
 TEST_CONFIRMATION_BASELINE_RED = "baseline_red"
+TEST_CONFIRMATION_NATIVE_UNVERIFIED = "native_unverified"
 
 #: Every value `test_confirmation` may hold — for validation / display sites
 #: that want to assert exhaustiveness rather than silently falling through.
@@ -334,6 +348,7 @@ TEST_CONFIRMATION_VALUES = frozenset({
     TEST_CONFIRMATION_UNCONFIRMED,
     TEST_CONFIRMATION_REFUTED,
     TEST_CONFIRMATION_BASELINE_RED,
+    TEST_CONFIRMATION_NATIVE_UNVERIFIED,
 })
 
 #: #3378: the canonical prefix a ``test_reason`` carries when a ``skipped``
@@ -1464,6 +1479,7 @@ __all__ = [
     "STALE_WORKTREE_MAX_AGE_HOURS",
     "TEST_CONFIRMATION_BASELINE_RED",
     "TEST_CONFIRMATION_CONFIRMED",
+    "TEST_CONFIRMATION_NATIVE_UNVERIFIED",
     "TEST_CONFIRMATION_REFUTED",
     "TEST_CONFIRMATION_UNCONFIRMED",
     "TEST_CONFIRMATION_VALUES",

{code_coordinator-0.5.523 → code_coordinator-0.5.524}/coord/gates.py

@@ -47,6 +47,7 @@ from typing import TYPE_CHECKING
 
 from coord.confirm_test import (
     TEST_CONFIRMATION_BASELINE_RED,
+    TEST_CONFIRMATION_NATIVE_UNVERIFIED,
     TEST_CONFIRMATION_UNCONFIRMED,
 )
 from coord.models import WORK_LIKE_TYPES, effective_issue_number
@@ -1065,6 +1066,13 @@ def format_gate_report(report: GateReport) -> str:
                     suffix = " (UNCONFIRMED — suite never ran)"
                 elif confirmation == TEST_CONFIRMATION_BASELINE_RED:
                     suffix = " (baseline-red — branch not at fault, #2170)"
+                elif confirmation == TEST_CONFIRMATION_NATIVE_UNVERIFIED:
+                    # #3455: this leg ran on a machine that declares only the
+                    # bare/build side of a required capability (e.g. a
+                    # WSL-hosted `windows` machine) — a plain "passed" here
+                    # would read exactly like a genuinely native-hardware
+                    # green, which this is not.
+                    suffix = " (NOT NATIVELY VERIFIED — #3455)"
                 lines.append(
                     "  test   : passed"
                     + (f" (recorded on {test.assignment_id})" if test.assignment_id else "")

{code_coordinator-0.5.523 → code_coordinator-0.5.524}/coord/notify.py

@@ -2358,12 +2358,114 @@ def _run_pass_confirmation(transition: Transition, entry: dict):
             record_inconclusive_confirmation(transition.repo_name, result.kind)
 
 
-def _confirmed_pass_verdict(
+def _native_unverified_capabilities(transition: Transition, entry: dict) -> list[str]:
+    """#3455: which of this smoke leg's required capabilities the machine
+    that ran it declares only the bare/build side of, not the paired
+    native-execution proof — recomputed HERE, independently of whatever the
+    worker's own ``SMOKE:`` marker text says, so a claimed pass can be
+    downgraded even when the worker never prints the caveat
+    `coord.smoke.build_smoke_briefing` asks for (a purely advisory,
+    worker-cooperation-dependent fix would leave that gap wide open — see
+    the #3455 review).
+
+    Best-effort and fail-open, matching every other diagnostic in this
+    module (`_run_pass_confirmation` et al.): a config load failure, an
+    unknown repo/machine, or a PR/diff lookup failure returns ``[]`` — this
+    must never turn "couldn't tell" into a false downgrade, and must never
+    abandon the caller's verdict-recording transition over a network blip.
+    """
+    from coord.config import load as _load_config  # noqa: PLC0415
+    from coord.smoke import (  # noqa: PLC0415
+        _fetch_touched_files,
+        native_unverified_for_verdict,
+    )
+
+    try:
+        config = _load_config()
+    except Exception as exc:  # noqa: BLE001
+        log.debug(
+            "smoke %s: could not load config for the #3455 native-"
+            "verification check (%s) — skipping it.",
+            transition.assignment_id, exc,
+        )
+        return []
+
+    repo = config.repo(transition.repo_name)
+    machine = next(
+        (m for m in config.machines if m.name == transition.machine_name), None
+    )
+    if repo is None or machine is None:
+        return []
+
+    branch = entry.get("branch")
+    if not branch:
+        return []
+
+    try:
+        touched_files = _fetch_touched_files(repo.github, branch)
+    except Exception as exc:  # noqa: BLE001
+        log.debug(
+            "smoke %s: could not fetch touched files for the #3455 native-"
+            "verification check (%s) — skipping it.",
+            transition.assignment_id, exc,
+        )
+        return []
+
+    return native_unverified_for_verdict(
+        repo=repo, machine=machine, smoke_cfg=config.smoke_tests,
+        touched_files=touched_files,
+    )
+
+
+def _downgrade_for_native_unverified(
+    state: str,
+    reason: str,
+    confirmation: str,
+    native_unverified: list[str] | None,
+) -> tuple[str, str, str]:
+    """#3455: a claimed pass on a leg whose machine declares only the bare
+    (build/cross-compile) side of a required capability — never the paired
+    native-execution proof (`coord.smoke.native_unverified_for_verdict`) —
+    must not read as a plain confirmed/unconfirmed pass. This is what
+    actually closes the loop the #3455 review found open: it fires
+    regardless of what the worker's own ``SMOKE:`` marker text says, so a
+    worker that never prints the caveat `coord.smoke.build_smoke_briefing`
+    asks for still gets a genuinely distinct, machine-readable
+    ``test_confirmation`` on the row.
+
+    Only applies to a ``state == "passed"`` result — a real ``failed``,
+    the #2579 ``TEST_STATE_CONTESTED``, or a ``baseline_red`` skip already
+    carry more urgent, more specific information and must never be
+    overwritten by this.
+    """
+    if state != "passed" or not native_unverified:
+        return state, reason, confirmation
+    from coord.confirm_test import (  # noqa: PLC0415
+        TEST_CONFIRMATION_NATIVE_UNVERIFIED,
+    )
+
+    caps = ", ".join(native_unverified)
+    return (
+        state,
+        f"{reason} — NOT NATIVELY VERIFIED for {caps} (#3455): this leg ran "
+        "on a machine that declares the bare capability but not native "
+        "execution for it, so a platform-conditional failure specific to "
+        f"real {caps} hardware would not have shown up here.",
+        TEST_CONFIRMATION_NATIVE_UNVERIFIED,
+    )
+
+
+def _confirmed_pass_verdict_core(
     transition: Transition, entry: dict, parent_id: str, *, claim_reason: str,
 ) -> tuple[str, str, str]:
     """#2464: the ``(test_state, test_reason, test_confirmation)`` to record
     for a *claimed* pass.
 
+    Callers should use the public :func:`_confirmed_pass_verdict` wrapper,
+    not this directly — it additionally applies the #3455 native-
+    verification downgrade (:func:`_downgrade_for_native_unverified`) this
+    core function knows nothing about.
+
     The Test stage's pass claim — whether it arrived as a ``SMOKE: pass``
     marker or as the worker calling ``coord test --passed`` on itself (#2217) —
     is a self-report by the thing being graded. This turns it into an
@@ -2544,6 +2646,38 @@ def _confirmed_pass_verdict(
     )
 
 
+def _confirmed_pass_verdict(
+    transition: Transition,
+    entry: dict,
+    parent_id: str,
+    *,
+    claim_reason: str,
+    native_unverified: list[str] | None = None,
+) -> tuple[str, str, str]:
+    """#2464/#3455: the ``(test_state, test_reason, test_confirmation)`` to
+    record for a *claimed* pass — :func:`_confirmed_pass_verdict_core`'s
+    out-of-band confirmation, with the #3455 native-verification downgrade
+    (:func:`_downgrade_for_native_unverified`) applied on top.
+
+    *native_unverified* — non-empty means this leg's machine declares only
+    the bare/build side of one or more of its required capabilities, not
+    the paired native-execution proof (`coord.smoke.native_unverified_for_
+    verdict`). This downgrade is unconditional on the worker's own
+    ``SMOKE:`` marker text: it fires purely from the machine/capability
+    facts, so a claimed pass this leg cannot actually back with native
+    hardware never records as a plain ``confirmed``/``unconfirmed`` pass —
+    see the #3455 review that made this the mandatory second half of the
+    fix (the briefing-text caveat alone changes nothing this repo's own
+    gates/merge-queue code ever reads back).
+    """
+    state, reason, confirmation = _confirmed_pass_verdict_core(
+        transition, entry, parent_id, claim_reason=claim_reason,
+    )
+    return _downgrade_for_native_unverified(
+        state, reason, confirmation, native_unverified,
+    )
+
+
 def _mechanical_mute_verdict(
     transition: Transition, entry: dict, parent_id: str,
 ) -> tuple[str, str, str] | None:
@@ -2725,6 +2859,7 @@ def _record_smoke_verdict(
             state, reason, confirmation = _confirmed_pass_verdict(
                 transition, entry, parent_id,
                 claim_reason="worker self-recorded via `coord test` (#2217)",
+                native_unverified=_native_unverified_capabilities(transition, entry),
             )
             record_test_verdict(
                 assignment_id=parent_id,
@@ -2814,6 +2949,7 @@ def _record_smoke_verdict(
         state, reason, confirmation = _confirmed_pass_verdict(
             transition, entry, parent_id,
             claim_reason="headless smoke reported SMOKE: pass",
+            native_unverified=_native_unverified_capabilities(transition, entry),
         )
         record_test_verdict(
             assignment_id=parent_id,
@@ -2842,7 +2978,9 @@ def _record_smoke_verdict(
     # away, with no leg spent and no tally incremented.
     mechanical = _mechanical_mute_verdict(transition, entry, parent_id)
     if mechanical is not None:
-        state, reason, confirmation = mechanical
+        state, reason, confirmation = _downgrade_for_native_unverified(
+            *mechanical, _native_unverified_capabilities(transition, entry),
+        )
         record_test_verdict(
             assignment_id=parent_id,
             test_state=state,