code-coordinator 0.5.116__tar.gz → 0.5.117__tar.gz

{code_coordinator-0.5.116 → code_coordinator-0.5.117}/PKG-INFO

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

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

@@ -1,7 +1,7 @@
 {
-  "tag": "0.5.116",
+  "tag": "0.5.117",
   "distance": 0,
-  "node": "gf24de3d23e8fe5dd6998c12ce6e8fee637f65f25",
+  "node": "g8f82380a31b6a3d5fd2dea0b4528a11a28c52148",
   "dirty": false,
   "branch": "HEAD",
   "node_date": "2026-08-16"

{code_coordinator-0.5.116 → code_coordinator-0.5.117}/coord/agent.py

@@ -4416,9 +4416,26 @@ class AgentServer:
     #:                          capability that disappears simply stops
     #:                          attracting new work (degrade) instead of
     #:                          stranding anything in flight.
+    #:   * ``providers``      — #2326: rebuilt from ``providers.definitions``
+    #:                          at DISPATCH time (``assign()``, before
+    #:                          ``_resolve_provider``), not on a timer — that
+    #:                          is the only moment the answer matters. Before
+    #:                          #2326 this dict was parsed once at startup and
+    #:                          never invalidated, so an agent with its own
+    #:                          local ``coordinator.yml`` silently ran on a
+    #:                          days-stale provider definition (wrong model,
+    #:                          missing env) even though every coordinator-
+    #:                          side surface (``coord config``, the daemon's
+    #:                          own ``build_provider(...)``) showed the edit
+    #:                          as live. Any provider name in use by a
+    #:                          PENDING/RUNNING assignment is pinned to its
+    #:                          pre-reload entry (present or absent) —
+    #:                          swapping a live worker's provider identity
+    #:                          mid-flight (model, env, log-parser shape)
+    #:                          remains forbidden; only the NEXT dispatch
+    #:                          sees the new definition.
     #:
     #: RESTART-ONLY (documented at their assignment sites in ``__init__``):
-    #:   * ``providers``      — a live worker holds a resolved provider.
     #:   * ``bash_wrap_spawn`` / ``first_output_timeout`` — process tuning.
     #:   * bind host/port     — uvicorn has already bound the socket.
     _RELOADABLE_FIELDS = (
@@ -4427,6 +4444,7 @@ class AgentServer:
         "artifact_paths",
         "build_commands",
         "capabilities",
+        "providers",
     )
 
     def _maybe_reload_config(self) -> bool:
@@ -4491,6 +4509,40 @@ class AgentServer:
             self._apply_reloaded_config(reloaded, machine)
             return True
 
+    def _rebuild_providers(self, cfg: "Any") -> "dict[str, object] | None":
+        """Build a fresh provider registry from *cfg*'s ``providers.definitions``.
+
+        Mirrors the startup-time loop in
+        ``coord.commands.agent_ops._resolve_agent_startup`` (``build_provider``
+        for every entry), but — unlike startup — must never raise. A typo'd
+        ``providers.definitions`` entry reaching this agent via a hot reload
+        must not take a running daemon down; ``reload_config_if_stale``
+        already applies that same fail-soft contract to a malformed YAML
+        edit, and a config that parses fine but names an unknown provider
+        ``type`` deserves the identical treatment. Returns ``None`` (rather
+        than a partial dict) on any failure, so the caller keeps the
+        entire previous registry until the edit is fixed — matching the
+        "keep last-good config" behaviour for a bad ``coordinator.yml``.
+        """
+        from coord.providers import build_provider  # noqa: PLC0415
+
+        fresh: dict[str, object] = {}
+        try:
+            for name, defn in cfg.providers.definitions.items():
+                fresh[name] = build_provider(name, defn, cfg.models)
+        except Exception as exc:  # noqa: BLE001 — never let a bad edit kill the agent
+            _log.warning(
+                "coord agent: %s's providers.definitions failed to rebuild "
+                "(%s: %s); keeping the previous provider registry (%s) "
+                "until the edit is fixed",
+                cfg.path,
+                type(exc).__name__,
+                exc,
+                sorted(self._providers) if self._providers else "none configured",
+            )
+            return None
+        return fresh
+
     def _apply_reloaded_config(self, cfg: "Any", machine: "Any") -> None:
         """Swap the reloadable fields in place, pinning anything in flight.
 
@@ -4510,6 +4562,17 @@ class AgentServer:
         advertise *new* work only, so removing a repo correctly means "take no
         more dispatches for it", not "abandon the worker already running".
 
+        #2326: ``providers`` gets the exact same pin treatment, keyed by
+        provider *name* instead of repo name. A provider name in use by a
+        PENDING/RUNNING assignment keeps its pre-reload instance (including
+        absence) — ``_reap`` re-resolves the same ``spec`` after the worker
+        exits (to pick a log parser), and it must get back the SAME provider
+        identity ``assign()``/``_spawn()`` resolved, not one a reload swapped
+        underneath it (different model/env/log-parser shape). Any provider
+        name with no in-flight assignment is free to pick up the new
+        definition immediately — that is the entire point of #2326: the next
+        *dispatch*, not the next restart, sees a config edit.
+
         Every field is *rebound* to a freshly-built list/dict rather than
         mutated in place, so the many unsynchronized readers elsewhere in this
         class (``_servable_repos``, ``_stash_artifacts``, ``assign``, ...) see
@@ -4525,6 +4588,11 @@ class AgentServer:
         new_build_commands: dict[str, str] = {
             r.name: r.build_command for r in cfg.repos if r.build_command
         }
+        # #2326: built outside the lock — `build_provider` is pure
+        # construction (no I/O), but there is no reason to hold `self._lock`
+        # across it. `None` means "rebuild failed, keep the old registry
+        # verbatim" (see `_rebuild_providers`'s docstring).
+        new_providers = self._rebuild_providers(cfg)
 
         def _pin(old: dict, new: dict, keys: "Iterable[str]") -> None:
             """Restore *old*'s entry for each pinned key — including absence."""
@@ -4553,6 +4621,33 @@ class AgentServer:
             self.repo_paths = new_repo_paths
             self.artifact_paths = new_artifact_paths
             self.build_commands = new_build_commands
+
+            providers_added: list[str] = []
+            providers_removed: list[str] = []
+            providers_pinned: list[str] = []
+            if new_providers is not None:
+                in_flight_providers = {
+                    a.spec.provider
+                    for a in self._assignments.values()
+                    if a.status in (PENDING, RUNNING) and a.spec.provider is not None
+                }
+                old_providers = self._providers
+                _pin(old_providers, new_providers, in_flight_providers)
+                # Deliberately NOT trying to report "changed vs unchanged" per
+                # provider: `build_provider` mints a fresh instance every call
+                # and the provider classes carry no value equality, so any such
+                # comparison is really just "was it rebuilt", which is always
+                # true for every non-pinned entry. Report what IS knowable —
+                # the resulting registry, which names appeared/disappeared, and
+                # which kept their pre-reload instance because a PENDING/
+                # RUNNING assignment pinned them.
+                providers_added = [p for p in new_providers if p not in old_providers]
+                providers_removed = [p for p in old_providers if p not in new_providers]
+                providers_pinned = sorted(
+                    p for p in in_flight_providers if p in old_providers
+                )
+                self._providers = new_providers
+
             self._health_config = cfg
             self._config_reloads += 1
             self._config_reloaded_at = time.time()
@@ -4565,7 +4660,7 @@ class AgentServer:
 
         _log.info(
             "coord agent: applied config reload from %s — repos=%s "
-            "(added=%s removed=%s) capabilities=%s%s",
+            "(added=%s removed=%s) capabilities=%s%s%s",
             getattr(cfg, "path", None),
             new_repos,
             added or "[]",
@@ -4576,6 +4671,17 @@ class AgentServer:
                 if in_flight
                 else ""
             ),
+            (
+                # #2326: separate clause so a provider-only edit (the #2321
+                # incident this issue describes) shows up even when no repo
+                # changed at all.
+                f" providers={sorted(self._providers)}"
+                f"{f' (added={providers_added})' if providers_added else ''}"
+                f"{f' (removed={providers_removed})' if providers_removed else ''}"
+                f"{f' (pinned in-flight={providers_pinned})' if providers_pinned else ''}"
+                if new_providers is not None
+                else " providers=rebuild failed, kept previous registry"
+            ),
         )
 
     # ── Public API ──────────────────────────────────────────────────────────
@@ -4681,6 +4787,29 @@ class AgentServer:
                 "watching": str(watched_config) if watched_config else None,
                 "reloads": self._config_reloads,
                 "last_reload_at": self._config_reloaded_at,
+                # #2326: this agent's own last-observed mtime of `watching`
+                # (seeded from the file at startup, advanced on every
+                # reload attempt — including a swallowed bad edit, see
+                # `reload_config_if_stale`). `coord status` can diff this
+                # against the coordinator's own mtime for the SAME path to
+                # flag an agent whose config — and therefore whose
+                # `provider_names` below — predates the edit, without
+                # needing to probe `/proc/<pid>/environ` on the worker to
+                # notice (the failure mode that made #2326 a live-process
+                # investigation instead of a one-line `coord status` read).
+                # `None` for a config-free/thin-client agent, same as
+                # `watching`.
+                "config_mtime": self._config_mtime,
+                # #2326: the provider names THIS process would actually
+                # resolve `spec.provider` against right now — i.e. the keys
+                # of `self._providers`, refreshed at dispatch time (see
+                # `_apply_reloaded_config`). Lets `coord status` compare this
+                # list (or `config_mtime` above) against the coordinator's
+                # `providers.definitions` and flag drift directly, instead of
+                # every surface short of the worker's own process agreeing
+                # while the running registry is actually stale — exactly the
+                # split-brain #2326 describes.
+                "provider_names": sorted(self._providers) if self._providers else [],
             },
         }
 
@@ -5940,7 +6069,36 @@ class AgentServer:
         if spec.provider is None:
             return None
         if spec.provider in self._providers:
-            return self._providers[spec.provider]
+            local = self._providers[spec.provider]
+            if spec.provider_def is not None:
+                # #2326: step 2 (local override) is winning over a wire
+                # provider_def the coordinator DID send — the precedence is
+                # deliberate (see docstring), but before this the decision
+                # left no trace, which is why a days-stale local registry
+                # silently shadowing a fresh coordinator edit took a live
+                # `/proc/<pid>/environ` probe to catch instead of a log
+                # line. Env keys only (not values) — provider env commonly
+                # carries API keys/tokens, and the point here is "does this
+                # instance carry the key the coordinator's does", not the
+                # secret itself.
+                try:
+                    local_env_keys = sorted(local.env())  # type: ignore[attr-defined]
+                except Exception:  # noqa: BLE001 — logging must never break dispatch
+                    local_env_keys = None
+                wire_env_keys = sorted((spec.provider_def or {}).get("env") or {})
+                _log.info(
+                    "coord agent: provider %r resolved from this agent's "
+                    "local providers.definitions (env keys=%s), overriding "
+                    "the coordinator's wire-carried provider_def (env "
+                    "keys=%s) — local-wins-over-wire is deliberate "
+                    "precedence (#1796); if that's not what you expected, "
+                    "check this agent's own coordinator.yml for a stale "
+                    "definition (#2326)",
+                    spec.provider,
+                    local_env_keys,
+                    wire_env_keys,
+                )
+            return local
         if spec.provider_def is not None:
             from coord.providers import build_provider_from_wire  # noqa: PLC0415
 

{code_coordinator-0.5.116 → code_coordinator-0.5.117}/coord/commands/agent_ops.py

@@ -333,9 +333,12 @@ def _resolve_agent_startup(
     if cfg.path is not None:
         notices.append(
             f"coord agent: watching {cfg.path} for edits — repos, repo_paths, "
-            "capabilities, artifact_paths and build_command are re-read on the "
-            "next /health poll, no restart needed (#2299). RESTART-ONLY: "
-            "providers, concurrency (bash_wrap_spawn/first_output_timeout), "
+            "capabilities, artifact_paths, build_command and (#2326) "
+            "providers.definitions are re-read on the next /health poll or "
+            "dispatch, no restart needed (#2299). providers.definitions "
+            "changes apply to the NEXT dispatch of that provider name — an "
+            "in-flight assignment keeps the definition it started with. "
+            "RESTART-ONLY: concurrency (bash_wrap_spawn/first_output_timeout) "
             "and the bind host/port."
         )
     else:

{code_coordinator-0.5.116 → code_coordinator-0.5.117}/tests/test_agent.py

@@ -4210,6 +4210,56 @@ class TestProviderLayerDispatch:
         assert "legacy-SHOULD-NOT-RUN" not in log
         server.shutdown()
 
+    def test_local_wins_over_wire_provider_def_is_logged(
+        self, tmp_path: Path, caplog: pytest.LogCaptureFixture
+    ) -> None:
+        """#2326 item 3: when `_resolve_provider` takes the local-registry
+        branch over an available `spec.provider_def`, it must say so in the
+        agent log, naming both — this decision used to leave no trace,
+        which is why a stale local override took a live-process probe to
+        catch instead of a `journalctl` grep."""
+        from coord.config import ProviderDef
+        from coord.providers import build_provider
+
+        repo = _init_repo(tmp_path / "repo")
+        defn = ProviderDef(type="claude", env={"LOCAL_ONLY": "1"})
+        provider = build_provider("myprovider", defn, None)
+
+        server = AgentServer(
+            machine_name="test",
+            repos=["api"],
+            state_dir=tmp_path / "state",
+            worker_command=lambda spec: ["/bin/sh", "-c", "echo legacy-SHOULD-NOT-RUN"],
+            repo_paths={"api": str(repo)},
+            providers={"myprovider": provider},
+            bash_wrap_spawn=False,
+        )
+        spec = _spec(
+            repo,
+            provider="myprovider",
+            provider_def={
+                "type": "claude",
+                "binary": None,
+                "model": None,
+                "attach_url": None,
+                "env": {"FROM_WIRE": "1"},
+                "extra_args": [],
+            },
+        )
+        try:
+            with caplog.at_level("INFO", logger="coord.agent"):
+                resolved = server._resolve_provider(spec)
+        finally:
+            server.shutdown()
+
+        assert resolved is provider
+        assert "myprovider" in caplog.text
+        assert "local providers.definitions" in caplog.text
+        assert "wire-carried provider_def" in caplog.text
+        # Env KEYS only — never the values (secrets commonly live here).
+        assert "LOCAL_ONLY" in caplog.text
+        assert "FROM_WIRE" in caplog.text
+
 
 class TestCapabilityGates:
     """#324/#425: assign() enforces capability gates before spawning."""
@@ -5563,6 +5613,45 @@ def _bump_mtime(path: Path, seconds_ahead: float = 5.0) -> None:
     os.utime(path, (new_time, new_time))
 
 
+def _write_config_with_provider(
+    path: Path,
+    *,
+    repos: list[str],
+    repo_paths: dict[str, str],
+    provider_binary: str,
+    provider_env: dict[str, str] | None = None,
+    machine_name: str = "test",
+) -> Path:
+    """Write a minimal coordinator.yml with one `providers.definitions`
+    entry named "myprovider" (#2326 hot-reload coverage)."""
+    provider_env = provider_env or {}
+    lines = ["repos:"]
+    for name in repos:
+        lines.append(f"  - name: {name}")
+        lines.append(f"    github: acme/{name}")
+    lines.append("")
+    lines.append("providers:")
+    lines.append("  definitions:")
+    lines.append("    myprovider:")
+    lines.append("      type: claude")
+    lines.append(f"      binary: {provider_binary!r}")
+    if provider_env:
+        lines.append("      env:")
+        for k, v in provider_env.items():
+            lines.append(f"        {k}: {v!r}")
+    lines.append("")
+    lines.append("machines:")
+    lines.append(f"  - name: {machine_name}")
+    lines.append(f"    host: {machine_name}.tailnet")
+    lines.append("    capabilities: [python]")
+    lines.append(f"    repos: [{', '.join(repos)}]")
+    lines.append("    repo_paths:")
+    for name, p in repo_paths.items():
+        lines.append(f"      {name}: {p!r}")
+    path.write_text("\n".join(lines) + "\n")
+    return path
+
+
 class TestConfigHotReload:
     """#2299: `coordinator.yml` edits land within one health tick, no restart.
 
@@ -5887,14 +5976,17 @@ class TestConfigHotReload:
             server.shutdown()
 
     def test_restart_only_fields_are_not_reloaded(self, tmp_path: Path) -> None:
-        """`providers`, `bash_wrap_spawn` and `first_output_timeout` are
-        documented restart-only — a live worker holds a resolved provider, and
-        the other two are process tuning uvicorn/`_spawn` already committed
-        to. A reload must leave all three exactly as they were."""
-        sentinel = object()
+        """`bash_wrap_spawn` and `first_output_timeout` are documented
+        restart-only process tuning that uvicorn/`_spawn` already committed
+        to at startup. A reload must leave both exactly as they were.
+
+        #2326: `providers` used to be on this list too — a sibling test,
+        `test_provider_registry_is_hot_reloaded_when_not_in_flight` below,
+        now covers that it IS reloaded (a live worker's OWN resolved
+        provider is still protected, just via in-flight pinning rather than
+        blanket restart-only-ness — see `_apply_reloaded_config`)."""
         server, cfg_path, api, web = self._build(
             tmp_path,
-            providers={"stub": sentinel},
             bash_wrap_spawn=False,
             first_output_timeout=12.5,
         )
@@ -5907,12 +5999,187 @@ class TestConfigHotReload:
             _bump_mtime(cfg_path)
             assert server._maybe_reload_config() is True
 
-            assert server._providers == {"stub": sentinel}
             assert server.bash_wrap_spawn is False
             assert server.first_output_timeout == 12.5
         finally:
             server.shutdown()
 
+    # ── #2326: providers.definitions is hot too ─────────────────────────────
+
+    def test_provider_registry_is_hot_reloaded_when_not_in_flight(
+        self, tmp_path: Path
+    ) -> None:
+        """An agent with its own local `coordinator.yml` must not pin
+        `providers.definitions` at startup (#2326) — a provider config
+        change (new env, new binary, ...) must apply on the NEXT dispatch,
+        no restart, exactly like `repos`/`capabilities`/etc already do.
+
+        Verifies the resolution itself: the env dict a fresh dispatch's
+        provider carries, not a re-read of the config file."""
+        from coord.config import load as load_config
+        from coord.providers import build_provider
+
+        api = _init_repo(tmp_path / "api")
+        stub = tmp_path / "fake-claude.sh"
+        stub.write_text('#!/bin/sh\necho "SPAWN_ENV_FOO=$SPAWN_ENV_FOO"\n')
+        stub.chmod(0o755)
+
+        cfg_path = _write_config_with_provider(
+            tmp_path / "coordinator.yml",
+            repos=["api"],
+            repo_paths={"api": str(api)},
+            provider_binary=str(stub),
+        )
+        cfg = load_config(cfg_path)
+
+        server = AgentServer(
+            machine_name="test",
+            capabilities=["python"],
+            repos=["api"],
+            state_dir=tmp_path / "state",
+            worker_command=lambda spec: [
+                "/bin/sh", "-c", "echo legacy-SHOULD-NOT-RUN"
+            ],
+            repo_paths={"api": str(api)},
+            providers={
+                "myprovider": build_provider(
+                    "myprovider",
+                    cfg.providers.definitions["myprovider"],
+                    cfg.models,
+                )
+            },
+            health_config=cfg,
+            worktree_writable_settings_files=[],
+            bash_wrap_spawn=False,
+        )
+        try:
+            a1 = server.assign(_spec(api, provider="myprovider"))
+            final1 = server.wait_for(a1.id, timeout=5)
+            log1 = Path(final1.log_path).read_text()
+            assert "SPAWN_ENV_FOO=bar" not in log1
+            assert "legacy-SHOULD-NOT-RUN" not in log1
+
+            _write_config_with_provider(
+                cfg_path,
+                repos=["api"],
+                repo_paths={"api": str(api)},
+                provider_binary=str(stub),
+                provider_env={"SPAWN_ENV_FOO": "bar"},
+            )
+            _bump_mtime(cfg_path)
+
+            a2 = server.assign(_spec(api, provider="myprovider"))
+            final2 = server.wait_for(a2.id, timeout=5)
+            log2 = Path(final2.log_path).read_text()
+            assert "SPAWN_ENV_FOO=bar" in log2, (
+                f"providers.definitions edit did not reach the next "
+                f"dispatch: {log2!r}"
+            )
+            # An implicit "claude" entry is always materialised alongside
+            # whatever's explicitly configured (see `ProvidersConfig`).
+            assert server.health()["config_reload"]["provider_names"] == [
+                "claude",
+                "myprovider",
+            ]
+        finally:
+            server.shutdown()
+
+    def test_in_flight_provider_is_pinned_across_a_reload(
+        self, tmp_path: Path
+    ) -> None:
+        """The #2299 in-flight invariant applies to providers too (#2326): a
+        RUNNING assignment must keep resolving to the provider instance it
+        started with, even though a reload landed while it was running —
+        `_reap` re-resolves the SAME spec afterwards to pick a log parser,
+        and must get back the SAME identity `_spawn` used, not one a reload
+        swapped underneath it."""
+        from coord.config import load as load_config
+        from coord.providers import build_provider
+
+        api = _init_repo(tmp_path / "api")
+        go = tmp_path / "go"
+        stub = tmp_path / "fake-claude.sh"
+        stub.write_text(
+            "#!/bin/sh\n"
+            f"while [ ! -f {go} ]; do sleep 0.05; done\n"
+            'echo "SPAWN_ENV_FOO=$SPAWN_ENV_FOO"\n'
+        )
+        stub.chmod(0o755)
+
+        cfg_path = _write_config_with_provider(
+            tmp_path / "coordinator.yml",
+            repos=["api"],
+            repo_paths={"api": str(api)},
+            provider_binary=str(stub),
+        )
+        cfg = load_config(cfg_path)
+        server = AgentServer(
+            machine_name="test",
+            capabilities=["python"],
+            repos=["api"],
+            state_dir=tmp_path / "state",
+            worker_command=lambda spec: ["/bin/sh", "-c", "echo legacy"],
+            repo_paths={"api": str(api)},
+            providers={
+                "myprovider": build_provider(
+                    "myprovider",
+                    cfg.providers.definitions["myprovider"],
+                    cfg.models,
+                )
+            },
+            health_config=cfg,
+            worktree_writable_settings_files=[],
+            bash_wrap_spawn=False,
+        )
+        try:
+            a = server.assign(_spec(api, provider="myprovider"))
+            deadline = time.time() + 10
+            while server.get(a.id).status != RUNNING and time.time() < deadline:
+                time.sleep(0.05)
+            assert server.get(a.id).status == RUNNING
+            pre_reload_provider = server._providers["myprovider"]
+
+            # Edit lands WHILE the worker above is running.
+            _write_config_with_provider(
+                cfg_path,
+                repos=["api"],
+                repo_paths={"api": str(api)},
+                provider_binary=str(stub),
+                provider_env={"SPAWN_ENV_FOO": "bar"},
+            )
+            _bump_mtime(cfg_path)
+            assert server._maybe_reload_config() is True
+
+            # The RUNNING assignment's own provider identity must survive
+            # the reload untouched — asserted directly (object identity),
+            # not just inferred from behaviour.
+            in_flight_provider = server._resolve_provider(server.get(a.id).spec)
+            assert in_flight_provider is pre_reload_provider
+            assert in_flight_provider.env().get("SPAWN_ENV_FOO") is None
+
+            go.write_text("done")
+            final = server.wait_for(a.id, timeout=10)
+            log = Path(final.log_path).read_text()
+            assert "SPAWN_ENV_FOO=bar" not in log, (
+                "a reload must not retarget an in-flight worker's provider "
+                f"mid-run: {log!r}"
+            )
+
+            # The pin lifts once the assignment is terminal AND the next
+            # reload runs (a pin is only re-evaluated when a reload actually
+            # happens — an unchanged file triggers no reload at all, so it
+            # takes one more on-disk change, exactly like a genuine second
+            # `coordinator.yml` edit would).
+            _bump_mtime(cfg_path)
+            assert server._maybe_reload_config() is True
+            a2 = server.assign(_spec(api, provider="myprovider"))
+            final2 = server.wait_for(a2.id, timeout=10)
+            log2 = Path(final2.log_path).read_text()
+            assert "SPAWN_ENV_FOO=bar" in log2
+        finally:
+            server._assignments.clear()
+            server.shutdown()
+
     def test_reload_busts_the_local_health_cache(self, tmp_path: Path) -> None:
         """The H-1 block in /health is built from the loaded Config's
         checkouts — a cache left in place would keep republishing the