code-coordinator 0.5.660__tar.gz → 0.5.662__tar.gz

{code_coordinator-0.5.660 → code_coordinator-0.5.662}/PKG-INFO

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

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

@@ -1,7 +1,7 @@
 {
-  "tag": "0.5.660",
+  "tag": "0.5.662",
   "distance": 0,
-  "node": "g84e0243c5811e3c81d1a5513d483f0637e3c0f74",
+  "node": "ge117a8cdf2f43c28be0be40fec94a54767d63259",
   "dirty": false,
   "branch": "HEAD",
   "node_date": "2026-10-22"

{code_coordinator-0.5.660 → code_coordinator-0.5.662}/coord/commands/merge.py

@@ -2114,7 +2114,12 @@ def merge(
         # #1477: re-test any parked CONFLICT entry before resolving
         # --only — a branch repaired since the last tick should be eligible
         # for --only the moment it's clean, not only after a manual --drop.
+        # Keep the events so the --override-human-required check below can
+        # tell "already HUMAN_REQUIRED" apart from "just auto-cleared by this
+        # same reconcile pass" instead of treating the latter as a usage error.
+        _reconciled_assignment_ids = set()
         for _ev in mq.reconcile_conflict_entries(gh_ops):
+            _reconciled_assignment_ids.add(_ev.entry.assignment_id)
             click.echo(
                 f"  {_ev.entry.repo_name} #{_ev.entry.issue_number} "
                 f"({_ev.entry.branch}): {_ev.kind} — {_ev.message}"
@@ -2173,49 +2178,63 @@ def merge(
         # so it gets its own flag, its own validation, and its own audit
         # row, never bundled into --force-merge.
         if override_human_required:
+            _override_already_moot = False
             if only_entry.state != HUMAN_REQUIRED:
-                click.echo(
-                    "error: --override-human-required only applies to a "
-                    f"HUMAN_REQUIRED entry; {only_assignment!r} is in state "
-                    f"{only_entry.state!r}",
-                    err=True,
-                )
-                sys.exit(1)
-            if dry_run:
-                click.echo(
-                    "  --override-human-required: (dry run) would clear "
-                    f"HUMAN_REQUIRED on {only_assignment!r} — "
-                    f"{override_human_required!r}"
-                )
-            else:
-                from coord.audit import record_audit  # noqa: PLC0415
-
-                record_audit(
-                    tier="business",
-                    category="merge",
-                    event_type="human_required_override",
-                    actor="user",
-                    summary=(
-                        f"human_required override: {only_entry.repo_name}"
-                        f"#{only_entry.issue_number} ({only_assignment}) — "
-                        f"{override_human_required}"
-                    ),
-                    repo=only_entry.repo_name,
-                    issue=only_entry.issue_number,
-                    assignment_id=only_entry.assignment_id,
-                    details={"reason": override_human_required},
-                )
-                click.echo(
-                    "  --override-human-required: cleared HUMAN_REQUIRED on "
-                    f"{only_assignment!r} — {override_human_required!r} — "
-                    "requeued as PENDING"
-                )
-            # Reset in-memory state either way so the dry-run event stream
-            # below reflects what a real run would do (matching the review/
-            # smoke gate dry-run convention); actual persistence is still
-            # gated on `not dry_run` in the save block further down.
-            only_entry.state = PENDING
-            only_entry.error = None
+                if only_entry.assignment_id in _reconciled_assignment_ids:
+                    # The reconcile pass just above this already found the
+                    # PR mergeable again and cleared the latch itself — the
+                    # override the operator asked for is moot, not an error.
+                    _override_already_moot = True
+                    click.echo(
+                        "  --override-human-required: not needed — "
+                        f"{only_assignment!r} was already auto-cleared to "
+                        f"{only_entry.state!r} by the conflict reconcile pass"
+                    )
+                else:
+                    click.echo(
+                        "error: --override-human-required only applies to a "
+                        f"HUMAN_REQUIRED entry; {only_assignment!r} is in state "
+                        f"{only_entry.state!r}",
+                        err=True,
+                    )
+                    sys.exit(1)
+            if not _override_already_moot:
+                if dry_run:
+                    click.echo(
+                        "  --override-human-required: (dry run) would clear "
+                        f"HUMAN_REQUIRED on {only_assignment!r} — "
+                        f"{override_human_required!r}"
+                    )
+                else:
+                    from coord.audit import record_audit  # noqa: PLC0415
+
+                    record_audit(
+                        tier="business",
+                        category="merge",
+                        event_type="human_required_override",
+                        actor="user",
+                        summary=(
+                            f"human_required override: {only_entry.repo_name}"
+                            f"#{only_entry.issue_number} ({only_assignment}) — "
+                            f"{override_human_required}"
+                        ),
+                        repo=only_entry.repo_name,
+                        issue=only_entry.issue_number,
+                        assignment_id=only_entry.assignment_id,
+                        details={"reason": override_human_required},
+                    )
+                    click.echo(
+                        "  --override-human-required: cleared HUMAN_REQUIRED on "
+                        f"{only_assignment!r} — {override_human_required!r} — "
+                        "requeued as PENDING"
+                    )
+                # Reset in-memory state either way so the dry-run event
+                # stream below reflects what a real run would do (matching
+                # the review/smoke gate dry-run convention); actual
+                # persistence is still gated on `not dry_run` in the save
+                # block further down.
+                only_entry.state = PENDING
+                only_entry.error = None
         # #2157: MERGED is the one non-PENDING state that is not a failure.
         # An exit code reports whether the CALLER's postcondition holds, and
         # for `--only <aid>` that postcondition is "aid's branch is on the

{code_coordinator-0.5.660 → code_coordinator-0.5.662}/coord/confirm_test.py

@@ -788,6 +788,41 @@ class ConfirmationResult:
         return self.kind in INCONCLUSIVE_KINDS
 
 
+def write_test_output_file(assignment_id: str, output: str) -> Path | None:
+    """Best-effort persist of *output* to ``COORD_DIR/test_output/<assignment_id>.txt``.
+
+    This is the one dedicated channel for quoting raw worker-/suite-authored
+    text back to a fix worker: ``coord fix`` (:mod:`coord.commands.plan_followup`)
+    prefers reading this file over every other evidence source, and —
+    critically — ``test_reason`` does not: that column is scanned by several
+    unanchored regex readers (:func:`coord.state.classify_failure` on every
+    ``test_state="failed"`` write, the smoke budget tallies in
+    :mod:`coord.smoke`) that must never see raw log prose, only the
+    coordinator's own one-line summaries. Anything longer than a headline
+    belongs here, not in ``test_reason``.
+
+    *assignment_id* is the parent **work** row's id (the one a fix leg is
+    spawned from), not a confirming/smoke transition's id — the same key
+    :func:`coord.commands.plan_followup.fix` reads back by.
+
+    A no-op, returning ``None``, when there is nothing to write or when the
+    write itself fails (a read-only ``COORD_DIR``, a full disk, ...); callers
+    treat this as best-effort and must never let it break verdict recording.
+    """
+    if not output:
+        return None
+    from coord.state import COORD_DIR  # noqa: PLC0415
+
+    try:
+        test_output_dir = COORD_DIR / "test_output"
+        test_output_dir.mkdir(parents=True, exist_ok=True)
+        stored = test_output_dir / f"{assignment_id}.txt"
+        stored.write_text(output)
+    except OSError:
+        return None
+    return stored
+
+
 def write_confirmation_output(assignment_id: str, result: ConfirmationResult) -> Path | None:
     """Persist a confirmation run's captured output tail for the fix briefing (#2563).
 
@@ -802,29 +837,13 @@ def write_confirmation_output(assignment_id: str, result: ConfirmationResult) ->
     failing test names, no tracebacks, and had to re-derive the diagnosis the
     daemon already held in memory.
 
-    *assignment_id* is the parent **work** row's id (the one the fix leg is
-    spawned from), not the confirming smoke transition's id — same key
-    :func:`coord.commands.plan_followup.fix` reads back by.
-
     A no-op, returning ``None``, when there is nothing to write (``KIND_OK``
     and ``KIND_SETUP`` both carry an empty ``.output`` — the former because
     nothing failed, the latter because no command ever ran) or when the write
-    itself fails (a read-only ``COORD_DIR``, a full disk, ...); this must
-    never break verdict recording, which is why the caller in
-    :mod:`coord.notify` treats it as best-effort.
+    itself fails; see :func:`write_test_output_file`, which does the actual
+    work.
     """
-    if not result.output:
-        return None
-    from coord.state import COORD_DIR  # noqa: PLC0415
-
-    try:
-        test_output_dir = COORD_DIR / "test_output"
-        test_output_dir.mkdir(parents=True, exist_ok=True)
-        stored = test_output_dir / f"{assignment_id}.txt"
-        stored.write_text(result.output)
-    except OSError:
-        return None
-    return stored
+    return write_test_output_file(assignment_id, result.output)
 
 
 def confirmation_enabled(config=None) -> bool:

{code_coordinator-0.5.660 → code_coordinator-0.5.662}/coord/merge_queue.py

@@ -5763,21 +5763,69 @@ def refresh_entry_assignment(
 
 # ── Stale-conflict reconciliation (#1477) ───────────────────────────────────
 
+# A HUMAN_REQUIRED entry's `error` is not always the pristine original
+# conflict message: `coord.reconcile`'s conflict-fix completion hook builds
+# several of its own escalation messages as `f"{existing_error}; ..."`,
+# prefixing a fresh explanation onto whatever was already there rather than
+# replacing it. `classify_conflict` only pattern-matches wording, so a
+# message carrying one of these prefixes can still contain a `_REBASEABLE_
+# SIGNALS` phrase from the ORIGINAL conflict text and classify as
+# "rebaseable" even though the actual latch reason has nothing to do with
+# mergeability (the branch's content already landed elsewhere, a worker was
+# killed by a usage-limit reset, a reword was refused as non-content-
+# preserving, or an escalation attempt itself could not be dispatched).
+# These phrases are the ones `reconcile_conflict_entries` must still
+# recognize and refuse to unpark, even when `classify_conflict` disagrees.
+_NON_MERGEABILITY_HUMAN_REQUIRED_SIGNALS = (
+    "not a real conflict",  # usage-limit kill — never was a conflict
+    "nothing to merge",  # already-upstream — content already landed elsewhere
+    "manual reword required",  # reword worker declined a non-content-preserving rewrite
+    "escalation could not be dispatched",  # ordinary conflict-fix escalation itself declined
+)
+
+
+def _is_non_mergeability_human_latch(error: str | None) -> bool:
+    """True when ``error`` carries a known non-mergeability escalation
+    phrase, even though it may also contain conflict wording from a
+    prefixed original message (see ``_NON_MERGEABILITY_HUMAN_REQUIRED_
+    SIGNALS`` above).
+    """
+    if not error:
+        return False
+    text = error.lower()
+    return any(sig in text for sig in _NON_MERGEABILITY_HUMAN_REQUIRED_SIGNALS)
+
+
 def reconcile_conflict_entries(gh_ops: "GhOps") -> list["MergeEvent"]:
-    """Re-test every ``CONFLICT`` entry's mergeability and clear stale verdicts.
+    """Re-test stale conflict verdicts (``CONFLICT``, and retry-cap-latched
+    ``HUMAN_REQUIRED``) against live mergeability and clear them when stale.
 
     A ``CONFLICT`` entry caches the ``gh pr merge`` failure message from
     whenever the queue last attempted it, and ``process()`` never looks at it
     again — it only ever iterates ``PENDING`` entries. When a conflict-fix
-    worker (#241) lands a rebase, or a human pushes a fix by hand, the branch
+    worker lands a rebase, or a human pushes a fix by hand, the branch
     becomes clean but the entry sits parked on the old verdict forever,
-    requiring the three-step manual incantation described in #1477
-    (``--drop`` → a bare re-enqueue → ``--only``) to notice.
-
-    This re-tests GitHub's own mergeability computation for every
-    ``CONFLICT`` entry that has an open PR and, when it now reports clean,
-    returns the entry to ``PENDING`` and clears the stored error so it
-    re-enters the ordinary merge flow on this tick — no manual archaeology.
+    requiring a manual ``--drop`` → re-enqueue → ``--only`` incantation to
+    notice.
+
+    The same staleness bites a ``HUMAN_REQUIRED`` entry escalated after a
+    conflict-fix retry-cap hit: if the branch was rebased or the conflict
+    resolved by hand afterwards (e.g. a develop merge that happened to land
+    after the latch), the cached error is now pure archaeology and nothing
+    else re-checks it — a clean, approved branch stays blocked until a
+    manual ``--override-human-required``. Eligibility here requires BOTH
+    that :func:`classify_conflict` reads the message as ``"rebaseable"``
+    AND that it does not carry one of the ``_NON_MERGEABILITY_HUMAN_
+    REQUIRED_SIGNALS`` phrases — a permission/protection latch
+    (``classify_conflict(...) == "human"``), and any latch whose actual
+    cause was never a mergeability question in the first place (content
+    already upstream, a usage-limit kill, a declined reword, a declined
+    escalation), are left untouched.
+
+    This re-tests GitHub's own mergeability computation for every eligible
+    entry that has an open PR and, when it now reports clean, returns the
+    entry to ``PENDING`` and clears the stored error so it re-enters the
+    ordinary merge flow on this tick — no manual archaeology.
 
     Fail-closed by design: an entry with no PR yet, or whose mergeability
     can't be determined (``gh`` error, or GitHub still computing it — both
@@ -5812,7 +5860,22 @@ def reconcile_conflict_entries(gh_ops: "GhOps") -> list["MergeEvent"]:
     events: list[MergeEvent] = []
     changed = False
     for entry in items:
-        if entry.state != CONFLICT or not entry.pr_number:
+        if not entry.pr_number:
+            continue
+        was_human_required = entry.state == HUMAN_REQUIRED
+        if was_human_required:
+            # Only a conflict-fix retry-cap latch is a mergeability
+            # question — a permission/protection latch, or a latch whose
+            # message merely contains leftover conflict wording from a
+            # prefixed original error but was actually caused by something
+            # re-checking `check_pr_mergeable` could never resolve, is left
+            # alone.
+            if (
+                classify_conflict(entry.error) != "rebaseable"
+                or _is_non_mergeability_human_latch(entry.error)
+            ):
+                continue
+        elif entry.state != CONFLICT:
             continue
         try:
             mergeable = gh_ops.check_pr_mergeable(entry.repo_github, entry.pr_number)
@@ -5835,9 +5898,10 @@ def reconcile_conflict_entries(gh_ops: "GhOps") -> list["MergeEvent"]:
         entry.state = PENDING
         entry.error = None
         changed = True
+        cleared_kind = "human_required latch" if was_human_required else "conflict"
         events.append(MergeEvent(
             entry, "reopened",
-            f"conflict cleared — PR #{entry.pr_number} ({entry.branch}) is "
+            f"{cleared_kind} cleared — PR #{entry.pr_number} ({entry.branch}) is "
             "mergeable again, returned to pending",
         ))
     if changed:

{code_coordinator-0.5.660 → code_coordinator-0.5.662}/coord/notify.py

@@ -3280,14 +3280,38 @@ def _record_smoke_verdict(
         # `test_state`, so a headless smoke FAILURE lands as
         # test_state='failed' AND smoke_test='fail' and stays reachable from
         # `coord fix`.
+        #
+        # A plain-runner's marker line (`SMOKE: fail exit=1`) carries nothing
+        # but an exit code — useless to a fix worker who can't tell its own
+        # diff from a red base from that alone. `verdict.context` is the
+        # bounded log tail that preceded the marker, which for the
+        # plain-runner is the captured failing-test output (panic/assertion
+        # lines, the `error: test failed, to rerun pass -p <crate> --test
+        # <name>` hint), and for a `claude -p` smoke worker is usually the
+        # turn where it identified the failure.
+        #
+        # That text is raw worker-/suite-authored prose, so it goes to the
+        # dedicated `test_output` file (`coord.confirm_test.
+        # write_test_output_file`), never into `test_reason` itself —
+        # `test_reason` is scanned unanchored by several readers
+        # (`coord.state.classify_failure` on every failed write,
+        # `coord.smoke`'s budget tallies) that must only ever see the
+        # coordinator's own short summary, not a worker's log output which
+        # could coincidentally contain one of their matched phrases.
+        # `plan_followup.fix()` already prefers this file over `test_reason`
+        # when composing the briefing.
+        from coord.confirm_test import write_test_output_file  # noqa: PLC0415
+
+        write_test_output_file(parent_id, verdict.context)
+        headline = (
+            f"headless smoke: {verdict.reason}"
+            if verdict.reason
+            else "headless smoke reported SMOKE: fail"
+        )
         record_test_verdict(
             assignment_id=parent_id,
             test_state="failed",
-            test_reason=(
-                f"headless smoke: {verdict.reason}"
-                if verdict.reason
-                else "headless smoke reported SMOKE: fail"
-            ),
+            test_reason=headline,
         )
         return
 

{code_coordinator-0.5.660 → code_coordinator-0.5.662}/coord/progress.py

@@ -90,11 +90,22 @@ class SmokeVerdict:
     """#2244: a smoke worker's self-reported verdict line.
 
     ``kind`` is normalised to exactly one of ``"pass"``, ``"fail"`` or
-    ``"baseline-red"``; ``reason`` is the (possibly empty) trailing text.
+    ``"baseline-red"``; ``reason`` is the (possibly empty) trailing text on
+    the marker's own line.
+
+    ``context`` is a bounded tail (:func:`coord.revalidate._tail`) of
+    whatever text preceded the marker — a plain-runner writes its captured
+    test output immediately before `SMOKE: fail exit=N`, and a `claude -p`
+    smoke worker usually states the failing test/assertion in the same turn
+    it prints the marker. This is raw worker-authored text, not a short
+    summary: callers must route it to a channel meant for that (e.g.
+    `coord.confirm_test.write_test_output_file`), never append it to a
+    structured field like `test_reason`.
     """
 
     kind: str
     reason: str = ""
+    context: str = ""
 
 
 @dataclass
@@ -484,17 +495,27 @@ def _extract_smoke_verdict_from_text(text: str) -> "SmokeVerdict | None":
     itself — "I said baseline-red, but re-running shows a real failure")
     means the final line, not the first.
     """
+    from coord.revalidate import _tail  # noqa: PLC0415
+
     matches = list(_SMOKE_VERDICT_RE.finditer(text))
     if not matches:
         return None
-    raw_kind = matches[-1].group(1).lower()
+    last = matches[-1]
+    raw_kind = last.group(1).lower()
     if raw_kind.startswith("baseline"):
         kind = "baseline-red"
     elif raw_kind.startswith("pass"):
         kind = "pass"
     else:
         kind = "fail"
-    return SmokeVerdict(kind=kind, reason=matches[-1].group(2).strip())
+    # Whatever preceded the marker line, bounded the same way
+    # `coord.revalidate`'s own failure tails are. `text[:last.start()]` not
+    # `.end()` — the marker line itself (e.g. `SMOKE: fail exit=1`) is
+    # already captured as `reason` and would just duplicate here.
+    preceding = _tail(text[: last.start()])
+    return SmokeVerdict(
+        kind=kind, reason=last.group(2).strip(), context=preceding,
+    )
 
 
 def _smoke_verdict_texts_from_event(event: object) -> list[str]:

{code_coordinator-0.5.660 → code_coordinator-0.5.662}/tests/test_cli_fix_headless_review.py

@@ -594,6 +594,46 @@ class TestFixFromRedCi:
 
         assert result.exit_code == 0, result.output
 
+    def test_test_output_file_content_reaches_the_rendered_briefing(
+        self, ci_config: Path, coord_dir: Path, monkeypatch
+    ) -> None:
+        """`fix()`'s `elif test_output_file.exists()` branch wins over
+        `test_reason` — pin that the file's content, not just its
+        existence, actually lands in the rendered `## Test failure`
+        section a fix worker reads."""
+        work = _work(test_state="failed", test_reason="exit=1")
+        state_mod.save_board(Board(completed=[work]))
+
+        def boom(*a, **k):
+            raise AssertionError("CI must not be consulted when the test gate failed")
+
+        monkeypatch.setattr("coord.ci_store.build_ci_store", boom)
+
+        test_output_dir = coord_dir / "test_output"
+        test_output_dir.mkdir(parents=True, exist_ok=True)
+        (test_output_dir / "work-abc.txt").write_text(
+            "FAILED tests/readme_truth.rs::version_matches\n"
+            "error: test failed, to rerun pass -p vimcode --test readme_truth\n"
+            "SMOKE: fail exit=1\n"
+        )
+
+        captured = {}
+
+        def fake_dispatch(proposal, config, **kwargs):
+            captured["briefing"] = proposal.briefing
+            return {"id": "fix-t"}
+
+        with patch("coord.dispatch.dispatch", side_effect=fake_dispatch), \
+             patch("coord.github_ops.post_issue_comment"):
+            result = CliRunner().invoke(
+                main, ["fix", "work-abc", "--config", str(ci_config)]
+            )
+
+        assert result.exit_code == 0, result.output
+        assert "## Test failure" in captured["briefing"]
+        assert "FAILED tests/readme_truth.rs::version_matches" in captured["briefing"]
+        assert "to rerun pass -p vimcode --test readme_truth" in captured["briefing"]
+
     def test_dispatch_refused_by_a_pre_dispatch_guard_exits_distinctly(
         self, ci_config: Path, coord_dir: Path, monkeypatch
     ) -> None:

{code_coordinator-0.5.660 → code_coordinator-0.5.662}/tests/test_cli_merge.py

@@ -1132,6 +1132,49 @@ class TestMergeOverrideHumanRequired:
         ).fetchall()
         assert rows == []
 
+    def test_override_moot_when_reconcile_already_cleared_entry(
+        self, config_file: Path, coord_dir: Path, coord_db,
+    ) -> None:
+        """`--only`'s own stale-conflict reconcile pass (#1477) runs before
+        this validation and can itself unpark a HUMAN_REQUIRED retry-cap
+        latch the moment GitHub reports the PR mergeable again. That is not
+        a usage error — the override the operator asked for is simply no
+        longer needed — so it must not be reported as one, and must not
+        write a spurious `human_required_override` audit row for an
+        override that never actually applied."""
+        entry = mq.QueuedMerge(
+            assignment_id="h1", repo_name="api", repo_github="acme/api",
+            branch="worker/h1", target_branch="main", issue_number=1,
+            issue_title="t", state=mq.HUMAN_REQUIRED, pr_number=900,
+            error="gh pr merge 900 ... --rebase failed: not mergeable",
+        )
+        _seed_queue([entry])
+
+        def fake_merge(repo, number, method="rebase"):
+            return True, "ok"
+
+        with patch("coord.github_ops.check_pr_mergeable", return_value=True), \
+             patch("coord.github_ops.create_pr") as create, \
+             patch("coord.github_ops.get_pr_size", return_value=10), \
+             patch("coord.github_ops.merge_pr", side_effect=fake_merge):
+            result = CliRunner().invoke(
+                main,
+                [
+                    "merge", "--config", str(config_file),
+                    "--only", "h1",
+                    "--override-human-required", "no longer needed",
+                ],
+            )
+
+        assert result.exit_code == 0, result.output
+        assert "not needed" in result.output
+        assert "cleared HUMAN_REQUIRED" not in result.output
+
+        rows = coord_db.execute(
+            "SELECT * FROM audit_log WHERE event_type='human_required_override'"
+        ).fetchall()
+        assert rows == []
+
     def test_override_dry_run_does_not_persist_or_audit(
         self, config_file: Path, coord_dir: Path, coord_db,
     ) -> None:

{code_coordinator-0.5.660 → code_coordinator-0.5.662}/tests/test_epic_up_down_symlinked_config_1887.py

@@ -120,17 +120,46 @@ def _fake_coord_home(tmp_path: Path) -> Path:
     return home
 
 
+def _venv_pythonpath() -> str:
+    """site-packages (for PyYAML) and REPO_ROOT (for `coord`), as the block's
+    `PYBIN` subprocess sees them.
+
+    The real daemon host's ~/.coord-venv/bin/python is a venv interpreter that
+    finds `coord` and its deps in its own site-packages. `_fake_coord_home`
+    fakes that interpreter with a bare symlink to this test process's
+    executable -- but a symlink with no adjacent `pyvenv.cfg` is not a venv, so
+    the subprocess resolves its prefix to the base interpreter and cannot see
+    the test venv's site-packages (notably PyYAML, which `coord.config` imports
+    at module top). Python 3.13 made this prefix resolution stricter, so the
+    bare symlink no longer happens to import `yaml`. Hand the subprocess the
+    exact directories where `yaml` and `coord` live for this interpreter, which
+    stands in for the real venv having them installed."""
+    import coord
+    import yaml
+
+    return os.pathsep.join(
+        str(p)
+        for p in (
+            Path(yaml.__file__).resolve().parent.parent,  # site-packages
+            Path(coord.__file__).resolve().parent.parent,  # REPO_ROOT
+        )
+    )
+
+
 def _run_remote_block(body: str, home: Path, *args: str):
     import subprocess
 
     driver = f"set -euo pipefail\n{body}\n"
+    extra_path = _venv_pythonpath()
+    existing = os.environ.get("PYTHONPATH")
+    pythonpath = f"{extra_path}{os.pathsep}{existing}" if existing else extra_path
     return subprocess.run(
         [POSIX_BASH, "-c", driver, "bash", *args],
         capture_output=True,
         text=True,
         timeout=30,
         cwd=REPO_ROOT,
-        env={**os.environ, "HOME": str(home)},
+        env={**os.environ, "HOME": str(home), "PYTHONPATH": pythonpath},
         check=False,
     )