code-coordinator 0.5.72__tar.gz → 0.5.73__tar.gz

{code_coordinator-0.5.72 → code_coordinator-0.5.73}/PKG-INFO

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: code-coordinator
-Version: 0.5.72
+Version: 0.5.73
 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.72 → code_coordinator-0.5.73}/code_coordinator.egg-info/SOURCES.txt

@@ -459,6 +459,7 @@ tests/test_cli_assign.py
 tests/test_cli_assign_interactive_oracle_gate.py
 tests/test_cli_assign_interactive_remote.py
 tests/test_cli_assign_provider.py
+tests/test_cli_assign_repo_drift_2219.py
 tests/test_cli_audit.py
 tests/test_cli_chat_continue.py
 tests/test_cli_diagnose_config_provenance.py

{code_coordinator-0.5.72 → code_coordinator-0.5.73}/code_coordinator.egg-info/scm_file_list.json

@@ -489,6 +489,7 @@
     "tests/test_cli_assign_interactive_oracle_gate.py",
     "tests/test_cli_assign_interactive_remote.py",
     "tests/test_cli_assign_provider.py",
+    "tests/test_cli_assign_repo_drift_2219.py",
     "tests/test_cli_audit.py",
     "tests/test_cli_chat_continue.py",
     "tests/test_cli_diagnose_config_provenance.py",

{code_coordinator-0.5.72 → code_coordinator-0.5.73}/code_coordinator.egg-info/scm_version.json

@@ -1,7 +1,7 @@
 {
-  "tag": "0.5.72",
+  "tag": "0.5.73",
   "distance": 0,
-  "node": "gf89a7326b4afe98af0d76d9cbafabea51928013f",
+  "node": "g14e77699382902c886b02c14ee83a233c166d4cb",
   "dirty": false,
   "branch": "HEAD",
   "node_date": "2026-08-14"

{code_coordinator-0.5.72 → code_coordinator-0.5.73}/coord/commands/dispatch.py

@@ -9,6 +9,7 @@ import dataclasses
 import socket
 import sys
 from pathlib import Path
+from typing import TYPE_CHECKING
 
 import click
 import httpx
@@ -31,6 +32,9 @@ from coord.commands.dispatch_workers import (
     _dispatch_troubleshoot,
 )
 
+if TYPE_CHECKING:
+    from coord.models import Machine
+
 
 def _stdin_is_tty() -> bool:
     """Seam over ``sys.stdin.isatty()`` — see ``_require_interactive_tty``
@@ -89,6 +93,88 @@ def _require_interactive_tty(dry_run: bool) -> None:
     )
 
 
+def _repo_capability_refusal(
+    machine_obj: Machine, repo: str, *, timeout: float = 3.0
+) -> str | None:
+    """Cross-check *repo* against the target agent's LIVE ``/health`` repo
+    list, returning a refusal message when the two disagree — or ``None``
+    when they agree, the agent is unreachable, or the agent is config-free
+    (#2219).
+
+    ``assign()``'s ``machine_obj.can_work_on(repo)`` check (just above this
+    call site) only ever reads ``coordinator.yml`` — which the operator can
+    edit any time — never the agent process actually running on that
+    machine. A repo added to config after the agent started stays invisible
+    to it until a full ``systemctl --user restart coord-agent`` (there is no
+    partial re-read today). Every pre-flight surface an operator would
+    check before spending a dispatch reads config too: ``coord config``,
+    ``coord status``, and — worst of all — ``coord assign ... --dry-run``,
+    which is the documented way to sanity-check a dispatch before paying
+    for it. All three said this was fine while the live agent rejected it
+    outright, and a drive queue burned both retry attempts discovering that
+    by trial before landing terminally ``blocked`` (#2219). This is the
+    same ``/health`` read ``coord status``/``coord doctor`` already make
+    (``coord.network.check_machine``) — reused, not duplicated.
+
+    ``/health``'s ``repos`` field is NOT what ``AgentServer.assign()``
+    itself gates on, though — it's ``AgentServer._servable_repos()``'s
+    FILTERED list (``coord/agent.py``, #1527), which drops any repo with no
+    ``repo_paths`` entry or whose configured path is missing on disk.
+    ``assign()``'s own gate (``coord/agent.py``: ``if self.repos and
+    spec.repo_name not in self.repos``) checks the UNFILTERED
+    ``self.repos``. The two disagree exactly when a repo is configured on
+    that machine but degraded (``/health``'s ``degraded`` dict, #1527): in
+    that case ``assign()`` would NOT reject with "does not handle repo" —
+    it proceeds and fails later with the distinct "repo path does not
+    exist" — so this helper checks ``degraded`` FIRST and reports that
+    reason (with no restart advice, since restarting coord-agent cannot
+    repair a missing/misconfigured ``repo_paths`` entry) before ever
+    falling back to the "hasn't re-read config since *repo* was added"
+    story, which is only accurate when *repo* is absent from ``/health``
+    entirely — not merely degraded.
+
+    Deliberately narrow otherwise: only refuses when the agent is
+    reachable, ANSWERED with a real ``/health`` body, is not running
+    config-free (#1801 — a config-free agent's repos come from the dispatch
+    payload, not its own config, so an empty/mismatched list there is not a
+    capability gap), and either lists *repo* as degraded or published a
+    NON-empty repo list that plainly excludes it. Every other case
+    (offline, timeout, old agent with no ``repos`` key, empty list) falls
+    through to ``None`` — today's behavior, where the POST itself is left
+    to surface a real problem — so this never turns a transient network
+    hiccup into a new dispatch failure mode.
+    """
+    from coord.network import check_machine
+
+    status = check_machine(machine_obj, timeout=timeout)
+    if not status.is_online or status.health is None:
+        return None
+    health = status.health
+    if health.get("config_free"):
+        return None
+    degraded = health.get("degraded") or {}
+    if repo in degraded:
+        return (
+            f"{machine_obj.name!r} lists {repo!r} in coordinator.yml, and "
+            f"the live agent agrees it's configured, but the repo is "
+            f"DEGRADED there, not just unrefreshed: {degraded[repo]} "
+            f"(#1527). This is not the #2219 stale-config case — "
+            f"restarting coord-agent will not fix a missing or "
+            f"misconfigured repo_paths entry. Repair repo_paths[{repo!r}] "
+            f"on {machine_obj.name!r} instead, then retry."
+        )
+    live_repos = health.get("repos")
+    if not live_repos or repo in live_repos:
+        return None
+    return (
+        f"{machine_obj.name!r} rejected the assignment: this agent does "
+        f"not handle repo {repo!r} (supported: {live_repos}) — "
+        f"coordinator.yml lists it, but the live agent process hasn't "
+        f"re-read its config since {repo!r} was added (#2219). Restart "
+        f"coord-agent on {machine_obj.name!r} to pick it up, then retry."
+    )
+
+
 @click.command(help="Brain proposes assignments for idle machines.")
 @_CONFIG_OPTION
 @click.option("--dry-run", is_flag=True, help="Plan without saving proposals.")
@@ -951,6 +1037,18 @@ def assign(
         )
         sys.exit(2)
 
+    # #2219: config says this machine handles `repo` — but the LIVE agent
+    # process may not (yet) agree, if `repo` was added to coordinator.yml
+    # after that agent started. Refuse with the agent's real reason here,
+    # before any claim/worktree/network work — including under --dry-run,
+    # which is exactly the surface that used to green-light this. See
+    # _repo_capability_refusal's docstring for the full rationale and what
+    # it deliberately does NOT block on (offline/unreachable/config-free).
+    capability_refusal = _repo_capability_refusal(machine_obj, repo)
+    if capability_refusal is not None:
+        click.echo(f"error: {capability_refusal}", err=True)
+        sys.exit(2)
+
     # Refuse direct assignment to a paused machine — `coord pause` exists
     # so the user can explicitly steer work away.  If they meant to dispatch
     # anyway they should `coord unpause` first.  #1862: also refuses inside

{code_coordinator-0.5.72 → code_coordinator-0.5.73}/coord/commands/status.py

@@ -765,6 +765,53 @@ def _health_vs_config_lines(machine, health: dict) -> list[tuple[bool, str]]:
             ))
             for repo, reason in sorted(degraded.items()):
                 out.append((True, f"        {repo}: {reason}"))
+    elif declared_repos and published_repos and not config_free:
+        # #2219: the ABOVE branch only fires when /health publishes NOTHING
+        # — it silently missed the partial-drift shape that actually bit
+        # stick-demo#1: a repo added to coordinator.yml after the agent
+        # process started stays off /health's list while everything ELSE
+        # the agent publishes (including all its OTHER repos) looks
+        # perfectly healthy. `coord config`/`coord status` both read
+        # config, so both still advertised it; only the live agent —
+        # and, at dispatch cost, the drive queue that burned both retry
+        # attempts on it — knew better.
+        #
+        # `published_repos` (``/health``'s ``repos``) is
+        # ``AgentServer._servable_repos()``'s FILTERED list (#1527) — it
+        # also drops any repo that IS configured on that machine but is
+        # DEGRADED (no ``repo_paths`` entry, or the configured path is
+        # missing on disk). A drifted repo that's actually degraded is not
+        # the #2219 stale-config story: `AgentServer.assign()` gates on the
+        # UNFILTERED `self.repos`, so it would still accept that repo and
+        # fail later with a distinct "repo path does not exist" error —
+        # restarting coord-agent cannot repair a missing/misconfigured
+        # `repo_paths` entry. Split on `degraded` so each drifted repo gets
+        # the accurate story and remedy.
+        drifted = [r for r in declared_repos if r not in published_repos]
+        stale = [r for r in drifted if r not in degraded]
+        if stale:
+            out.append((
+                True,
+                f"  ✗ CRIT repos: coordinator.yml declares {declared_repos} "
+                f"but /health only advertises {published_repos} — {stale} "
+                "were added to config after this agent process started and "
+                "it hasn't re-read them; a dispatch to any of "
+                f"{stale} on this machine will be refused despite `coord "
+                "config`/`coord status` showing it as supported (#2219). "
+                "Restart coord-agent on this machine to pick it up.",
+            ))
+        for repo in drifted:
+            if repo in degraded:
+                out.append((
+                    True,
+                    f"  ✗ CRIT repos: coordinator.yml declares {repo!r} for "
+                    "this machine and the live agent agrees it's "
+                    f"configured, but it's DEGRADED there, not just "
+                    f"unrefreshed: {degraded[repo]} (#1527). This is not "
+                    "the #2219 stale-config case — restarting coord-agent "
+                    f"will not fix it; repair repo_paths[{repo!r}] on this "
+                    "machine instead.",
+                ))
 
     return out
 

{code_coordinator-0.5.72 → code_coordinator-0.5.73}/tests/conftest.py

@@ -68,6 +68,24 @@ def _no_agent_health_probe(monkeypatch):
     )
 
 
+@pytest.fixture(autouse=True)
+def _no_assign_repo_drift_probe(monkeypatch):
+    """#2219: default `coord assign`'s live-agent repo-capability cross-check
+    (``coord.commands.dispatch._repo_capability_refusal``) to fail-open
+    (``None`` — never refuse) so tests that don't care about it don't make a
+    real ``httpx.get(".../health")`` call keyed off whatever bogus
+    ``host.tailnet`` hostnames the fixture configs use. Mirrors
+    ``_no_agent_health_probe`` (#904) for the same reason: the suite's
+    default behavior must not depend on network/DNS timing. Tests exercising
+    the drift check itself monkeypatch this function to return a message
+    (or call the real one against a stubbed ``coord.network.check_machine``),
+    which takes priority over this default and is unaffected by it.
+    """
+    monkeypatch.setattr(
+        "coord.commands.dispatch._repo_capability_refusal", lambda *a, **k: None
+    )
+
+
 @pytest.fixture(autouse=True)
 def _no_worktree_writable_deny_scan(monkeypatch):
     """#1445 review: keep `check_worktree_writable`'s deny-rule scan from

code_coordinator-0.5.73/tests/test_cli_assign_repo_drift_2219.py

@@ -0,0 +1,240 @@
+"""#2219: `coord assign` (`--dry-run` especially) must refuse a dispatch the
+LIVE agent will reject, not just one `coordinator.yml` happens to still list.
+
+Before this, every pre-flight surface — `coord config`, `coord status`, and
+`coord assign ... --dry-run` — read config only. A repo added to
+coordinator.yml after the target agent process started stayed invisible to
+that agent (no partial config re-read short of a full restart), so all three
+said the dispatch was fine while the live `/health` repo list, and the
+agent's own `assign()`, disagreed. `--dry-run` green-lit a dispatch that
+could not succeed, and the drive queue burned both retry attempts
+discovering that by trial before landing terminally `blocked`.
+
+`_repo_capability_refusal` (coord/commands/dispatch.py) is the fix: a
+pre-flight cross-check against the SAME `/health` read `coord doctor`/`coord
+status` already make, reused via `coord.network.check_machine`. The autouse
+`_no_assign_repo_drift_probe` fixture (tests/conftest.py) stubs it to `None`
+by default for every other test in the suite; these tests exercise it
+directly.
+"""
+
+from __future__ import annotations
+
+from pathlib import Path
+from unittest.mock import patch
+
+import pytest
+from click.testing import CliRunner
+
+from coord.cli import main
+from coord.commands.dispatch import _repo_capability_refusal
+from coord.models import Machine
+from coord.network import ONLINE, OFFLINE, MachineStatus
+
+CONFIG_YAML = """\
+repos:
+  - name: api
+    github: acme/api
+    default_branch: main
+  - name: stick-demo
+    github: acme/stick-demo
+    default_branch: main
+machines:
+  - name: dellserver
+    host: dellserver.tailnet
+    repos: [api, stick-demo]
+    repo_paths:
+      api: /tmp/api
+      stick-demo: /tmp/stick-demo
+"""
+
+
+@pytest.fixture
+def config_file(tmp_path: Path) -> Path:
+    p = tmp_path / "coordinator.yml"
+    p.write_text(CONFIG_YAML)
+    return p
+
+
+@pytest.fixture
+def coord_dir(tmp_path: Path, coord_db):
+    d = tmp_path / "state"
+    d.mkdir(parents=True, exist_ok=True)
+    return d
+
+
+def _machine(**kwargs) -> Machine:
+    base = dict(
+        name="dellserver", host="dellserver.tailnet",
+        repos=["api", "stick-demo"],
+    )
+    base.update(kwargs)
+    return Machine(**base)
+
+
+class TestRepoCapabilityRefusalUnit:
+    """Pure unit coverage of the cross-check helper (network mocked)."""
+
+    def test_refuses_when_live_repos_exclude_the_target(self, monkeypatch) -> None:
+        monkeypatch.setattr(
+            "coord.network.check_machine",
+            lambda *a, **k: MachineStatus(
+                machine=_machine(), state=ONLINE, latency_ms=5.0,
+                health={
+                    "machine": "dellserver",
+                    "repos": ["api"],  # stick-demo missing — the #2219 shape
+                },
+            ),
+        )
+        reason = _repo_capability_refusal(_machine(), "stick-demo")
+        assert reason is not None
+        assert "stick-demo" in reason
+        assert "does not handle repo" in reason
+        assert "['api']" in reason
+
+    def test_none_when_live_repos_include_the_target(self, monkeypatch) -> None:
+        monkeypatch.setattr(
+            "coord.network.check_machine",
+            lambda *a, **k: MachineStatus(
+                machine=_machine(), state=ONLINE, latency_ms=5.0,
+                health={"machine": "dellserver", "repos": ["api", "stick-demo"]},
+            ),
+        )
+        assert _repo_capability_refusal(_machine(), "stick-demo") is None
+
+    def test_none_when_agent_is_offline(self, monkeypatch) -> None:
+        """A transient/unreachable agent must not become a NEW dispatch
+        failure mode — that's still left to the POST itself."""
+        monkeypatch.setattr(
+            "coord.network.check_machine",
+            lambda *a, **k: MachineStatus(
+                machine=_machine(), state=OFFLINE, reason="connection refused",
+            ),
+        )
+        assert _repo_capability_refusal(_machine(), "stick-demo") is None
+
+    def test_none_when_agent_publishes_no_repos_key(self, monkeypatch) -> None:
+        """An agent old enough to predate the `repos` field in /health."""
+        monkeypatch.setattr(
+            "coord.network.check_machine",
+            lambda *a, **k: MachineStatus(
+                machine=_machine(), state=ONLINE, latency_ms=5.0,
+                health={"machine": "dellserver"},
+            ),
+        )
+        assert _repo_capability_refusal(_machine(), "stick-demo") is None
+
+    def test_degraded_repo_gets_its_own_reason_not_the_stale_config_story(
+        self, monkeypatch
+    ) -> None:
+        """A repo missing from /health's `repos` because it's DEGRADED
+        (#1527 — no repo_path entry, or the configured path doesn't exist)
+        is not the #2219 stale-config shape: `AgentServer.assign()` gates
+        on the UNFILTERED `self.repos`, which still contains a degraded
+        repo, so it would NOT reject with "does not handle repo" — it
+        would proceed and fail later with a distinct "repo path does not
+        exist" error. The refusal message must say so and must not tell
+        the operator to restart coord-agent, which cannot fix a missing
+        repo_paths entry."""
+        monkeypatch.setattr(
+            "coord.network.check_machine",
+            lambda *a, **k: MachineStatus(
+                machine=_machine(), state=ONLINE, latency_ms=5.0,
+                health={
+                    "machine": "dellserver",
+                    "repos": ["api"],
+                    "degraded": {
+                        "stick-demo": "no repo_path configured for this machine",
+                    },
+                },
+            ),
+        )
+        reason = _repo_capability_refusal(_machine(), "stick-demo")
+        assert reason is not None
+        assert "no repo_path configured for this machine" in reason
+        assert "does not handle repo" not in reason
+        assert "hasn't re-read its config" not in reason
+        assert "Restart coord-agent" not in reason
+
+    def test_none_when_agent_is_config_free(self, monkeypatch) -> None:
+        """#1801: a config-free agent's repos come from the dispatch
+        payload, not its own config — a mismatch there is not a capability
+        gap."""
+        monkeypatch.setattr(
+            "coord.network.check_machine",
+            lambda *a, **k: MachineStatus(
+                machine=_machine(), state=ONLINE, latency_ms=5.0,
+                health={
+                    "machine": "dellserver", "repos": ["api"],
+                    "config_free": "no local coordinator.yml and no board service",
+                },
+            ),
+        )
+        assert _repo_capability_refusal(_machine(), "stick-demo") is None
+
+
+class TestAssignRefusesOnLiveDrift:
+    """CLI-level: `coord assign` (including --dry-run) must surface the
+    live refusal before any network/claim work."""
+
+    def test_dry_run_refuses_on_live_repo_drift(
+        self, config_file: Path, coord_dir: Path
+    ) -> None:
+        with patch(
+            "coord.commands.dispatch._repo_capability_refusal",
+            return_value=(
+                "'dellserver' rejected the assignment: this agent does not "
+                "handle repo 'stick-demo' (supported: ['api'])"
+            ),
+        ), patch("coord.github_ops.get_issue") as mock_get_issue:
+            result = CliRunner().invoke(
+                main,
+                [
+                    "assign", "dellserver", "stick-demo", "1",
+                    "--config", str(config_file), "--dry-run",
+                ],
+            )
+        assert result.exit_code == 2
+        assert "does not handle repo" in result.output
+        assert "stick-demo" in result.output
+        # #2219's whole point: refuse BEFORE spending the (harmless but
+        # unnecessary) GitHub round-trip a dry run would otherwise still make.
+        mock_get_issue.assert_not_called()
+
+    def test_real_dispatch_also_refuses_on_live_repo_drift(
+        self, config_file: Path, coord_dir: Path
+    ) -> None:
+        with patch(
+            "coord.commands.dispatch._repo_capability_refusal",
+            return_value=(
+                "'dellserver' rejected the assignment: this agent does not "
+                "handle repo 'stick-demo' (supported: ['api'])"
+            ),
+        ), patch("coord.github_ops.get_issue") as mock_get_issue, \
+             patch("coord.dispatch.dispatch") as mock_dispatch:
+            result = CliRunner().invoke(
+                main,
+                [
+                    "assign", "dellserver", "stick-demo", "1",
+                    "--config", str(config_file),
+                ],
+            )
+        assert result.exit_code == 2
+        mock_get_issue.assert_not_called()
+        mock_dispatch.assert_not_called()
+
+    def test_dry_run_proceeds_when_no_live_drift(
+        self, config_file: Path, coord_dir: Path
+    ) -> None:
+        """Sanity check: the default (autouse-stubbed) fail-open path still
+        lets a genuinely healthy dispatch through --dry-run."""
+        with patch("coord.github_ops.get_issue", return_value={"title": "t"}):
+            result = CliRunner().invoke(
+                main,
+                [
+                    "assign", "dellserver", "stick-demo", "1",
+                    "--config", str(config_file), "--dry-run",
+                ],
+            )
+        assert result.exit_code == 0
+        assert "dry run" in result.output

{code_coordinator-0.5.72 → code_coordinator-0.5.73}/tests/test_cli_doctor_config_mismatch_1712.py

@@ -211,3 +211,103 @@ class TestHealthVsConfigLines:
             )
             == []
         )
+
+    def test_partial_repo_drift_is_a_problem_even_when_health_is_nonempty(self) -> None:
+        """#2219: stick-demo's actual shape — /health still publishes
+        something (unlike the all-repos-missing #1485 case above), just not
+        the ONE repo added to coordinator.yml after this agent process
+        started. The `not published_repos` branch above never fires here,
+        so this needs its own check."""
+        lines = _health_vs_config_lines(
+            self._machine(repos=["vimcode", "quadraui", "stick-demo"]),
+            {
+                "capabilities": ["gtk", "rust", "python"],
+                "repos": ["vimcode", "quadraui"],
+            },
+        )
+        assert any(is_problem for is_problem, _ in lines)
+        assert any(
+            "CRIT repos" in text and "stick-demo" in text for _, text in lines
+        )
+
+    def test_partial_repo_drift_is_degraded_not_stale_when_in_degraded_dict(
+        self,
+    ) -> None:
+        """#2219 follow-up: a repo missing from `/health`'s `repos` because
+        it's DEGRADED (#1527 — no repo_path entry, or the configured path
+        doesn't exist) is not the "hasn't re-read config" story —
+        `AgentServer.assign()` gates on the UNFILTERED `self.repos`, which
+        still contains a degraded repo, so it would NOT reject with "does
+        not handle repo"; it would proceed and fail later with a distinct
+        "repo path does not exist" error. `coord doctor` must say so and
+        must not tell the operator to restart coord-agent, which cannot fix
+        a missing/misconfigured repo_paths entry."""
+        lines = _health_vs_config_lines(
+            self._machine(repos=["vimcode", "quadraui", "stick-demo"]),
+            {
+                "capabilities": ["gtk", "rust", "python"],
+                "repos": ["vimcode", "quadraui"],
+                "degraded": {
+                    "stick-demo": "no repo_path configured for this machine",
+                },
+            },
+        )
+        assert any(is_problem for is_problem, _ in lines)
+        assert any(
+            "stick-demo" in text and "no repo_path configured" in text
+            for _, text in lines
+        )
+        joined = "\n".join(text for _, text in lines)
+        assert "hasn't re-read them" not in joined
+        assert "Restart coord-agent" not in joined
+
+    def test_partial_repo_drift_mixed_stale_and_degraded_repos(self) -> None:
+        """One repo genuinely stale (missing from /health, not degraded)
+        and one degraded (missing from /health, present in `degraded`) —
+        each must get its own accurate story, not be lumped together."""
+        lines = _health_vs_config_lines(
+            self._machine(repos=["vimcode", "quadraui", "stick-demo", "tui"]),
+            {
+                "capabilities": ["gtk", "rust", "python"],
+                "repos": ["vimcode", "quadraui"],
+                "degraded": {
+                    "tui": "repo_path /home/x/src/tui does not exist",
+                },
+            },
+        )
+        joined = "\n".join(text for _, text in lines)
+        assert "stick-demo" in joined and "hasn't re-read them" in joined
+        assert "tui" in joined and "repo_path /home/x/src/tui does not exist" in joined
+        # The stale-config CRIT's *drifted-repos* list — the part actually
+        # blamed on staleness — must name only the truly-stale repo, not
+        # the degraded one (which `declared_repos` also mentions, harmlessly,
+        # in the same line's leading "coordinator.yml declares [...]" clause).
+        stale_lines = [t for _, t in lines if "hasn't re-read them" in t]
+        assert len(stale_lines) == 1
+        assert "['stick-demo'] were added to config" in stale_lines[0]
+
+    def test_partial_repo_drift_is_silent_when_agent_is_config_free(self) -> None:
+        """A config-free agent's repos come from the dispatch payload, not
+        its own coordinator.yml (#1801) — a mismatch against the
+        coordinator's OWN machine entry for it is not a capability gap."""
+        lines = _health_vs_config_lines(
+            self._machine(repos=["vimcode", "quadraui", "stick-demo"]),
+            {
+                "capabilities": [],
+                "repos": ["vimcode", "quadraui"],
+                "config_free": "no local coordinator.yml and no board service",
+            },
+        )
+        assert not any("stick-demo" in text for _, text in lines)
+
+    def test_no_partial_drift_line_when_published_repos_match_declared(self) -> None:
+        assert (
+            _health_vs_config_lines(
+                self._machine(repos=["vimcode", "quadraui"]),
+                {
+                    "capabilities": ["gtk", "rust", "python"],
+                    "repos": ["vimcode", "quadraui", "extra-repo-agent-also-serves"],
+                },
+            )
+            == []
+        )