code-coordinator 0.5.189__tar.gz → 0.5.190__tar.gz

{code_coordinator-0.5.189 → code_coordinator-0.5.190}/PKG-INFO

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

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

@@ -1,7 +1,7 @@
 {
-  "tag": "0.5.189",
+  "tag": "0.5.190",
   "distance": 0,
-  "node": "g9c81a5128ae2355b8dee8b005e2836f58e553167",
+  "node": "g99757b0d4a54a8a5b3c7ec90b7c5beeb9f118ecc",
   "dirty": false,
   "branch": "HEAD",
   "node_date": "2026-08-20"

{code_coordinator-0.5.189 → code_coordinator-0.5.190}/coord/agent.py

@@ -3901,13 +3901,16 @@ def _base_checkout_write_guard_tools(repo_path: str) -> list[str]:
 # editing coordinator.yml/coord.db) silently also blocked every worker's own
 # worktree under `~/.coord/worktrees/<id>/`, burning a full $5.23 session
 # that reasoned, designed, and only discovered at the very end that it could
-# not save anything. `default_worker_command`'s `--setting-sources user`
-# (above) closes off the specific mechanism (workers no longer load
-# project/local settings at all), but this preflight check is kept as a
-# defense-in-depth: it also catches a blanket deny rule living in the
-# machine's *user*-level settings (`~/.claude/settings.json`, still loaded)
-# and plain OS-level write failures (read-only mount, wrong ownership, full
-# disk) that have nothing to do with Claude Code at all.
+# not save anything. `default_worker_command`'s `--bare` (above, #2462;
+# originally the narrower `--setting-sources user`) closes off the specific
+# mechanism for headless workers — they no longer load *any* Claude Code
+# settings.json (user, project, or local) — but this preflight check is kept
+# as a defense-in-depth: it still catches a blanket deny rule living in the
+# machine's *user*-level settings (`~/.claude/settings.json`) that would
+# affect the human-attended interactive PTY path (which intentionally keeps
+# the default setting sources, see the comment in `default_worker_command`),
+# and it catches plain OS-level write failures (read-only mount, wrong
+# ownership, full disk) that have nothing to do with Claude Code at all.
 _DENY_PATTERN_RE = re.compile(r"^(Edit|Write)\(//(.+)\)$")
 
 
@@ -3977,11 +3980,13 @@ def find_blocking_deny_rule(
     """Scan Claude Code settings files for a deny rule blocking *worktree_path*.
 
     Defaults to scanning just the machine's user-level settings
-    (``~/.claude/settings.json``) — the one settings source a worker still
-    loads after the ``--setting-sources user`` restriction in
-    :func:`default_worker_command`; a checkout-local
-    ``.claude/settings.local.json`` can no longer reach a worker at all, so
-    it is intentionally not scanned here.
+    (``~/.claude/settings.json``). Since #2462, headless workers run with
+    ``--bare`` and load no Claude Code settings.json at all (user, project,
+    or local) — this file matters for the human-attended interactive PTY
+    path (:class:`coord.providers.claude_pty.ClaudePtyProvider`), which
+    intentionally keeps the default setting sources; a checkout-local
+    ``.claude/settings.local.json`` can no longer reach a headless worker at
+    all either way, so it is intentionally not scanned here.
 
     Returns a human-readable ``"'<pattern>' in <file>"`` message for the
     first matching rule found, or ``None`` when no scanned file carries one
@@ -4051,6 +4056,34 @@ def check_worktree_writable(
     return None
 
 
+def _claude_md_system_prompt_suffix(repo_path: str) -> str:
+    """Return a system-prompt suffix embedding the target repo's CLAUDE.md.
+
+    #2462: worker dispatch below passes ``--bare``, which disables Claude
+    Code's own automatic CLAUDE.md auto-discovery (along with hooks,
+    ``.mcp.json``, and settings — see the ``--bare`` comment in
+    :func:`default_worker_command`). Nothing else in a work-shaped leg's
+    briefing embeds the target repo's actual CLAUDE.md text, so without this
+    a worker would silently lose every per-repo convention, testing rule,
+    and sealed-path note that isn't hardcoded into the repo-agnostic
+    ``WORKER_SYSTEM_PROMPT``.
+
+    Mirrors :func:`coord.review.read_repo_claude_md`, which the review leg
+    already uses for the same reason (a review must never run blind to
+    CLAUDE.md) — this repo's own CLAUDE.md says it is "loaded into every
+    worker leg, every review leg, and every coordinator session", so the
+    work-shaped legs need the identical defensive read now that ambient
+    discovery is gone. Returns ``""`` (a no-op suffix) when the repo has no
+    CLAUDE.md or it can't be read.
+    """
+    from coord.review import read_repo_claude_md  # noqa: PLC0415
+
+    claude_md = read_repo_claude_md(Path(repo_path).expanduser())
+    if not claude_md:
+        return ""
+    return "\n\n## Project rules (from CLAUDE.md)\n\n" + claude_md.strip() + "\n"
+
+
 def default_worker_command(spec: AssignmentSpec, *, binary: str = DEFAULT_WORKER_BINARY) -> list[str]:
     """Build the argv for invoking the worker on this assignment.
 
@@ -4073,6 +4106,9 @@ def default_worker_command(spec: AssignmentSpec, *, binary: str = DEFAULT_WORKER
     """
     if spec.type == "plan":
         system_prompt = spec.system_prompt if spec.system_prompt else WORKER_PLAN_PROMPT
+        # #2462: --bare drops CLAUDE.md auto-discovery; a plan leg still
+        # needs the target repo's conventions to plan against.
+        system_prompt += _claude_md_system_prompt_suffix(spec.repo_path)
         allowed_tools = "Read,Bash"
     elif spec.type == "refinement":
         # #264: refinement is a developer-driven chat for scoping an issue.
@@ -4126,6 +4162,8 @@ def default_worker_command(spec: AssignmentSpec, *, binary: str = DEFAULT_WORKER
         # and deny list instead of the generic WORKER_SYSTEM_PROMPT.
         system_prompt = spec.system_prompt if spec.system_prompt else MOCK_AUTHOR_SYSTEM_PROMPT
         system_prompt += build_deny_prompt(MOCK_AUTHOR_DENY_COMMANDS)
+        # #2462: --bare drops CLAUDE.md auto-discovery.
+        system_prompt += _claude_md_system_prompt_suffix(spec.repo_path)
         allowed_tools = "Read,Edit,Write,Bash"
     elif spec.type == "smoke":
         # #2301: smoke gets its own branch instead of falling through to the
@@ -4177,6 +4215,11 @@ def default_worker_command(spec: AssignmentSpec, *, binary: str = DEFAULT_WORKER
     else:
         system_prompt = spec.system_prompt if spec.system_prompt else WORKER_SYSTEM_PROMPT
         system_prompt += build_deny_prompt(spec.deny_commands)
+        # #2462: --bare drops CLAUDE.md auto-discovery for this catch-all
+        # branch too — it covers "work", "fix", "conflict-fix", and
+        # "test-author", every one of which edits code and needs the
+        # target repo's conventions. See _claude_md_system_prompt_suffix.
+        system_prompt += _claude_md_system_prompt_suffix(spec.repo_path)
         # #2169: `Monitor` is the sanctioned way to poll a backgrounded
         # long-running command in bounded steps (see the ONE-SHOT section of
         # WORKER_SYSTEM_PROMPT) instead of a foreground loop that blocks
@@ -4204,8 +4247,8 @@ def default_worker_command(spec: AssignmentSpec, *, binary: str = DEFAULT_WORKER
         "--system-prompt", system_prompt,
         "--allowedTools", allowed_tools,
         "--permission-mode", "acceptEdits",
-        # #1445: a worker must not inherit whatever project/local Claude Code
-        # settings the host's checkout happens to carry — e.g. a
+        # #1445 / #2462: a worker must not inherit whatever project/local
+        # Claude Code settings the host's checkout happens to carry — e.g. a
         # `.claude/settings.local.json` deny rule the OPERATOR added for
         # their own interactive session in that checkout (meant to protect
         # ~/.coord/coordinator.yml etc from an interactive session, but
@@ -4216,17 +4259,48 @@ def default_worker_command(spec: AssignmentSpec, *, binary: str = DEFAULT_WORKER
         # has no .claude/ dir of its own (it's untracked/gitignored there),
         # so a deny rule that never touches the worktree's working directory
         # still blocked Edit/Write calls from a `claude -p` session cwd'd
-        # into that worktree. Restricting to "user" means a worker's
-        # permission profile is fully controlled by the --allowedTools /
-        # --disallowedTools / --permission-mode flags in this function (and
-        # its own hard-coded system prompt), not by the checkout's
-        # settings.json / settings.local.json. This is the headless/
-        # `claude -p` path only — the human-attended interactive PTY path
-        # (coord.providers.claude_pty.ClaudePtyProvider) intentionally keeps
-        # the default sources so an operator's own `coord init`-configured
-        # convenience allow-list still applies to a session they're
-        # attached to and watching.
-        "--setting-sources", "user",
+        # into that worktree.
+        #
+        # `--setting-sources user` (the original #1445 fix) only closed this
+        # for *settings.json* — a checkout's `.claude/hooks/` and `.mcp.json`
+        # are governed separately and kept loading regardless, so a
+        # never-trusted repo's hooks would still run and its MCP servers
+        # would still connect in every worker session, because a `-p`
+        # session shows neither the workspace-trust dialog nor the
+        # per-server MCP approval prompt that would normally gate that (see
+        # code.claude.com/docs/en/headless.md). `--bare` is the flag that
+        # closes all three sources (settings, hooks, .mcp.json) at once, plus
+        # LSP/plugin-sync/CLAUDE.md auto-discovery — none of which a headless
+        # worker should be picking up *ambiently* from the target repo's own
+        # checkout either. A worker's permission profile is fully controlled
+        # by the --allowedTools / --disallowedTools / --permission-mode
+        # flags in this function (and its own hard-coded system prompt); it
+        # needs no MCP servers (no spec.type grants the `Agent` tool, so
+        # `--agents` is unneeded too) and no `--settings`.
+        #
+        # CLAUDE.md is the one exception worth calling out: losing its
+        # *ambient* auto-discovery does NOT mean a work-shaped leg loses the
+        # content. `_claude_md_system_prompt_suffix` (see the branches
+        # above: "plan", "mock-author", and this catch-all "else") reads it
+        # explicitly off *spec.repo_path* and embeds it into --system-prompt
+        # instead — the same defensive pattern coord.review.read_repo_claude_md
+        # already used for review legs (#2462).
+        #
+        # AUTH CAVEAT: per Claude Code's own docs, `--bare` "never reads
+        # OAuth credentials or the system keychain" — only `ANTHROPIC_API_KEY`
+        # (env, inherited via `_worker_subprocess_env`) or an `apiKeyHelper`
+        # supplied via `--settings` authenticate. This is a behavior change
+        # for any fleet machine whose worker auth today comes from
+        # `claude setup-token` / `CLAUDE_CODE_OAUTH_TOKEN` or an interactive
+        # `claude login` (the pattern docs/CONTROL_CENTER.md §14 documents for
+        # per-person subscription auth) rather than an API key — such a
+        # machine must switch to `ANTHROPIC_API_KEY` (or an `apiKeyHelper`)
+        # for headless dispatch to keep authenticating. This is the
+        # headless/`claude -p` path only — the human-attended interactive PTY
+        # path (coord.providers.claude_pty.ClaudePtyProvider) intentionally
+        # keeps the default sources, so OAuth/keychain login still works for
+        # a session an operator is attached to and watching.
+        "--bare",
     ]
     if spec.model:
         argv.extend(["--model", spec.model])

{code_coordinator-0.5.189 → code_coordinator-0.5.190}/coord/commands/dispatch_workers.py

@@ -147,8 +147,8 @@ def _dispatch_review_of(
 
     from coord.review import (  # noqa: PLC0415
         REVIEWER_SYSTEM_PROMPT,
-        _read_repo_claude_md,
         build_review_briefing,
+        read_repo_claude_md,
     )
     from coord.models import Assignment  # noqa: PLC0415
     from coord.state import (  # noqa: PLC0415
@@ -194,7 +194,7 @@ def _dispatch_review_of(
     # have the reviewer read ./CLAUDE.md in the remote checkout it sits
     # in (its actual rules, not the coordinator's possibly-divergent copy).
     claude_md = (
-        _read_repo_claude_md(Path(review_repo_path)) if _is_local else ""
+        read_repo_claude_md(Path(review_repo_path)) if _is_local else ""
     )
 
     # #612: embed the merge-base (three-dot) diff so the reviewer has

{code_coordinator-0.5.189 → code_coordinator-0.5.190}/coord/providers/claude.py

@@ -118,6 +118,7 @@ class ClaudeProvider(Provider):
             WORKER_PLAN_PROMPT,
             WORKER_SYSTEM_PROMPT,
             _base_checkout_write_guard_tools,
+            _claude_md_system_prompt_suffix,
             _sealed_write_guard_tools,
             build_deny_prompt,
         )
@@ -142,6 +143,10 @@ class ClaudeProvider(Provider):
         if system_prompt is None or allowed_tools is None:
             if spec.type == "plan":
                 _sp = spec.system_prompt if spec.system_prompt else WORKER_PLAN_PROMPT
+                # #2462: keep in sync with default_worker_command's identical
+                # branch — `--bare` below drops CLAUDE.md auto-discovery, so a
+                # plan leg needs the target repo's conventions embedded here.
+                _sp += _claude_md_system_prompt_suffix(spec.repo_path)
                 _at = "Read,Bash"
             elif spec.type == "refinement":
                 _sp = spec.system_prompt if spec.system_prompt else REFINEMENT_SYSTEM_PROMPT
@@ -172,6 +177,9 @@ class ClaudeProvider(Provider):
             elif spec.type == "mock-author":
                 _sp = spec.system_prompt if spec.system_prompt else MOCK_AUTHOR_SYSTEM_PROMPT
                 _sp += build_deny_prompt(MOCK_AUTHOR_DENY_COMMANDS)
+                # #2462: keep in sync with default_worker_command — `--bare`
+                # drops CLAUDE.md auto-discovery.
+                _sp += _claude_md_system_prompt_suffix(spec.repo_path)
                 _at = "Read,Edit,Write,Bash"
             elif spec.type == "smoke":
                 # #2301: keep in sync with default_worker_command's identical
@@ -196,6 +204,12 @@ class ClaudeProvider(Provider):
             else:
                 _sp = spec.system_prompt if spec.system_prompt else WORKER_SYSTEM_PROMPT
                 _sp += build_deny_prompt(spec.deny_commands)
+                # #2462: keep in sync with default_worker_command's identical
+                # catch-all branch — it covers "work", "fix", "conflict-fix"
+                # and "test-author", every one of which edits code and needs
+                # the target repo's CLAUDE.md conventions, which `--bare`
+                # below stops Claude Code from auto-discovering.
+                _sp += _claude_md_system_prompt_suffix(spec.repo_path)
                 # #2169: keep in sync with default_worker_command's identical
                 # branch — Monitor is the sanctioned bounded-poll tool for a
                 # backgrounded long-running command. #2301: this grant is for
@@ -215,10 +229,11 @@ class ClaudeProvider(Provider):
             "--system-prompt", system_prompt,
             "--allowedTools", allowed_tools,
             "--permission-mode", permission_mode,
-            # #1445: see the matching comment in default_worker_command —
-            # workers must not inherit the host checkout's project/local
-            # Claude Code settings.
-            "--setting-sources", "user",
+            # #1445 / #2462: see the matching comment in
+            # default_worker_command — workers must not inherit the host
+            # checkout's project/local Claude Code settings, hooks, or
+            # .mcp.json MCP servers. `--bare` closes all of those at once.
+            "--bare",
         ]
         if effective_model:
             argv.extend(["--model", effective_model])

{code_coordinator-0.5.189 → code_coordinator-0.5.190}/coord/review.py

@@ -1213,7 +1213,7 @@ def _ranked_reviewer_candidates(
 
 # ── Briefing construction ───────────────────────────────────────────────────
 
-def _read_repo_claude_md(repo_path: Path) -> str | None:
+def read_repo_claude_md(repo_path: Path) -> str | None:
     """Return the contents of CLAUDE.md at the repo root, or None.
 
     The coordinator runs on the machine that dispatches; the reviewer runs on
@@ -1221,6 +1221,12 @@ def _read_repo_claude_md(repo_path: Path) -> str | None:
     here so the briefing is self-contained — if the reviewer's checkout is
     behind, the worker's diff still gets reviewed against the rules the
     coordinator thought were current.
+
+    Public (no leading underscore) because #2462 reuses it from
+    :mod:`coord.agent` — since worker dispatch switched to ``--bare``,
+    Claude Code's own CLAUDE.md auto-discovery no longer runs for
+    work-shaped legs, so ``default_worker_command`` embeds this the same
+    defensive way the review briefing already did.
     """
     candidate = repo_path / "CLAUDE.md"
     if not candidate.exists():
@@ -1883,7 +1889,7 @@ def dispatch_review(
     *,
     http_client: httpx.Client | None = None,
     pr_lookup=_find_or_open_pr,
-    claude_md_reader=_read_repo_claude_md,
+    claude_md_reader=read_repo_claude_md,
     issue_body_fetcher=None,
     now: float | None = None,
     terminal_cache: dict | None = None,

{code_coordinator-0.5.189 → code_coordinator-0.5.190}/tests/test_agent.py

@@ -1533,11 +1533,12 @@ def test_default_worker_command_mock_author_not_sealed() -> None:
 # ── #1445: worktree-writability preflight ───────────────────────────────────
 
 
-def test_default_worker_command_restricts_setting_sources_to_user() -> None:
+def test_default_worker_command_uses_bare_mode() -> None:
     """A worker must not inherit the host checkout's project/local Claude
-    Code settings (e.g. a `.claude/settings.local.json` deny rule) — see
-    #1445. --setting-sources user means only the machine's own user-level
-    settings apply; project/local (the checkout) are never loaded."""
+    Code settings, hooks, or .mcp.json MCP servers — see #1445 and #2462.
+    `--bare` closes all three sources at once; the narrower
+    `--setting-sources user` (the original #1445 fix) only closed settings.json
+    and left hooks/.mcp.json loading from a never-trusted repo."""
     spec = AssignmentSpec(
         repo_name="api",
         repo_path="/tmp/repo",
@@ -1546,12 +1547,11 @@ def test_default_worker_command_restricts_setting_sources_to_user() -> None:
         briefing="b",
     )
     argv = default_worker_command(spec)
-    assert "--setting-sources" in argv
-    idx = argv.index("--setting-sources")
-    assert argv[idx + 1] == "user"
+    assert "--bare" in argv
+    assert "--setting-sources" not in argv
 
 
-def test_default_worker_command_restricts_setting_sources_for_plan_type() -> None:
+def test_default_worker_command_uses_bare_mode_for_plan_type() -> None:
     """Same restriction applies to every spec.type, not just 'work' — all of
     them are headless dispatches that must not depend on host checkout
     state."""
@@ -1564,9 +1564,79 @@ def test_default_worker_command_restricts_setting_sources_for_plan_type() -> Non
         type="plan",
     )
     argv = default_worker_command(spec)
-    assert "--setting-sources" in argv
-    idx = argv.index("--setting-sources")
-    assert argv[idx + 1] == "user"
+    assert "--bare" in argv
+    assert "--setting-sources" not in argv
+
+
+def test_default_worker_command_embeds_claude_md_for_work_type(tmp_path: Path) -> None:
+    """#2462: `--bare` disables Claude Code's own CLAUDE.md auto-discovery,
+    so a work-shaped leg would otherwise never see the target repo's
+    CLAUDE.md at all. default_worker_command must embed it into the
+    --system-prompt argv itself, mirroring the review leg's
+    read_repo_claude_md defensive read (coord/review.py)."""
+    (tmp_path / "CLAUDE.md").write_text("# Project rules\n\nAlways use tabs.\n")
+    spec = AssignmentSpec(
+        repo_name="api",
+        repo_path=str(tmp_path),
+        issue_number=1,
+        issue_title="t",
+        briefing="b",
+    )
+    argv = default_worker_command(spec)
+    assert "--bare" in argv
+    idx = argv.index("--system-prompt")
+    system_prompt = argv[idx + 1]
+    assert "Always use tabs." in system_prompt
+    assert "Project rules (from CLAUDE.md)" in system_prompt
+
+
+def test_default_worker_command_embeds_claude_md_for_plan_type(tmp_path: Path) -> None:
+    """Same defensive read applies to type='plan', which gets its own
+    branch in default_worker_command rather than falling into the
+    catch-all 'work' else-branch."""
+    (tmp_path / "CLAUDE.md").write_text("# Project rules\n\nNo emoji.\n")
+    spec = AssignmentSpec(
+        repo_name="api",
+        repo_path=str(tmp_path),
+        issue_number=1,
+        issue_title="t",
+        briefing="b",
+        type="plan",
+    )
+    argv = default_worker_command(spec)
+    idx = argv.index("--system-prompt")
+    assert "No emoji." in argv[idx + 1]
+
+
+def test_default_worker_command_embeds_claude_md_for_mock_author_type(tmp_path: Path) -> None:
+    """Same defensive read applies to type='mock-author'."""
+    (tmp_path / "CLAUDE.md").write_text("# Project rules\n\nGate A first.\n")
+    spec = AssignmentSpec(
+        repo_name="api",
+        repo_path=str(tmp_path),
+        issue_number=1,
+        issue_title="[gate-a] t",
+        briefing="b",
+        type="mock-author",
+    )
+    argv = default_worker_command(spec)
+    idx = argv.index("--system-prompt")
+    assert "Gate A first." in argv[idx + 1]
+
+
+def test_default_worker_command_no_claude_md_is_a_noop(tmp_path: Path) -> None:
+    """A repo with no CLAUDE.md must not blow up or inject an empty section
+    header into the system prompt."""
+    spec = AssignmentSpec(
+        repo_name="api",
+        repo_path=str(tmp_path),
+        issue_number=1,
+        issue_title="t",
+        briefing="b",
+    )
+    argv = default_worker_command(spec)
+    idx = argv.index("--system-prompt")
+    assert "Project rules (from CLAUDE.md)" not in argv[idx + 1]
 
 
 def test_deny_pattern_blocks_path_matches_blanket_prefix() -> None:

{code_coordinator-0.5.189 → code_coordinator-0.5.190}/tests/test_providers.py

@@ -187,6 +187,91 @@ def test_parity_custom_system_prompt() -> None:
     _parity(spec)
 
 
+# ── #2462: CLAUDE.md embed parity (--bare kills auto-discovery) ──────────────
+#
+# The parity helper above uses repo_path="/some/path", which does not exist —
+# so `_claude_md_system_prompt_suffix` returns "" on BOTH sides and the parity
+# assertion cannot see a divergence in the CLAUDE.md embed. These cases point
+# the spec at a tmp_path that really contains a CLAUDE.md, so the embed is
+# non-empty and parity is actually load-bearing for it. The direct
+# `build_command` assertions below then pin the provider seam itself — the
+# path production dispatch really takes (coord/commands/dispatch_workers.py
+# and friends call provider.build_command(), never default_worker_command) —
+# so "both sides dropped the embed" fails too, not just "they diverged".
+
+
+def _claude_md_repo(tmp_path: Path, body: str) -> Path:
+    (tmp_path / "CLAUDE.md").write_text(body)
+    return tmp_path
+
+
+def test_parity_work_type_with_real_claude_md(tmp_path: Path) -> None:
+    """Work leg: identical argv when the repo really has a CLAUDE.md."""
+    repo = _claude_md_repo(tmp_path, "# Project rules\n\nAlways use tabs.\n")
+    _parity(_make_spec(type="work", repo_path=str(repo)))
+
+
+def test_parity_plan_type_with_real_claude_md(tmp_path: Path) -> None:
+    """Plan leg: identical argv when the repo really has a CLAUDE.md."""
+    repo = _claude_md_repo(tmp_path, "# Project rules\n\nNo emoji.\n")
+    _parity(_make_spec(type="plan", repo_path=str(repo)))
+
+
+def test_parity_mock_author_type_with_real_claude_md(tmp_path: Path) -> None:
+    """Mock-author leg: identical argv when the repo really has a CLAUDE.md."""
+    repo = _claude_md_repo(tmp_path, "# Project rules\n\nGate A first.\n")
+    _parity(_make_spec(type="mock-author", repo_path=str(repo)))
+
+
+def test_parity_fix_type_with_real_claude_md(tmp_path: Path) -> None:
+    """Fix leg (catch-all branch, same as work/conflict-fix/test-author)."""
+    repo = _claude_md_repo(tmp_path, "# Project rules\n\nRun ruff.\n")
+    _parity(_make_spec(type="fix", repo_path=str(repo)))
+
+
+@pytest.mark.parametrize(
+    ("spec_type", "rule"),
+    [
+        ("work", "Always use tabs."),
+        ("fix", "Run ruff."),
+        ("conflict-fix", "Rebase, never merge."),
+        ("test-author", "Black-box tests only."),
+        ("plan", "No emoji."),
+        ("mock-author", "Gate A first."),
+    ],
+)
+def test_build_command_embeds_claude_md_for_work_shaped_types(
+    tmp_path: Path, spec_type: str, rule: str
+) -> None:
+    """#2462: the provider seam — the path real dispatch takes — must embed
+    the target repo's CLAUDE.md into --system-prompt for every work-shaped
+    leg, since `--bare` disables Claude Code's own auto-discovery of it."""
+    repo = _claude_md_repo(tmp_path, f"# Project rules\n\n{rule}\n")
+    argv = ClaudeProvider().build_command(_make_spec(type=spec_type, repo_path=str(repo)))
+    assert "--bare" in argv
+    system_prompt = argv[argv.index("--system-prompt") + 1]
+    assert rule in system_prompt
+    assert "Project rules (from CLAUDE.md)" in system_prompt
+
+
+def test_build_command_no_claude_md_is_a_noop(tmp_path: Path) -> None:
+    """A repo with no CLAUDE.md must not inject an empty section header."""
+    argv = ClaudeProvider().build_command(_make_spec(type="work", repo_path=str(tmp_path)))
+    system_prompt = argv[argv.index("--system-prompt") + 1]
+    assert "Project rules (from CLAUDE.md)" not in system_prompt
+
+
+def test_build_command_system_prompt_override_wins_over_claude_md(tmp_path: Path) -> None:
+    """An explicit system_prompt kwarg is used verbatim — the CLAUDE.md embed
+    is part of the *computed* prompt only, matching default_worker_command's
+    behaviour when a caller supplies its own prompt."""
+    repo = _claude_md_repo(tmp_path, "# Project rules\n\nAlways use tabs.\n")
+    argv = ClaudeProvider().build_command(
+        _make_spec(type="work", repo_path=str(repo)), system_prompt="Custom."
+    )
+    assert argv[argv.index("--system-prompt") + 1] == "Custom."
+
+
 def test_resolved_model_overrides_spec_model() -> None:
     """resolved_model takes precedence over spec.model."""
     spec = _make_spec(type="work", model="sonnet")