claude-dev-env 1.28.1 → 1.29.1

package/scripts/test_setup_project_paths.py

@@ -0,0 +1,532 @@
+"""Tests for setup_project_paths — one-time bootstrap script."""
+
+import inspect
+import json
+import subprocess
+import sys
+from pathlib import Path
+from unittest.mock import patch
+
+import pytest
+
+_SCRIPTS_DIR = Path(__file__).resolve().parent
+_HOOKS_DIR = _SCRIPTS_DIR.parent / "hooks"
+_SESSION_HOOKS_PACKAGE_DIR = _SCRIPTS_DIR.parent / "hooks" / "session"
+for each_sys_path_entry in (
+    str(_SCRIPTS_DIR),
+    str(_HOOKS_DIR),
+    str(_SESSION_HOOKS_PACKAGE_DIR),
+):
+    if each_sys_path_entry not in sys.path:
+        sys.path.insert(0, each_sys_path_entry)
+
+import setup_project_paths as setup
+import untracked_repo_detector as detector_module
+from config.project_paths_reader import registry_file_path
+from config.setup_project_paths_constants import (
+    ABORTED_NOTHING_WRITTEN_MESSAGE,
+    CONFIRMATION_PROMPT_TEXT,
+    ES_EXE_FOLDERS_ONLY_QUERY_ARGUMENTS,
+    WROTE_ENTRIES_STATUS_TEMPLATE,
+)
+
+
+class TestFinalSegmentFilter:
+    def test_retains_dot_git_directory(self) -> None:
+        all_paths = ["C:\\Projects\\my-repo\\.git"]
+        retained = setup.filter_to_git_roots(all_paths)
+        assert retained == ["C:\\Projects\\my-repo"]
+
+    def test_rejects_dot_gitignore(self) -> None:
+        all_paths = ["C:\\Projects\\my-repo\\.gitignore"]
+        retained = setup.filter_to_git_roots(all_paths)
+        assert retained == []
+
+    def test_rejects_dot_github(self) -> None:
+        all_paths = ["C:\\Projects\\my-repo\\.github"]
+        retained = setup.filter_to_git_roots(all_paths)
+        assert retained == []
+
+    def test_accepts_dot_git_with_forward_slashes(self) -> None:
+        all_paths = ["C:/Projects/my-repo/.git"]
+        retained = setup.filter_to_git_roots(all_paths)
+        assert retained == ["C:/Projects/my-repo"]
+
+    def test_retains_multiple_valid_git_roots(self) -> None:
+        all_paths = [
+            "C:\\Projects\\alpha\\.git",
+            "D:\\Work\\beta\\.git",
+        ]
+        retained = setup.filter_to_git_roots(all_paths)
+        assert "C:\\Projects\\alpha" in retained
+        assert "D:\\Work\\beta" in retained
+
+    def test_rejects_dot_git_attributes(self) -> None:
+        all_paths = ["C:\\Projects\\my-repo\\.gitattributes"]
+        retained = setup.filter_to_git_roots(all_paths)
+        assert retained == []
+
+
+class TestExclusionFilter:
+    def test_drops_path_with_temp_segment(self) -> None:
+        all_candidates = ["C:\\temp\\my-repo"]
+        filtered = setup.apply_exclusion_filter(all_candidates)
+        assert filtered == []
+
+    def test_drops_path_with_tmp_segment(self) -> None:
+        all_candidates = ["C:\\tmp\\my-repo"]
+        filtered = setup.apply_exclusion_filter(all_candidates)
+        assert filtered == []
+
+    def test_drops_path_with_worktree_segment(self) -> None:
+        all_candidates = ["C:\\Projects\\main\\worktree\\feature"]
+        filtered = setup.apply_exclusion_filter(all_candidates)
+        assert filtered == []
+
+    def test_drops_path_with_node_modules_segment(self) -> None:
+        all_candidates = ["C:\\Projects\\app\\node_modules\\pkg"]
+        filtered = setup.apply_exclusion_filter(all_candidates)
+        assert filtered == []
+
+    def test_drops_path_with_dot_cache_segment(self) -> None:
+        all_candidates = ["C:\\Users\\jon\\.cache\\build"]
+        filtered = setup.apply_exclusion_filter(all_candidates)
+        assert filtered == []
+
+    def test_drops_path_with_recycle_bin_segment(self) -> None:
+        all_candidates = ["C:\\$Recycle.Bin\\S-1-5\\my-repo"]
+        filtered = setup.apply_exclusion_filter(all_candidates)
+        assert filtered == []
+
+    def test_preserves_path_with_template_segment(self) -> None:
+        all_candidates = ["C:\\Projects\\template"]
+        filtered = setup.apply_exclusion_filter(all_candidates)
+        assert filtered == ["C:\\Projects\\template"]
+
+    def test_preserves_legitimate_project_path(self) -> None:
+        all_candidates = ["Y:\\Projects\\my-app"]
+        filtered = setup.apply_exclusion_filter(all_candidates)
+        assert filtered == ["Y:\\Projects\\my-app"]
+
+    def test_whole_segment_match_does_not_drop_template(self) -> None:
+        all_candidates = ["C:\\Projects\\my-templates\\repo"]
+        filtered = setup.apply_exclusion_filter(all_candidates)
+        assert filtered == ["C:\\Projects\\my-templates\\repo"]
+
+
+class TestMergeRegistries:
+    def test_merge_preserves_pre_existing_entries(self) -> None:
+        existing_registry = {
+            "_meta": {"schema_version": 1, "last_scan": "2026-01-01T00:00:00Z"},
+            "old-repo": "C:\\Old\\old-repo",
+        }
+        new_path_by_name = {"new-repo": "D:\\New\\new-repo"}
+        merged = setup.merge_registries(existing_registry, new_path_by_name)
+        assert merged["old-repo"] == "C:\\Old\\old-repo"
+        assert merged["new-repo"] == "D:\\New\\new-repo"
+
+    def test_merge_updates_meta_last_scan(self) -> None:
+        existing_registry: dict = {}
+        new_path_by_name = {"alpha": "C:\\alpha"}
+        merged = setup.merge_registries(existing_registry, new_path_by_name)
+        assert "_meta" in merged
+        assert "last_scan" in merged["_meta"]
+
+    def test_merge_new_entry_wins_on_name_collision(self) -> None:
+        existing_registry = {"my-repo": "C:\\Old\\path"}
+        new_path_by_name = {"my-repo": "D:\\New\\path"}
+        merged = setup.merge_registries(existing_registry, new_path_by_name)
+        assert merged["my-repo"] == "D:\\New\\path"
+
+
+class TestAtomicWrite:
+    def test_write_creates_file_with_correct_content(self, tmp_path: Path) -> None:
+        target_file = tmp_path / "project-paths.json"
+        registry_to_write = {"_meta": {"schema_version": 1}, "repo": "C:\\repo"}
+        setup.write_registry_atomically(registry_to_write, target_file)
+        written_content = json.loads(target_file.read_text(encoding="utf-8"))
+        assert written_content["repo"] == "C:\\repo"
+
+    def test_write_leaves_no_temp_file_on_success(self, tmp_path: Path) -> None:
+        target_file = tmp_path / "project-paths.json"
+        registry_to_write = {"_meta": {"schema_version": 1}}
+        setup.write_registry_atomically(registry_to_write, target_file)
+        all_files = list(tmp_path.iterdir())
+        assert all_files == [target_file]
+
+    def test_write_overwrites_without_schema_check(self, tmp_path: Path) -> None:
+        target_file = tmp_path / "project-paths.json"
+        target_file.write_text(
+            json.dumps({"_meta": {"schema_version": 99}}), encoding="utf-8"
+        )
+        registry_to_write = {"_meta": {"schema_version": 1}, "repo": "C:\\repo"}
+        setup.write_registry_atomically(registry_to_write, target_file)
+        written_content = json.loads(target_file.read_text(encoding="utf-8"))
+        assert written_content["repo"] == "C:\\repo"
+
+
+class TestEsExeQueryArguments:
+    def test_arguments_do_not_include_name_flag(self) -> None:
+        assert "-name" not in ES_EXE_FOLDERS_ONLY_QUERY_ARGUMENTS
+
+    def test_arguments_include_folders_only_flag(self) -> None:
+        assert "/ad" in ES_EXE_FOLDERS_ONLY_QUERY_ARGUMENTS
+
+    def test_arguments_include_git_folder_query(self) -> None:
+        assert "folder:.git" in ES_EXE_FOLDERS_ONLY_QUERY_ARGUMENTS
+
+    def test_filter_to_git_roots_processes_full_absolute_paths(self) -> None:
+        all_raw_paths = [
+            "C:\\Projects\\my-repo\\.git",
+            "D:\\Work\\other-repo\\.git",
+        ]
+        all_roots = setup.filter_to_git_roots(all_raw_paths)
+        assert "C:\\Projects\\my-repo" in all_roots
+        assert "D:\\Work\\other-repo" in all_roots
+
+
+class TestUserRejection:
+    def test_user_rejection_at_final_prompt_writes_nothing(
+        self, tmp_path: Path
+    ) -> None:
+        target_file = tmp_path / "project-paths.json"
+        assert not target_file.exists()
+        with patch("builtins.input", return_value="no"):
+            setup.prompt_and_write(
+                path_by_name={"my-repo": "C:\\my-repo"},
+                save_path=target_file,
+            )
+        assert not target_file.exists()
+
+
+class TestDuplicateLeafName:
+    def test_duplicate_leaf_name_keeps_first_seen_entry(
+        self, capsys: pytest.CaptureFixture
+    ) -> None:
+        all_roots = sorted(["Y:\\A\\foo", "Y:\\B\\foo"])
+        path_by_name = setup._build_path_by_name_from_roots(all_roots)
+        assert len(path_by_name) == 1
+        assert path_by_name["foo"] == "Y:\\A\\foo"
+
+    def test_duplicate_leaf_name_prints_collision_warning(
+        self, capsys: pytest.CaptureFixture
+    ) -> None:
+        all_roots = sorted(["Y:\\A\\foo", "Y:\\B\\foo"])
+        setup._build_path_by_name_from_roots(all_roots)
+        captured = capsys.readouterr()
+        assert "Duplicate leaf name 'foo'" in captured.out
+        assert "Y:\\A\\foo" in captured.out
+        assert "Y:\\B\\foo" in captured.out
+
+
+class TestMapNamingConvention:
+    def test_merge_registries_signature_uses_path_by_name(self) -> None:
+        """Pin PR #230 round 3 rename: X_by_Y means X indexed by Y.
+
+        The map's keys are repo names and values are paths, so the correct
+        name is `path_by_name` (path indexed by name). The old inverted
+        name `name_by_path` must not reappear.
+        """
+        merge_signature = inspect.signature(setup.merge_registries)
+        assert "new_path_by_name" in merge_signature.parameters
+        assert "new_name_by_path" not in merge_signature.parameters
+
+    def test_build_helper_is_named_path_by_name(self) -> None:
+        assert hasattr(setup, "_build_path_by_name_from_roots")
+        assert not hasattr(setup, "_build_name_by_path_from_roots")
+
+
+class TestRegistryReadError:
+    def test_missing_file_returns_empty_dict(self, tmp_path: Path) -> None:
+        missing_file = tmp_path / "nonexistent.json"
+        result = setup._read_existing_registry(missing_file)
+        assert result == {}
+
+    def test_malformed_json_raises_registry_read_error(self, tmp_path: Path) -> None:
+        corrupt_file = tmp_path / "project-paths.json"
+        corrupt_file.write_text("{ not valid json", encoding="utf-8")
+        with pytest.raises(setup.RegistryReadError):
+            setup._read_existing_registry(corrupt_file)
+
+    def test_non_dict_top_level_raises_registry_read_error(self, tmp_path: Path) -> None:
+        non_dict_file = tmp_path / "project-paths.json"
+        non_dict_file.write_text(json.dumps(["a", "b"]), encoding="utf-8")
+        with pytest.raises(setup.RegistryReadError):
+            setup._read_existing_registry(non_dict_file)
+
+    def test_oserror_raises_registry_read_error(self, tmp_path: Path) -> None:
+        existing_file = tmp_path / "project-paths.json"
+        existing_file.write_text("{}", encoding="utf-8")
+        with patch.object(
+            type(existing_file),
+            "read_text",
+            side_effect=OSError("permission denied"),
+        ):
+            with pytest.raises(setup.RegistryReadError):
+                setup._read_existing_registry(existing_file)
+
+    def test_registry_read_error_in_prompt_and_write_exits_nonzero(
+        self, tmp_path: Path
+    ) -> None:
+        corrupt_file = tmp_path / "project-paths.json"
+        corrupt_file.write_text("{ not valid json", encoding="utf-8")
+        with patch("builtins.input", return_value="yes"):
+            with pytest.raises(SystemExit) as raised_exit:
+                setup.prompt_and_write(
+                    path_by_name={"my-repo": "C:\\my-repo"},
+                    save_path=corrupt_file,
+                )
+        assert raised_exit.value.code != 0
+
+    def test_registry_read_error_does_not_overwrite_file(
+        self, tmp_path: Path, capsys: pytest.CaptureFixture
+    ) -> None:
+        corrupt_file = tmp_path / "project-paths.json"
+        original_content = "{ not valid json"
+        corrupt_file.write_text(original_content, encoding="utf-8")
+        with patch("builtins.input", return_value="yes"):
+            with pytest.raises(SystemExit):
+                setup.prompt_and_write(
+                    path_by_name={"my-repo": "C:\\my-repo"},
+                    save_path=corrupt_file,
+                )
+        assert corrupt_file.read_text(encoding="utf-8") == original_content
+
+
+class TestEarlyRegistryValidation:
+    def test_malformed_registry_exits_before_prompting(self, tmp_path: Path) -> None:
+        corrupt_file = tmp_path / "project-paths.json"
+        corrupt_file.write_text("{ not valid json", encoding="utf-8")
+        prompt_call_count = 0
+
+        def counting_input(prompt_text: str) -> str:
+            nonlocal prompt_call_count
+            prompt_call_count += 1
+            return "yes"
+
+        with patch("builtins.input", side_effect=counting_input):
+            with pytest.raises(SystemExit) as raised_exit:
+                setup.prompt_and_write(
+                    path_by_name={"my-repo": "C:\\my-repo"},
+                    save_path=corrupt_file,
+                )
+        assert raised_exit.value.code != 0
+        assert prompt_call_count == 0
+
+    def test_malformed_registry_leaves_file_untouched(self, tmp_path: Path) -> None:
+        corrupt_file = tmp_path / "project-paths.json"
+        original_content = "{ not valid json"
+        corrupt_file.write_text(original_content, encoding="utf-8")
+        with patch("builtins.input", return_value="yes"):
+            with pytest.raises(SystemExit):
+                setup.prompt_and_write(
+                    path_by_name={"my-repo": "C:\\my-repo"},
+                    save_path=corrupt_file,
+                )
+        assert corrupt_file.read_text(encoding="utf-8") == original_content
+
+    def test_schema_mismatch_exits_before_prompting(self, tmp_path: Path) -> None:
+        target_file = tmp_path / "project-paths.json"
+        target_file.write_text(
+            json.dumps({"_meta": {"schema_version": 99}}), encoding="utf-8"
+        )
+        prompt_call_count = 0
+
+        def counting_input(prompt_text: str) -> str:
+            nonlocal prompt_call_count
+            prompt_call_count += 1
+            return "yes"
+
+        with patch("builtins.input", side_effect=counting_input):
+            with pytest.raises(SystemExit) as raised_exit:
+                setup.prompt_and_write(
+                    path_by_name={"my-repo": "C:\\my-repo"},
+                    save_path=target_file,
+                )
+        assert raised_exit.value.code != 0
+        assert prompt_call_count == 0
+
+    def test_schema_mismatch_leaves_file_untouched(self, tmp_path: Path) -> None:
+        target_file = tmp_path / "project-paths.json"
+        original_registry = {"_meta": {"schema_version": 99}}
+        target_file.write_text(json.dumps(original_registry), encoding="utf-8")
+        with patch("builtins.input", return_value="yes"):
+            with pytest.raises(SystemExit):
+                setup.prompt_and_write(
+                    path_by_name={"my-repo": "C:\\my-repo"},
+                    save_path=target_file,
+                )
+        written_back = json.loads(target_file.read_text(encoding="utf-8"))
+        assert written_back == original_registry
+
+    def test_registry_read_exactly_once_across_full_write_path(
+        self, tmp_path: Path
+    ) -> None:
+        target_file = tmp_path / "project-paths.json"
+        target_file.write_text(
+            json.dumps({"_meta": {"schema_version": 1}, "existing-repo": "C:\\existing"}),
+            encoding="utf-8",
+        )
+        read_call_count = 0
+        original_read = setup._read_existing_registry
+
+        def counting_read(target: Path) -> dict:
+            nonlocal read_call_count
+            read_call_count += 1
+            return original_read(target)
+
+        with patch("setup_project_paths._read_existing_registry", side_effect=counting_read):
+            with patch("builtins.input", return_value="yes"):
+                setup.prompt_and_write(
+                    path_by_name={"my-repo": "C:\\my-repo"},
+                    save_path=target_file,
+                )
+        assert read_call_count == 1
+
+
+class TestDiscoverRepoRootsDedup:
+    def test_discover_returns_sorted_unique_paths(self) -> None:
+        all_paths = [
+            "C:\\Projects\\beta\\.git",
+            "C:\\Projects\\alpha\\.git",
+            "C:\\Projects\\alpha\\.git",
+        ]
+        with patch("setup_project_paths._run_es_exe_folders_query", return_value=all_paths):
+            all_roots = setup.discover_repo_roots_via_everything()
+        assert all_roots == sorted(set(all_roots))
+        assert len(all_roots) == len(set(all_roots))
+
+
+class TestPromptAndWriteUsesConstants:
+    def test_confirmation_prompt_text_comes_from_constants(self) -> None:
+        captured_prompts: list[str] = []
+
+        def capturing_input(prompt_text: str) -> str:
+            captured_prompts.append(prompt_text)
+            return "no"
+
+        with patch("builtins.input", side_effect=capturing_input):
+            setup.prompt_and_write(
+                path_by_name={"my-repo": "C:\\my-repo"},
+                save_path=Path("/nonexistent/path.json"),
+            )
+        assert len(captured_prompts) == 1
+        assert captured_prompts[0] == CONFIRMATION_PROMPT_TEXT
+
+    def test_abort_message_comes_from_constants(
+        self, capsys: pytest.CaptureFixture
+    ) -> None:
+        with patch("builtins.input", return_value="no"):
+            setup.prompt_and_write(
+                path_by_name={"my-repo": "C:\\my-repo"},
+                save_path=Path("/nonexistent/path.json"),
+            )
+        captured = capsys.readouterr()
+        assert ABORTED_NOTHING_WRITTEN_MESSAGE in captured.out
+
+    def test_wrote_entries_status_uses_constants_template(
+        self, tmp_path: Path, capsys: pytest.CaptureFixture
+    ) -> None:
+        target_file = tmp_path / "project-paths.json"
+        with patch("builtins.input", return_value="yes"):
+            setup.prompt_and_write(
+                path_by_name={"my-repo": "C:\\my-repo"},
+                save_path=target_file,
+            )
+        captured = capsys.readouterr()
+        expected_message = WROTE_ENTRIES_STATUS_TEMPLATE.format(
+            entry_count=1, save_path=target_file
+        )
+        assert expected_message in captured.out
+
+
+class TestEverythingScanError:
+    def test_nonzero_return_code_raises_everything_scan_error(self) -> None:
+        failed_completion = subprocess.CompletedProcess(
+            args=["es.exe"],
+            returncode=1,
+            stdout="",
+            stderr="service not running",
+        )
+        with patch("subprocess.run", return_value=failed_completion):
+            with pytest.raises(setup.EverythingScanError) as raised_error:
+                setup._run_es_exe_folders_query()
+        assert "service not running" in str(raised_error.value)
+
+    def test_nonzero_return_code_includes_return_code_in_message(self) -> None:
+        failed_completion = subprocess.CompletedProcess(
+            args=["es.exe"],
+            returncode=2,
+            stdout="",
+            stderr="access denied",
+        )
+        with patch("subprocess.run", return_value=failed_completion):
+            with pytest.raises(setup.EverythingScanError) as raised_error:
+                setup._run_es_exe_folders_query()
+        assert "2" in str(raised_error.value)
+
+    def test_zero_return_code_returns_parsed_paths(self) -> None:
+        successful_completion = subprocess.CompletedProcess(
+            args=["es.exe"],
+            returncode=0,
+            stdout="C:\\Projects\\alpha\\.git\nD:\\Work\\beta\\.git\n",
+            stderr="",
+        )
+        with patch("subprocess.run", return_value=successful_completion):
+            all_paths = setup._run_es_exe_folders_query()
+        assert all_paths == ["C:\\Projects\\alpha\\.git", "D:\\Work\\beta\\.git"]
+
+    def test_main_catches_everything_scan_error_and_exits_nonzero(self) -> None:
+        with (
+            patch(
+                "setup_project_paths._everything_binary_is_available",
+                return_value=True,
+            ),
+            patch(
+                "setup_project_paths._run_es_exe_folders_query",
+                side_effect=setup.EverythingScanError("service not running: exit 1"),
+            ),
+            pytest.raises(SystemExit) as raised_exit,
+        ):
+            setup.main()
+        assert raised_exit.value.code != 0
+
+    def test_main_prints_clear_error_to_stderr_on_everything_scan_error(
+        self, capsys: pytest.CaptureFixture
+    ) -> None:
+        with (
+            patch(
+                "setup_project_paths._everything_binary_is_available",
+                return_value=True,
+            ),
+            patch(
+                "setup_project_paths._run_es_exe_folders_query",
+                side_effect=setup.EverythingScanError("service not running: exit 1"),
+            ),
+            pytest.raises(SystemExit),
+        ):
+            setup.main()
+        captured = capsys.readouterr()
+        assert "Everything scan failed" in captured.err
+        assert "service" in captured.err.lower()
+
+
+class TestSharedConfigPath:
+    def test_default_user_config_path_matches_project_paths_reader(self) -> None:
+        assert setup._default_user_config_path() == registry_file_path()
+
+    def test_untracked_repo_detector_config_path_matches_project_paths_reader(
+        self,
+    ) -> None:
+        shared_path = registry_file_path()
+        assert str(shared_path) in detector_module._build_confirm_instruction(
+            str(shared_path.parent)
+        ) or "project-paths.json" in detector_module._build_confirm_instruction(
+            str(shared_path.parent)
+        )
+
+    def test_all_three_modules_resolve_identical_config_path(self) -> None:
+        shared_path = registry_file_path()
+        assert shared_path == setup._default_user_config_path()
+        assert shared_path.name == "project-paths.json"
+        assert shared_path.parent.name == ".claude"

package/scripts/test_setup_project_paths_config.py

@@ -0,0 +1,6 @@
+"""This module is intentionally empty.
+
+Constant-contract coverage for setup_project_paths is consolidated in
+packages/claude-dev-env/hooks/config/test_setup_project_paths_constants.py
+to avoid maintaining duplicate assertions across two files.
+"""

package/skills/bugteam/CONSTRAINTS.md

@@ -12,7 +12,7 @@
 - **Code rules gate before every AUDIT.** Run `scripts/bugteam_code_rules_gate.py` until exit **0** before spawning **bugfind**. Same `validate_content` logic as `hooks/blocking/code_rules_enforcer.py`.
 - **Clean-room audits, every loop.** Each bugfind teammate's spawn prompt contains only the PR scope, audit rubric, and the current loop number. Prior loop history stays in the lead.
 - **Targeted fixes.** Each fix teammate sees ONLY the most recent audit's findings. Prior loops are invisible to the fix teammate.
-- **Sonnet for both teammates.** Predictable cost, fits-purpose for code work.
+- **Opus 4.7 at xhigh effort for both teammates.** Both `Agent(...)` spawns pass `model="opus"`, which resolves to Opus 4.7 on the Anthropic API. Opus 4.7's default effort level in Claude Code is `xhigh` (https://code.claude.com/docs/en/model-config — *"On Opus 4.7, the default effort is `xhigh` for all plans and providers."*), so no `effort` override is needed at spawn time. Effort is set per-subagent in YAML frontmatter, not via the `Agent` tool's parameters; `code-quality-agent` and `clean-coder` rely on the model default. The trade vs Sonnet is higher per-loop cost in exchange for deeper audit recall and stronger fix correctness on bug-hunting work, which the per-PR loop economics tolerate (10-loop hard cap bounds total spend).
 - **Fix teammate receives the latest audit as its input contract.** Passing the audit's findings to the fix teammate is the input contract — each loop's fix run operates on the current audit's output and only that.
 - **One commit per fix action.** Loops produce one commit per loop, not one per bug.
 - **Linear branch, fixed PR base.** Every loop appends one forward-only commit; existing commits and the PR base stay intact throughout the cycle.

package/skills/bugteam/PROMPTS.md

@@ -29,7 +29,7 @@ cd into `<worktree_path>` before any git, gh, or file operation.
   B. Selector / query / engine compatibility
   C. Resource cleanup and lifecycle (file handles, connections, processes, locks)
   D. Variable scoping, ordering, and unbound references
-  E. Dead code and unused imports
+  E. Dead code: dead parameters, dead locals, dead imports, dead branches, dead returns, and unused imports
   F. Silent failures (catch-all excepts, unconditional success returns, missing error propagation)
   G. Off-by-one, bounds, and integer overflow
   H. Security boundaries (injection, path traversal, auth bypass, secret leakage)

package/skills/bugteam/SKILL.md

@@ -2,8 +2,8 @@
 name: bugteam
 description: >-
   Claude Code agent team on the open pull request: run the CODE_RULES gate,
-  spawn a fresh clean-room audit (code-quality-agent, sonnet) and a fix pass
-  (clean-coder, sonnet), post per-loop GitHub review threads from teammates,
+  spawn a fresh clean-room audit (code-quality-agent, opus) and a fix pass
+  (clean-coder, opus), post per-loop GitHub review threads from teammates,
   stop at zero findings or a 10-audit safety cap. Grants then revokes
   `.claude/**` edit permission around the run. SKILL.md is the orchestration
   checklist; `reference/` holds expanded prose by domain; CONSTRAINTS,
@@ -122,7 +122,7 @@ TeamCreate(
 
 **`<team_temp_dir>`:** `Path(tempfile.gettempdir()) / team_name` (lead resolves once to an absolute path; every shell gets that literal string).
 
-**Roles (spawned per loop, not here):** bugfind → `code-quality-agent` sonnet; bugfix → `clean-coder` sonnet. **Display:** inherit `teammateMode` from `~/.claude.json`. Reference subagent types by name when spawning teammates ([`sources.md`](sources.md) § Referencing subagent types when spawning teammates).
+**Roles (spawned per loop, not here):** bugfind → `code-quality-agent` opus (4.7) at xhigh effort; bugfix → `clean-coder` opus (4.7) at xhigh effort. `model="opus"` resolves to Opus 4.7 on the Anthropic API and runs at the model's default `xhigh` effort level — see [`CONSTRAINTS.md`](CONSTRAINTS.md) § **Opus 4.7 at xhigh effort for both teammates** for rationale. **Display:** inherit `teammateMode` from `~/.claude.json`. Reference subagent types by name when spawning teammates ([`sources.md`](sources.md) § Referencing subagent types when spawning teammates).
 
 **Loop state (lead; not a single script):**
 
@@ -231,7 +231,7 @@ Agent(
   subagent_type="code-quality-agent",
   name="bugfind-pr<N>-loop<L>",
   team_name="<team_name>",
-  model="sonnet",
+  model="opus",
   description="Bugfind audit PR <N> loop <L>",
   prompt="<audit XML; see PROMPTS.md>"
 )
@@ -261,7 +261,7 @@ Agent(
   subagent_type="clean-coder",
   name="bugfix-pr<N>-loop<L>",
   team_name="<team_name>",
-  model="sonnet",
+  model="opus",
   description="Bugfix PR <N> loop <L>",
   prompt="<fix XML; see PROMPTS.md>"
 )

package/skills/bugteam/SKILL_EVALS.md

@@ -23,7 +23,7 @@ Each invariant cites the normative section or companion file it derives from.
 | I-3 | Exactly one `TeamCreate` and exactly one `TeamDelete` per invocation. | `SKILL.md` § Step 2; § Step 4 |
 | I-4 | Before `TeamDelete`, no teammate remains active without cleanup: either the teammate self-terminated after `Agent` returned, or the lead sent a matching `SendMessage(..., shutdown_request)` (including parallel-auditor shutdowns). No orphaned teammates when `TeamDelete` runs. | `SKILL.md` § AUDIT action (**Shutdown**); § FIX action (**Shutdown**); § Step 4 |
 | I-5 | `Agent` calls are fresh per loop — the same `name` is never reused across loops without an intervening shutdown. | `CONSTRAINTS.md` — **Fresh teammate per loop** |
-| I-6 | Both audit and fix `Agent` calls pass `model="sonnet"`. | `SKILL.md` § Step 2 (**Roles**); `CONSTRAINTS.md` — **Sonnet for both teammates** |
+| I-6 | Both audit and fix `Agent` calls pass `model="opus"` (resolves to Opus 4.7 via the Anthropic API alias; effort remains the Claude Code/model-config default `xhigh`). | `SKILL.md` § Step 2 (**Roles**); `CONSTRAINTS.md` — **Opus 4.7 at xhigh effort for both teammates** |
 | I-7 | `TeamDelete()` is called with no arguments. | TeamDelete schema: no required params, no properties |
 | I-8 | Loop count ≤ 10 audits. 11th audit never fires. | `SKILL.md` YAML `description` (10-loop cap); § Step 3 (**Pre-audit** / **FIX** increment rules) |
 | I-9 | From loop 4 onward without convergence, the audit phase emits three parallel `Agent` calls in a single assistant message with names `bugfind-loop-<N>-a/b/c`. | `SKILL.md` § AUDIT action (**Parallel auditors**); `reference/audit-and-teammates.md` § **Parallel auditors** |
@@ -111,10 +111,10 @@ The harness does not yet exist; this document defines its contract.
 | 4 | `TeamCreate(team_name="bugteam-pr-42-<ts>", description=..., agent_type="team-lead")` | `SKILL.md` § Step 2 |
 | 5 | `Bash("mkdir -p <team_temp_dir>")` | `SKILL.md` § AUDIT action |
 | 6 | `Bash("gh pr diff 42 -R ... > <team_temp_dir>/loop-1.patch")` | `SKILL.md` § AUDIT action |
-| 7 | `Agent(subagent_type="code-quality-agent", name="bugfind", team_name=..., model="sonnet", description=..., prompt=<audit XML loop 1>)` | `SKILL.md` § AUDIT action |
+| 7 | `Agent(subagent_type="code-quality-agent", name="bugfind", team_name=..., model="opus", description=..., prompt=<audit XML loop 1>)` | `SKILL.md` § AUDIT action |
 | 8 | `Read(".bugteam-loop-1.outcomes.xml")` | `SKILL.md` § AUDIT action |
 | 9 | `SendMessage(to="bugfind", message={type: "shutdown_request", reason: "audit loop 1 complete; outcome XML captured"})` | `SKILL.md` § AUDIT action (**Shutdown** fallback) |
-| 10 | `Agent(subagent_type="clean-coder", name="bugfix", team_name=..., model="sonnet", description=..., prompt=<fix XML loop 1>)` | `SKILL.md` § FIX action |
+| 10 | `Agent(subagent_type="clean-coder", name="bugfix", team_name=..., model="opus", description=..., prompt=<fix XML loop 1>)` | `SKILL.md` § FIX action |
 | 11 | `Read(".bugteam-loop-1.outcomes.xml")` — bugfix outcome XML overwrites same filename | `SKILL.md` § FIX action |
 | 12 | `Bash("git rev-parse HEAD")` → verify HEAD advanced | `SKILL.md` § FIX action (**Verify**) |
 | 13 | `Bash("git fetch origin <branch> && git rev-parse origin/<branch>")` → verify push landed | `SKILL.md` § FIX action (**Verify**) |
@@ -302,7 +302,7 @@ Agent(
   subagent_type="code-quality-agent",
   name="bugfind-adjacent",
   team_name="<lead_team_name>",          // same team as bugfind/bugfix
-  model="sonnet",
+  model="opus",
   description="Supplementary audit of adjacent infrastructure",
   prompt=<brief naming the specific adjacent files + observed symptom>
 )
@@ -343,4 +343,4 @@ A minimal Python harness under `packages/claude-dev-env/skills/bugteam/evals/`:
 
 1. **GitHub REST review-POST payload shape.** Eval 9 and Eval 10 depend on the exact body shape of `POST /pulls/<number>/reviews`. The `jq -n --rawfile ... --argjson ... | gh api ... --input -` fence lives in `SKILL.md` § Step 2.5 (**Review POST**); expanded copy in `reference/github-pr-reviews.md` § **Per-loop review**. Before running Eval 9/10 for real, fetch the current GitHub REST reference to confirm the request schema (fields `commit_id`, `event`, `body`, `comments[]`) and the multi-line anchor `{path, start_line, start_side, line, side, body}` shape still apply. Record the confirmed version and URL here.
 2. **`SendMessage` shutdown origination — RESOLVED.** `SendMessage` tool docs include the line "Don't originate `shutdown_request` unless asked." `TeamCreate` tool docs explicitly direct the lead to originate `{type: "shutdown_request"}` for teammate cleanup. Real-run observation (loop 1 of eval run 2026-04-18) resolved the contradiction: teammates self-terminate when their task is complete — the `Agent` call returns and the teammate's session ends without any `SendMessage`. The cycle proceeded correctly without the lead ever needing to originate a `shutdown_request`. `SKILL.md` § AUDIT / FIX actions document self-termination as the expected path and lead-originated `SendMessage(shutdown_request)` as a fallback; `reference/audit-and-teammates.md` carries the longer shutdown narrative. Layer A **I-4** encodes “no orphaned teammates,” not “always send SendMessage.”
-3. **Model override redundancy.** `code-quality-agent` and `clean-coder` may already pin `model` in their agent definitions. The explicit `model="sonnet"` in every spawn is insurance, but on the first real run confirm no conflict between the lead-passed model and the agent-frontmatter model.
+3. **Model override redundancy.** `clean-coder` pins `model: opus` in its agent definition, while `code-quality-agent` currently uses `model: inherit`. The explicit `model="opus"` in every spawn is insurance against frontmatter drift; on the first real run, confirm the resolved model is `claude-opus-4-7` and that effort defaults to `xhigh` (Claude Code shows the active effort next to the spinner per the model-config docs). If a teammate's frontmatter ever pins a non-default `effort:` value, that frontmatter overrides the model default for that subagent (https://code.claude.com/docs/en/model-config — *"Frontmatter effort applies when that skill or subagent is active, overriding the session level but not the environment variable."*).

package/skills/bugteam/reference/audit-and-teammates.md

@@ -76,9 +76,9 @@ The teammate replies with `{type: "shutdown_response", approve: true}`. If `appr
 The pre-audit gate must pass immediately before this step. After three full audit/fix rounds without convergence, issue three `Agent` calls in **one** assistant message so they run in parallel:
 
 ```
-Agent(subagent_type="code-quality-agent", name="bugfind-loop-<N>-a", team_name="<team_name>", model="sonnet", description="Bugfind audit loop <N> variant a", prompt="<audit XML; write outcome to .bugteam-loop-<N>.outcomes.xml; post the per-loop review; read and merge b/c outcomes from <team_temp_dir>/loop-<N>-b.outcomes.xml and <team_temp_dir>/loop-<N>-c.outcomes.xml>")
-Agent(subagent_type="code-quality-agent", name="bugfind-loop-<N>-b", team_name="<team_name>", model="sonnet", description="Bugfind audit loop <N> variant b", prompt="<audit XML; write outcome to <team_temp_dir>/loop-<N>-b.outcomes.xml; skip PR posting>")
-Agent(subagent_type="code-quality-agent", name="bugfind-loop-<N>-c", team_name="<team_name>", model="sonnet", description="Bugfind audit loop <N> variant c", prompt="<audit XML; write outcome to <team_temp_dir>/loop-<N>-c.outcomes.xml; skip PR posting>")
+Agent(subagent_type="code-quality-agent", name="bugfind-loop-<N>-a", team_name="<team_name>", model="opus", description="Bugfind audit loop <N> variant a", prompt="<audit XML; write outcome to .bugteam-loop-<N>.outcomes.xml; post the per-loop review; read and merge b/c outcomes from <team_temp_dir>/loop-<N>-b.outcomes.xml and <team_temp_dir>/loop-<N>-c.outcomes.xml>")
+Agent(subagent_type="code-quality-agent", name="bugfind-loop-<N>-b", team_name="<team_name>", model="opus", description="Bugfind audit loop <N> variant b", prompt="<audit XML; write outcome to <team_temp_dir>/loop-<N>-b.outcomes.xml; skip PR posting>")
+Agent(subagent_type="code-quality-agent", name="bugfind-loop-<N>-c", team_name="<team_name>", model="opus", description="Bugfind audit loop <N> variant c", prompt="<audit XML; write outcome to <team_temp_dir>/loop-<N>-c.outcomes.xml; skip PR posting>")
 ```
 
 Teammate `-a` is the post-owner: read all three outcome XML files at explicit absolute paths (`.bugteam-loop-<N>.outcomes.xml` in cwd, plus sibling paths under `<team_temp_dir>`), merge findings by `(file, line, category_letter)` (collapse duplicates, keep longest description and highest severity), re-assign merged IDs as `loopN-K`, post the single per-loop review. The `-a` prompt must embed sibling paths as literal absolutes so `Read` works without discovery.