code-coordinator 0.5.302__tar.gz → 0.5.304__tar.gz

{code_coordinator-0.5.302 → code_coordinator-0.5.304}/PKG-INFO

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

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

@@ -1,7 +1,7 @@
 {
-  "tag": "0.5.302",
+  "tag": "0.5.304",
   "distance": 0,
-  "node": "g4db839a79669e9ada2d3461267662cb4cefd6e52",
+  "node": "gb83a731bf96fbaf2df6909f80889af064839b081",
   "dirty": false,
   "branch": "HEAD",
   "node_date": "2026-08-30"

{code_coordinator-0.5.302 → code_coordinator-0.5.304}/coord/prereqs.py

@@ -278,6 +278,102 @@ def _probe_playwright_browsers(prereq: Prereq, _timeout: float) -> ToolProbe:
     )
 
 
+# --- `windows` capability: the msvc cross-target lives per-toolchain (#2952) --
+#
+# dell64's Windows toolchain is a WSL-side cross-compile: `rustup target add
+# x86_64-pc-windows-msvc` plus `cargo install cargo-xwin` (for the MSVC
+# CRT/SDK cargo-xwin downloads and caches). `cargo-xwin` is an ordinary
+# binary probe, same shape as `cargo`/`opencode` below. The target is not —
+# `rustup target list --installed` is scoped to whichever toolchain is
+# *active*, and quadraui pins a specific one in `rust-toolchain.toml`
+# (`1.97.1` at the time of writing). Adding the target only to the default
+# toolchain leaves the pinned one without it, and a probe that only checked
+# the default would report MET while quadraui's own build still fails —
+# laundering an unbacked claim into a verified one, which is worse than no
+# probe at all. So this asserts the target against EVERY installed
+# toolchain and names the offending one in `what_breaks` when it's missing
+# from any of them.
+WINDOWS_MSVC_TARGET = "x86_64-pc-windows-msvc"
+
+
+def _rustup_toolchains(timeout: float) -> list[str]:
+    """Names of every installed rustup toolchain (`rustup toolchain list`).
+
+    Returns `[]` if `rustup` itself is missing or the call fails — the
+    caller treats that as "cannot confirm the target is installed" rather
+    than raising.
+    """
+    if shutil.which("rustup") is None:
+        return []
+    try:
+        result = subprocess.run(
+            ["rustup", "toolchain", "list"],
+            capture_output=True, text=True, timeout=timeout,
+        )
+    except (OSError, subprocess.TimeoutExpired):
+        return []
+    if result.returncode != 0:
+        return []
+    toolchains = []
+    for line in (result.stdout or "").splitlines():
+        line = line.strip()
+        if not line:
+            continue
+        # `rustup toolchain list` suffixes the active one with "(default)"
+        # (and possibly "(override)") — strip it, `--toolchain` wants the
+        # bare name.
+        toolchains.append(line.split()[0])
+    return toolchains
+
+
+def _toolchain_has_target(toolchain: str, target: str, timeout: float) -> bool:
+    try:
+        result = subprocess.run(
+            ["rustup", "target", "list", "--installed", "--toolchain", toolchain],
+            capture_output=True, text=True, timeout=timeout,
+        )
+    except (OSError, subprocess.TimeoutExpired):
+        return False
+    if result.returncode != 0:
+        return False
+    installed = {line.strip() for line in (result.stdout or "").splitlines() if line.strip()}
+    return target in installed
+
+
+def _probe_windows_msvc_target(prereq: Prereq, timeout: float) -> ToolProbe:
+    """`custom_probe` backing the `windows` capability's cross-target check
+    (#2952). See the module comment above `WINDOWS_MSVC_TARGET` for why this
+    cannot be a plain binary probe."""
+    toolchains = _rustup_toolchains(timeout)
+    if not toolchains:
+        return ToolProbe(
+            tool=prereq.tool, capability=prereq.capability, found=False,
+            version=None, min_version=prereq.min_version, meets_floor=None,
+            what_breaks=(
+                "rustup reports no installed toolchains (or rustup itself "
+                f"is missing on PATH) — {prereq.what_breaks}"
+            ),
+        )
+    missing = [
+        tc for tc in toolchains
+        if not _toolchain_has_target(tc, WINDOWS_MSVC_TARGET, timeout)
+    ]
+    if missing:
+        return ToolProbe(
+            tool=prereq.tool, capability=prereq.capability, found=False,
+            version=None, min_version=prereq.min_version, meets_floor=None,
+            what_breaks=(
+                f"{WINDOWS_MSVC_TARGET} missing from toolchain(s) "
+                f"{', '.join(missing)} — {prereq.what_breaks}"
+            ),
+        )
+    return ToolProbe(
+        tool=prereq.tool, capability=prereq.capability, found=True,
+        version=", ".join(sorted(toolchains)), min_version=prereq.min_version,
+        meets_floor=None, what_breaks=prereq.what_breaks,
+    )
+
+
 # Required on every machine, no matter its declared capabilities — coord
 # itself doesn't function without these.
 BASELINE_PREREQS: tuple[Prereq, ...] = (
@@ -378,6 +474,33 @@ CAPABILITY_PREREQS: tuple[Prereq, ...] = (
         ),
         custom_probe=_probe_opencode,
     ),
+    # #2952: backs the `windows` capability — dell64's WSL-side cross-compile
+    # to `x86_64-pc-windows-msvc` via cargo-xwin, routing quadraui's
+    # `src/win/` (and vimcode's equivalent) Win-GUI work. Two independent
+    # things can silently regress in that one home directory: the
+    # `cargo-xwin` binary (`~/.cargo/bin`) and the rustup target (see
+    # `_probe_windows_msvc_target` above for why that one needs its own
+    # custom probe rather than a plain binary check).
+    Prereq(
+        tool="cargo-xwin", binary="cargo-xwin", version_args=("--version",),
+        version_re=r"(\d+\.\d+\.\d+\S*)", min_version=None, capability="windows",
+        what_breaks=(
+            "quadraui's `--target x86_64-pc-windows-msvc` cross-compile "
+            "cannot link against the MSVC CRT/SDK — `cargo install "
+            "cargo-xwin`"
+        ),
+    ),
+    Prereq(
+        tool="windows-msvc-target", binary="", version_args=(), version_re="",
+        min_version=None, capability="windows",
+        what_breaks=(
+            f"`rustup target add {WINDOWS_MSVC_TARGET}` is missing from an "
+            "installed toolchain — quadraui pins one in rust-toolchain.toml, "
+            "so add the target to it explicitly, not just the default "
+            "toolchain (#2952)"
+        ),
+        custom_probe=_probe_windows_msvc_target,
+    ),
 )
 
 ALL_PREREQS: tuple[Prereq, ...] = BASELINE_PREREQS + CAPABILITY_PREREQS

{code_coordinator-0.5.302 → code_coordinator-0.5.304}/coord/serve_app.py

@@ -2518,6 +2518,15 @@ def _board_response_schema(components: dict) -> dict:
                             "additionalProperties": {"type": "string"},
                         },
                         "has_approved_review": {"type": "boolean"},
+                        "uat_preview_url": {
+                            "type": ["string", "null"],
+                            "description": (
+                                "#2951: rendered UAT preview URL for this issue's "
+                                "PR, when the repo has opted in (Repo.uat_preview) "
+                                "and one could be resolved — null otherwise, "
+                                "including for every repo that hasn't opted in."
+                            ),
+                        },
                     },
                     "required": ["repo_name", "issue_number", "stages", "has_approved_review"],
                 },
@@ -5432,6 +5441,11 @@ def build_app(store: CoordStore, config: Config, *, token: str | None = None) ->
                     default_gates=list(_cfg.pipeline.default_gates),
                     require_plan=bool(_cfg.dispatch.require_plan),
                     ci_store=_ci,
+                    # #2951: resolves the UAT gate's per-repo opt-in
+                    # (Repo.uat_preview) so the "uat" badge only appears for
+                    # a repo that actually configured it, not fleet-wide
+                    # merely from "uat" in pipeline.default_gates.
+                    config=_cfg,
                 )
             except Exception:  # noqa: BLE001 — projection failure must not blank the board
                 projection["issue_stage_projection"] = []

{code_coordinator-0.5.302 → code_coordinator-0.5.304}/coord/stage_projection.py

@@ -79,6 +79,8 @@ class _AssignmentLike(Protocol):
     acceptance_state: str | None
     acceptance_total: int | None
     acceptance_passed: int | None
+    uat_state: str | None
+    uat_reason: str | None
 
 
 # ── Helpers ──────────────────────────────────────────────────────────────
@@ -319,6 +321,49 @@ def test_stage_status_for(
     return PENDING
 
 
+def uat_stage_status_for(
+    assignments_for_issue: list,
+    *,
+    is_closed: bool,
+    require_plan: bool,
+) -> str:
+    """The UAT box's status (#2687/#2951) — modelled directly on
+    :func:`test_stage_status_for`, which solves the identical "verdict is
+    stamped onto the work row, not a dedicated ``type="uat"`` assignment"
+    shape: ``coord uat <id> --passed|--failed`` writes ``uat_state``/
+    ``uat_reason`` straight onto the work row exactly the way ``coord test``
+    writes ``test_state``/``test_reason`` (see ``coord.state.
+    record_uat_verdict``).
+
+    Simpler than Test in two ways that both trace back to #2687's design
+    (see ``coord.merge_queue.evaluate_uat_verdict``'s docstring): there is
+    no ``"running"``/ACTIVE transient — ``coord uat`` records a human's
+    one-shot judgment on a rendered preview, not a re-runnable driver — and
+    no staleness re-check, since a UAT verdict isn't a measurement that a
+    moved SHA could invalidate the way a Test/Review verdict can.
+
+    Before this existed, ``stage_status_for``'s generic dispatcher matched
+    on assignment *type*, and nothing ever creates a ``type="uat"``
+    assignment — the badge sat PENDING forever regardless of the recorded
+    verdict (#2951 cause 2).
+    """
+    work_status = stage_status_for_internal_work(
+        assignments_for_issue, is_closed=is_closed, require_plan=require_plan
+    )
+    if work_status != DONE:
+        return SKIPPED if is_closed else PENDING
+
+    work = assignments_for_stage(assignments_for_issue, "work", require_plan=require_plan)
+    with_verdict = [a for a in work if (a.uat_state or "") != ""]
+    verdict_assignment = _latest_by_dispatch(with_verdict)
+    verdict = verdict_assignment.uat_state if verdict_assignment else None
+    if verdict == "passed":
+        return DONE
+    if verdict == "failed":
+        return FAILED
+    return PENDING
+
+
 def acceptance_stage_status_for(assignments_for_issue: list) -> str:
     """The Acceptance box's status (#932/#944) — reported and gated
     *separately* from the Test box (docs/ORACLE_LOOP.md), so this mirrors
@@ -448,6 +493,10 @@ def stage_status_for(
         return test_stage_status_for(
             assignments_for_issue, is_closed=is_closed, require_plan=require_plan
         )
+    if stage == "uat":
+        return uat_stage_status_for(
+            assignments_for_issue, is_closed=is_closed, require_plan=require_plan
+        )
 
     matching = assignments_for_stage(assignments_for_issue, stage, require_plan=require_plan)
     if stage == "review":
@@ -550,9 +599,68 @@ def issue_has_any_approved_review(
 # ── Board-level projection ──────────────────────────────────────────────
 
 
-def pipeline_stage_names(default_gates: list[str]) -> list[str]:
+def _repo_for(repo_name: str, config: Any | None) -> Any | None:
+    """Best-effort ``config.repo(repo_name)`` lookup, duck-typed the same
+    fail-soft way as ``coord.merge_queue._uat_repo_for`` — an unknown repo
+    name or a config stand-in without ``.repo()`` (a minimal test double)
+    is "can't confirm this repo opted in", not a crash. ``config`` is
+    already fully loaded by the caller (no file/network I/O happens here),
+    so this stays inside the module's "pure computation" contract."""
+    if config is None:
+        return None
+    try:
+        return config.repo(repo_name)
+    except Exception:  # noqa: BLE001 — unknown/malformed repo: no signal
+        return None
+
+
+def repo_has_uat_preview(repo_name: str, config: Any | None) -> bool:
+    """The per-repo half of ``coord.merge_queue.requires_uat``'s two-part
+    UAT opt-in (#2687) — the fleet-wide half (``"uat" in default_gates``) is
+    threaded separately as ``uat_enabled`` (see :func:`pipeline_stage_names`).
+    """
+    repo = _repo_for(repo_name, config)
+    return bool(repo is not None and getattr(repo, "uat_preview", None))
+
+
+def uat_preview_url_for(
+    repo_name: str,
+    issue_number: int | None,
+    merge_entry: Any | None,
+    config: Any | None,
+) -> str | None:
+    """Best-effort rendered UAT preview URL for this issue's PR (#2951 item
+    3) — mirrors the preview-resolution half of ``coord.merge_queue.
+    evaluate_uat_verdict`` (minus its ``coord uat`` command text, which the
+    caller can build itself from the assignment id it already has). Returns
+    ``None`` when the repo isn't configured or hasn't opted in."""
+    repo = _repo_for(repo_name, config)
+    if repo is None:
+        return None
+    return repo.resolve_uat_preview_url(
+        branch=getattr(merge_entry, "branch", None),
+        issue_number=issue_number,
+        pr_number=getattr(merge_entry, "pr_number", None),
+    )
+
+
+def pipeline_stage_names(default_gates: list[str], *, uat_enabled: bool = False) -> list[str]:
     """Mirrors ``pipeline.rs::pipeline_stage_names`` (module-default, no
-    per-issue plan-assignment prepend — see ``issue_stage_names``)."""
+    per-issue plan-assignment prepend — see ``issue_stage_names``), plus the
+    #2951 repo-awareness half ``pipeline.rs`` does not have yet (see that
+    issue's "The Rust mirror" section — ``coord-tui`` isn't a dispatchable
+    fleet repo, so this drifts from the Rust mirror on purpose until it is).
+
+    ``"uat"`` is a two-part opt-in (``coord.merge_queue.requires_uat``):
+    ``default_gates`` alone is only the FLEET-WIDE half. ``uat_enabled``
+    carries the caller's already-resolved per-repo half (``bool(repo and
+    repo.uat_preview)``) — this module has no config/repo lookup of its own
+    (see module docstring: pure computation, no I/O) — so a repo that
+    hasn't set ``uat_preview`` never gets the badge, no matter what
+    ``default_gates`` says. Defaults to ``False`` (hidden) rather than
+    ``True`` so a caller that forgets to resolve it fails toward "no repo
+    opted in" — the common case — not toward a fleet-wide false badge.
+    """
     stages = ["work"]
     for g in default_gates:
         # #1429: "merge" is restored to the per-issue stage-name ordering as
@@ -561,14 +669,20 @@ def pipeline_stage_names(default_gates: list[str]) -> list[str]:
         # affordance, not observation; merge is still initiated solely from
         # the Merge Queue panel). "work"/"plan" stay excluded here since
         # they're prepended explicitly above / by the caller.
-        if g not in ("work", "plan"):
-            stages.append(g)
+        if g in ("work", "plan"):
+            continue
+        if g == "uat" and not uat_enabled:
+            continue
+        stages.append(g)
     return stages
 
 
-def issue_stage_names(assignments_for_issue: list, default_gates: list[str]) -> list[str]:
-    """Mirrors ``pipeline.rs::pipeline_stage_names_for_issue``."""
-    stages = pipeline_stage_names(default_gates)
+def issue_stage_names(
+    assignments_for_issue: list, default_gates: list[str], *, uat_enabled: bool = False
+) -> list[str]:
+    """Mirrors ``pipeline.rs::pipeline_stage_names_for_issue`` (see
+    :func:`pipeline_stage_names` for the #2951 ``uat_enabled`` addendum)."""
+    stages = pipeline_stage_names(default_gates, uat_enabled=uat_enabled)
     if stages[0] != "plan" and _issue_has_plan_assignment(assignments_for_issue):
         stages = ["plan", *stages]
     return stages
@@ -582,6 +696,8 @@ def compute_issue_projection(
     require_plan: bool,
     default_gates: list[str],
     ci_store: Any | None = None,
+    uat_enabled: bool = False,
+    uat_preview_url: str | None = None,
 ) -> dict[str, Any]:
     """Compute the full per-issue stage badge dict.
 
@@ -592,8 +708,17 @@ def compute_issue_projection(
     loop below already produces the correct value) — plus a redundant explicit
     ``merge`` assignment as a defensive fallback in case ``merge`` is ever
     absent from ``names`` again (e.g. a future ``default_gates`` without it).
+
+    ``uat_enabled`` (#2951) is the caller's already-resolved per-repo half of
+    ``requires_uat``'s two-part opt-in — see :func:`pipeline_stage_names` —
+    so ``"uat"`` only appears in ``stages`` for a repo that actually
+    configured ``Repo.uat_preview``. ``uat_preview_url`` is the rendered
+    preview link for THIS issue's PR when available (``None`` otherwise);
+    carried through unconditionally so a caller can show it next to the
+    badge instead of sending the operator to ``coord merge``'s refusal
+    message to find it (#2951 item 3).
     """
-    names = issue_stage_names(assignments_for_issue, default_gates)
+    names = issue_stage_names(assignments_for_issue, default_gates, uat_enabled=uat_enabled)
     stages: dict[str, str] = {}
     for name in names:
         stages[name] = stage_status_for(
@@ -619,6 +744,7 @@ def compute_issue_projection(
     return {
         "stages": stages,
         "acceptance_progress": acceptance_progress_for(assignments_for_issue),
+        "uat_preview_url": uat_preview_url if uat_enabled else None,
         "has_approved_review": issue_has_any_approved_review(
             assignments_for_issue,
             seed_work_id=merge_entry.assignment_id if merge_entry is not None else None,
@@ -634,6 +760,7 @@ def compute_board_stage_projection(
     default_gates: list[str],
     require_plan: bool = False,
     ci_store: Any | None = None,
+    config: Any | None = None,
 ) -> list[dict[str, Any]]:
     """Compute the per-issue stage projection for every issue that appears
     on the board — the payload injected into ``GET /board`` as
@@ -643,6 +770,15 @@ def compute_board_stage_projection(
     ``issues`` table (open + recently-synced) and every assignment's
     ``(repo_name, issue_number)`` (so closed issues with assignment history
     still get a projection, matching what the TUI's Pipeline tab shows).
+
+    ``config`` (#2951) is the ONLY place in this module that resolves the
+    per-repo half of the UAT gate's two-part opt-in — every issue on a given
+    repo shares the same ``repo_has_uat_preview`` answer, so it's resolved
+    once here (not re-derived per-issue by lower functions, which take the
+    already-resolved ``uat_enabled``/``uat_preview_url`` as plain values).
+    ``None`` (the default — e.g. a caller with no config loaded) means no
+    repo is treated as opted in, matching :func:`pipeline_stage_names`'s own
+    fail-toward-hidden default.
     """
     is_closed_by_key: dict[tuple[str, int], bool] = {
         (i["repo_name"], i["number"]): str(i.get("state", "")).lower() == "closed"
@@ -681,17 +817,29 @@ def compute_board_stage_projection(
 
     keys = set(is_closed_by_key) | set(assignments_by_key)
 
+    uat_enabled_by_repo: dict[str, bool] = {}
+
     result: list[dict[str, Any]] = []
     for repo_name, issue_number in keys:
         key = (repo_name, issue_number)
         issue_assignments = assignments_by_key.get(key, [])
+        merge_entry = merge_by_key.get(key)
+        if repo_name not in uat_enabled_by_repo:
+            uat_enabled_by_repo[repo_name] = repo_has_uat_preview(repo_name, config)
+        uat_enabled = uat_enabled_by_repo[repo_name]
         entry = compute_issue_projection(
             issue_assignments,
-            merge_by_key.get(key),
+            merge_entry,
             is_closed=is_closed_by_key.get(key, False),
             require_plan=require_plan,
             default_gates=default_gates,
             ci_store=ci_store,
+            uat_enabled=uat_enabled,
+            uat_preview_url=(
+                uat_preview_url_for(repo_name, issue_number, merge_entry, config)
+                if uat_enabled
+                else None
+            ),
         )
         entry["repo_name"] = repo_name
         entry["issue_number"] = issue_number

{code_coordinator-0.5.302 → code_coordinator-0.5.304}/tests/test_prereqs.py

@@ -534,6 +534,171 @@ class TestProviderOpencodeCapabilityManifest:
         assert "not found" in unmet["provider:opencode"][0]
 
 
+class TestWindowsCapabilityManifest:
+    """#2952: `windows` (dell64's WSL-side cross-compile to
+    x86_64-pc-windows-msvc) is backed by two independent prereqs — the
+    `cargo-xwin` binary and the rustup target, checked per-toolchain."""
+
+    def _windows_prereqs(self):
+        return [p for p in prereqs.CAPABILITY_PREREQS if p.capability == "windows"]
+
+    def test_backed_by_cargo_xwin_and_the_msvc_target(self) -> None:
+        assert {p.tool for p in self._windows_prereqs()} == {
+            "cargo-xwin", "windows-msvc-target",
+        }
+
+    def test_probe_all_covers_it_only_when_declared(self) -> None:
+        with patch("coord.prereqs.shutil.which", return_value=None):
+            probes = prereqs.probe_all(["windows"])
+        assert {"cargo-xwin", "windows-msvc-target"} <= set(probes)
+        assert "cargo" not in probes
+
+        with patch("coord.prereqs.shutil.which", return_value=None):
+            probes_undeclared = prereqs.probe_all(["rust"])
+        assert "cargo-xwin" not in probes_undeclared
+        assert "windows-msvc-target" not in probes_undeclared
+
+    def test_cargo_xwin_missing_binary_reports_not_found(self) -> None:
+        with patch("coord.prereqs.shutil.which", return_value=None):
+            probes = prereqs.probe_all(["windows"])
+        assert probes["cargo-xwin"].found is False
+        assert probes["cargo-xwin"].ok is False
+
+    def test_cargo_xwin_present_extracts_version(self) -> None:
+        with patch("coord.prereqs.shutil.which", return_value="/root/.cargo/bin/cargo-xwin"), \
+             patch(
+                 "coord.prereqs.subprocess.run",
+                 return_value=_Result(stdout="cargo-xwin 0.17.5\n", returncode=0),
+             ):
+            probes = prereqs.probe_all(["windows"])
+        assert probes["cargo-xwin"].found is True
+        assert probes["cargo-xwin"].version == "0.17.5"
+        assert probes["cargo-xwin"].ok is True
+
+    def test_target_probe_is_a_custom_probe_not_a_binary_check(self) -> None:
+        """No single binary's `--version` answers "is the target
+        installed" — this prereq must delegate entirely to a custom probe,
+        never fall through to the generic `shutil.which` path."""
+        target_prereq = next(
+            p for p in self._windows_prereqs() if p.tool == "windows-msvc-target"
+        )
+        assert target_prereq.custom_probe is not None
+
+    def test_target_missing_when_rustup_itself_is_absent(self) -> None:
+        with patch("coord.prereqs.shutil.which", return_value=None):
+            probes = prereqs.probe_all(["windows"])
+        assert probes["windows-msvc-target"].found is False
+        assert "no installed toolchains" in probes["windows-msvc-target"].what_breaks
+
+    def test_target_present_on_the_only_installed_toolchain(self) -> None:
+        def fake_run(cmd, **kwargs):
+            if cmd[:2] == ["rustup", "toolchain"]:
+                return _Result(stdout="stable-x86_64-unknown-linux-gnu (default)\n", returncode=0)
+            if cmd[:2] == ["rustup", "target"]:
+                return _Result(
+                    stdout="x86_64-pc-windows-msvc\nx86_64-unknown-linux-gnu\n",
+                    returncode=0,
+                )
+            return _Result(returncode=0)
+
+        with patch("coord.prereqs.shutil.which", return_value="/usr/bin/rustup"), \
+             patch("coord.prereqs.subprocess.run", side_effect=fake_run):
+            probes = prereqs.probe_all(["windows"])
+        assert probes["windows-msvc-target"].found is True
+        assert probes["windows-msvc-target"].ok is True
+
+    def test_target_missing_from_the_pinned_toolchain_reports_unmet(self) -> None:
+        """The #2952 trap: the target was added to the default toolchain
+        but not to quadraui's `rust-toolchain.toml` pin (1.97.1) — a probe
+        that only checked the default toolchain would report MET while
+        quadraui's own build still fails. Must check every toolchain and
+        name the offending one."""
+        def fake_run(cmd, **kwargs):
+            if cmd[:2] == ["rustup", "toolchain"]:
+                return _Result(
+                    stdout=(
+                        "stable-x86_64-unknown-linux-gnu (default)\n"
+                        "1.97.1-x86_64-unknown-linux-gnu\n"
+                    ),
+                    returncode=0,
+                )
+            if cmd[:2] == ["rustup", "target"]:
+                toolchain = cmd[cmd.index("--toolchain") + 1]
+                if toolchain == "1.97.1-x86_64-unknown-linux-gnu":
+                    return _Result(stdout="x86_64-unknown-linux-gnu\n", returncode=0)
+                return _Result(
+                    stdout="x86_64-pc-windows-msvc\nx86_64-unknown-linux-gnu\n",
+                    returncode=0,
+                )
+            return _Result(returncode=0)
+
+        with patch("coord.prereqs.shutil.which", return_value="/usr/bin/rustup"), \
+             patch("coord.prereqs.subprocess.run", side_effect=fake_run):
+            probes = prereqs.probe_all(["windows"])
+        result = probes["windows-msvc-target"]
+        assert result.found is False
+        assert result.ok is False
+        assert "1.97.1-x86_64-unknown-linux-gnu" in result.what_breaks
+
+    def test_target_probe_never_raises_on_a_broken_rustup(self) -> None:
+        with patch("coord.prereqs.shutil.which", return_value="/usr/bin/rustup"), \
+             patch(
+                 "coord.prereqs.subprocess.run",
+                 side_effect=subprocess.TimeoutExpired(cmd="rustup", timeout=10),
+             ):
+            probes = prereqs.probe_all(["windows"])
+        assert probes["windows-msvc-target"].found is False
+        assert probes["windows-msvc-target"].ok is False
+
+    def test_unmet_when_cargo_xwin_missing(self) -> None:
+        probes = {
+            "cargo-xwin": prereqs.ToolProbe(
+                tool="cargo-xwin", capability="windows", found=False, version=None,
+                min_version=None, meets_floor=None, what_breaks="",
+            ),
+            "windows-msvc-target": prereqs.ToolProbe(
+                tool="windows-msvc-target", capability="windows", found=True,
+                version="stable", min_version=None, meets_floor=None, what_breaks="",
+            ),
+        }
+        unmet = prereqs.unmet_capabilities(["windows"], probes)
+        assert "windows" in unmet
+        assert len(unmet["windows"]) == 1
+        assert "cargo-xwin not found" in unmet["windows"][0]
+
+    def test_unmet_when_target_missing(self) -> None:
+        probes = {
+            "cargo-xwin": prereqs.ToolProbe(
+                tool="cargo-xwin", capability="windows", found=True, version="0.17.5",
+                min_version=None, meets_floor=None, what_breaks="",
+            ),
+            "windows-msvc-target": prereqs.ToolProbe(
+                tool="windows-msvc-target", capability="windows", found=False,
+                version=None, min_version=None, meets_floor=None, what_breaks="",
+            ),
+        }
+        unmet = prereqs.unmet_capabilities(["windows"], probes)
+        assert "windows" in unmet
+        assert "windows-msvc-target not found" in unmet["windows"][0]
+
+    def test_met_when_both_probes_pass(self) -> None:
+        probes = {
+            tool: prereqs.ToolProbe(
+                tool=tool, capability="windows", found=True, version="x",
+                min_version=None, meets_floor=None, what_breaks="",
+            )
+            for tool in ("cargo-xwin", "windows-msvc-target")
+        }
+        assert prereqs.unmet_capabilities(["windows"], probes) == {}
+
+    def test_all_capability_names_includes_windows(self) -> None:
+        """#2952 acceptance: `ALL_CAPABILITY_NAMES` is derived from
+        `CAPABILITY_PREREQS`, so adding these two entries must pick
+        `windows` up automatically — no separate registration needed for a
+        config-free agent to probe it too (see TestAllCapabilityNames)."""
+        assert "windows" in prereqs.ALL_CAPABILITY_NAMES
+
+
 class TestGhFloorIsSingleSourceOfTruth:
     def test_baseline_gh_prereq_imports_the_floor(self) -> None:
         """#1564's constant stays the single source of truth — this module