code-coordinator 0.5.306__tar.gz → 0.5.308__tar.gz

{code_coordinator-0.5.306 → code_coordinator-0.5.308}/PKG-INFO

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

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

@@ -445,6 +445,7 @@ tests/test_cli_diagnose_config_provenance.py
 tests/test_cli_diagnose_forge_availability.py
 tests/test_cli_diagnose_graph.py
 tests/test_cli_diagnose_self.py
+tests/test_cli_diagnose_test_coverage.py
 tests/test_cli_doctor.py
 tests/test_cli_doctor_config_free_1801.py
 tests/test_cli_doctor_config_mismatch_1712.py

{code_coordinator-0.5.306 → code_coordinator-0.5.308}/code_coordinator.egg-info/scm_file_list.json

@@ -471,6 +471,7 @@
     "tests/test_cli_diagnose_forge_availability.py",
     "tests/test_cli_diagnose_graph.py",
     "tests/test_cli_diagnose_self.py",
+    "tests/test_cli_diagnose_test_coverage.py",
     "tests/test_cli_doctor.py",
     "tests/test_cli_doctor_config_free_1801.py",
     "tests/test_cli_doctor_config_mismatch_1712.py",

{code_coordinator-0.5.306 → code_coordinator-0.5.308}/code_coordinator.egg-info/scm_version.json

@@ -1,7 +1,7 @@
 {
-  "tag": "0.5.306",
+  "tag": "0.5.308",
   "distance": 0,
-  "node": "g3c4702ef295a9bb7fd88162d870354e73e905833",
+  "node": "gde30a174fcc1e82cb10b2f750bbe379e349de5e4",
   "dirty": false,
   "branch": "HEAD",
   "node_date": "2026-08-30"

{code_coordinator-0.5.306 → code_coordinator-0.5.308}/coord/commands/status.py

@@ -1921,6 +1921,21 @@ def _diagnose_via_daemon(svc, params: dict) -> None:
         "network required."
     ),
 )
+@click.option(
+    "--test-coverage",
+    "test_coverage_check",
+    is_flag=True,
+    help=(
+        "#2967: report repos whose effective Test-stage command (same "
+        "ci_command > smoke_tests.default_command > test_command precedence "
+        "the Test gate itself uses) enables fewer cargo `--features` than "
+        "the repo's build_command — e.g. quadraui building "
+        "tui+gtk+terminal but testing only tui, so a `passed` verdict never "
+        "compiled the gtk/terminal code. Repos with no explicit "
+        "`--features` on either side are silently skipped (no signal). "
+        "Read-only, no checkout or network required."
+    ),
+)
 @click.option(
     "--self",
     "self_check",
@@ -1980,6 +1995,7 @@ def diagnose(
     graph_health: bool = False,
     config_provenance_check: bool = False,
     capability_rules_check: bool = False,
+    test_coverage_check: bool = False,
     self_check: bool = False,
     self_no_fetch: bool = False,
     forge_availability: bool = False,
@@ -2006,6 +2022,11 @@ def diagnose(
         _diagnose_capability_rules(config_path)
         return
 
+    # ── #2967: test_command feature-flag coverage vs build_command ──────────
+    if test_coverage_check:
+        _diagnose_test_coverage(config_path)
+        return
+
     # ── #2436: THIS process's own editable coord install freshness ──────────
     if self_check:
         _diagnose_self(fetch=not self_no_fetch)
@@ -2236,6 +2257,29 @@ def _diagnose_capability_rules(config_path: Path) -> None:
     click.echo(capability_rule_summary_line(findings, unclaimed))
 
 
+def _diagnose_test_coverage(config_path: Path) -> None:
+    """Report repos whose effective Test-stage command enables fewer cargo
+    ``--features`` than their ``build_command`` (#2967).
+
+    Read-only, local-machine only, same family as ``--capability-rules``.
+    Unlike ``--capability-rules`` this needs no repo checkout at all — it's
+    a pure comparison of two command strings already in ``coordinator.yml``
+    — so it reports identically wherever it's run, including a thin client
+    with no local checkouts (see ``coord/fleet_config_health.py``).
+    """
+    from coord.fleet_config_health import (  # noqa: PLC0415
+        feature_coverage_findings,
+        feature_coverage_summary_line,
+        format_feature_coverage_lines,
+    )
+
+    cfg = _load_config(config_path)
+    findings = feature_coverage_findings(cfg)
+    for line in format_feature_coverage_lines(findings):
+        click.echo(f"  {line}")
+    click.echo(feature_coverage_summary_line(findings))
+
+
 def _diagnose_self(*, fetch: bool) -> None:
     """Report whether THIS process's own editable ``coord`` install is
     behind origin (#2436).

{code_coordinator-0.5.306 → code_coordinator-0.5.308}/coord/dispatch.py

@@ -17,7 +17,7 @@ from coord.comments import (
     format_refused_policy,
 )
 from coord.config import Config
-from coord.models import Proposal, Repo
+from coord.models import Proposal, Repo, coordinator_owned_docs
 
 AGENT_PORT = 7433
 
@@ -582,9 +582,14 @@ def dispatch(
         deny_commands = repo.worker_permissions.deny
 
     # Resolve coordinator-only files (workers must not read or modify these).
-    files_forbidden: list[str] = []
-    if repo is not None and repo.coordinator_only_files:
-        files_forbidden = list(repo.coordinator_only_files)
+    # #2966: coordinator_only_files was set by zero repos fleet-wide, so this
+    # started empty for every work dispatch and only ever grew sealed
+    # acceptance paths below — never a doc. coordinator_owned_docs() unions
+    # in a fleet-wide default (the repo's own CLAUDE.md) regardless of
+    # whether coordinator_only_files is configured, so "only the coordinator
+    # writes docs" is enforced (advisory, like every non-oracle
+    # files_forbidden entry) without depending on 10 repos' worth of config.
+    files_forbidden: list[str] = coordinator_owned_docs(repo)
 
     # #944 sealing v1 (docs/ORACLE_LOOP.md): the acceptance oracle is
     # read-only/run-only for the worker — it's authored by an independent

{code_coordinator-0.5.306 → code_coordinator-0.5.308}/coord/fleet_config_health.py

@@ -57,6 +57,7 @@ precedent as :func:`config_provenance` applies per repo.
 from __future__ import annotations
 
 import os
+import shlex
 import subprocess
 from dataclasses import dataclass, field
 from pathlib import Path
@@ -615,3 +616,166 @@ def capability_rule_summary_line(
         f"prefixes={len(findings)} dead={dead} partial={partial} "
         f"unclaimed_caps={len(unclaimed)}"
     )
+
+
+# ── Test-command feature-flag coverage vs build_command (#2967) ─────────────
+#
+# quadraui is configured `test_command: cargo test --features tui` against
+# `build_command: cargo build --features tui --features gtk --features
+# terminal` — the Test gate never compiles `src/gtk/**` or the terminal
+# backend, so a `passed` verdict on a change confined to either carries no
+# information at all. Nothing previously compared the two commands; this is
+# the same "config looks right in review but silently does less than it
+# claims" shape as #2953's dead capability_rules prefixes, one seam over:
+# there it was a `files` prefix matching nothing, here it's a `--features`
+# flag the build enables that the effective Test-stage command never turns
+# on. Pure string comparison against the already-loaded config — no local
+# checkout required, so (unlike `capability_rule_health`) this runs the same
+# everywhere, including a thin client with no repo checkouts at all.
+
+
+def _cargo_features(command: str | None) -> set[str]:
+    """Every value named by a `--features`/`-F`/`--features=...` token in
+    *command*, comma- or space-separated, deduped.
+
+    Returns the empty set for a falsy, unparseable (unbalanced quoting), or
+    feature-less command — treated as "no feature-flag signal to compare",
+    never as a gap by itself. That is what keeps a plain `cargo build` /
+    `cargo test` pair (vimcode, coord-tui) and non-cargo commands (npm/pnpm
+    repos) out of the findings entirely: both sides parse to an empty set,
+    which is equal, not missing.
+    """
+    if not command:
+        return set()
+    try:
+        tokens = shlex.split(command)
+    except ValueError:
+        return set()
+    features: set[str] = set()
+    i = 0
+    while i < len(tokens):
+        tok = tokens[i]
+        value: str | None = None
+        if tok in ("--features", "-F"):
+            if i + 1 < len(tokens):
+                value = tokens[i + 1]
+                i += 1
+        elif tok.startswith("--features="):
+            value = tok[len("--features=") :]
+        if value is not None:
+            features.update(part for part in value.replace(",", " ").split() if part)
+        i += 1
+    return features
+
+
+@dataclass
+class FeatureCoverageFinding:
+    """Feature-flag coverage of one repo's effective Test-stage command
+    against its ``build_command`` (#2967).
+
+    ``effective_test_command``/``test_command_source``/``ci_equivalent``
+    mirror ``coord.smoke.resolve_smoke_command`` — the SAME precedence
+    (``ci_command`` > ``smoke_tests.default_command`` > ``test_command``)
+    the Test stage itself uses, so this reports on the command that will
+    actually gate the repo, not always the raw ``repos[].test_command``.
+    """
+
+    repo: str
+    build_command: str
+    effective_test_command: str | None
+    test_command_source: str
+    ci_equivalent: bool
+    build_features: tuple[str, ...] = ()
+    test_features: tuple[str, ...] = ()
+    missing_features: tuple[str, ...] = ()
+
+    @property
+    def gap(self) -> bool:
+        """``build_command`` enables a feature the effective test command
+        never turns on — a passed verdict didn't compile that code."""
+        return bool(self.missing_features)
+
+    @property
+    def healthy(self) -> bool:
+        return not self.gap
+
+
+def feature_coverage_findings(config: "Config") -> list[FeatureCoverageFinding]:
+    """Cargo `--features` coverage of every configured repo's effective
+    Test-stage command against its ``build_command`` (#2967).
+
+    Only repos whose ``build_command`` names at least one `--features` value
+    are considered — a repo with no explicit features (or a non-cargo build,
+    e.g. npm/pnpm) parses to an empty set on both sides and is silently
+    omitted, matching :func:`capability_rule_health`'s "no signal, no
+    finding" precedent. The effective test command is resolved with
+    ``coord.smoke.resolve_smoke_command`` (deferred import: `coord.smoke`
+    pulls in ``httpx``/``github_ops``, which this otherwise-light,
+    network-free module avoids at import time), so a repo that already
+    covers the gap via ``ci_command`` or ``smoke_tests.default_command``
+    correctly reports healthy rather than flagging the raw
+    ``test_command`` alone.
+    """
+    from coord.smoke import resolve_smoke_command  # noqa: PLC0415
+
+    findings: list[FeatureCoverageFinding] = []
+    for repo_cfg in config.repos:
+        build_command = repo_cfg.build_command
+        if not build_command:
+            continue
+        build_features = _cargo_features(build_command)
+        if not build_features:
+            continue
+        smoke_cmd = resolve_smoke_command(repo_cfg, config.smoke_tests)
+        test_features = _cargo_features(smoke_cmd.command)
+        missing = tuple(sorted(build_features - test_features))
+        findings.append(
+            FeatureCoverageFinding(
+                repo=repo_cfg.name,
+                build_command=build_command,
+                effective_test_command=smoke_cmd.command,
+                test_command_source=smoke_cmd.source,
+                ci_equivalent=smoke_cmd.ci_equivalent,
+                build_features=tuple(sorted(build_features)),
+                test_features=tuple(sorted(test_features)),
+                missing_features=missing,
+            )
+        )
+    return findings
+
+
+def format_feature_coverage_lines(findings: list[FeatureCoverageFinding]) -> list[str]:
+    """Human-readable report lines for *findings* (used by ``coord diagnose
+    --test-coverage``)."""
+    if not findings:
+        return [
+            "· no repo's build_command names an explicit `--features` value "
+            "— nothing to check (this only applies to cargo feature-flagged "
+            "builds)"
+        ]
+
+    lines: list[str] = []
+    for f in findings:
+        if f.gap:
+            lines.append(
+                f"✗ GAP: {f.repo} — build_command (`{f.build_command}`) enables "
+                f"[{', '.join(f.build_features)}], but the effective Test-stage "
+                f"command ({f.test_command_source}: "
+                f"`{f.effective_test_command or '(unconfigured)'}`) enables "
+                f"[{', '.join(f.test_features) or '(none)'}]. Missing: "
+                f"{', '.join(f.missing_features)} — a `passed` verdict never "
+                "compiled that code (#2967)."
+            )
+        else:
+            lines.append(
+                f"✓ {f.repo} — {f.test_command_source} covers every feature "
+                f"build_command enables ([{', '.join(f.build_features)}])"
+            )
+    return lines
+
+
+def feature_coverage_summary_line(findings: list[FeatureCoverageFinding]) -> str:
+    """The machine-readable trailer ``coord diagnose --test-coverage``
+    prints, mirroring ``GRAPH_HEALTH:``/``CAPABILITY_RULES:``."""
+    gap = sum(1 for f in findings if f.gap)
+    return f"TEST_COMMAND_COVERAGE: repos_checked={len(findings)} gap={gap}"

{code_coordinator-0.5.306 → code_coordinator-0.5.308}/coord/models.py

@@ -423,6 +423,50 @@ CLOSES_ISSUE_TYPES: frozenset[str] = frozenset({"work"})
 # which must also list it since it mutates GitHub via `gh pr create`.
 PR_HELPER_TYPE = "pr-helper"
 
+# #2966: "only the coordinator writes docs" (this repo's CLAUDE.md says so
+# for every worker) was text-only enforcement — `Repo.coordinator_only_files`
+# is the config key that was clearly designed to seed a work dispatch's
+# `files_forbidden` with the repo's shared docs (see `coord.dispatch.dispatch`
+# lines around #587), but it was set by ZERO of the fleet's 10 repos, so
+# `files_forbidden` started empty for every work dispatch and only ever
+# gained sealed acceptance paths (#944), never a doc. Two workers in the same
+# repo consequently rewrote the same CLAUDE.md section in the same week,
+# producing a semantic (prose) merge conflict that stalled a five-issue
+# cross-repo chain for ~98 ticks until an operator intervened.
+#
+# Mirror the #944 sealed-paths fix for the same class of problem: don't
+# depend on every operator remembering to configure this per repo. A repo's
+# own rulebook is auto-forbidden unconditionally — `coordinator_owned_docs()`
+# below UNIONS this default in regardless of what `coordinator_only_files`
+# says, the same way sealed acceptance paths are auto-added regardless of
+# `coordinator_only_files` (`coord.dispatch.dispatch`'s #944 comment).
+COORDINATOR_OWNED_DOC_DEFAULTS: tuple[str, ...] = ("CLAUDE.md",)
+
+
+def coordinator_owned_docs(repo: "Repo | None") -> list[str]:
+    """Coordinator-only doc paths for *repo* (#2966).
+
+    Returns :data:`COORDINATOR_OWNED_DOC_DEFAULTS` UNIONED with *repo*'s own
+    ``coordinator_only_files`` (if any), deduped and order-preserving
+    (defaults first). Callers use this instead of reading
+    ``repo.coordinator_only_files`` directly so the fleet-wide default keeps
+    applying even for the common case — today, every repo — where
+    ``coordinator_only_files`` is unset.
+
+    #1388-style fail-open: some ``Repo``-shaped stand-ins (a
+    wire-reconstructed object, or a stale install predating this field)
+    don't carry ``coordinator_only_files`` at all — ``getattr`` with a
+    default treats that the same as "unset" rather than raising, matching
+    how ``dispatch_review`` already tolerates a stand-in missing
+    ``develop_branch``.
+    """
+    result: list[str] = list(COORDINATOR_OWNED_DOC_DEFAULTS)
+    if repo is not None:
+        for f in getattr(repo, "coordinator_only_files", None) or []:
+            if f not in result:
+                result.append(f)
+    return result
+
 
 def trust_issue_closed_for(assignment_type: str | None) -> bool:
     """Whether :func:`coord.github_ops.work_is_terminal` may trust

{code_coordinator-0.5.306 → code_coordinator-0.5.308}/coord/review.py

@@ -48,6 +48,7 @@ from coord.models import (
     Assignment,
     Board,
     Machine,
+    coordinator_owned_docs,
     trust_issue_closed_for,
 )
 from coord.refine_chat import MAX_CLAUDE_MD_CHARS
@@ -1558,6 +1559,7 @@ def build_review_briefing(
     diff_text: str | None = None,
     sealed_paths: list[str] | None = None,
     sealed_entrypoints: list[str] | None = None,
+    coordinator_doc_paths: list[str] | None = None,
     assignment_type: str = "work",
     provider_same_as_worker: bool = False,
     review_provider: str | None = None,
@@ -1632,6 +1634,18 @@ def build_review_briefing(
     is expected and non-blocking. Every other type (default ``"work"``) keeps
     the original rule unchanged: any touch to *sealed_paths* is mandatory
     ``request-changes``.
+
+    *coordinator_doc_paths* (#2966) is the repo's coordinator-owned doc set —
+    :func:`coord.models.coordinator_owned_docs`, the repo's own CLAUDE.md plus
+    anything it additionally lists under ``coordinator_only_files``. CLAUDE.md
+    already states "only the coordinator writes docs" for every worker, but
+    that was prose-only: nothing structurally backstopped it, and two workers
+    independently rewriting the same CLAUDE.md section produced a semantic
+    merge conflict that stalled a five-issue chain (#2966). Unlike
+    *sealed_paths*, this rule never inverts — no assignment type's job is
+    ever editing the repo's own rulebook, so any diff that touches one of
+    these paths is mandatory ``request-changes`` regardless of
+    *assignment_type*.
     """
 
     lines: list[str] = []
@@ -1829,6 +1843,43 @@ def build_review_briefing(
                     "this is a hard rule, not a suggestion (docs/ORACLE_LOOP.md)."
                 )
 
+    if coordinator_doc_paths:
+        # #2966: "only the coordinator writes docs" was prose-only — nothing
+        # backstopped it structurally, and two workers independently
+        # rewrote the same CLAUDE.md section in the same week, producing a
+        # semantic (prose) merge conflict that stalled a five-issue chain.
+        # This rule never inverts by assignment_type (unlike sealed_paths
+        # above): no dispatched worker type's job is ever editing the
+        # repo's own rulebook.
+        lines.append("")
+        touched_docs = (
+            _diff_touched_sealed_paths(diff_text, coordinator_doc_paths)
+            if diff_text else []
+        )
+        if touched_docs:
+            lines.append("## \U0001f6a8 COORDINATOR-OWNED DOC EDITED")
+            lines.append("")
+            lines.append(
+                "The diff modifies a coordinator-owned doc: "
+                + ", ".join(f"`{p}`" for p in touched_docs)
+                + ". \"Only the coordinator writes docs\" — a worker must "
+                "never edit the repo's own rulebook or other shared docs; "
+                "parallel doc edits from independent workers collide "
+                "(#2966). **request-changes is mandatory here**, regardless "
+                "of anything else in this diff — even if the edit itself "
+                "looks correct in isolation."
+            )
+        else:
+            lines.append("## Coordinator-owned docs (do not touch)")
+            lines.append("")
+            lines.append(
+                "This repo reserves "
+                + ", ".join(f"`{p}`" for p in coordinator_doc_paths)
+                + " for the coordinator (#2966). If the diff modifies any of "
+                "them, **request-changes** — this is a hard rule, not a "
+                "suggestion, regardless of assignment type."
+            )
+
     lines.append("")
     lines.append("## What to do")
     lines.append("")
@@ -2637,6 +2688,12 @@ def dispatch_review(
     sealed_paths = config.acceptance.sealed_paths(completed.repo_name)
     sealed_entrypoints = config.acceptance.entrypoints(completed.repo_name)
 
+    # #2966: coordinator-owned docs (repo's own CLAUDE.md plus anything it
+    # additionally lists under coordinator_only_files) — see
+    # coordinator_owned_docs' docstring for why this doesn't depend on the
+    # repo actually configuring coordinator_only_files.
+    coordinator_doc_paths = coordinator_owned_docs(repo)
+
     client = http_client or httpx
 
     # Iterate candidates in priority order.  On agent rejection (4xx from a
@@ -2706,6 +2763,7 @@ def dispatch_review(
             diff_text=diff_text,
             sealed_paths=sealed_paths,
             sealed_entrypoints=sealed_entrypoints,
+            coordinator_doc_paths=coordinator_doc_paths,
             assignment_type=completed.type,
         )
 

code_coordinator-0.5.308/tests/test_cli_diagnose_test_coverage.py

@@ -0,0 +1,153 @@
+"""End-to-end tests for `coord diagnose --test-coverage` — driven through the
+real Click command against real ``coordinator.yml`` files, asserting on
+rendered output (CLAUDE.md black-box coverage bar).
+
+#2967: quadraui is configured ``test_command: cargo test --features tui``
+against ``build_command: cargo build --features tui --features gtk
+--features terminal`` — the Test gate never compiles ``src/gtk/**`` or the
+terminal backend, so a `passed` verdict on a change confined to either
+carries no information at all. Nothing previously compared the two
+commands; this drives the CLI end to end against that exact live shape, plus
+the healthy/neutral cases that must NOT be flagged.
+"""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+from click.testing import CliRunner
+
+from coord.commands.status import diagnose
+
+
+def _write_config(tmp_path: Path, repos_yaml: str, *, smoke_tests_yaml: str = "") -> Path:
+    cfg = tmp_path / "coordinator.yml"
+    cfg.write_text(
+        "repos:\n"
+        f"{repos_yaml}"
+        "\n"
+        "machines:\n"
+        "  - name: desktop\n"
+        "    host: desktop.tailnet\n"
+        "    capabilities: [rust]\n"
+        "    repos: [quadraui]\n"
+        "    repo_paths:\n"
+        "      quadraui: ~/src/quadraui\n"
+        f"{smoke_tests_yaml}",
+        encoding="utf-8",
+    )
+    return cfg
+
+
+def _run(cfg: Path) -> str:
+    result = CliRunner().invoke(
+        diagnose, ["--test-coverage", "--config", str(cfg)], catch_exceptions=False
+    )
+    assert result.exit_code == 0, result.output
+    return result.output
+
+
+def test_reports_gap_for_the_live_quadraui_shape(tmp_path: Path) -> None:
+    """The exact live incident (#2967): build_command enables tui+gtk+terminal,
+    test_command enables only tui — gtk and terminal are missing and must be
+    named explicitly."""
+    cfg = _write_config(
+        tmp_path,
+        "  - name: quadraui\n"
+        "    github: acme/quadraui\n"
+        "    build_command: \"cargo build --features tui --features gtk --features terminal\"\n"
+        "    test_command: \"cargo test --features tui\"\n",
+    )
+
+    out = _run(cfg)
+
+    assert "GAP" in out
+    assert "quadraui" in out
+    assert "Missing: gtk, terminal" in out
+    assert "TEST_COMMAND_COVERAGE: repos_checked=1 gap=1" in out
+
+
+def test_healthy_when_test_command_covers_every_build_feature(tmp_path: Path) -> None:
+    cfg = _write_config(
+        tmp_path,
+        "  - name: quadraui\n"
+        "    github: acme/quadraui\n"
+        "    build_command: \"cargo build --features tui --features gtk\"\n"
+        "    test_command: \"cargo test --features tui --features gtk\"\n",
+    )
+
+    out = _run(cfg)
+
+    assert "GAP" not in out
+    assert "TEST_COMMAND_COVERAGE: repos_checked=1 gap=0" in out
+
+
+def test_ci_command_closing_the_gap_reports_healthy_not_the_raw_test_command(
+    tmp_path: Path,
+) -> None:
+    """`ci_command` outranks `test_command` for what the Test stage actually
+    runs (`coord.smoke.resolve_smoke_command`) — a repo that declares a wider
+    `ci_command` must report healthy even though its bare `test_command`
+    alone would be a gap."""
+    cfg = _write_config(
+        tmp_path,
+        "  - name: quadraui\n"
+        "    github: acme/quadraui\n"
+        "    build_command: \"cargo build --features tui --features gtk\"\n"
+        "    test_command: \"cargo test --features tui\"\n"
+        "    ci_command: \"cargo test --features tui --features gtk\"\n",
+    )
+
+    out = _run(cfg)
+
+    assert "GAP" not in out
+    assert "ci_command" in out
+    assert "TEST_COMMAND_COVERAGE: repos_checked=1 gap=0" in out
+
+
+def test_plain_cargo_build_and_test_with_no_features_is_not_flagged(tmp_path: Path) -> None:
+    """vimcode/coord-tui shape: neither command names `--features` at all —
+    nothing to compare, so the repo is silently omitted, not reported."""
+    cfg = _write_config(
+        tmp_path,
+        "  - name: quadraui\n"
+        "    github: acme/quadraui\n"
+        "    build_command: \"cargo build\"\n"
+        "    test_command: \"cargo test\"\n",
+    )
+
+    out = _run(cfg)
+
+    assert "GAP" not in out
+    assert "nothing to check" in out
+    assert "TEST_COMMAND_COVERAGE: repos_checked=0 gap=0" in out
+
+
+def test_no_build_command_at_all_is_not_flagged(tmp_path: Path) -> None:
+    cfg = _write_config(
+        tmp_path,
+        "  - name: quadraui\n"
+        "    github: acme/quadraui\n"
+        "    test_command: \"cargo test --features tui\"\n",
+    )
+
+    out = _run(cfg)
+
+    assert "GAP" not in out
+    assert "TEST_COMMAND_COVERAGE: repos_checked=0 gap=0" in out
+
+
+def test_unconfigured_test_command_reports_every_feature_missing(tmp_path: Path) -> None:
+    cfg = _write_config(
+        tmp_path,
+        "  - name: quadraui\n"
+        "    github: acme/quadraui\n"
+        "    build_command: \"cargo build --features tui --features gtk\"\n",
+    )
+
+    out = _run(cfg)
+
+    assert "GAP" in out
+    assert "(unconfigured)" in out
+    assert "Missing: gtk, tui" in out
+    assert "TEST_COMMAND_COVERAGE: repos_checked=1 gap=1" in out

{code_coordinator-0.5.306 → code_coordinator-0.5.308}/tests/test_dispatch.py

@@ -302,7 +302,10 @@ class TestDispatch:
         )
         dispatch(proposal, cfg)
         payload = mock_post.call_args.kwargs["json"]
-        assert payload["files_forbidden"] == ["README.md", "CHANGELOG.md"]
+        # #2966: CLAUDE.md is unioned in as a fleet-wide default ahead of
+        # the repo's own configured coordinator_only_files — see
+        # coord.models.coordinator_owned_docs.
+        assert payload["files_forbidden"] == ["CLAUDE.md", "README.md", "CHANGELOG.md"]
 
     @patch("coord.dispatch.httpx.post")
     def test_payload_auto_seals_acceptance_dir_when_driver_configured(
@@ -404,7 +407,33 @@ class TestDispatch:
         mock_post.return_value = mock_resp
         dispatch(proposal, config)
         payload = mock_post.call_args.kwargs["json"]
-        assert payload["files_forbidden"] == []
+        # #2966: no acceptance driver and no coordinator_only_files configured
+        # still carries the fleet-wide doc default (CLAUDE.md) — the source
+        # list is never actually empty, unlike pre-#2966.
+        assert payload["files_forbidden"] == ["CLAUDE.md"]
+
+    @patch("coord.dispatch.httpx.post")
+    def test_payload_forbids_claude_md_by_default(
+        self, mock_post: MagicMock, proposal: Proposal,
+    ) -> None:
+        """#2966: repo.coordinator_only_files is set by zero repos fleet-wide,
+        so files_forbidden must not depend on it to protect the repo's own
+        rulebook — CLAUDE.md is auto-forbidden the same way sealed acceptance
+        paths are auto-added regardless of config (#944)."""
+        mock_resp = MagicMock()
+        mock_resp.json.return_value = {"ok": True}
+        mock_post.return_value = mock_resp
+
+        cfg = Config(
+            repos=[Repo(name="api", github="acme/api")],
+            machines=[Machine(
+                name="laptop", host="laptop.tailnet", repos=["api"],
+                repo_paths={"api": "/home/user/src/api"},
+            )],
+        )
+        dispatch(proposal, cfg)
+        payload = mock_post.call_args.kwargs["json"]
+        assert "CLAUDE.md" in payload["files_forbidden"]
 
     @patch("coord.dispatch.httpx.post")
     def test_payload_acceptance_seal_dedupes_with_coordinator_only_files(