code-coordinator 0.5.285__tar.gz → 0.5.287__tar.gz

{code_coordinator-0.5.285 → code_coordinator-0.5.287}/PKG-INFO

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

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

@@ -1,7 +1,7 @@
 {
-  "tag": "0.5.285",
+  "tag": "0.5.287",
   "distance": 0,
-  "node": "g20de37c9769bbedc43a885378d37737a25b31ac4",
+  "node": "g9301f73a7d9cb01987024a21890ff9eff768b19c",
   "dirty": false,
   "branch": "HEAD",
   "node_date": "2026-08-29"

{code_coordinator-0.5.285 → code_coordinator-0.5.287}/coord/agent.py

@@ -6130,14 +6130,30 @@ class AgentServer:
 
         See `_tool_versions_ttl` for why: probing shells out per tool, and
         `/health` is polled frequently.
+
+        #2913: `probe_all()` normally restricts probing to `self.capabilities`
+        so a plain CLI-only machine never pays to probe a browser or GTK4 it
+        never claimed. A config-free agent's `self.capabilities` is `[]` by
+        construction — it has nothing of its own to declare; the coordinator
+        supplies capabilities from its OWN `coordinator.yml` at dispatch time
+        (docs/EPHEMERAL_WORKERS.md). Probing only `self.capabilities` there
+        means `/health.tool_versions` never covers cargo, python3, or any
+        other capability-gated tool, so `unmet_capabilities()` — the #1570 D
+        cross-check `dispatch_smoke` relies on before routing capability-
+        gated work here — finds nothing to compare and fails OPEN, not
+        closed, exactly backwards from what #1570 D exists to guarantee.
+        Probe every known capability instead for a config-free agent: it has
+        no legitimate narrower set to restrict to anyway, since it doesn't
+        know what the coordinator is about to route to it.
         """
         now = time.time()
         cached = self._tool_versions_cache
         if cached is not None and (now - cached[0]) < self._tool_versions_ttl:
             return cached[1]
-        from coord.prereqs import probe_all, tool_versions_summary
+        from coord.prereqs import ALL_CAPABILITY_NAMES, probe_all, tool_versions_summary
 
-        summary = tool_versions_summary(probe_all(self.capabilities))
+        probe_caps = ALL_CAPABILITY_NAMES if self.config_free_reason is not None else self.capabilities
+        summary = tool_versions_summary(probe_all(probe_caps))
         self._tool_versions_cache = (now, summary)
         return summary
 

{code_coordinator-0.5.285 → code_coordinator-0.5.287}/coord/prereqs.py

@@ -382,6 +382,24 @@ CAPABILITY_PREREQS: tuple[Prereq, ...] = (
 
 ALL_PREREQS: tuple[Prereq, ...] = BASELINE_PREREQS + CAPABILITY_PREREQS
 
+# Every capability name any `CAPABILITY_PREREQS` entry gates, in one place
+# (#2913). `probe_all()` restricts probing to a caller-supplied capability
+# set so a normal, fully-configured machine never pays to probe a browser
+# or GTK4 it never claimed — but that same restriction silently defeats
+# `unmet_capabilities()` for a config-free agent (docs/EPHEMERAL_WORKERS.md):
+# its OWN `capabilities` is `[]` by construction (nothing to declare — the
+# coordinator's `coordinator.yml` supplies capabilities at dispatch time,
+# not this process), so `probe_all(self.capabilities)` never probes cargo,
+# python3, or any other capability-gated tool, and the #1570 D cross-check
+# has nothing to compare against. `AgentServer._cached_tool_versions`
+# (coord/agent.py) passes this set instead of `self.capabilities` for a
+# config-free agent, so `/health` always reports the truth about what is
+# actually on the box regardless of what config, if any, this process
+# itself holds.
+ALL_CAPABILITY_NAMES: frozenset[str] = frozenset(
+    p.capability for p in CAPABILITY_PREREQS if p.capability is not None
+)
+
 
 def _parse_version(text: str, pattern: str) -> str | None:
     match = re.search(pattern, text)
@@ -515,6 +533,18 @@ def unmet_capabilities(
     `CAPABILITY_PREREQS` names it) is silently skipped, not flagged — an
     unprobed claim is not (yet) a *known-broken* one; this only reports
     claims this module can actually verify.
+
+    The `p is None` skip is meant for exactly one case: an agent whose
+    `/health` predates this module probing that particular tool at all.
+    Before #2913 it also silently swallowed a second, permanent case — a
+    config-free agent (`self.capabilities == []`) whose `probes` therefore
+    never included the caller's `required_caps` in the first place, so
+    `dispatch_smoke`'s #1570 D cross-check verified nothing for exactly the
+    machines it exists to protect. `AgentServer._cached_tool_versions`
+    closes that by probing `ALL_CAPABILITY_NAMES` (not `self.capabilities`)
+    when the agent is config-free, so `probes` passed in here now genuinely
+    covers every capability this function is asked about, and `p is None`
+    goes back to meaning only "predates the probe" — see coord/agent.py.
     """
     unmet: dict[str, list[str]] = {}
     for cap in capabilities:

{code_coordinator-0.5.285 → code_coordinator-0.5.287}/coord/skills/fleet-restart-safety/SKILL.md

@@ -73,15 +73,28 @@ symlinks, silently replacing it with a disconnected regular file. Edit the
 checkout itself:
 
 ```bash
-coord sessions --remote        # MUST be empty — restart breaks interactive finalize
 ssh <daemon-host> 'vi ~/src/coord-settings/coord/coordinator.yml'
 ssh <daemon-host> 'git -C ~/src/coord-settings commit -am "..." && git -C ~/src/coord-settings push'
-ssh <daemon-host> 'XDG_RUNTIME_DIR=/run/user/$(id -u) systemctl --user restart coord-serve'
-coord config                   # re-caches from the daemon; new value proves both the edit and the reload
+coord config                   # re-caches from the daemon; new value proves the edit landed
 ```
 
-The daemon does not hot-reload — without the restart, the file is changed and
-nothing uses it.
+**No `coord-serve` restart needed here** (#1081). The daemon tracks the
+backing file's mtime and swaps in a freshly-parsed `Config` the moment the
+tick loop notices it changed (`_reload_config_if_stale` in
+`coord/serve_app.py`, bound to the shared `coord.config_reload.reload_config_if_stale`)
+— restarting the daemon for a config edit buys nothing for the config and
+costs you item above's interactive-finalize risk for no reason. `GET
+/config` (what `coord config` re-fetches) always serves the raw bytes fresh
+regardless of the reload.
+
+**A malformed edit is swallowed, not rejected** — if the pushed/pulled file
+fails to parse, the reload logs a warning and keeps serving the last-good
+`Config` (the daemon's own gating decisions keep running on stale rules,
+silently), but still advances its mtime marker so it won't retry until the
+file changes again. **Validate the YAML before you push it.** See
+`docs/OPERATING_GOTCHAS.md` #14 for the full failure-mode list (symlink
+replaced by a regular file, uncommitted checkout changes, checkout out of
+sync with `origin`) and `coord diagnose --config-provenance` to check them.
 
 ## Summary table
 
@@ -92,7 +105,9 @@ nothing uses it.
 
 A full deploy needs **both** checks, and often waiting: a machine running a
 worker can't be agent-updated, and a fleet with a live interactive session
-can't have its daemon restarted.
+can't have its daemon restarted. A `coordinator.yml` edit needs **neither** —
+it hot-reloads, so don't restart `coord-serve` just because you touched the
+config.
 
 ## Rules
 
@@ -102,3 +117,6 @@ can't have its daemon restarted.
 - Never edit `~/.coord/coordinator.yml` / `coordinator.remote.yml` directly on
   a thin client or via the daemon-host symlink and expect it to stick — edit
   the `coord-settings` checkout and push.
+- Never restart `coord-serve` after a `coordinator.yml` edit "just to be
+  safe" — it hot-reloads on its own (#1081), and the restart only adds the
+  interactive-finalize risk from the section above for no benefit.

{code_coordinator-0.5.285 → code_coordinator-0.5.287}/coord/smoke.py

@@ -436,6 +436,18 @@ def _capability_probe_reasons(
     would be strictly worse than the blind trust this replaces. Only an
     *explicit* probe failure refuses routing.
 
+    #2913: this used to fail open the same way for a config-free agent too
+    — `tool_versions` was present (baseline `git`/`gh`) but never covered
+    `required_caps`, since a config-free agent has no `capabilities` of its
+    own to probe against and `AgentServer._cached_tool_versions` used to
+    restrict probing to exactly that empty list. `unmet_capabilities` then
+    found nothing to compare and returned `{}`, indistinguishable from
+    "probed and clean". Fixed at the source: a config-free agent now probes
+    every known capability (`coord.prereqs.ALL_CAPABILITY_NAMES`) regardless
+    of what it declares, so `tool_versions` here genuinely covers
+    `required_caps` and this function's refusal path works the same for a
+    config-free agent as for a fully-configured one.
+
     Never raises — a connectivity hiccup here just skips the extra check;
     the POST to `/assign` right after this call in `dispatch_smoke` is the
     real reachability test and fails closed on its own if the machine is

{code_coordinator-0.5.285 → code_coordinator-0.5.287}/tests/test_agent.py

@@ -231,6 +231,54 @@ def test_health_tool_versions_is_cached(tmp_path: Path) -> None:
     assert third == first
 
 
+def test_health_tool_versions_probes_everything_when_config_free(
+    tmp_path: Path,
+) -> None:
+    """#2913: a config-free agent declares `capabilities=[]` by design
+    (docs/EPHEMERAL_WORKERS.md) — the coordinator's own `coordinator.yml`
+    supplies capabilities at dispatch time, not this process. Restricting
+    `/health.tool_versions` to `self.capabilities` (empty) meant the #1570 D
+    cross-check in `dispatch_smoke` never had cargo/python3/etc. to compare
+    against and silently failed OPEN for exactly the machines it exists to
+    protect. A config-free agent must now probe every known capability
+    regardless of its own (empty) declared list."""
+    from coord.prereqs import ALL_CAPABILITY_NAMES
+
+    server = AgentServer(
+        machine_name="ephemeral-1",
+        capabilities=[],
+        repos=[],
+        state_dir=tmp_path / "state",
+        worktree_writable_settings_files=[],
+        config_free_reason="no local coordinator.yml and no board service",
+    )
+    tool_versions = server.health()["tool_versions"]
+    assert "cargo" in tool_versions
+    assert "python3" in tool_versions
+    assert "gtk4" in tool_versions
+    assert "node" in tool_versions
+    # Sanity: the probed set really does cover every capability-gated tool,
+    # not just a hardcoded couple of names.
+    probed_capabilities = {
+        info["capability"] for info in tool_versions.values() if info["capability"]
+    }
+    assert probed_capabilities == set(ALL_CAPABILITY_NAMES)
+
+
+def test_health_tool_versions_stays_restricted_when_not_config_free(
+    tmp_path: Path,
+) -> None:
+    """A normal, fully-configured agent (`config_free_reason=None`, the
+    default) must NOT gain the config-free agent's wider probe — `_server`
+    declares only `capabilities=["python"]`, so `cargo`/`gtk4` stay absent,
+    same as before #2913."""
+    server = _server(tmp_path)
+    tool_versions = server.health()["tool_versions"]
+    assert "python3" in tool_versions
+    assert "cargo" not in tool_versions
+    assert "gtk4" not in tool_versions
+
+
 def test_assign_success(tmp_path: Path) -> None:
     repo = _init_repo(tmp_path / "repo")
     server = _server(tmp_path, repo_path=repo)

{code_coordinator-0.5.285 → code_coordinator-0.5.287}/tests/test_prereqs.py

@@ -178,6 +178,30 @@ class TestProbeAll:
             "meets_floor": None, "capability": None, "ok": False,
         }
 
+    def test_all_capability_names_probes_every_capability_prereq(self) -> None:
+        """#2913: `ALL_CAPABILITY_NAMES` is what `AgentServer` probes for a
+        config-free agent in place of its own (empty) `capabilities` — it
+        must actually cover every `CAPABILITY_PREREQS` entry, else the
+        cross-check it exists to unblock would quietly narrow again."""
+        with patch("coord.prereqs.shutil.which", return_value=None):
+            probes = prereqs.probe_all(prereqs.ALL_CAPABILITY_NAMES)
+        expected_tools = {p.tool for p in prereqs.CAPABILITY_PREREQS} | {"git", "gh"}
+        assert set(probes) == expected_tools
+
+
+class TestAllCapabilityNames:
+    def test_matches_every_declared_capability(self) -> None:
+        declared = {
+            p.capability for p in prereqs.CAPABILITY_PREREQS if p.capability is not None
+        }
+        assert prereqs.ALL_CAPABILITY_NAMES == declared
+
+    def test_nonempty(self) -> None:
+        # A regression guard against this collapsing to an empty set (e.g. a
+        # future refactor of CAPABILITY_PREREQS dropping `capability` values)
+        # and silently making the #2913 fix probe nothing again.
+        assert prereqs.ALL_CAPABILITY_NAMES
+
 
 class TestUnmetCapabilities:
     def test_empty_when_capability_backs_out(self) -> None: