code-coordinator 0.5.554__tar.gz → 0.5.556__tar.gz

{code_coordinator-0.5.554 → code_coordinator-0.5.556}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: code-coordinator
-Version: 0.5.554
+Version: 0.5.556
 Summary: Coordinate Claude Code workers across multiple machines and repos.
 Author-email: John Donaghy <johnfdonaghy@gmail.com>
 License-Expression: LicenseRef-FSL-1.1-MIT
@@ -38,6 +38,8 @@ Requires-Dist: comtypes>=1.2; sys_platform == "win32" and extra == "win-native"
 Provides-Extra: mac-native
 Requires-Dist: pyobjc-framework-Quartz>=10.0; sys_platform == "darwin" and extra == "mac-native"
 Requires-Dist: pyobjc-framework-ApplicationServices>=10.0; sys_platform == "darwin" and extra == "mac-native"
+Provides-Extra: gtk-native
+Requires-Dist: PyGObject>=3.46; sys_platform == "linux" and extra == "gtk-native"
 Provides-Extra: all
 Requires-Dist: code-coordinator[server]; extra == "all"
 Requires-Dist: code-coordinator[reports-xlsx]; extra == "all"

{code_coordinator-0.5.554 → code_coordinator-0.5.556}/code_coordinator.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: code-coordinator
-Version: 0.5.554
+Version: 0.5.556
 Summary: Coordinate Claude Code workers across multiple machines and repos.
 Author-email: John Donaghy <johnfdonaghy@gmail.com>
 License-Expression: LicenseRef-FSL-1.1-MIT
@@ -38,6 +38,8 @@ Requires-Dist: comtypes>=1.2; sys_platform == "win32" and extra == "win-native"
 Provides-Extra: mac-native
 Requires-Dist: pyobjc-framework-Quartz>=10.0; sys_platform == "darwin" and extra == "mac-native"
 Requires-Dist: pyobjc-framework-ApplicationServices>=10.0; sys_platform == "darwin" and extra == "mac-native"
+Provides-Extra: gtk-native
+Requires-Dist: PyGObject>=3.46; sys_platform == "linux" and extra == "gtk-native"
 Provides-Extra: all
 Requires-Dist: code-coordinator[server]; extra == "all"
 Requires-Dist: code-coordinator[reports-xlsx]; extra == "all"

{code_coordinator-0.5.554 → code_coordinator-0.5.556}/code_coordinator.egg-info/SOURCES.txt

@@ -173,6 +173,7 @@ coord/uat_checks.py
 coord/usage.py
 coord/usage_limits.py
 coord/usage_rollup.py
+coord/win_native_bridge.py
 coord/win_native_driver.py
 coord/worker_events.py
 coord/agents/opencode/.gitignore
@@ -694,7 +695,9 @@ tests/test_hooks.py
 tests/test_housekeeping.py
 tests/test_human_attended_437.py
 tests/test_init.py
+tests/test_install_agent_capabilities_3515.py
 tests/test_install_agent_venv_2911.py
+tests/test_install_agent_wsl_bridge_3515.py
 tests/test_integration.py
 tests/test_interactive.py
 tests/test_interactive_briefing_echo.py
@@ -877,6 +880,7 @@ tests/test_usage_rollup.py
 tests/test_venv_live_install_2121.py
 tests/test_version_single_source.py
 tests/test_watch.py
+tests/test_win_native_bridge.py
 tests/test_win_native_driver.py
 tests/test_windows_job_is_a_real_gate_2000.py
 tests/test_worker_env_venv_isolation.py

{code_coordinator-0.5.554 → code_coordinator-0.5.556}/code_coordinator.egg-info/requires.txt

@@ -22,6 +22,11 @@ setuptools>=68
 setuptools-scm>=8
 wheel
 
+[gtk-native]
+
+[gtk-native:sys_platform == "linux"]
+PyGObject>=3.46
+
 [mac-native]
 
 [mac-native:sys_platform == "darwin"]

{code_coordinator-0.5.554 → code_coordinator-0.5.556}/code_coordinator.egg-info/scm_file_list.json

@@ -301,6 +301,7 @@
     "coord/usage.py",
     "coord/usage_limits.py",
     "coord/usage_rollup.py",
+    "coord/win_native_bridge.py",
     "coord/win_native_driver.py",
     "coord/worker_events.py",
     "coordinator.example.yml",
@@ -721,7 +722,9 @@
     "tests/test_housekeeping.py",
     "tests/test_human_attended_437.py",
     "tests/test_init.py",
+    "tests/test_install_agent_capabilities_3515.py",
     "tests/test_install_agent_venv_2911.py",
+    "tests/test_install_agent_wsl_bridge_3515.py",
     "tests/test_integration.py",
     "tests/test_interactive.py",
     "tests/test_interactive_briefing_echo.py",
@@ -904,6 +907,7 @@
     "tests/test_venv_live_install_2121.py",
     "tests/test_version_single_source.py",
     "tests/test_watch.py",
+    "tests/test_win_native_bridge.py",
     "tests/test_win_native_driver.py",
     "tests/test_windows_job_is_a_real_gate_2000.py",
     "tests/test_worker_env_venv_isolation.py",

code_coordinator-0.5.556/code_coordinator.egg-info/scm_version.json

@@ -0,0 +1,8 @@
+{
+  "tag": "0.5.556",
+  "distance": 0,
+  "node": "gde6caedc9afc7f0f9a375055f1468dc8f6f1b27b",
+  "dirty": false,
+  "branch": "HEAD",
+  "node_date": "2026-10-02"
+}

{code_coordinator-0.5.554 → code_coordinator-0.5.556}/coord/acceptance_drivers.py

@@ -78,7 +78,12 @@ in :mod:`coord.win_native_driver` — see that module's docstring for the spec
 format. This adapter (:func:`_run_win_native`) is the same thin seam
 :func:`_run_tui_pty` is: it resolves the native spec from the driver's
 ``entrypoint:`` and hands off to
-:func:`coord.win_native_driver.run_native_spec`.
+:func:`coord.win_native_driver.run_native_spec` — or, on a WSL-hosted agent
+(dell64, ``docs/WSL_WINDOWS_WORKER.md``), to
+:func:`coord.win_native_bridge.run_native_spec_via_bridge`, which runs the
+spec on a real Windows-side Python found through WSL's own interop instead
+(#3515 — see that module's docstring for why `comtypes` can never resolve
+in-process on a WSL-hosted agent no matter what gets pip-installed there).
 
 ``mac-native`` (#3485, the macOS-native tier alongside ``win-native``)
 launches the driven repo's real compiled ``.app``/binary and drives it with
@@ -143,6 +148,7 @@ import re
 import subprocess
 import tempfile
 import xml.etree.ElementTree as ET
+from collections.abc import Iterable, Mapping
 from dataclasses import dataclass, field
 from pathlib import Path
 
@@ -154,6 +160,92 @@ SUPPORTED_KINDS = (
     "win-native", "mac-native", "gtk-native",
 )
 
+# #3515: the one place a machine's `capabilities` (coordinator.yml) map to
+# the `pyproject.toml` optional-dependency extra its Tier-2 lane driver
+# actually needs installed. No fleet roll or agent update ever pulled these
+# in before this — a lane only worked if someone hand-installed into
+# `~/.coord-venv`, and the next `coord agent update`/`coord release
+# propagate` rebuilt that venv from scratch and silently wiped it (observed
+# live 2026-10-01: `gi` hand-installed on precision, `pyte` missing
+# everywhere a Tier-2 lane runs). Kept here, next to :data:`SUPPORTED_KINDS`
+# — the same "one question, one answer" reasoning (epic #2096): `coord.
+# agent_app`'s self-update, `coord.release_propagate`'s fleet roll and
+# `install-agent.sh`'s bootstrap must all resolve a machine's required
+# extras through this ONE mapping, never three independently-drifting
+# copies.
+LANE_CAPABILITY_EXTRAS: dict[str, str] = {
+    "windows": "win-native",
+    "macos": "mac-native",
+    "gtk": "gtk-native",
+}
+
+
+def repos_requiring_tui_pty(drivers: Mapping[str, object]) -> frozenset[str]:
+    """Repo names (keys of `coordinator.yml`'s `acceptance.drivers`) that
+    declare a ``tui-pty``-kind acceptance driver somewhere — the flat form,
+    or one of its ``routes`` (#1125 in-repo path routing).
+
+    Duck-typed (``getattr``, not an import of
+    ``coord.config.AcceptanceDriverConfig``) for the same reason
+    :mod:`coord.bugbash` duck-types its own config parameter rather than
+    importing :mod:`coord.config`: this module is foundational and widely
+    imported, so taking a dependency on the config module risks a cycle the
+    other direction never needs — the same posture :data:`TIER2_LANE_KINDS`'s
+    docstring (``coord.config``) describes from the other side.
+    """
+    out: set[str] = set()
+    for repo_name, entry in drivers.items():
+        kind = getattr(entry, "kind", "")
+        routes = getattr(entry, "routes", None) or ()
+        if kind == "tui-pty" or any(
+            getattr(route, "kind", "") == "tui-pty" for route in routes
+        ):
+            out.add(repo_name)
+    return frozenset(out)
+
+
+def lane_extras_for_machine(
+    capabilities: Iterable[str],
+    *,
+    repos: Iterable[str] = (),
+    tui_pty_repos: frozenset[str] | None = None,
+) -> list[str]:
+    """The `pyproject.toml` lane extras a machine with *capabilities* needs
+    installed alongside `server` (#3515).
+
+    ``windows``/``macos``/``gtk`` each map straight through
+    :data:`LANE_CAPABILITY_EXTRAS`. ``tui-pty`` is different: it isn't a
+    machine capability at all, it's a property of *which repos* a host
+    serves — "is this host in a repo's `tui-pty` route" — so it's derived
+    from *repos* (a machine's own `coordinator.yml` `repos:` list)
+    intersected against *tui_pty_repos* (every repo name
+    :func:`repos_requiring_tui_pty` found to declare one).
+
+    *tui_pty_repos* is ``None`` when the caller only has the machine's own
+    capabilities/repos in hand, never the fleet-wide, repo-keyed
+    `acceptance.drivers` map needed to compute it properly — the agent's own
+    in-process self-update fallback (`coord.agent_app._agent_pkg_spec`) is
+    exactly that caller. In that case this falls back to the conservative
+    default: any host that already needs a native lane extra needs
+    `tui-pty` too, because every native lane observed in #3515's own
+    incident table also needed `pyte`, and `tui-pty` is pure-Python (no
+    C-extension/version-skew cost — the same reasoning `pyproject.toml`'s
+    own comment on the extra gives), so installing it somewhere that turns
+    out not to need it costs nothing. A caller that DOES have the full
+    config (`coord.release_propagate`, which has `cfg.acceptance.drivers`)
+    passes the exact computed set instead, which may be empty even when
+    *extras* is non-empty (a win-native host that serves no `tui-pty`-kind
+    repo) — passing ``frozenset()`` explicitly opts OUT of the fallback.
+    """
+    caps = set(capabilities)
+    extras = [extra for cap, extra in LANE_CAPABILITY_EXTRAS.items() if cap in caps]
+    if tui_pty_repos is None:
+        if extras:
+            extras.append("tui-pty")
+    elif set(repos) & tui_pty_repos:
+        extras.append("tui-pty")
+    return extras
+
 # #2748 (IL-2): driver kinds whose `run` produces a real pass/fail verdict
 # but NOT yet a deterministic one, because an input they depend on hasn't
 # shipped. `web-playwright` is the one case today — the driver itself
@@ -745,20 +837,30 @@ def _run_win_native(run_command: str, cwd: str, entrypoint: str, *, timeout: int
     ``capture_b64`` ``PrintWindow`` snapshot) into a :class:`DriverResult`
     the same way :func:`_run_tui_pty` does.
 
+    **The WSL case (#3515).** `ctypes.windll`/`comtypes` have no meaning
+    outside a genuine Win32 process, so a WSL-hosted ``windows``-capability
+    agent (dell64, ``docs/WSL_WINDOWS_WORKER.md``) can never run
+    :func:`coord.win_native_driver.run_native_spec` in-process no matter
+    what gets pip-installed into its own (Linux) venv. :func:`coord.
+    win_native_bridge.is_wsl_host` detects that case and routes through
+    :func:`coord.win_native_bridge.run_native_spec_via_bridge` instead,
+    which bootstraps a real Windows-side Python reachable through WSL's own
+    interop and runs the spec on THAT interpreter — see that module's
+    docstring for the full mechanism. A native-Windows agent (or any
+    non-WSL host, including every test in this suite) takes the in-process
+    path unchanged.
+
     Raises :class:`DriverError` — never a bare exception — for a missing
-    ``entrypoint:``, a spec file that doesn't exist, or a malformed spec
-    (an invalid-YAML/unknown-step-type
-    :class:`coord.win_native_driver.WinNativeSpecError`). A process that
-    never launches, a window that never appears, or a failed probe do NOT
-    raise here — :func:`coord.win_native_driver.run_native_spec` folds those
-    into individual failing entries in ``tests`` instead.
+    ``entrypoint:``, a spec file that doesn't exist, a malformed spec (an
+    invalid-YAML/unknown-step-type
+    :class:`coord.win_native_driver.WinNativeSpecError`), or — WSL only — a
+    :class:`coord.win_native_bridge.WinNativeBridgeError` (the Windows-side
+    Python couldn't be found/bootstrapped, or the bridge subprocess itself
+    failed to run). A process that never launches, a window that never
+    appears, or a failed probe do NOT raise either way — both
+    :func:`coord.win_native_driver.run_native_spec` and the bridge fold
+    those into individual failing entries in ``tests`` instead.
     """
-    from coord.win_native_driver import (  # noqa: PLC0415 — see module docstring on the deferred import
-        WinNativeRuntimeError,
-        WinNativeSpecError,
-        run_native_spec,
-    )
-
     if not entrypoint:
         raise DriverError(
             "win-native driver requires an `entrypoint:` naming the native "
@@ -773,14 +875,33 @@ def _run_win_native(run_command: str, cwd: str, entrypoint: str, *, timeout: int
     except OSError as e:
         raise DriverError(f"win-native spec could not be read: {spec_path}: {e}") from e
 
-    try:
-        tests = run_native_spec(
-            spec_text, launch_command=run_command, cwd=cwd, timeout=timeout,
+    from coord.win_native_bridge import (  # noqa: PLC0415 — see module docstring on the deferred import
+        WinNativeBridgeError,
+        is_wsl_host,
+        run_native_spec_via_bridge,
+    )
+
+    if is_wsl_host():
+        try:
+            tests = run_native_spec_via_bridge(
+                spec_text, run_command=run_command, cwd=cwd, timeout=timeout,
+            )
+        except WinNativeBridgeError as e:
+            raise DriverError(f"win-native WSL bridge could not run: {e}") from e
+    else:
+        from coord.win_native_driver import (  # noqa: PLC0415 — see module docstring on the deferred import
+            WinNativeRuntimeError,
+            WinNativeSpecError,
+            run_native_spec,
         )
-    except WinNativeSpecError as e:
-        raise DriverError(f"win-native spec is invalid: {e}") from e
-    except WinNativeRuntimeError as e:
-        raise DriverError(f"win-native driver could not run: {e}") from e
+        try:
+            tests = run_native_spec(
+                spec_text, launch_command=run_command, cwd=cwd, timeout=timeout,
+            )
+        except WinNativeSpecError as e:
+            raise DriverError(f"win-native spec is invalid: {e}") from e
+        except WinNativeRuntimeError as e:
+            raise DriverError(f"win-native driver could not run: {e}") from e
 
     # #3510: a locked/absent interactive session reports a distinct
     # "unavailable" status (coord.win_native_driver's session precheck),

{code_coordinator-0.5.554 → code_coordinator-0.5.556}/coord/agent.py

@@ -3795,6 +3795,39 @@ internal-only change (CLAUDE.md's existing exemption), say so explicitly \
 in your final message instead — that already satisfies the reviewer, no \
 test required.
 
+#3502: this ONLY applies to `type="work"` assignments — the ones whose \
+merge auto-closes the linked issue (`CLOSES_ISSUE_TYPES` in \
+`coord/models.py`). If you were dispatched as `mock-author`, \
+`test-author`, or `epic-decompose`, the `issue_number` you were given is \
+a milestone's TRACKING issue, not one your merge closes — this marker is \
+meaningless on those legs and you should omit it. For `type="work"`: your \
+PR merging does NOT automatically mean issue it's for is \
+actually resolved. If merging this PR would make the coordinator \
+auto-close the issue, but you know the issue's own problem is NOT fully \
+fixed — root cause lives in another repo and only a dependent half of \
+the fix landed here, this PR is investigation-only (no production change, \
+or only one hypothesis ruled out), or you only confirmed a symptom \
+without fixing the cause — say so explicitly, right before your \
+SMOKE_TESTS block:
+
+  ISSUE_RESOLUTION: partial — <what remains, in one sentence>
+
+or
+
+  ISSUE_RESOLUTION: investigation — <what you ruled out / what's still \
+unknown>
+
+Omit the line entirely (it defaults to `resolved`, today's behaviour) \
+when this PR genuinely fixes the issue. A drafted-but-unfiled upstream \
+issue — a bullet in a design doc, a TODO comment, a line in a tracking \
+markdown file — is NOT "filed"; only a real GitHub issue number counts, \
+so don't write `partial — see quadraui issue` unless that issue actually \
+exists and you name its number. This is read by the coordinator's merge \
+gate (not posted to GitHub by you — never run `gh` commands): a `partial`/ \
+`investigation` here keeps the issue OPEN after your PR merges, with a \
+comment on the issue quoting what remains, instead of auto-closing work \
+that still has a reported bug live.
+
 #252: before exiting, emit a SMOKE_TESTS block telling the human what to \
 manually verify.  You changed the code; you know what's worth poking.
 

{code_coordinator-0.5.554 → code_coordinator-0.5.556}/coord/agent_app.py

@@ -13,6 +13,7 @@ import sys
 import threading
 import time
 import urllib.request
+from collections.abc import Iterable
 from pathlib import Path
 from typing import Callable
 
@@ -32,7 +33,12 @@ from coord.platform_paths import venv_python as platform_venv_python
 _log = logging.getLogger(__name__)
 
 
-def _agent_pkg_spec() -> str:
+def _agent_pkg_spec(
+    *,
+    capabilities: Iterable[str] = (),
+    repos: Iterable[str] = (),
+    tui_pty_repos: frozenset[str] | None = None,
+) -> str:
     """What `POST /update` asks pip to install (#1237). An agent *is* the
     server half of the package, so it must reinstall itself WITH the
     `[server]` extra — a bare upgrade would, on a fresh venv, leave the
@@ -45,8 +51,54 @@ def _agent_pkg_spec() -> str:
     (`_do_update`'s existing try/except) turns that into an explicit
     `last_update.json` failure naming what was expected, instead of
     guessing.
+
+    #3515: ALSO folds in whichever Tier-2 lane extras *capabilities*/*repos*
+    need — `win-native`/`mac-native`/`gtk-native`/`tui-pty`
+    (`coord.acceptance_drivers.lane_extras_for_machine`, the one mapping
+    every install surface resolves through). Before this, no fleet roll or
+    agent update ever installed a lane driver's Python deps at all: a lane
+    only worked if someone hand-installed into `~/.coord-venv`, and the next
+    blue/green swap silently wiped it. Callers default to `()`/`None` (no
+    lane extras) rather than re-deriving them here, so a caller with no
+    capabilities/repos in hand — there is none left in this codebase, but a
+    future direct call — degrades to the pre-#3515 `[server]`-only spec
+    instead of raising.
+    """
+    from coord.acceptance_drivers import lane_extras_for_machine  # noqa: PLC0415 — avoid an import cycle
+
+    extras = ["server", *lane_extras_for_machine(
+        capabilities, repos=repos, tui_pty_repos=tui_pty_repos,
+    )]
+    return _dist_pkg_spec(extra=",".join(extras))
+
+
+def _tui_pty_repos_for_server(server: AgentServer) -> frozenset[str] | None:
+    """The repo-keyed `tui-pty` set `_agent_pkg_spec` needs (#3515), read
+    straight off whatever `coordinator.yml` this agent itself last loaded.
+
+    `AgentServer` keeps that full, freshly-reloaded `Config` (`acceptance`
+    included) on `_health_config` purely so `/health`'s own local checkout
+    probe can resolve repos the same way `coord health` does — see that
+    attribute's docstring in `coord.agent.AgentServer.__init__`. There is no
+    public accessor for it (nothing outside that one `/health` probe has
+    needed one before), so this reaches the private attribute directly
+    rather than widening `AgentServer`'s public surface for a single read.
+    `None` — the honest "don't know" the agent-only fallback in
+    `coord.acceptance_drivers.lane_extras_for_machine` expects — whenever
+    this agent is config-free, predates the `acceptance:` block, or hasn't
+    loaded a config at all (every case `getattr` degrades gracefully
+    through rather than raising).
     """
-    return _dist_pkg_spec(extra="server")
+    from coord.acceptance_drivers import repos_requiring_tui_pty  # noqa: PLC0415 — avoid an import cycle
+
+    cfg = getattr(server, "_health_config", None)
+    if cfg is None:
+        return None
+    acceptance = getattr(cfg, "acceptance", None)
+    drivers = getattr(acceptance, "drivers", None)
+    if drivers is None:
+        return None
+    return repos_requiring_tui_pty(drivers)
 
 
 #: The sibling systemd *user* units `POST /restart-services` (#2069) is
@@ -1408,7 +1460,7 @@ def build_app(
 
         Request body (JSON, optional)::
 
-            {"target_version": "0.4.85", "force": false}
+            {"target_version": "0.4.85", "force": false, "extras": ["gtk-native"]}
 
         #1568: when the caller (``coord agent update``) knows exactly which
         release it's asking for, it passes ``target_version``, pinning the
@@ -1417,6 +1469,19 @@ def build_app(
         matching distribution") instead of a silent no-op. ``target_version``
         is echoed back in ``last_update`` so ``/health`` lets the caller
         verify the upgrade actually landed.
+
+        #3515: ``extras`` lets a caller that already has the fleet-wide
+        picture in hand (``coord release propagate``, which resolves
+        :func:`coord.release_propagate.lane_extras_for_host` against the
+        full `coordinator.yml` — repos AND `acceptance.drivers`, not just
+        this one agent's own capabilities) OVERRIDE this agent's own
+        self-derived lane extras (:func:`_agent_pkg_spec`'s default, driven
+        off ``self.capabilities``/``self.repos`` and whatever `acceptance:`
+        this agent's own last-reloaded config happened to carry). Absent —
+        the default, and every pre-#3515 caller — this agent derives its own
+        extras, exactly as described there. `server` is **always** included
+        regardless of what's passed; a caller only ever needs to name the
+        LANE extras.
         """
         is_editable, project_path = _detect_install_mode()
         if is_editable:
@@ -1445,6 +1510,12 @@ def build_app(
             body = {}
         target_version = body.get("target_version") or None
         force = bool(body.get("force"))
+        raw_extras = body.get("extras")
+        explicit_extras: list[str] | None = (
+            [str(e) for e in raw_extras]
+            if isinstance(raw_extras, list) and raw_extras
+            else None
+        )
 
         # #2121 item 2: every install must name who asked for it. A caller
         # that knows (`coord release propagate`, `coord agent update`) says
@@ -1480,9 +1551,20 @@ def build_app(
             }
             try:
                 venv_dir = _venv_dir()
+                if explicit_extras is not None:
+                    lane_extras = explicit_extras
+                else:
+                    from coord.acceptance_drivers import lane_extras_for_machine  # noqa: PLC0415 — avoid an import cycle
+
+                    lane_extras = lane_extras_for_machine(
+                        server.capabilities,
+                        repos=server.repos,
+                        tui_pty_repos=_tui_pty_repos_for_server(server),
+                    )
+                pkg_spec = _dist_pkg_spec(extra=",".join(["server", *lane_extras]))
                 result = agent_update.perform_update(
                     venv_dir,
-                    _agent_pkg_spec(),
+                    pkg_spec,
                     target_version=target_version,
                     initiator=initiator,
                 )
@@ -1513,6 +1595,33 @@ def build_app(
                     _write_last_update(state_dir, payload)
                     return
 
+                # #3515: a WSL-hosted `windows`-capability agent (dell64,
+                # docs/WSL_WINDOWS_WORKER.md) just reinstalled `win-native`
+                # into its OWN (Linux) venv above, where `comtypes` correctly
+                # resolves to "skip it" — this ALSO bootstraps/refreshes the
+                # separate, real Windows-side venv `coord.win_native_bridge`
+                # needs, the same non-fatal "warn, never fail the update"
+                # posture `install-agent.sh`'s own bootstrap hook follows. A
+                # failure here must never turn an otherwise-successful swap
+                # into a reported update failure — `coord doctor`'s
+                # `comtypes` prereq (`coord.prereqs._probe_comtypes`) is the
+                # durable signal for this gap, not `last_update.json`.
+                if "win-native" in lane_extras:
+                    from coord.win_native_bridge import (  # noqa: PLC0415 — avoid an import cycle
+                        WinNativeBridgeError,
+                        ensure_windows_win_native_venv,
+                        is_wsl_host,
+                    )
+
+                    if is_wsl_host():
+                        try:
+                            ensure_windows_win_native_venv()
+                        except WinNativeBridgeError as e:
+                            _log.warning(
+                                "win-native WSL bridge bootstrap failed after "
+                                "agent update: %s", e,
+                            )
+
                 # #1241: prefer the version the smoke check already read
                 # straight from the new slot (deterministic, no reliance on
                 # this process's own site-packages resolution having

{code_coordinator-0.5.554 → code_coordinator-0.5.556}/coord/commands/release.py

@@ -1602,6 +1602,21 @@ def release_propagate(  # noqa: PLR0912, PLR0915 — a pipeline; the decisions a
     updated_hosts: list[str] = []
     local_name = _local_machine_name(config)
 
+    # #3515: resolved ONCE, up front — propagate has the full,
+    # just-loaded `config` (every machine's `repos:` AND the repo-keyed
+    # `acceptance.drivers` map) in hand, which is exactly the fleet-wide
+    # picture `coord.agent_app`'s own in-agent self-update fallback does
+    # NOT have. Passed explicitly to `_roll_python` below (even when
+    # empty) via `rp.lane_extras_for_host`, so this run's `/update` asks
+    # for the precise extras this host's capabilities/repos need rather
+    # than leaving each agent to guess from its own, possibly stale,
+    # last-reloaded config.
+    from coord.acceptance_drivers import repos_requiring_tui_pty  # noqa: PLC0415
+
+    tui_pty_repos = repos_requiring_tui_pty(
+        getattr(getattr(config, "acceptance", None), "drivers", None) or {}
+    )
+
     # #1835 review: plan_lanes() puts the daemon host's python lane first
     # specifically so "a caller must never reach an endpoint its daemon
     # predates" holds — but that is only true if a failure there actually
@@ -1664,6 +1679,10 @@ def release_propagate(  # noqa: PLR0912, PLR0915 — a pipeline; the decisions a
             ok, detail, serve_unit_ok = _roll_python(
                 machine, target_version=record.target_version,
                 agent_port=AGENT_PORT, timeout=timeout, force=force,
+                extras=rp.lane_extras_for_host(
+                    machine.capabilities, repos=machine.repos,
+                    tui_pty_repos=tui_pty_repos,
+                ),
             )
             if ok:
                 updated_hosts.append(roll.host)
@@ -2530,7 +2549,7 @@ def _local_machine_name(config) -> str | None:
 
 
 def _roll_python(machine, *, target_version: str, agent_port: int, timeout: float,
-                 force: bool) -> tuple[bool, str, bool]:
+                 force: bool, extras: "list[str] | None" = None) -> tuple[bool, str, bool]:
     """POST /update and wait for the agent to actually report the version.
 
     Success is judged by the version the agent reports, never by "the POST
@@ -2559,6 +2578,14 @@ def _roll_python(machine, *, target_version: str, agent_port: int, timeout: floa
       2026-08-10 incident's shape (dellserver's coord-serve was fine;
       coord-web was what failed). Callers deciding whether it's safe to
       let OTHER hosts proceed must key off ``serve_unit_ok``, not ``ok``.
+
+    #3515: *extras* — the python lane's pip extras BEYOND ``server``
+    (``coord.release_propagate.lane_extras_for_host``'s result, resolved by
+    the caller against the fleet-wide ``repos``/``acceptance.drivers``
+    picture) — are forwarded verbatim as ``/update``'s own ``extras`` field,
+    overriding that agent's in-process self-derivation. ``None``/``[]`` omits
+    the field entirely, so a pre-#3515 agent (one that predates the
+    ``extras`` body key) still gets exactly the request it always has.
     """
     from coord.agent_update import cli_initiator  # noqa: PLC0415
     from coord.commands.agent_ops import (  # noqa: PLC0415
@@ -2568,16 +2595,19 @@ def _roll_python(machine, *, target_version: str, agent_port: int, timeout: floa
     from coord.release_verify import DAEMON_UNIT  # noqa: PLC0415
 
     pre = _fetch_pre_started_at([machine])
+    update_body: dict = {
+        "target_version": target_version,
+        "force": force,
+        # #2121: the roll names itself on the target host's audit trail.
+        "initiator": cli_initiator(
+            f"coord release propagate -> {machine.name} python lane"
+        ),
+    }
+    if extras:
+        update_body["extras"] = extras
     status, body, error = _post(
         f"http://{machine.host}:{agent_port}/update",
-        {
-            "target_version": target_version,
-            "force": force,
-            # #2121: the roll names itself on the target host's audit trail.
-            "initiator": cli_initiator(
-                f"coord release propagate -> {machine.name} python lane"
-            ),
-        },
+        update_body,
         timeout=15.0,
     )
     if error: