code-coordinator 0.5.68__tar.gz → 0.5.70__tar.gz

{code_coordinator-0.5.68 → code_coordinator-0.5.70}/PKG-INFO

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

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

@@ -1,7 +1,7 @@
 {
-  "tag": "0.5.68",
+  "tag": "0.5.70",
   "distance": 0,
-  "node": "g5c48dfa28457562839e0f3dc02d1de4a685b0a3d",
+  "node": "g522a9f215942bd8d54b0906c6f672934c636ad73",
   "dirty": false,
   "branch": "HEAD",
   "node_date": "2026-08-14"

{code_coordinator-0.5.68 → code_coordinator-0.5.70}/coord/agent.py

@@ -747,6 +747,43 @@ def _graphify_update(repo_path: Path, *, timeout: float = 600.0) -> tuple[bool,
     return True, (result.stdout or "").strip()
 
 
+# #2212: count how many Bash commands in a worker's leg invoked `graphify` —
+# the measurable half of the graph-first navigation rule in
+# WORKER_SYSTEM_PROMPT above. The rule has lapsed into disuse before (see
+# #2212's issue body) because nothing tracked whether workers actually
+# queried the graph; this is written into every reaped worker's log (see
+# the "# reap: done" line in `_reap`) as a plain `grep`-able counter — zero
+# across N consecutive legs means the prompt instruction isn't landing.
+# Deliberately NOT a DB column: this is a cheap, best-effort signal, not a
+# gate anything blocks on, so it stays out of the Assignment schema/migrations.
+# Separators recognized before a command token: `;`, `&`, `|` (covers `&&`
+# and `||` too, since `\s*` after the class soaks up the second char) and a
+# bare newline — Claude Code's Bash tool very commonly emits multi-line
+# command strings (e.g. `cd repo\ngraphify query "foo"`) that aren't joined
+# with `;`/`&&`, so newline must count as a separator or those legs
+# undercount to 0 (#2212 review).
+_GRAPHIFY_INVOCATION_RE = re.compile(r"(?:^|[\n;&|]\s*)graphify(?:\s|$)")
+
+
+def _count_graphify_invocations(bash_commands: list[str]) -> int:
+    """Count *bash_commands* entries that invoke the ``graphify`` CLI.
+
+    Matches ``graphify`` as a command token — at the start of the string,
+    after a shell separator (``;``, ``&&``, ``||``, ``|``), or after a bare
+    newline (multi-line Bash tool calls, e.g. ``cd repo\\ngraphify query
+    "..."``) — so ``graphify query "..."`` counts but a path or string that
+    merely contains the substring ``graphify`` (e.g. ``cat
+    graphify-out/graph.json``, where ``graphify`` is a path component rather
+    than a command) does not.
+
+    Note this counts matching *entries* in ``bash_commands``, not individual
+    invocations: a single command like ``"graphify query a && graphify query
+    b"`` counts once, not twice. Treat the result as an "at least one graph
+    query this leg" signal, not an exact invocation tally.
+    """
+    return sum(1 for cmd in bash_commands if cmd and _GRAPHIFY_INVOCATION_RE.search(cmd))
+
+
 def _infer_repo_github_slug(repo_path: str) -> str | None:
     """Best-effort ``owner/repo`` slug for *repo_path*'s ``origin`` remote (#1492).
 
@@ -1081,6 +1118,7 @@ def _worker_subprocess_env(
     prefix: str | None = None,
     base_prefix: str | None = None,
     cwd: "str | Path | None" = None,
+    assignment_id: str | None = None,
 ) -> dict[str, str]:
     """Environment for worker `claude -p` subprocesses, with the agent's own
     venv removed (#402).
@@ -1113,6 +1151,21 @@ def _worker_subprocess_env(
     ``provider.env()`` on top of this result may still override ``PWD``
     deliberately; that ordering is preserved since we only set it here, not
     after.
+
+    #2217: ``assignment_id``, when given, is written to
+    ``COORD_ASSIGNMENT_ID``. The headless worker prompt (built in
+    ``review.py`` and elsewhere) tells every worker that if this variable is
+    set it should call ``coord report-result --assignment
+    "$COORD_ASSIGNMENT_ID" ...`` directly as the *authoritative* verdict
+    path, with the transcript-parsed ``END_REVIEW`` block as a fallback only.
+    Before this, nothing in the headless ``claude -p`` dispatch lane (this
+    function is the only place that lane's subprocess environment is built)
+    ever set the variable, so that "primary" path was dead on arrival for
+    every headless review — the fragile transcript parse was silently the
+    *only* path, not a backup. Both spawn call sites below pass
+    ``assignment_id=assignment.id`` so it's set for every worker type (review,
+    smoke, work), matching what ``coord/commands/review.py`` already reads as
+    its ``--assignment`` default.
     """
     env = dict(os.environ if base_env is None else base_env)
     pfx = sys.prefix if prefix is None else prefix
@@ -1135,6 +1188,9 @@ def _worker_subprocess_env(
     if cwd is not None:
         env["PWD"] = str(cwd)
 
+    if assignment_id is not None:
+        env["COORD_ASSIGNMENT_ID"] = assignment_id
+
     return env
 
 
@@ -2878,6 +2934,11 @@ absolute path outside your cwd). That shared checkout is not yours: edits \
 there are lost, or collide with other workers running at the same time. If \
 your worktree looks unexpectedly empty or unwritable, STOP and report it — \
 do not fall back to editing the base checkout and copying files over.
+- For "where is X handled" / "what calls this" / architecture questions, \
+query the codebase graph first: `graphify query "<question>"` via Bash. \
+Grep/Read are for confirming an exact string or line, not for discovering \
+structure. No `graphify-out/graph.json` in this worktree? Skip straight to \
+grep, silently — do not stop to build one (#2212).
 
 This session is ONE-SHOT and non-interactive (#1394):
 - There is no next turn and no human to reply to you. Background-task \
@@ -6452,7 +6513,7 @@ class AgentServer:
         # daemon happened to start in — worktree confinement for those
         # providers must not depend on `bash_wrap_spawn` recomputing PWD as
         # a side effect (see `_maybe_bash_wrap`).
-        _spawn_env = _worker_subprocess_env(cwd=repo_path)
+        _spawn_env = _worker_subprocess_env(cwd=repo_path, assignment_id=assignment.id)
         # #1402: shared per-repo cargo target dir (see coord.cargo_cache).
         # Must stay in sync with the PTY path in ``_spawn_pty``.
         _spawn_env.update(
@@ -6626,7 +6687,7 @@ class AgentServer:
             # docstring above), so unlike the headless path it never got an
             # incidental PWD correction — confinement here must not depend
             # on a provider trusting $PWD over getcwd() by accident.
-            env = _worker_subprocess_env(cwd=repo_path)
+            env = _worker_subprocess_env(cwd=repo_path, assignment_id=assignment.id)
             env.setdefault("TERM", "xterm-256color")
             # #1402: point cargo at this machine's shared per-repo target dir
             # so the build cache survives worktree cleanup and is reused by
@@ -7440,7 +7501,20 @@ class AgentServer:
         try:
             with open(assignment.log_path, "a") as reopen:
                 final_status = assignment.status if assignment else "unknown"
-                reopen.write(f"# reap: done (exit_code={exit_code} status={final_status})\n")
+                # #2212: log a plain `graphify_invocations=N` counter alongside
+                # the existing reap line — this is the measurable half of the
+                # graph-first navigation rule (see WORKER_SYSTEM_PROMPT and
+                # `_count_graphify_invocations`). `_worker_summary` is `None`
+                # for a non-stream-json log or a parse failure; counting 0 in
+                # that case is the honest answer, not a lie — best-effort like
+                # everything else in this function.
+                _graphify_invocations = _count_graphify_invocations(
+                    _worker_summary.bash_commands if _worker_summary is not None else []
+                )
+                reopen.write(
+                    f"# reap: done (exit_code={exit_code} status={final_status} "
+                    f"graphify_invocations={_graphify_invocations})\n"
+                )
         except (OSError, AttributeError):
             pass
 

{code_coordinator-0.5.68 → code_coordinator-0.5.70}/tests/test_agent.py

@@ -146,6 +146,36 @@ def test_worker_env_no_cwd_leaves_pwd_untouched() -> None:
     assert env["PWD"] == "/whatever"
 
 
+def test_worker_env_sets_coord_assignment_id() -> None:
+    """#2217: the headless worker prompt (review.py) tells every worker that
+    if $COORD_ASSIGNMENT_ID is set, it must report its verdict straight to
+    the coordinator board via `coord report-result` as the *authoritative*
+    path — with the transcript-parsed END_REVIEW block as a fallback only.
+    Nothing set the variable for the headless `claude -p` dispatch lane, so
+    that "primary" instruction was dead on arrival for every review and the
+    fragile transcript parse was silently the only path. Both `_spawn` call
+    sites must pass assignment_id= so this is set for every worker type."""
+    env = _worker_subprocess_env(
+        {"PATH": "/usr/bin"},
+        prefix="/usr",
+        base_prefix="/usr",
+        assignment_id="abc123",
+    )
+    assert env["COORD_ASSIGNMENT_ID"] == "abc123"
+
+
+def test_worker_env_no_assignment_id_leaves_var_unset() -> None:
+    """When assignment_id isn't passed, COORD_ASSIGNMENT_ID must not appear
+    at all (not even empty) — callers that don't have an assignment yet
+    (e.g. standalone helper use) shouldn't leak a stale/empty value."""
+    env = _worker_subprocess_env(
+        {"PATH": "/usr/bin"},
+        prefix="/usr",
+        base_prefix="/usr",
+    )
+    assert "COORD_ASSIGNMENT_ID" not in env
+
+
 def test_health_reports_machine(tmp_path: Path) -> None:
     server = _server(tmp_path)
     h = server.health()
@@ -431,6 +461,40 @@ def test_spawn_sets_pwd_to_worktree_bash_wrap_enabled(tmp_path: Path) -> None:
     server.shutdown()
 
 
+def test_spawn_sets_coord_assignment_id(tmp_path: Path) -> None:
+    """#2217: the headless `_spawn` path must set COORD_ASSIGNMENT_ID to the
+    assignment's own id — this is the variable the review prompt tells every
+    worker to use for `coord report-result --assignment "$COORD_ASSIGNMENT_ID"
+    ...`, the "authoritative" primary verdict path. Before #2217 nothing set
+    it anywhere in this dispatch lane, so that instruction was silently
+    unreachable for every headless review; only the fragile transcript-parsed
+    END_REVIEW fallback ever ran. This test must fail against pre-#2217 code.
+    """
+    import coord.agent as agent_mod
+
+    repo = _init_repo(tmp_path / "repo")
+    server = _server(tmp_path, repo_path=repo)
+
+    captured_env: list[dict[str, str]] = []
+    real_popen = agent_mod.subprocess.Popen
+
+    def recording_popen(spawn_argv, *args, **kwargs):
+        if kwargs.get("start_new_session"):
+            captured_env.append(dict(kwargs.get("env") or {}))
+        return real_popen(spawn_argv, *args, **kwargs)
+
+    agent_mod.subprocess.Popen = recording_popen  # type: ignore[assignment]
+    try:
+        a = server.assign(_spec(repo, type="review"))
+        final = server.wait_for(a.id)
+    finally:
+        agent_mod.subprocess.Popen = real_popen  # type: ignore[assignment]
+
+    assert captured_env, "Popen was not called"
+    assert captured_env[0]["COORD_ASSIGNMENT_ID"] == final.id == a.id
+    server.shutdown()
+
+
 def test_pty_spawn_sets_pwd_to_repo_path(tmp_path: Path) -> None:
     """#1783: the PTY spawn path (_spawn_pty) gets the same explicit-PWD
     treatment as the headless path.
@@ -1572,6 +1636,66 @@ def test_reap_captures_claude_session_id(tmp_path: Path) -> None:
     server.shutdown()
 
 
+def test_reap_logs_graphify_invocation_count(tmp_path: Path) -> None:
+    """#2212: `_reap` writes a plain `graphify_invocations=N` counter into
+    the worker's log alongside the existing "# reap: done" line — the
+    measurable half of the graph-first navigation rule in
+    WORKER_SYSTEM_PROMPT. A worker whose transcript shows one `graphify
+    query ...` Bash call and one unrelated Bash call must be counted 1, not
+    2 or 0, end-to-end through the real reap path (not just the
+    `_count_graphify_invocations` unit)."""
+    repo = _init_repo(tmp_path / "repo")
+
+    graphify_call = json.dumps({
+        "type": "assistant",
+        "message": {
+            "model": "claude-sonnet-4-6",
+            "content": [{
+                "type": "tool_use",
+                "name": "Bash",
+                "id": "tu_1",
+                "input": {"command": 'graphify query "where is X handled"'},
+            }],
+        },
+    })
+    unrelated_call = json.dumps({
+        "type": "assistant",
+        "message": {
+            "model": "claude-sonnet-4-6",
+            "content": [{
+                "type": "tool_use",
+                "name": "Bash",
+                "id": "tu_2",
+                "input": {"command": "grep -rn foo ."},
+            }],
+        },
+    })
+    result_line = json.dumps({"type": "result", "subtype": "success", "is_error": False})
+    worker_sh = (
+        f"echo '{graphify_call}'; echo '{unrelated_call}'; echo '{result_line}'; exit 0"
+    )
+    server = AgentServer(
+        machine_name="test",
+        repos=["api"],
+        repo_paths={"api": str(repo)},
+        state_dir=tmp_path / "state",
+        worker_command=lambda spec: ["/bin/sh", "-c", worker_sh],
+    )
+    spec = AssignmentSpec(
+        repo_name="api",
+        repo_path=str(repo),
+        issue_number=2212,
+        issue_title="t",
+        briefing="b",
+    )
+    a = server.assign(spec)
+    final = server.wait_for(a.id, timeout=10)
+
+    log_text = Path(final.log_path).read_text()
+    assert "graphify_invocations=1" in log_text
+    server.shutdown()
+
+
 def test_assignment_spec_accepts_resume_session_id() -> None:
     """AssignmentSpec round-trips resume_session_id through to_dict / from dict."""
     spec = AssignmentSpec(

{code_coordinator-0.5.68 → code_coordinator-0.5.70}/tests/test_operational_defaults.py

@@ -13,7 +13,12 @@ from unittest.mock import MagicMock, patch
 
 import pytest
 
-from coord.agent import WORKER_SYSTEM_PROMPT, AssignmentSpec, default_worker_command
+from coord.agent import (
+    WORKER_SYSTEM_PROMPT,
+    AssignmentSpec,
+    _count_graphify_invocations,
+    default_worker_command,
+)
 from coord.config import ConfigError, ReviewsConfig, load
 from coord.models import Machine, Proposal, Repo
 
@@ -47,6 +52,111 @@ def test_worker_system_prompt_requires_clean_build_before_done() -> None:
     assert "explicitly call it out" in WORKER_SYSTEM_PROMPT
 
 
+# ── #2212: graph-first navigation instruction ───────────────────────────────
+
+
+def test_worker_system_prompt_contains_graph_first_instruction() -> None:
+    """#2212: the rule that workers should query the graphify graph before
+    grepping for structure lived only in CLAUDE.md (39.9KB, one paragraph)
+    and never survived contact with a real task — #2180's leg ran 48 greps
+    and 0 graph queries. The rule must live in the short, always-read
+    worker system prompt, name the concrete CLI entry point, and say what
+    grep/read ARE still for (exact-string/line confirmation) so this isn't
+    read as a blanket grep ban."""
+    assert 'graphify query "<question>"' in WORKER_SYSTEM_PROMPT
+    assert "query the codebase graph first" in WORKER_SYSTEM_PROMPT
+    assert "confirming an exact string or line" in WORKER_SYSTEM_PROMPT
+
+
+def test_worker_system_prompt_states_no_graph_fallback() -> None:
+    """A repo/worktree with no built graph must not stall or STUCK a
+    worker — the instruction must say what to do when the graph is
+    absent: fall back to grep, silently."""
+    assert "graphify-out/graph.json" in WORKER_SYSTEM_PROMPT
+    assert "Skip straight to grep" in WORKER_SYSTEM_PROMPT
+
+
+def test_worker_system_prompt_graph_instruction_present_regardless_of_repo() -> None:
+    """The instruction is baked into the static system prompt, not derived
+    per-repo — assert it survives `default_worker_command` for two
+    differently-named repos/specs, the same shape a real dispatch uses."""
+    for repo_name in ("api", "some-other-repo"):
+        spec = AssignmentSpec(
+            repo_name=repo_name,
+            repo_path=f"/tmp/{repo_name}",
+            issue_number=1,
+            issue_title="t",
+            briefing="b",
+        )
+        argv = default_worker_command(spec)
+        idx = argv.index("--system-prompt")
+        assert 'graphify query "<question>"' in argv[idx + 1]
+
+
+def test_default_worker_command_allowed_tools_permits_graph_query_path() -> None:
+    """The graph is queried via `graphify query ...` over Bash — the
+    worker's --allowedTools must still include Bash so that path is
+    reachable (today's allowlist is Read,Edit,Write,Bash,Monitor)."""
+    spec = AssignmentSpec(
+        repo_name="api",
+        repo_path="/tmp/repo",
+        issue_number=1,
+        issue_title="t",
+        briefing="b",
+    )
+    argv = default_worker_command(spec)
+    idx = argv.index("--allowedTools")
+    assert "Bash" in argv[idx + 1].split(",")
+
+
+def test_worker_system_prompt_hard_rules_unchanged_by_graph_instruction() -> None:
+    """The #2212 addition must not displace any of the existing hard
+    rules — assert each is still present so a future prompt edit can't
+    silently drop one of these while touching the nearby graph bullet."""
+    assert "Do NOT run gh commands" in WORKER_SYSTEM_PROMPT
+    assert "Work only inside your current working directory" in WORKER_SYSTEM_PROMPT
+    assert "NEVER commit or push to main or develop directly" in WORKER_SYSTEM_PROMPT
+    assert "This session is ONE-SHOT and non-interactive (#1394)" in WORKER_SYSTEM_PROMPT
+    assert (
+        "Background-task completion notifications will NEVER reach you"
+        in WORKER_SYSTEM_PROMPT
+    )
+    assert "ALWAYS `git add`, `git commit`, and `git push origin HEAD` BEFORE your" in (
+        WORKER_SYSTEM_PROMPT
+    )
+
+
+# ── #2212: graphify-invocation counter (measurability) ──────────────────────
+
+
+def test_count_graphify_invocations_counts_command_tokens() -> None:
+    assert _count_graphify_invocations(['graphify query "where is X handled"']) == 1
+    assert _count_graphify_invocations(["cd repo && graphify update ."]) == 1
+    assert _count_graphify_invocations(["grep -rn foo .", "rg bar ."]) == 0
+
+
+def test_count_graphify_invocations_ignores_path_substring() -> None:
+    """A command that merely mentions `graphify-out/` as a path (not the
+    `graphify` binary as a command token) must not be counted — otherwise
+    the counter over-reports and the "0 across N legs" signal is unreliable."""
+    assert _count_graphify_invocations(["cat graphify-out/graph.json"]) == 0
+
+
+def test_count_graphify_invocations_empty_list() -> None:
+    assert _count_graphify_invocations([]) == 0
+
+
+def test_count_graphify_invocations_counts_newline_separated_commands() -> None:
+    """Claude Code's Bash tool very commonly issues multi-line command
+    strings (`cd` then a command on the next line, multi-step scripts) not
+    joined with `&&`/`;`. A bare newline must count as a separator, or a
+    worker that genuinely queried the graph gets silently undercounted to
+    0 — undermining the "0 across N legs" landing signal (#2212 review)."""
+    assert _count_graphify_invocations(['cd repo\ngraphify query "foo"']) == 1
+    assert _count_graphify_invocations(["set -e\ngraphify update .\n"]) == 1
+    assert _count_graphify_invocations(["cd repo\n  graphify query x"]) == 1
+
+
 # ── Default ReviewsConfig checklist ─────────────────────────────────────────