code-coordinator 0.5.93__tar.gz → 0.5.94__tar.gz

{code_coordinator-0.5.93 → code_coordinator-0.5.94}/PKG-INFO

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

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

@@ -529,6 +529,7 @@ tests/test_config.py
 tests/test_config_acceptance.py
 tests/test_config_audit.py
 tests/test_config_pricing.py
+tests/test_config_snapshot_noncanonical_2208.py
 tests/test_config_usage_gate.py
 tests/test_conflict_fix.py
 tests/test_conflict_fix_semantic.py

{code_coordinator-0.5.93 → code_coordinator-0.5.94}/code_coordinator.egg-info/scm_file_list.json

@@ -559,6 +559,7 @@
     "tests/test_config_acceptance.py",
     "tests/test_config_audit.py",
     "tests/test_config_pricing.py",
+    "tests/test_config_snapshot_noncanonical_2208.py",
     "tests/test_config_usage_gate.py",
     "tests/test_conflict_fix.py",
     "tests/test_conflict_fix_semantic.py",

{code_coordinator-0.5.93 → code_coordinator-0.5.94}/code_coordinator.egg-info/scm_version.json

@@ -1,7 +1,7 @@
 {
-  "tag": "0.5.93",
+  "tag": "0.5.94",
   "distance": 0,
-  "node": "g827590698265fe1d05e3d77e84c364f63d767405",
+  "node": "gc872293016c9a4132c83fff7881956b707aacbf7",
   "dirty": false,
   "branch": "HEAD",
   "node_date": "2026-08-15"

{code_coordinator-0.5.93 → code_coordinator-0.5.94}/coord/commands/_common.py

@@ -27,7 +27,13 @@ from typing import TYPE_CHECKING
 
 import click
 
-from coord.config import Config, ConfigError, load, resolve_config_path
+from coord.config import (
+    Config,
+    ConfigError,
+    is_canonical_config_path,
+    load,
+    resolve_config_path,
+)
 
 if TYPE_CHECKING:  # pragma: no cover — typing only
     from collections.abc import Iterator
@@ -100,7 +106,55 @@ _CONFIG_OPTION = click.option(
 )
 
 
-def _save_config_snapshot(config: Config) -> None:
+def _note_withheld_snapshot(config: Config, config_path: Path) -> None:
+    """Tell the operator that the #2208 guard just withheld a snapshot — but
+    only when withholding it actually changed the outcome.
+
+    Silence is what turned the original incident into an hour of
+    misdiagnosis: the fleet's ``machines`` table said ``ci-runner`` and
+    nothing anywhere said why. So when a non-canonical ``--config`` would
+    have *replaced a populated table with a different fleet* — the exact
+    shape of that incident — say so on stderr.
+
+    Everything else stays quiet, and that restraint is load-bearing rather
+    than cosmetic. ``--config <tmpfile>`` is the normal way to run coord
+    against a scratch config: CI stubs, the config *validator* in
+    ``scripts/azure-workers/coordinator-machine.py``, and every one of this
+    repo's ~110 CLI test modules. Emitting a note on each of those would
+    have made the guard a per-invocation nag, and — because Click's
+    ``CliRunner`` folds stderr into ``result.output`` — would have corrupted
+    the machine-readable stdout of commands like ``coord plans --json`` and
+    ``coord scorecard --json`` for anyone parsing combined output.
+
+    A skip with nothing to clobber (empty table, or a table that already
+    matches) withheld nothing observable, so it warrants no words.
+    """
+    try:
+        from coord.db import get_connection
+        conn = get_connection()
+        existing = [
+            str(row[0])
+            for row in conn.execute("SELECT name FROM machines ORDER BY name")
+        ]
+    except Exception:  # noqa: BLE001 — advisory only; never break the command
+        return
+    if not existing:
+        # Nothing to protect: no snapshot has ever landed here (a fresh
+        # host, or a CI runner whose DB only exists for this one command).
+        return
+    if existing == sorted(m.name for m in config.machines):
+        # The override names the same fleet — the write would have been a
+        # no-op, so the skip cost the operator nothing.
+        return
+    click.echo(
+        f"note: --config points at a non-canonical path ({config_path}); "
+        f"leaving the shared machines/pipeline snapshot untouched (#2208). "
+        f"Fleet machines on record: {', '.join(existing)}.",
+        err=True,
+    )
+
+
+def _save_config_snapshot(config: Config, config_path: Path | None = None) -> None:
     """Persist machine + pipeline metadata to the DB so dashboards can read it.
 
     Writes:
@@ -111,6 +165,13 @@ def _save_config_snapshot(config: Config) -> None:
 
     The pipeline keys let the TUI Pipeline panel pick up coordinator.yml
     settings without having to parse YAML itself.
+
+    *config_path* is the file *config* was actually loaded from. When given
+    and it is not the canonical resolution (see
+    ``coord.config.is_canonical_config_path``), the write is skipped
+    entirely — see the #2208 guard below. Callers that omit it (mainly
+    direct unit tests exercising the write itself) get the pre-#2208
+    behavior: always write.
     """
     # #584: a thin client (board_service configured) must not create/write a
     # local DB — the daemon/host owns the config snapshot.  On the host
@@ -118,6 +179,14 @@ def _save_config_snapshot(config: Config) -> None:
     from coord.client import resolve_board_service
     if resolve_board_service() is not None:
         return
+    # #2208: an explicit `--config <file>` pointed away from the fleet's real
+    # config (a scratch fixture, a CI-only stub) must not be treated as a
+    # request to redefine the shared `machines` table — that table is global
+    # state every client's `/board` and the TUI read, not something a single
+    # throwaway invocation should own.
+    if config_path is not None and not is_canonical_config_path(config_path):
+        _note_withheld_snapshot(config, config_path)
+        return
     conn = None
     try:
         from coord.db import get_connection
@@ -270,7 +339,7 @@ def _load_config(path: Path | None) -> Config:
     except ConfigError as e:
         click.echo(f"error: {e}", err=True)
         sys.exit(2)
-    _save_config_snapshot(cfg)
+    _save_config_snapshot(cfg, path)
     return cfg
 
 

{code_coordinator-0.5.93 → code_coordinator-0.5.94}/coord/config.py

@@ -51,6 +51,27 @@ def resolve_config_path() -> Path:
             return candidate
     return USER_CONFIG_PATH
 
+
+def is_canonical_config_path(path: Path) -> bool:
+    """Whether *path* is what :func:`resolve_config_path` resolves to *right now*.
+
+    #2208: a coord command run with an explicit ``--config <file>`` pointed
+    somewhere other than the fleet's real config — a scratch fixture, a
+    CI-only stub someone wrote specifically so ``coord.config.load()`` has
+    something to parse — is not a request to redefine the fleet. This gates
+    the shared machines/pipeline DB snapshot (``_save_config_snapshot`` in
+    ``coord/commands/_common.py``): only a *path* that matches the ordinary
+    resolution order ($COORD_CONFIG → ``~/.coord/coordinator.yml`` →
+    ``./coordinator.yml``) counts as canonical and is allowed to overwrite
+    that shared table. An explicit ``--config`` that happens to name the
+    same file the default resolution would have picked still counts as
+    canonical — this only catches a genuine *override*.
+    """
+    candidate = Path(path).expanduser().resolve()
+    canonical = resolve_config_path().expanduser().resolve()
+    return candidate == canonical
+
+
 # Safety-by-default: repos without explicit worker_permissions get this deny-list.
 DEFAULT_DENY_COMMANDS: list[str] = [
     "Bash(gh *)",

{code_coordinator-0.5.93 → code_coordinator-0.5.94}/tests/test_config.py

@@ -498,6 +498,54 @@ def test_load_with_no_arg_resolves_default(tmp_path, monkeypatch) -> None:
     assert [r.name for r in cfg.repos] == ["api"]
 
 
+# ── is_canonical_config_path (#2208) ─────────────────────────────────────────
+
+
+def test_is_canonical_config_path_true_for_the_resolved_default(tmp_path, monkeypatch) -> None:
+    from coord import config as cfgmod
+
+    monkeypatch.delenv("COORD_CONFIG", raising=False)
+    home_cfg = tmp_path / "home.yml"
+    home_cfg.write_text("x")
+    monkeypatch.setattr(cfgmod, "USER_CONFIG_PATH", home_cfg)
+    monkeypatch.setattr(cfgmod, "DEFAULT_CONFIG_PATH", tmp_path / "absent-cwd.yml")
+
+    assert cfgmod.is_canonical_config_path(home_cfg) is True
+    # An equivalent (non-normalized) spelling of the same file still counts.
+    assert cfgmod.is_canonical_config_path(tmp_path / "." / "home.yml") is True
+
+
+def test_is_canonical_config_path_false_for_a_scratch_override(tmp_path, monkeypatch) -> None:
+    """#2208: a throwaway --config pointed elsewhere is NOT canonical, even
+    though coord.config.load() parses it fine."""
+    from coord import config as cfgmod
+
+    monkeypatch.delenv("COORD_CONFIG", raising=False)
+    home_cfg = tmp_path / "home.yml"
+    home_cfg.write_text("x")
+    monkeypatch.setattr(cfgmod, "USER_CONFIG_PATH", home_cfg)
+    monkeypatch.setattr(cfgmod, "DEFAULT_CONFIG_PATH", tmp_path / "absent-cwd.yml")
+
+    scratch = tmp_path / "mini2.yml"
+    scratch.write_text("machines:\n  - name: ci-runner\n    host: ci-runner\n")
+
+    assert cfgmod.is_canonical_config_path(scratch) is False
+
+
+def test_is_canonical_config_path_respects_coord_config_env(tmp_path, monkeypatch) -> None:
+    """When $COORD_CONFIG is set, THAT is the canonical path for this
+    environment — matching it counts as canonical, same as any other
+    ordinary (non-override) resolution."""
+    from coord import config as cfgmod
+
+    env_file = tmp_path / "env.yml"
+    env_file.write_text("x")
+    monkeypatch.setenv("COORD_CONFIG", str(env_file))
+
+    assert cfgmod.is_canonical_config_path(env_file) is True
+    assert cfgmod.is_canonical_config_path(tmp_path / "other.yml") is False
+
+
 # ── PipelineConfig helpers ──────────────────────────────────────────────────
 
 

code_coordinator-0.5.94/tests/test_config_snapshot_noncanonical_2208.py

@@ -0,0 +1,299 @@
+"""#2208: `--config <scratch-file>` on the daemon host must not wipe the
+shared ``machines`` table.
+
+Root cause: ``_load_config`` always called ``_save_config_snapshot``, which
+unconditionally ``DELETE FROM machines`` + re-inserts from whatever config was
+just loaded — including a throwaway ``--config /tmp/mini2.yml`` a worker
+pointed at purely so ``coord.config.load()`` had something to parse. The
+#584 guard immediately above the ``DELETE`` only protects a *thin client*
+(``board_service`` configured); it does nothing about a host-side invocation
+carrying a non-canonical ``--config``, which is exactly the dangerous case:
+on the daemon host that guard is inert and the write always lands.
+
+Fix: ``_save_config_snapshot`` now takes the ``config_path`` the config was
+actually loaded from and skips the write (emitting a one-line stderr note
+instead of failing silently) unless that path is exactly what
+``coord.config.resolve_config_path()`` resolves to on its own — i.e. unless
+the caller did not actually override anything. This covers the acceptance
+criteria verbatim:
+
+1. ``--config <tmpfile>`` whose ``machines:`` differ from the canonical
+   config leaves the ``machines`` table unchanged (the exact regression).
+2. The same command with the canonical config still snapshots normally.
+3. A thin client still never writes (the #584 guard is preserved).
+4. The ``machines`` table after a ``--config`` override still lists the
+   real fleet — a plain follow-up run (no override) repairs it either way.
+
+The note is deliberately **scoped to skips that actually withheld a
+change** (:func:`coord.commands._common._note_withheld_snapshot`). A first
+cut printed it on every non-canonical ``--config``, which broke 21 tests
+across this suite: ``--config <tmpfile>`` is how essentially every CLI test
+here (and CI, and the config *validator* in
+``scripts/azure-workers/coordinator-machine.py``) runs coord, and Click's
+``CliRunner`` folds stderr into ``result.output`` — so a per-invocation nag
+corrupted the machine-readable stdout of ``coord plans --json`` /
+``coord scorecard --json`` for anyone parsing combined output.
+``TestTheNoteIsScopedToConsequentialSkips`` below is the regression gate for
+that.
+"""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+import pytest
+from click.testing import CliRunner
+
+from coord.cli import main
+from coord.commands._common import _load_config, _save_config_snapshot
+from coord.config import Config
+from coord.models import Machine, Repo
+
+
+REAL_FLEET_YAML = """\
+repos:
+  - name: real-repo
+    github: acme/real-repo
+machines:
+  - name: laptop
+    host: laptop.tailnet
+    capabilities: [python]
+    repos: [real-repo]
+  - name: server
+    host: server.tailnet
+    capabilities: [python, docker]
+    repos: [real-repo]
+"""
+
+# Mirrors the issue's exact repro file (#2180's worker's /tmp/mini2.yml):
+# just enough for coord.config.load() to parse, explicitly not a real
+# fleet machine.
+SCRATCH_YAML = """\
+# Not a real fleet machine -- just enough for coord.config.load() to parse.
+repos:
+  - name: scratch-repo
+    github: acme/scratch-repo
+machines:
+  - name: ci-runner
+    host: ci-runner
+"""
+
+
+def _real_fleet_config() -> Config:
+    return Config(
+        repos=[Repo(name="real-repo", github="acme/real-repo")],
+        machines=[
+            Machine(name="laptop", host="laptop.tailnet",
+                     capabilities=["python"], repos=["real-repo"]),
+            Machine(name="server", host="server.tailnet",
+                     capabilities=["python", "docker"], repos=["real-repo"]),
+        ],
+    )
+
+
+@pytest.fixture
+def canonical_config_path(tmp_path: Path, monkeypatch) -> Path:
+    """Point ``resolve_config_path()``'s canonical home at a real-looking
+    fleet config, mirroring ``~/.coord/coordinator.yml`` on the daemon host.
+    """
+    import coord.config as cfgmod
+
+    monkeypatch.delenv("COORD_CONFIG", raising=False)
+    p = tmp_path / "home-coordinator.yml"
+    p.write_text(REAL_FLEET_YAML)
+    monkeypatch.setattr(cfgmod, "USER_CONFIG_PATH", p)
+    monkeypatch.setattr(cfgmod, "DEFAULT_CONFIG_PATH", tmp_path / "absent-cwd-coordinator.yml")
+    return p
+
+
+@pytest.fixture
+def scratch_config_path(tmp_path: Path) -> Path:
+    p = tmp_path / "mini2.yml"
+    p.write_text(SCRATCH_YAML)
+    return p
+
+
+def _machine_names(coord_db) -> list[str]:
+    rows = coord_db.execute("SELECT name FROM machines ORDER BY name").fetchall()
+    return [r["name"] for r in rows]
+
+
+class TestNonCanonicalConfigLeavesMachinesUnchanged:
+    """Acceptance criterion 1 (the exact regression): --config <tmpfile>
+    whose machines: differ from the canonical config leaves `machines`
+    unchanged. This must fail before the fix."""
+
+    def test_load_config_with_scratch_override_does_not_wipe_machines(
+        self, coord_db, canonical_config_path, scratch_config_path, capsys
+    ):
+        # Seed the table with the real fleet, as if a prior `coord config`
+        # had already snapshotted it from the canonical file.
+        _save_config_snapshot(_real_fleet_config())
+        assert _machine_names(coord_db) == ["laptop", "server"]
+
+        cfg = _load_config(scratch_config_path)
+
+        # The scratch config parsed fine — that's its whole point...
+        assert [m.name for m in cfg.machines] == ["ci-runner"]
+        # ...but the shared table is untouched.
+        assert _machine_names(coord_db) == ["laptop", "server"]
+
+        err = capsys.readouterr().err
+        assert "non-canonical" in err
+        assert str(scratch_config_path) in err
+        # The note names the fleet it protected, so the operator does not
+        # have to go and ask the DB what it just declined to overwrite —
+        # silence about *that* is what cost an hour in the original
+        # incident.
+        assert "laptop, server" in err
+
+    def test_cli_config_command_with_scratch_override_does_not_wipe_machines(
+        self, coord_db, canonical_config_path, scratch_config_path
+    ):
+        """Mirrors the issue's exact repro: a `coord ... --config
+        /tmp/mini2.yml` invocation on the host must not clobber `machines`,
+        and /board would agree with `coord config`'s own parsed-config
+        output since neither touches the shared table here."""
+        _save_config_snapshot(_real_fleet_config())
+
+        runner = CliRunner()
+        result = runner.invoke(main, ["config", "--config", str(scratch_config_path)])
+
+        assert result.exit_code == 0, result.output
+        assert "ci-runner" in result.output  # `coord config` itself is unaffected
+        assert _machine_names(coord_db) == ["laptop", "server"]
+
+
+class TestCanonicalConfigStillSnapshotsNormally:
+    """Acceptance criterion 2: the same command with the canonical config
+    still snapshots normally."""
+
+    def test_load_config_with_explicit_canonical_path_snapshots(
+        self, coord_db, canonical_config_path
+    ):
+        # Explicitly passing --config pointed at the very file the default
+        # resolution would have picked is NOT an override — it must still
+        # write.
+        cfg = _load_config(canonical_config_path)
+        assert [m.name for m in cfg.machines] == ["laptop", "server"]
+        assert _machine_names(coord_db) == ["laptop", "server"]
+
+    def test_load_config_with_no_override_snapshots(self, coord_db, canonical_config_path):
+        """The default resolution path (no explicit --config at all) must
+        still write — this is what `coord config` on the daemon host relies
+        on to repair a wiped table per the issue's documented runbook."""
+        cfg = _load_config(None)
+        assert [m.name for m in cfg.machines] == ["laptop", "server"]
+        assert _machine_names(coord_db) == ["laptop", "server"]
+
+
+class TestThinClientStillNeverWrites:
+    """Acceptance criterion 3: a thin client still never writes (the #584
+    guard is preserved), independent of whether the resolved path looks
+    canonical."""
+
+    def test_thin_client_does_not_write_even_with_canonical_looking_path(
+        self, coord_db, canonical_config_path, monkeypatch
+    ):
+        import coord.client as cc
+
+        monkeypatch.setattr(
+            cc, "resolve_board_service",
+            lambda *a, **k: cc.ServiceConfig("http://daemon:7435"),
+        )
+        monkeypatch.setattr(cc, "fetch_remote_config", lambda svc, **kw: canonical_config_path)
+
+        _load_config(canonical_config_path)
+
+        assert _machine_names(coord_db) == []
+
+
+class TestTheNoteIsScopedToConsequentialSkips:
+    """The guard must be *silent* when the skip withheld nothing.
+
+    Regression gate for the first cut of this fix, which echoed the note on
+    every non-canonical ``--config`` and thereby broke 21 tests across this
+    suite — including every command that emits JSON, because Click's
+    ``CliRunner`` folds stderr into ``result.output``.
+    """
+
+    def test_no_note_when_the_machines_table_is_empty(
+        self, coord_db, canonical_config_path, scratch_config_path, capsys
+    ):
+        """A fresh host / CI runner has nothing to protect, so there is
+        nothing to say. This is the shape of ~110 CLI test modules here and
+        of every `coord ... --config` step in `.github/workflows/`."""
+        assert _machine_names(coord_db) == []
+
+        _load_config(scratch_config_path)
+
+        assert capsys.readouterr().err == ""
+
+    def test_no_note_when_the_override_names_the_same_fleet(
+        self, coord_db, canonical_config_path, tmp_path, capsys
+    ):
+        """The write would have been a no-op, so the skip cost nothing and
+        warrants no words."""
+        _save_config_snapshot(_real_fleet_config())
+
+        same_fleet = tmp_path / "copy-of-the-real-fleet.yml"
+        same_fleet.write_text(REAL_FLEET_YAML)
+
+        _load_config(same_fleet)
+
+        assert _machine_names(coord_db) == ["laptop", "server"]
+        assert capsys.readouterr().err == ""
+
+    def test_json_command_output_stays_parseable_under_an_override(
+        self, coord_db, canonical_config_path, scratch_config_path
+    ):
+        """The concrete breakage: `coord plans --json --config <tmpfile>`
+        must emit JSON and nothing else, even though `CliRunner` merges
+        stderr into `result.output`."""
+        import json
+        from unittest.mock import patch
+
+        with (
+            patch("coord.github_ops.get_repo_milestones", return_value=[]),
+            patch("coord.github_ops.get_open_issues", return_value=[]),
+            patch("coord.github_ops.get_closed_epics", return_value=[]),
+        ):
+            result = CliRunner().invoke(
+                main, ["plans", "--json", "--config", str(scratch_config_path)]
+            )
+
+        assert result.exit_code == 0, result.output
+        assert json.loads(result.output) == []
+
+    def test_a_db_failure_never_breaks_the_command(
+        self, canonical_config_path, scratch_config_path, monkeypatch, capsys
+    ):
+        """The note is advisory. If the DB cannot be read at all, the guard
+        still skips the write and the command still succeeds."""
+        import coord.db as dbmod
+
+        def _boom():
+            raise RuntimeError("no database here")
+
+        monkeypatch.setattr(dbmod, "get_connection", _boom)
+
+        cfg = _load_config(scratch_config_path)
+
+        assert [m.name for m in cfg.machines] == ["ci-runner"]
+        assert capsys.readouterr().err == ""
+
+
+class TestOverrideThenRepairRestoresRealFleet:
+    """Acceptance criterion 4: the machines table after a --config override
+    still lists the real fleet, and a plain follow-up run agrees."""
+
+    def test_repair_after_override(self, coord_db, canonical_config_path, scratch_config_path):
+        _save_config_snapshot(_real_fleet_config())
+
+        _load_config(scratch_config_path)  # the bogus override: now a no-op
+        assert _machine_names(coord_db) == ["laptop", "server"]
+
+        # Even if the table HAD been left stale, a plain `coord config` run
+        # (no override) repairs it from the canonical file.
+        _load_config(None)
+        assert _machine_names(coord_db) == ["laptop", "server"]

{code_coordinator-0.5.93 → code_coordinator-0.5.94}/tests/test_dist_name.py

@@ -187,8 +187,15 @@ def _renamed_tagged_clone(tmp_path: Path, new_name: str, version: str) -> Path:
     to `claude-coordinator` to model a not-yet-upgraded agent.
     """
     clone = tmp_path / f"renamed_clone_{new_name}"
+    # `--no-hardlinks`: `git clone --local` hardlinks `.git/objects` by
+    # default, which dies with "Invalid cross-device link" whenever pytest's
+    # tmp_path (/tmp) and the checkout sit on different filesystems — the
+    # normal shape of a worker worktree under ~/.coord/worktrees on a box
+    # with a separate /home. Copying the objects costs a fraction of a
+    # second here and makes the test filesystem-layout independent.
     result = _run(
-        ["git", "clone", "--quiet", "--local", "--no-tags", str(REPO_ROOT), str(clone)],
+        ["git", "clone", "--quiet", "--local", "--no-hardlinks", "--no-tags",
+         str(REPO_ROOT), str(clone)],
         cwd=tmp_path,
     )
     assert result.returncode == 0, result.stderr

{code_coordinator-0.5.93 → code_coordinator-0.5.94}/tests/test_providers.py

@@ -2259,6 +2259,37 @@ def _edit_tool_calls(events: list[dict]) -> list[dict]:
     ]
 
 
+def _require_attempt(events: list[dict], calls: list[dict], expectation: str) -> None:
+    """Skip (never fail) when the model refused to even ATTEMPT the
+    forbidden call.
+
+    The DENY tests below prove opencode's *permission system* blocks a
+    call — which requires the model to actually emit the tool_use event.
+    work.md's own system-prompt text ALSO forbids the same actions, and a
+    reasoning-capable free-tier model sometimes refuses in prose without
+    ever calling a tool, e.g. (observed live, 2026-08-14, against the
+    `gh --version` wording that was specifically chosen to avoid this):
+    "I can't run that — my session rules explicitly prohibit running `gh`
+    commands". That outcome exercised the *advisory*, not the enforcement
+    under test; per ``_run_real_opencode_work``'s contract ("skips on any
+    problem that isn't permission enforcement itself") it is skip
+    territory, not a failure — no coord-side change can force a live model
+    to attempt a call its instructions forbid, so a hard assert here is a
+    coin-flip red on every branch (~2 in 4 local runs)."""
+    if calls:
+        return
+    texts = " | ".join(
+        e.get("part", {}).get("text", "")
+        for e in events
+        if e.get("type") == "text"
+    ).strip()
+    pytest.skip(
+        f"model never attempted {expectation} (no matching tool_use event) — "
+        f"the system-prompt advisory preempted it, so permission enforcement "
+        f"was not exercised this run; model said: {texts[:300]!r}"
+    )
+
+
 @_requires_real_opencode
 def test_opencode_work_agent_blocks_gh_end_to_end(tmp_path: Path) -> None:
     """PROOF for capabilities().enforces_deny_list=True: a real `work`-agent
@@ -2279,6 +2310,11 @@ def test_opencode_work_agent_blocks_gh_end_to_end(tmp_path: Path) -> None:
     GitHub interaction" to the model (verified: it reliably attempts it),
     while still matching work.md's `"gh *": "deny"` pattern, which is
     genuinely what's under test here.
+
+    "Reliably" decayed: by 2026-08-14 the live model refuses even
+    `gh --version` on the advisory alone in roughly half of runs. When
+    that happens there is no enforcement to observe — see
+    ``_require_attempt``, which skips instead of failing.
     """
     repo = _init_oc_throwaway_repo(tmp_path)
     events = _run_real_opencode_work(
@@ -2291,7 +2327,7 @@ def test_opencode_work_agent_blocks_gh_end_to_end(tmp_path: Path) -> None:
         if e["part"].get("state", {}).get("input", {}).get("command", "").strip()
         == "gh --version"
     ]
-    assert gh_calls, f"expected the model to attempt 'gh --version': {events}"
+    _require_attempt(events, gh_calls, "'gh --version' via bash")
     for call in gh_calls:
         state = call["part"]["state"]
         assert state.get("status") == "error", f"gh call was not blocked: {call}"
@@ -2334,7 +2370,7 @@ def test_opencode_work_agent_blocks_external_directory_access_end_to_end(
         if e.get("type") == "tool_use"
         and str(victim) in json.dumps(e.get("part", {}).get("state", {}).get("input", {}))
     ]
-    assert outside_calls, f"expected the model to attempt a tool call against {victim}: {events}"
+    _require_attempt(events, outside_calls, f"a tool call against {victim}")
     for call in outside_calls:
         assert call["part"]["state"].get("status") == "error", (
             f"call against the external path was not blocked: {call}"
@@ -2363,7 +2399,7 @@ def test_opencode_work_agent_blocks_tests_acceptance_edit_end_to_end(
         for e in edit_calls
         if "tests/acceptance/" in e["part"].get("state", {}).get("input", {}).get("filePath", "")
     ]
-    assert acceptance_edits, f"expected the model to attempt the edit: {events}"
+    _require_attempt(events, acceptance_edits, "the edit under tests/acceptance/")
     for call in acceptance_edits:
         assert call["part"]["state"].get("status") == "error", (
             f"edit under tests/acceptance/ was not blocked: {call}"

{code_coordinator-0.5.93 → code_coordinator-0.5.94}/tests/test_version_single_source.py

@@ -342,10 +342,19 @@ def tagged_clone(tmp_path: Path) -> Path:
     """A throwaway local clone of this repo, cloned with no tags and then
     given exactly one synthetic `v9.9.9` tag on HEAD — models a tagged
     release checkout without depending on this repo's real (and
-    ever-changing) tag history."""
+    ever-changing) tag history.
+
+    `--no-hardlinks`: `git clone --local` hardlinks `.git/objects` by
+    default, which fails with "Invalid cross-device link" whenever pytest's
+    tmp_path (/tmp) and the checkout live on different filesystems — the
+    normal shape of a worker worktree under ~/.coord/worktrees on a box with
+    a separate /home. Copying instead keeps this fixture independent of the
+    runner's disk layout.
+    """
     clone = tmp_path / "tagged_clone"
     result = _run(
-        ["git", "clone", "--quiet", "--local", "--no-tags", str(REPO_ROOT), str(clone)],
+        ["git", "clone", "--quiet", "--local", "--no-hardlinks", "--no-tags",
+         str(REPO_ROOT), str(clone)],
         cwd=tmp_path,
     )
     assert result.returncode == 0, result.stderr
@@ -357,10 +366,12 @@ def tagged_clone(tmp_path: Path) -> Path:
 @pytest.fixture
 def tagless_clone(tmp_path: Path) -> Path:
     """A throwaway local clone of this repo with no tags reachable at
-    all — models a shallow/tagless CI checkout."""
+    all — models a shallow/tagless CI checkout. See `tagged_clone` for why
+    the clone is `--no-hardlinks`."""
     clone = tmp_path / "tagless_clone"
     result = _run(
-        ["git", "clone", "--quiet", "--local", "--no-tags", str(REPO_ROOT), str(clone)],
+        ["git", "clone", "--quiet", "--local", "--no-hardlinks", "--no-tags",
+         str(REPO_ROOT), str(clone)],
         cwd=tmp_path,
     )
     assert result.returncode == 0, result.stderr