claude-dev-env 2.2.1 → 2.4.0

package/skills/fresh-branch/scripts/test_create_fresh_branch.py

@@ -146,6 +146,21 @@ def build_repo_with_origin(workspace_path: Path) -> Path:
     return clone_path
 
 
+def read_branch_config(
+    repository_path: Path,
+    branch_name: str,
+    config_leaf: str,
+) -> str:
+    completed = subprocess.run(
+        ["git", "config", "--get", f"branch.{branch_name}.{config_leaf}"],
+        cwd=str(repository_path),
+        check=False,
+        capture_output=True,
+        text=True,
+    )
+    return completed.stdout.strip()
+
+
 def read_head_branch(repository_path: Path) -> str:
     completed = run_git(["rev-parse", "--abbrev-ref", "HEAD"], repository_path)
     return completed.stdout.strip()
@@ -156,6 +171,14 @@ def read_head_commit(repository_path: Path) -> str:
     return completed.stdout.strip()
 
 
+def read_remote_main_commit(repository_path: Path) -> str:
+    completed = run_git(
+        ["ls-remote", REMOTE_NAME, f"refs/heads/{MAIN_BRANCH_NAME}"],
+        repository_path,
+    )
+    return completed.stdout.split()[0]
+
+
 class TestResolveAgentSlug:
     def should_prefer_flag_over_environment(
         self,
@@ -512,6 +535,81 @@ class TestCreateFreshBranchIntegration:
         assert read_head_commit(worktree_path) != local_main_commit
 
 
+class TestWorktreeBranchTracking:
+    def should_leave_new_branch_without_an_upstream(
+        self,
+        tmp_path: Path,
+        monkeypatch: pytest.MonkeyPatch,
+    ) -> None:
+        module = load_create_fresh_branch_module()
+        repository_path = build_repo_with_origin(tmp_path / "repo")
+        agent_scratch_parent = tmp_path / "agent-scratch"
+        monkeypatch.setattr(module.sys, "platform", "linux")
+        monkeypatch.setattr(
+            module.tempfile,
+            "gettempdir",
+            lambda: str(agent_scratch_parent),
+        )
+        success_payload = module.create_fresh_branch(
+            branch_name="fix/no-upstream",
+            repo_path=repository_path,
+            agent_slug="claude",
+            base_ref=DEFAULT_BASE_REF,
+        )
+        worktree_path = Path(success_payload[PAYLOAD_KEY_WORKTREE_PATH])
+        assert read_head_branch(worktree_path) == "fix/no-upstream"
+        assert read_branch_config(repository_path, "fix/no-upstream", "merge") == ""
+        assert read_branch_config(repository_path, "fix/no-upstream", "remote") == ""
+
+    def should_not_aim_a_bare_push_at_main_under_push_default_upstream(
+        self,
+        tmp_path: Path,
+        monkeypatch: pytest.MonkeyPatch,
+    ) -> None:
+        module = load_create_fresh_branch_module()
+        repository_path = build_repo_with_origin(tmp_path / "repo")
+        empty_hooks_path = tmp_path / "repo" / "empty-hooks"
+        run_git(
+            ["config", "push.default", "upstream"],
+            repository_path,
+            empty_hooks_path=empty_hooks_path,
+        )
+        agent_scratch_parent = tmp_path / "agent-scratch"
+        monkeypatch.setattr(module.sys, "platform", "linux")
+        monkeypatch.setattr(
+            module.tempfile,
+            "gettempdir",
+            lambda: str(agent_scratch_parent),
+        )
+        success_payload = module.create_fresh_branch(
+            branch_name="feature/silent-push",
+            repo_path=repository_path,
+            agent_slug="claude",
+            base_ref=DEFAULT_BASE_REF,
+        )
+        worktree_path = Path(success_payload[PAYLOAD_KEY_WORKTREE_PATH])
+        (worktree_path / SEED_FILE_NAME).write_text("drive-by\n", encoding="utf-8")
+        run_git(["add", SEED_FILE_NAME], worktree_path, empty_hooks_path=empty_hooks_path)
+        run_git(
+            ["commit", "-m", "work on the feature branch"],
+            worktree_path,
+            empty_hooks_path=empty_hooks_path,
+        )
+        origin_main_before = read_remote_main_commit(repository_path)
+        push_attempt = subprocess.run(
+            ["git", "-c", f"core.hooksPath={empty_hooks_path}", "push"],
+            cwd=str(worktree_path),
+            check=False,
+            capture_output=True,
+            text=True,
+        )
+        assert push_attempt.returncode != 0, (
+            "bare push should be refused, but it succeeded:\n"
+            f"{push_attempt.stdout}{push_attempt.stderr}"
+        )
+        assert read_remote_main_commit(repository_path) == origin_main_before
+
+
 class TestMainCli:
     def should_print_success_json_and_exit_zero(
         self,

package/skills/fresh-branch/scripts/test_fresh_branch_git_commands.py

@@ -0,0 +1,310 @@
+"""Behavioral tests for fresh_branch_git_commands using real temporary git repos."""
+
+from __future__ import annotations
+
+import subprocess
+import sys
+from pathlib import Path
+
+import pytest
+
+SCRIPTS_DIRECTORY = Path(__file__).resolve().parent
+if str(SCRIPTS_DIRECTORY) not in sys.path:
+    sys.path.insert(0, str(SCRIPTS_DIRECTORY))
+
+from fresh_branch_git_commands import (
+    assert_git_accepts_branch_name,
+    build_worktree_add_arguments,
+    create_worktree_branch,
+    fetch_base_ref,
+    is_ref_present,
+    read_failure_text,
+    resolve_base_commit,
+    resolve_repo_root,
+    run_git,
+    split_remote_ref,
+)
+
+GIT_USER_NAME = "fresh-branch-test"
+GIT_USER_EMAIL = "fresh-branch-test@example.com"
+MAIN_BRANCH_NAME = "main"
+SEED_FILE_NAME = "README.md"
+SEED_FILE_CONTENTS = "seed\n"
+
+
+def build_repo(workspace_path: Path) -> Path:
+    workspace_path.mkdir(parents=True, exist_ok=True)
+    empty_hooks_path = workspace_path / "empty-hooks"
+    empty_hooks_path.mkdir()
+    hooks_argument = ["-c", f"core.hooksPath={empty_hooks_path}"]
+    subprocess.run(
+        ["git", *hooks_argument, "init", "-b", MAIN_BRANCH_NAME, str(workspace_path)],
+        check=True,
+        capture_output=True,
+        text=True,
+    )
+    for each_pair in (
+        ("user.name", GIT_USER_NAME),
+        ("user.email", GIT_USER_EMAIL),
+        ("commit.gpgsign", "false"),
+    ):
+        subprocess.run(
+            ["git", *hooks_argument, "config", *each_pair],
+            cwd=str(workspace_path),
+            check=True,
+            capture_output=True,
+            text=True,
+        )
+    (workspace_path / SEED_FILE_NAME).write_text(SEED_FILE_CONTENTS, encoding="utf-8")
+    subprocess.run(
+        ["git", *hooks_argument, "add", SEED_FILE_NAME],
+        cwd=str(workspace_path),
+        check=True,
+        capture_output=True,
+        text=True,
+    )
+    subprocess.run(
+        ["git", *hooks_argument, "commit", "-m", "initial commit"],
+        cwd=str(workspace_path),
+        check=True,
+        capture_output=True,
+        text=True,
+    )
+    return workspace_path
+
+
+def build_clone_with_origin(workspace_path: Path) -> tuple[Path, Path]:
+    seed_path = build_repo(workspace_path / "seed")
+    empty_hooks_path = seed_path / "empty-hooks"
+    hooks_argument = ["-c", f"core.hooksPath={empty_hooks_path}"]
+    bare_origin = workspace_path / "origin.git"
+    subprocess.run(
+        ["git", *hooks_argument, "clone", "--bare", str(seed_path), str(bare_origin)],
+        check=True,
+        capture_output=True,
+        text=True,
+    )
+    clone_path = workspace_path / "clone"
+    subprocess.run(
+        ["git", *hooks_argument, "clone", str(bare_origin), str(clone_path)],
+        check=True,
+        capture_output=True,
+        text=True,
+    )
+    for each_pair in (
+        ("user.name", GIT_USER_NAME),
+        ("user.email", GIT_USER_EMAIL),
+        ("commit.gpgsign", "false"),
+    ):
+        subprocess.run(
+            ["git", *hooks_argument, "config", *each_pair],
+            cwd=str(clone_path),
+            check=True,
+            capture_output=True,
+            text=True,
+        )
+    return clone_path, bare_origin
+
+
+def advance_origin_main(workspace_path: Path, bare_origin: Path) -> str:
+    pusher_path = workspace_path / "pusher"
+    empty_hooks_path = workspace_path / "seed" / "empty-hooks"
+    hooks_argument = ["-c", f"core.hooksPath={empty_hooks_path}"]
+    subprocess.run(
+        ["git", *hooks_argument, "clone", str(bare_origin), str(pusher_path)],
+        check=True,
+        capture_output=True,
+        text=True,
+    )
+    for each_pair in (
+        ("user.name", GIT_USER_NAME),
+        ("user.email", GIT_USER_EMAIL),
+        ("commit.gpgsign", "false"),
+    ):
+        subprocess.run(
+            ["git", *hooks_argument, "config", *each_pair],
+            cwd=str(pusher_path),
+            check=True,
+            capture_output=True,
+            text=True,
+        )
+    (pusher_path / SEED_FILE_NAME).write_text("advanced\n", encoding="utf-8")
+    subprocess.run(
+        ["git", *hooks_argument, "commit", "-am", "advance main"],
+        cwd=str(pusher_path),
+        check=True,
+        capture_output=True,
+        text=True,
+    )
+    subprocess.run(
+        ["git", *hooks_argument, "push", "origin", MAIN_BRANCH_NAME],
+        cwd=str(pusher_path),
+        check=True,
+        capture_output=True,
+        text=True,
+    )
+    completed = subprocess.run(
+        ["git", "rev-parse", "HEAD"],
+        cwd=str(pusher_path),
+        check=True,
+        capture_output=True,
+        text=True,
+    )
+    return completed.stdout.strip()
+
+
+def read_branch_config(
+    repository_path: Path,
+    branch_name: str,
+    config_leaf: str,
+) -> str:
+    completed = subprocess.run(
+        ["git", "config", "--get", f"branch.{branch_name}.{config_leaf}"],
+        cwd=str(repository_path),
+        check=False,
+        capture_output=True,
+        text=True,
+    )
+    return completed.stdout.strip()
+
+
+class TestBuildWorktreeAddArguments:
+    def test_pass_no_track_so_the_new_branch_gets_no_upstream(self) -> None:
+        all_arguments = build_worktree_add_arguments(
+            "fix/x",
+            Path("/tmp/agent/fix/x"),
+            "origin/main",
+        )
+        assert "--no-track" in all_arguments
+
+    def test_order_arguments_the_way_git_worktree_add_expects(self) -> None:
+        all_arguments = build_worktree_add_arguments(
+            "fix/x",
+            Path("/tmp/agent/fix/x"),
+            "origin/main",
+        )
+        assert all_arguments[:4] == ["worktree", "add", "-b", "fix/x"]
+        assert all_arguments[-1] == "origin/main"
+        assert all_arguments[-2] == str(Path("/tmp/agent/fix/x"))
+
+
+class TestSplitRemoteRef:
+    def test_split_an_origin_ref(self) -> None:
+        assert split_remote_ref("origin/main") == ("origin", "main")
+
+    def test_split_a_non_origin_remote_ref(self) -> None:
+        assert split_remote_ref("upstream/dev") == ("upstream", "dev")
+
+    def test_default_a_bare_name_to_origin(self) -> None:
+        assert split_remote_ref("main") == ("origin", "main")
+
+    def test_keep_slashes_inside_the_branch_name(self) -> None:
+        assert split_remote_ref("origin/fix/nested") == ("origin", "fix/nested")
+
+
+class TestAssertGitAcceptsBranchName:
+    def test_accept_a_conventional_branch_name(self) -> None:
+        assert assert_git_accepts_branch_name("fix/example-one") is None
+
+    def test_reject_a_name_git_refuses(self) -> None:
+        with pytest.raises(ValueError, match="relative path"):
+            assert_git_accepts_branch_name("fix..example")
+
+
+class TestResolveRepoRoot:
+    def test_return_the_toplevel_for_a_nested_path(self, tmp_path: Path) -> None:
+        repository_path = build_repo(tmp_path / "repo")
+        nested_path = repository_path / "nested"
+        nested_path.mkdir()
+        assert resolve_repo_root(nested_path).resolve() == repository_path.resolve()
+
+    def test_raise_outside_a_repository(self, tmp_path: Path) -> None:
+        plain_directory = tmp_path / "plain"
+        plain_directory.mkdir()
+        with pytest.raises(RuntimeError, match="git repository"):
+            resolve_repo_root(plain_directory)
+
+
+class TestIsRefPresent:
+    def test_find_a_local_branch(self, tmp_path: Path) -> None:
+        repository_path = build_repo(tmp_path / "repo")
+        assert is_ref_present(repository_path, MAIN_BRANCH_NAME) is True
+
+    def test_not_find_an_absent_ref(self, tmp_path: Path) -> None:
+        repository_path = build_repo(tmp_path / "repo")
+        assert is_ref_present(repository_path, "origin/nowhere") is False
+
+
+class TestReadFailureText:
+    def test_prefer_stderr(self, tmp_path: Path) -> None:
+        repository_path = build_repo(tmp_path / "repo")
+        completed = run_git(["rev-parse", "does-not-exist"], repository_path)
+        assert completed.returncode != 0
+        assert "does-not-exist" in read_failure_text(completed)
+
+
+class TestFetchBaseRef:
+    def test_bring_the_remote_tip_into_the_clone(self, tmp_path: Path) -> None:
+        clone_path, bare_origin = build_clone_with_origin(tmp_path / "workspace")
+        advanced_commit = advance_origin_main(tmp_path / "workspace", bare_origin)
+        fetch_base_ref(clone_path, "origin/main")
+        assert is_ref_present(clone_path, "origin/main") is True
+        assert resolve_base_commit(clone_path, "origin/main") == advanced_commit
+
+    def test_raise_for_a_remote_branch_that_does_not_exist(
+        self,
+        tmp_path: Path,
+    ) -> None:
+        clone_path, _bare_origin = build_clone_with_origin(tmp_path / "workspace")
+        with pytest.raises(RuntimeError, match="git fetch failed"):
+            fetch_base_ref(clone_path, "origin/nowhere")
+
+
+class TestResolveBaseCommit:
+    def test_return_the_sha_at_the_ref(self, tmp_path: Path) -> None:
+        repository_path = build_repo(tmp_path / "repo")
+        head_commit = run_git(["rev-parse", "HEAD"], repository_path).stdout.strip()
+        assert resolve_base_commit(repository_path, MAIN_BRANCH_NAME) == head_commit
+
+    def test_raise_for_an_unresolvable_ref(self, tmp_path: Path) -> None:
+        repository_path = build_repo(tmp_path / "repo")
+        with pytest.raises(RuntimeError, match="could not resolve base commit"):
+            resolve_base_commit(repository_path, "refs/heads/nowhere")
+
+
+class TestCreateWorktreeBranch:
+    def test_create_the_branch_at_the_base_ref_with_no_upstream(
+        self,
+        tmp_path: Path,
+    ) -> None:
+        clone_path, _bare_origin = build_clone_with_origin(tmp_path / "workspace")
+        origin_tip = resolve_base_commit(clone_path, "origin/main")
+        worktree_path = tmp_path / "worktrees" / "fix" / "created"
+        create_worktree_branch(
+            clone_path,
+            branch_name="fix/created",
+            worktree_path=worktree_path,
+            base_ref="origin/main",
+        )
+        assert worktree_path.is_dir()
+        assert resolve_base_commit(worktree_path, "HEAD") == origin_tip
+        assert read_branch_config(clone_path, "fix/created", "merge") == ""
+        assert read_branch_config(clone_path, "fix/created", "remote") == ""
+
+    def test_raise_when_the_branch_already_exists(self, tmp_path: Path) -> None:
+        clone_path, _bare_origin = build_clone_with_origin(tmp_path / "workspace")
+        first_path = tmp_path / "worktrees" / "dup-one"
+        second_path = tmp_path / "worktrees" / "dup-two"
+        create_worktree_branch(
+            clone_path,
+            branch_name="fix/dup",
+            worktree_path=first_path,
+            base_ref="origin/main",
+        )
+        with pytest.raises(RuntimeError, match="worktree add failed"):
+            create_worktree_branch(
+                clone_path,
+                branch_name="fix/dup",
+                worktree_path=second_path,
+                base_ref="origin/main",
+            )

package/skills/orchestrator/SKILL.md

@@ -30,32 +30,13 @@ The moment it edits a file or runs a test itself, the pairing breaks —
 its own tool use stays orchestration, run-artifact writes, and light
 verification reads.
 
-## Design rule — thin prompts, thick artifacts, thin skill
-
-Three faces of one rule (reading pinned by the audit spec on
-jl-cmd/claude-dev-env#174: thin means high-signal, not short; thick
-context lives outside the window, reachable by pointers):
-
-- **Thin prompts.** A spawn prompt is a dispatch ticket: one task,
-  pointers to the artifacts that hold the context, one done-check, a thin
-  return contract. The prompt can be thin because the context is thick
-  elsewhere.
-- **Thick artifacts.** Durable run state lives in files — the run
-  charter, one assignment file per task, result records — written once,
-  read by every agent that needs them, and still there when any one
-  agent's context is gone.
-- **Thin skill.** This file holds only what changes decisions at
-  orchestration time. Standing policy lives where it loads once:
-  [`_shared/advisor/advisor-protocol.md`](../../_shared/advisor/advisor-protocol.md)
-  for everything advisor, the agent definitions for executor discipline.
-
 ## Process
 
 1. **Invocation guard.** One `/orchestrator` per session. When the
    refresh loop is already running, do not schedule a second one; reuse
    the live advisor bind and go to step 4.
 2. **Register the discipline reminder.** Schedule it with
-   `ScheduleWakeup` at `delaySeconds: 1800`, prompt
+   `ScheduleWakeup` at `delaySeconds: 2700`, prompt
    `/orchestrator-refresh`, where each refresh re-schedules the next one.
 3. **Bind the shared advisor before any executor.** Follow
    [`_shared/advisor/advisor-protocol.md`](../../_shared/advisor/advisor-protocol.md)

package/skills/orchestrator-refresh/SKILL.md

@@ -1,7 +1,7 @@
 ---
 name: orchestrator-refresh
 description: >-
-  Fired by the /orchestrator loop reminder about every 20 minutes to
+  Fired by the /orchestrator loop reminder about every 45 minutes to
   re-assert the advisor discipline mid-run: orchestrate, route hard decisions
   to the shared advisor (ENDORSE / CORRECTION / PLAN / STOP — SendMessage on
   Claude, Claude CLI chain on a third-party host), reuse warm agents. Triggers:

package/skills/pr-converge/SKILL.md

@@ -195,7 +195,7 @@ the `persistent_agents` map
   record it, and continue the tick. Never abort a tick on a stale id;
   never retry the same dead id.
 - **Fresh every round (never persisted):** the Step 5 host-aware
-  `invoke_code_review.py` / `/code-review high --fix` pass and the Step 6
+  `invoke_code_review.py` / `/code-review xhigh --fix` pass and the Step 6
   bugteam audit (unbiased eyes each round; the enforcer needs the formal
   Skill call), and every `code-verifier` — a named code-verifier never fires
   `SubagentStop`, so no verdict mints (see the named-`code-verifier` entry
@@ -253,7 +253,7 @@ post a fresh PR in a fresh branch based on origin main to the user.
   Windows is Git Bash which cannot execute PowerShell cmdlets. Route all
   PowerShell work through the PowerShell tool or `pwsh -NoProfile -File`.
 - **Cross-repo PR: route cwd into the PR worktree before Step 5 review** —
-  `invoke_code_review.py` and `/code-review high --fix` audit the repo of the
+  `invoke_code_review.py` and `/code-review xhigh --fix` audit the repo of the
   cwd (the helper's `--cwd`). When the session is rooted in a different repo
   than the PR, `EnterWorktree` cannot re-root (it is scoped to the session's
   repo); resolve the PR worktree and `cd` into it per
@@ -351,7 +351,7 @@ round as converged. This rule holds every tick, every loop, every PR.
       - [ ] **Static sweep fails** → apply shared fix protocol → push → reset markers
             → stay CODE_REVIEW → Step 5
       - [ ] **`mode == in_session`** (Claude host, session model opus) → run
-            `/code-review high --fix` in-session (no path args)
+            `/code-review xhigh --fix` in-session (no path args)
       - [ ] **`mode == chain`** (any other host or non-opus session) → helper
             already ran the headless review; read `returncode`,
             `served_command`, and `dirty_tree` from JSON

package/skills/pr-converge/reference/examples.md

@@ -18,7 +18,7 @@ resets push-invalidated markers per [ground-rules.md](ground-rules.md) /
 at 270s, re-runs the sweep next tick]
 </example>
 
-<example> CODE_REVIEW tick, static sweep clean, `/code-review high --fix`
+<example> CODE_REVIEW tick, static sweep clean, `/code-review xhigh --fix`
 applies fixes to the working tree. Claude: [commits the applied fixes in one
 commit, pushes, resets push-invalidated markers per
 [ground-rules.md](ground-rules.md) / [state-schema.md](state-schema.md) (all
@@ -26,7 +26,7 @@ commit, pushes, resets push-invalidated markers per
 stays `phase = CODE_REVIEW`, Step 4 at 270s, returns]
 </example>
 
-<example> CODE_REVIEW tick, static sweep clean and `/code-review high --fix`
+<example> CODE_REVIEW tick, static sweep clean and `/code-review xhigh --fix`
 clean (no changes applied). Claude: [sets `code_review_clean_at = HEAD`,
 `phase = BUGTEAM`, runs `Skill({skill: "bugteam", ...})` in same tick]
 </example>
@@ -94,7 +94,7 @@ applies **Convergence** from `workflows/schedule-wakeup-loop.md`]
 
 <example> CODE_REVIEW tick, review body says "found 3 potential issues"
 against HEAD (a stale prior finding) but the diff is clean. Claude: [the static
-sweep and `/code-review high --fix` both pass, sets `code_review_clean_at =
+sweep and `/code-review xhigh --fix` both pass, sets `code_review_clean_at =
 HEAD`, `phase = BUGTEAM`]
 </example>
 

package/skills/pr-converge/reference/fix-protocol.md

@@ -32,6 +32,6 @@ files during fix phase in multi-PR mode.
 regardless of phase. A new commit **resets the full convergence cycle**: a
 code-review clean, a bugteam clean, and a Bugbot clean on an older SHA do
 **not** count toward convergence on the new `HEAD`. Re-run the static sweep and
-`/code-review high --fix` on `current_head`, then bugteam, then the terminal
+`/code-review xhigh --fix` on `current_head`, then bugteam, then the terminal
 Bugbot gate, all on the same `HEAD` with no intervening push. Re-entering in the
 same tick saves a wakeup cycle.

package/skills/pr-converge/reference/ground-rules.md

@@ -10,11 +10,11 @@
 - **All `*_clean_at`, `merge_state_status`, and `bugbot_down` / `codex_down` reset on every push.**
 - **`bugbot run` comment is load-bearing.** Literal phrase exactly —
   empirically the only re-trigger Cursor Bugbot recognizes.
-- **Production edits go through `clean-coder`, except `/code-review high --fix`.**
+- **Production edits go through `clean-coder`, except `/code-review xhigh --fix`.**
   The lead never hand-edits production files. Every bugbot, bugteam,
   Copilot, or Claude finding spawns `Agent(subagent_type="clean-coder")` to
   apply the fix. The CODE_REVIEW phase is the one exception: `/code-review
-  high --fix` applies its own findings to the working tree, which the next
+  xhigh --fix` applies its own findings to the working tree, which the next
   CODE_REVIEW/BUGTEAM cycle re-reviews after the loop resets.
 - **Adapt when reality contradicts on-disk state.** If `state.json`,
   `git`, or `gh` disagree with live PR, escalate as hard blocker per
@@ -22,7 +22,7 @@
 - **Cross-repo cwd routing is routine, not a fork.** When the PR under
   convergence lives in a different repo than the session is rooted in, route
   the working directory into a checkout of the PR's repo automatically —
-  `/code-review high --fix`, `git`, and every `clean-coder` fix spawn act on the
+  `/code-review xhigh --fix`, `git`, and every `clean-coder` fix spawn act on the
   repo of the current working directory. The resolution is fixed
   ([per-tick.md § Step 1.5](per-tick.md)): resolve the PR worktree, `cd` into
   it, run local work there. Do not pause, ask, or raise it as a material fork.

package/skills/pr-converge/reference/per-tick.md

@@ -71,7 +71,7 @@ Capture `number`, `head.sha` (= `current_head`), owner/repo, branch.
 
 The **PR worktree** is the local working tree of the PR's repo on its head
 branch. Every local operation this tick runs there: the CODE_REVIEW static sweep
-and `/code-review high --fix`, every `clean-coder` fix spawn, and every commit and
+and `/code-review xhigh --fix`, every `clean-coder` fix spawn, and every commit and
 push. `/code-review` and `git` both act on the repo of the current working
 directory, so the working directory must be the PR worktree before any local
 work begins. Re-resolve it every tick — a rebase or a fresh HEAD can move the
@@ -180,7 +180,7 @@ CODE_REVIEW.
 ### `phase == CODE_REVIEW`
 
 The entry phase of every convergence tick, re-entered after any fix push. It runs
-a deterministic static sweep, then the built-in `/code-review high --fix` on the
+a deterministic static sweep, then the built-in `/code-review xhigh --fix` on the
 full `origin/main...HEAD` diff at effort high on model opus. `/code-review`
 produces no GitHub review artifact, so there are no code-review threads to
 resolve.
@@ -196,7 +196,7 @@ a. **Static sweep — runs first, before `/code-review`.** Run the deterministic
    `phase = CODE_REVIEW`, and re-run the sweep. When the sweep is clean, run
    the host-aware review below.
 
-b. Run the built-in `/code-review high --fix` on the FULL `origin/main...HEAD`
+b. Run the built-in `/code-review xhigh --fix` with OPUS on the FULL `origin/main...HEAD`
    diff — every file the PR touches — via the
    [local diff review](https://code.claude.com/docs/en/code-review#review-a-diff-locally).
    The review always runs at effort high on model opus. It reviews the diff and
@@ -231,14 +231,14 @@ b. Run the built-in `/code-review high --fix` on the FULL `origin/main...HEAD`
    Match the first mode whose predicate holds:
 
    - **`mode == "in_session"`** (Claude host and session model is opus): run
-     `/code-review high --fix` in this session with no path arguments so it
+     `/code-review xhigh --fix` with OPUS in this session with no path arguments so it
      audits the whole branch diff against `origin/main`. After it returns, a
      non-empty `git status --porcelain` means fixes applied (`dirty_tree`
      equivalent). Treat a failed in-session slash command the same as a failed
      review: do not set `code_review_clean_at`.
    - **`mode == "chain"`** (any other host, or a Claude session on any model
      other than opus): the helper already ran the headless review
-     (`claude -p "/code-review high --fix" --model opus` through the chain
+     (`claude -p "/code-review xhigh --fix" --model opus` through the chain
      runner) with cwd set to the PR worktree. Read `returncode`,
      `served_command`, and `dirty_tree` from the JSON. A successful serve is
      `returncode == 0` with a non-null `served_command`. `dirty_tree` true

package/skills/pr-converge/reference/progress-checklist.md

@@ -91,7 +91,7 @@ round as converged. This rule holds every tick, every loop, every PR.
       - [ ] **Static sweep fails** → apply shared fix protocol → push → reset markers
             → stay CODE_REVIEW → Step 5
       - [ ] **`mode == in_session`** (Claude host, session model opus) → run
-            `/code-review high --fix` in-session (no path args)
+            `/code-review xhigh --fix` in-session (no path args)
       - [ ] **`mode == chain`** (any other host or non-opus session) → helper
             already ran the headless review; read `returncode`,
             `served_command`, and `dirty_tree` from JSON

package/skills/pr-converge/test_step5_host_branch.py

@@ -32,7 +32,7 @@ NEVER_PUSHES_PHRASE = "never pushes"
 EMPTY_STDIN_PHRASE = "empty"
 CWD_FLAG = "--cwd"
 OPUS_MODEL = "opus"
-HIGH_EFFORT_SLASH = "/code-review high --fix"
+HIGH_EFFORT_SLASH = "/code-review xhigh --fix"
 
 
 def _read_markdown(markdown_path: Path) -> str: