claude-dev-env 2.9.0 → 2.11.0

package/skills/split-pr/scripts/test_analyze_pr.py

@@ -0,0 +1,228 @@
+"""Boundary tests for the 199/200/599/600 hand-written line gates."""
+
+from __future__ import annotations
+
+import json
+import subprocess
+import sys
+from pathlib import Path
+
+import pytest
+
+_SCRIPTS_DIR = Path(__file__).resolve().parent
+if str(_SCRIPTS_DIR) not in sys.path:
+    sys.path.insert(0, str(_SCRIPTS_DIR))
+
+from analyze_pr import (
+    _fetch_pr_files,
+    _file_records_from_gh,
+    _flatten_paginated_file_pages,
+    build_analysis_from_files,
+)
+from config.split_pr_constants import (
+    DEFAULT_SPLIT_HAND_WRITTEN_LINE_THRESHOLD,
+    EXIT_CODE_SUCCESS,
+    FILE_KEY_ADDITIONS,
+    FILE_KEY_DELETIONS,
+    FILE_KEY_PATH,
+    GH_API_SUBCOMMAND,
+    GH_PAGINATE_FLAG,
+    GH_SLURP_FLAG,
+    PAYLOAD_KEY_ATOMIC_EXCEPTION,
+    PAYLOAD_KEY_DEFAULT_SPLIT,
+    PAYLOAD_KEY_EXCLUDED_CHURN_LINES,
+    PAYLOAD_KEY_FILE_COUNT,
+    PAYLOAD_KEY_HAND_WRITTEN_LINES,
+    PAYLOAD_KEY_REQUIRES_SPLIT_ANALYSIS,
+    SPLIT_ANALYSIS_HAND_WRITTEN_LINE_THRESHOLD,
+)
+
+
+def _records_for_hand_written_lines(line_count: int) -> list[dict[str, object]]:
+    return [
+        {
+            FILE_KEY_PATH: "src/module.py",
+            FILE_KEY_ADDITIONS: line_count,
+            FILE_KEY_DELETIONS: 0,
+        }
+    ]
+
+
+def test_hand_written_199_does_not_require_split_analysis() -> None:
+    analysis = build_analysis_from_files(
+        _records_for_hand_written_lines(
+            SPLIT_ANALYSIS_HAND_WRITTEN_LINE_THRESHOLD - 1
+        )
+    )
+    assert analysis[PAYLOAD_KEY_HAND_WRITTEN_LINES] == 199
+    assert analysis[PAYLOAD_KEY_REQUIRES_SPLIT_ANALYSIS] is False
+    assert analysis[PAYLOAD_KEY_DEFAULT_SPLIT] is False
+
+
+def test_hand_written_200_requires_recorded_split_analysis() -> None:
+    analysis = build_analysis_from_files(
+        _records_for_hand_written_lines(SPLIT_ANALYSIS_HAND_WRITTEN_LINE_THRESHOLD)
+    )
+    assert analysis[PAYLOAD_KEY_HAND_WRITTEN_LINES] == 200
+    assert analysis[PAYLOAD_KEY_REQUIRES_SPLIT_ANALYSIS] is True
+    assert analysis[PAYLOAD_KEY_DEFAULT_SPLIT] is False
+
+
+def test_hand_written_599_requires_analysis_but_not_default_split() -> None:
+    analysis = build_analysis_from_files(
+        _records_for_hand_written_lines(
+            DEFAULT_SPLIT_HAND_WRITTEN_LINE_THRESHOLD - 1
+        )
+    )
+    assert analysis[PAYLOAD_KEY_HAND_WRITTEN_LINES] == 599
+    assert analysis[PAYLOAD_KEY_REQUIRES_SPLIT_ANALYSIS] is True
+    assert analysis[PAYLOAD_KEY_DEFAULT_SPLIT] is False
+
+
+def test_hand_written_600_defaults_to_multiple_slices() -> None:
+    analysis = build_analysis_from_files(
+        _records_for_hand_written_lines(DEFAULT_SPLIT_HAND_WRITTEN_LINE_THRESHOLD)
+    )
+    assert analysis[PAYLOAD_KEY_HAND_WRITTEN_LINES] == 600
+    assert analysis[PAYLOAD_KEY_REQUIRES_SPLIT_ANALYSIS] is True
+    assert analysis[PAYLOAD_KEY_DEFAULT_SPLIT] is True
+
+
+def test_atomic_exception_records_reason_and_fable_verdict() -> None:
+    analysis = build_analysis_from_files(
+        _records_for_hand_written_lines(DEFAULT_SPLIT_HAND_WRITTEN_LINE_THRESHOLD),
+        atomic_exception_reason="single schema migration cannot be sliced",
+        fable_verdict="ENDORSE",
+    )
+    assert analysis[PAYLOAD_KEY_DEFAULT_SPLIT] is False
+    atomic = analysis[PAYLOAD_KEY_ATOMIC_EXCEPTION]
+    assert isinstance(atomic, dict)
+    assert atomic["reason"] == "single schema migration cannot be sliced"
+    assert atomic["fable_verdict"] == "ENDORSE"
+
+
+def test_atomic_exception_without_fable_verdict_is_rejected() -> None:
+    with pytest.raises(ValueError, match="Fable verdict"):
+        build_analysis_from_files(
+            _records_for_hand_written_lines(
+                DEFAULT_SPLIT_HAND_WRITTEN_LINE_THRESHOLD
+            ),
+            atomic_exception_reason="cannot split",
+        )
+
+
+def test_excluded_churn_does_not_inflate_hand_written_threshold() -> None:
+    analysis = build_analysis_from_files(
+        [
+            {
+                FILE_KEY_PATH: "src/a.py",
+                FILE_KEY_ADDITIONS: 50,
+                FILE_KEY_DELETIONS: 0,
+            },
+            {
+                FILE_KEY_PATH: "package-lock.json",
+                FILE_KEY_ADDITIONS: 5000,
+                FILE_KEY_DELETIONS: 0,
+            },
+        ]
+    )
+    assert analysis[PAYLOAD_KEY_HAND_WRITTEN_LINES] == 50
+    assert analysis[PAYLOAD_KEY_EXCLUDED_CHURN_LINES] == 5000
+    assert analysis[PAYLOAD_KEY_REQUIRES_SPLIT_ANALYSIS] is False
+    assert analysis[PAYLOAD_KEY_FILE_COUNT] == 2
+
+
+def test_file_count_is_reported_but_not_a_hard_gate() -> None:
+    analysis = build_analysis_from_files(
+        [
+            {
+                FILE_KEY_PATH: f"src/file_{each_index}.py",
+                FILE_KEY_ADDITIONS: 1,
+                FILE_KEY_DELETIONS: 0,
+            }
+            for each_index in range(20)
+        ]
+    )
+    assert analysis[PAYLOAD_KEY_FILE_COUNT] == 20
+    assert analysis[PAYLOAD_KEY_HAND_WRITTEN_LINES] == 20
+    assert analysis[PAYLOAD_KEY_REQUIRES_SPLIT_ANALYSIS] is False
+
+
+def test_fetch_pr_files_uses_paginated_pulls_files_api(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    all_captured_commands: list[list[str]] = []
+
+    def _fake_run(all_command: list[str], **_kwargs: object) -> object:
+        all_captured_commands.append(list(all_command))
+
+        class _Completed:
+            returncode = EXIT_CODE_SUCCESS
+            stdout = json.dumps(
+                [
+                    [
+                        {
+                            "filename": "src/a.py",
+                            "additions": 3,
+                            "deletions": 1,
+                        }
+                    ]
+                ]
+            )
+            stderr = ""
+
+        return _Completed()
+
+    monkeypatch.setattr("analyze_pr.subprocess.run", _fake_run)
+    all_records = _fetch_pr_files(895, "jl-cmd/claude-dev-env")
+    assert len(all_captured_commands) == 1
+    assert all_captured_commands[0][0:2] == ["gh", GH_API_SUBCOMMAND]
+    assert "repos/jl-cmd/claude-dev-env/pulls/895/files" in all_captured_commands[0]
+    assert GH_PAGINATE_FLAG in all_captured_commands[0]
+    assert GH_SLURP_FLAG in all_captured_commands[0]
+    assert all_records[0][FILE_KEY_PATH] == "src/a.py"
+    assert all_records[0][FILE_KEY_ADDITIONS] == 3
+    assert all_records[0][FILE_KEY_DELETIONS] == 1
+
+
+def test_flatten_paginated_file_pages_merges_pages() -> None:
+    all_files = _flatten_paginated_file_pages(
+        [
+            [{"filename": "a.py", "additions": 1, "deletions": 0}],
+            [{"filename": "b.py", "additions": 2, "deletions": 0}],
+        ]
+    )
+    assert len(all_files) == 2
+    all_records = _file_records_from_gh(all_files)
+    assert {each[FILE_KEY_PATH] for each in all_records} == {"a.py", "b.py"}
+
+
+def test_analyze_pr_cli_files_json(tmp_path: Path) -> None:
+    files_path = tmp_path / "files.json"
+    files_path.write_text(
+        json.dumps(
+            [
+                {"path": "src/a.py", "additions": 200, "deletions": 0},
+                {"path": "yarn.lock", "additions": 900, "deletions": 0},
+            ]
+        ),
+        encoding="utf-8",
+    )
+    completed = subprocess.run(
+        [
+            sys.executable,
+            str(_SCRIPTS_DIR / "analyze_pr.py"),
+            "--files-json",
+            str(files_path),
+            "--pretty",
+        ],
+        cwd=str(_SCRIPTS_DIR),
+        capture_output=True,
+        text=True,
+        check=False,
+    )
+    assert completed.returncode == EXIT_CODE_SUCCESS, completed.stderr
+    analysis = json.loads(completed.stdout)
+    assert analysis[PAYLOAD_KEY_HAND_WRITTEN_LINES] == 200
+    assert analysis[PAYLOAD_KEY_EXCLUDED_CHURN_LINES] == 900
+    assert analysis[PAYLOAD_KEY_REQUIRES_SPLIT_ANALYSIS] is True

package/skills/split-pr/scripts/test_categorize_files.py

@@ -0,0 +1,55 @@
+"""Classification tests for hand-written vs excluded churn paths."""
+
+from __future__ import annotations
+
+import sys
+from pathlib import Path
+
+_SCRIPTS_DIR = Path(__file__).resolve().parent
+if str(_SCRIPTS_DIR) not in sys.path:
+    sys.path.insert(0, str(_SCRIPTS_DIR))
+
+from categorize_files import annotate_files, classify_path_churn, sum_churn_by_class
+from config.split_pr_constants import (
+    CHURN_CLASS_GENERATED,
+    CHURN_CLASS_HAND_WRITTEN,
+    CHURN_CLASS_LOCKFILE,
+    CHURN_CLASS_MINIFIED,
+    CHURN_CLASS_VENDOR,
+    FILE_KEY_ADDITIONS,
+    FILE_KEY_DELETIONS,
+    FILE_KEY_PATH,
+)
+
+
+def test_classify_hand_written_source_paths() -> None:
+    assert classify_path_churn("packages/app/main.py") == CHURN_CLASS_HAND_WRITTEN
+    assert classify_path_churn("src/components/Button.tsx") == CHURN_CLASS_HAND_WRITTEN
+
+
+def test_classify_excluded_churn_classes() -> None:
+    assert classify_path_churn("package-lock.json") == CHURN_CLASS_LOCKFILE
+    assert classify_path_churn("vendor/lib/util.js") == CHURN_CLASS_VENDOR
+    assert classify_path_churn("assets/app.min.js") == CHURN_CLASS_MINIFIED
+    assert classify_path_churn("src/generated/types.ts") == CHURN_CLASS_GENERATED
+
+
+def test_annotate_and_sum_separates_hand_written_from_excluded() -> None:
+    all_annotated = annotate_files(
+        [
+            {
+                FILE_KEY_PATH: "src/a.py",
+                FILE_KEY_ADDITIONS: 10,
+                FILE_KEY_DELETIONS: 5,
+            },
+            {
+                FILE_KEY_PATH: "package-lock.json",
+                FILE_KEY_ADDITIONS: 1000,
+                FILE_KEY_DELETIONS: 0,
+            },
+        ]
+    )
+    assert sum_churn_by_class(
+        all_annotated, churn_class=CHURN_CLASS_HAND_WRITTEN
+    ) == 15
+    assert sum_churn_by_class(all_annotated, churn_class=CHURN_CLASS_LOCKFILE) == 1000

package/skills/split-pr/scripts/test_categorize_files_packing.py

@@ -0,0 +1,59 @@
+"""Packing stays under the 200 hand-written review budget per slice."""
+
+from __future__ import annotations
+
+import sys
+from pathlib import Path
+
+import pytest
+
+_SCRIPTS_DIR = Path(__file__).resolve().parent
+if str(_SCRIPTS_DIR) not in sys.path:
+    sys.path.insert(0, str(_SCRIPTS_DIR))
+
+from config.packing_constants import REVIEW_BUDGET_HAND_WRITTEN_LINES
+from config.split_pr_constants import (
+    FILE_KEY_ADDITIONS,
+    FILE_KEY_DELETIONS,
+    FILE_KEY_PATH,
+)
+from pack_files_into_slices import infer_path_layer, pack_files_into_slices
+
+
+def test_infer_path_layer_maps_tests_and_docs() -> None:
+    assert infer_path_layer("packages/x/tests/test_a.py") == "tests"
+    assert infer_path_layer("README.md") == "docs"
+    assert infer_path_layer("src/app.py") == "backend"
+
+
+def test_pack_splits_when_budget_exceeded() -> None:
+    all_files = [
+        {FILE_KEY_PATH: "a.py", FILE_KEY_ADDITIONS: 120, FILE_KEY_DELETIONS: 0},
+        {FILE_KEY_PATH: "b.py", FILE_KEY_ADDITIONS: 120, FILE_KEY_DELETIONS: 0},
+    ]
+    plan = pack_files_into_slices("deadbeef", all_files)
+    assert len(plan["all_slices"]) == 2
+    for each_slice in plan["all_slices"]:
+        assert len(each_slice["all_paths"]) == 1
+
+
+def test_pack_keeps_same_layer_under_budget() -> None:
+    all_files = [
+        {FILE_KEY_PATH: "a.py", FILE_KEY_ADDITIONS: 40, FILE_KEY_DELETIONS: 0},
+        {FILE_KEY_PATH: "b.py", FILE_KEY_ADDITIONS: 40, FILE_KEY_DELETIONS: 0},
+    ]
+    plan = pack_files_into_slices("deadbeef", all_files)
+    assert len(plan["all_slices"]) == 1
+    assert set(plan["all_slices"][0]["all_paths"]) == {"a.py", "b.py"}
+
+
+def test_pack_rejects_single_file_above_hard_cap() -> None:
+    all_files = [
+        {
+            FILE_KEY_PATH: "huge.py",
+            FILE_KEY_ADDITIONS: REVIEW_BUDGET_HAND_WRITTEN_LINES * 4,
+            FILE_KEY_DELETIONS: 0,
+        }
+    ]
+    with pytest.raises(ValueError, match="hard cap"):
+        pack_files_into_slices("deadbeef", all_files)

package/skills/split-pr/scripts/test_execute_split_slices.py

@@ -0,0 +1,99 @@
+"""Local slice materialization walks dependency order with restore on error."""
+
+from __future__ import annotations
+
+import sys
+from pathlib import Path
+
+import pytest
+
+_SCRIPTS_DIR = Path(__file__).resolve().parent
+if str(_SCRIPTS_DIR) not in sys.path:
+    sys.path.insert(0, str(_SCRIPTS_DIR))
+
+from execute_split_slices import materialize_plan_locally
+from split_pr_process_runner import CapturedProcessOutcome
+
+
+class _SequenceRunner:
+    def __init__(self) -> None:
+        self.head = "sha0"
+        self.commit_count = 0
+        self.fail_on_commit_index: int | None = None
+
+    def __call__(
+        self, all_command: list[str], working_directory: str
+    ) -> CapturedProcessOutcome:
+        all_git_args = all_command[1:]
+        if all_git_args[:2] == ["status", "--porcelain"]:
+            return CapturedProcessOutcome(0, "", "")
+        if all_git_args[:2] == ["rev-parse", "HEAD"]:
+            return CapturedProcessOutcome(0, self.head + "\n", "")
+        if all_git_args[:1] == ["add"]:
+            return CapturedProcessOutcome(0, "", "")
+        if all_git_args[:1] == ["commit"]:
+            self.commit_count += 1
+            if self.fail_on_commit_index == self.commit_count:
+                return CapturedProcessOutcome(1, "", "boom")
+            self.head = f"sha{self.commit_count}"
+            return CapturedProcessOutcome(0, "", "")
+        if all_git_args[:1] == ["checkout"]:
+            self.head = all_git_args[-1]
+            return CapturedProcessOutcome(0, "", "")
+        if all_git_args[:1] in (["restore"], ["clean"]):
+            return CapturedProcessOutcome(0, "", "")
+        return CapturedProcessOutcome(1, "", f"unexpected {all_command}")
+
+
+def test_materialize_plan_locally_commits_in_layer_order(tmp_path: Path) -> None:
+    plan = {
+        "schema_version": 1,
+        "source_commit": "sha0",
+        "all_changed_paths": ["a.py", "b.md"],
+        "all_slices": [
+            {
+                "id": "02-docs",
+                "title": "docs: b",
+                "layer": "docs",
+                "all_paths": ["b.md"],
+            },
+            {
+                "id": "01-backend",
+                "title": "feat: a",
+                "layer": "backend",
+                "all_paths": ["a.py"],
+            },
+        ],
+    }
+    runner = _SequenceRunner()
+    all_commit_records = materialize_plan_locally(tmp_path, plan, run=runner)
+    assert [each["commit_sha"] for each in all_commit_records] == ["sha1", "sha2"]
+    assert all_commit_records[0]["all_paths"] == ["a.py"]
+    assert all_commit_records[1]["all_paths"] == ["b.md"]
+
+
+def test_materialize_plan_locally_restores_source_on_failure(tmp_path: Path) -> None:
+    plan = {
+        "schema_version": 1,
+        "source_commit": "sha0",
+        "all_changed_paths": ["a.py", "b.py"],
+        "all_slices": [
+            {
+                "id": "01",
+                "title": "feat: a",
+                "layer": "backend",
+                "all_paths": ["a.py"],
+            },
+            {
+                "id": "02",
+                "title": "feat: b",
+                "layer": "backend",
+                "all_paths": ["b.py"],
+            },
+        ],
+    }
+    runner = _SequenceRunner()
+    runner.fail_on_commit_index = 2
+    with pytest.raises(RuntimeError, match="boom"):
+        materialize_plan_locally(tmp_path, plan, run=runner)
+    assert runner.head == "sha0"

package/skills/split-pr/scripts/test_split_pr_dependency_graph.py

@@ -0,0 +1,47 @@
+"""Dependency graph is deterministic and layer-ordered."""
+
+from __future__ import annotations
+
+import sys
+from pathlib import Path
+
+import pytest
+
+_SCRIPTS_DIR = Path(__file__).resolve().parent
+if str(_SCRIPTS_DIR) not in sys.path:
+    sys.path.insert(0, str(_SCRIPTS_DIR))
+
+from split_pr_dependency_graph import build_dependency_graph
+
+
+def test_graph_orders_config_before_docs() -> None:
+    all_slices = [
+        {"id": "02-docs", "layer": "docs"},
+        {"id": "01-config", "layer": "config"},
+    ]
+    graph = build_dependency_graph(all_slices)
+    assert graph["topological_order"] == ["01-config", "02-docs"]
+    assert {"from": "01-config", "to": "02-docs"} in graph["edges"]
+
+
+def test_duplicate_id_fails() -> None:
+    with pytest.raises(ValueError, match="duplicate"):
+        build_dependency_graph(
+            [{"id": "x", "layer": "backend"}, {"id": "x", "layer": "tests"}]
+        )
+
+
+def test_unknown_layer_fails() -> None:
+    with pytest.raises(ValueError, match="unknown layer"):
+        build_dependency_graph([{"id": "x", "layer": "mystery"}])
+
+
+def test_same_layer_no_edge() -> None:
+    graph = build_dependency_graph(
+        [
+            {"id": "a", "layer": "backend"},
+            {"id": "b", "layer": "backend"},
+        ]
+    )
+    assert graph["edges"] == []
+    assert graph["topological_order"] == ["a", "b"]

package/skills/split-pr/scripts/test_split_pr_git_operations.py

@@ -0,0 +1,125 @@
+"""Git materialization stages only slice paths and restores on failure."""
+
+from __future__ import annotations
+
+import sys
+from pathlib import Path
+
+import pytest
+
+_SCRIPTS_DIR = Path(__file__).resolve().parent
+if str(_SCRIPTS_DIR) not in sys.path:
+    sys.path.insert(0, str(_SCRIPTS_DIR))
+
+from split_pr_git_operations import (
+    assert_clean_worktree,
+    materialize_slice_commit,
+    read_head_sha,
+    restore_repository_state,
+)
+from split_pr_process_runner import CapturedProcessOutcome
+
+
+class _FakeRunner:
+    def __init__(self) -> None:
+        self.all_calls: list[list[str]] = []
+        self.head_sha = "base111"
+        self.fail_commit = False
+        self.is_dirty = False
+
+    def __call__(
+        self, all_command: list[str], working_directory: str
+    ) -> CapturedProcessOutcome:
+        self.all_calls.append(list(all_command))
+        all_git_args = all_command[1:]
+        if all_git_args[:2] == ["status", "--porcelain"]:
+            text = " M dirty.py\n" if self.is_dirty else ""
+            return CapturedProcessOutcome(0, text, "")
+        if all_git_args[:2] == ["rev-parse", "HEAD"]:
+            return CapturedProcessOutcome(0, self.head_sha + "\n", "")
+        if all_git_args[:1] == ["add"]:
+            return CapturedProcessOutcome(0, "", "")
+        if all_git_args[:1] == ["commit"]:
+            if self.fail_commit:
+                return CapturedProcessOutcome(1, "", "commit failed")
+            self.head_sha = "commit222"
+            return CapturedProcessOutcome(0, "", "")
+        if all_git_args[:1] == ["checkout"]:
+            self.head_sha = all_git_args[-1]
+            return CapturedProcessOutcome(0, "", "")
+        if all_git_args[:1] == ["restore"]:
+            return CapturedProcessOutcome(0, "", "")
+        if all_git_args[:1] == ["clean"]:
+            return CapturedProcessOutcome(0, "", "")
+        return CapturedProcessOutcome(1, "", f"unexpected {all_command}")
+
+
+def test_read_head_sha_returns_current_head(tmp_path: Path) -> None:
+    runner = _FakeRunner()
+    assert read_head_sha(tmp_path, run=runner) == "base111"
+
+
+def test_assert_clean_worktree_passes_on_empty_status(tmp_path: Path) -> None:
+    runner = _FakeRunner()
+    assert_clean_worktree(tmp_path, run=runner)
+
+
+def test_restore_repository_state_checks_out_target(tmp_path: Path) -> None:
+    runner = _FakeRunner()
+    restore_repository_state(tmp_path, "restore999", run=runner)
+    assert runner.head_sha == "restore999"
+
+
+def test_materialize_slice_commit_stages_only_slice_paths(tmp_path: Path) -> None:
+    runner = _FakeRunner()
+    commit_record = materialize_slice_commit(
+        repository_path=tmp_path,
+        all_slice_paths=["a.py", "b.py"],
+        commit_message="chore: slice",
+        expected_base_sha="base111",
+        run=runner,
+    )
+    assert commit_record["commit_sha"] == "commit222"
+    assert commit_record["all_paths"] == ["a.py", "b.py"]
+    add_call = next(each for each in runner.all_calls if each[1] == "add")
+    assert add_call[3:] == ["a.py", "b.py"]
+
+
+def test_materialize_slice_commit_refuses_dirty_tree(tmp_path: Path) -> None:
+    runner = _FakeRunner()
+    runner.is_dirty = True
+    with pytest.raises(RuntimeError, match="dirty"):
+        materialize_slice_commit(
+            repository_path=tmp_path,
+            all_slice_paths=["a.py"],
+            commit_message="chore: x",
+            expected_base_sha="base111",
+            run=runner,
+        )
+
+
+def test_materialize_slice_commit_restores_on_commit_failure(tmp_path: Path) -> None:
+    runner = _FakeRunner()
+    runner.fail_commit = True
+    with pytest.raises(RuntimeError, match="commit failed"):
+        materialize_slice_commit(
+            repository_path=tmp_path,
+            all_slice_paths=["a.py"],
+            commit_message="chore: x",
+            expected_base_sha="base111",
+            run=runner,
+        )
+    assert any(each[1] == "checkout" for each in runner.all_calls)
+    assert runner.head_sha == "base111"
+
+
+def test_materialize_slice_commit_rejects_base_mismatch(tmp_path: Path) -> None:
+    runner = _FakeRunner()
+    with pytest.raises(RuntimeError, match="does not match"):
+        materialize_slice_commit(
+            repository_path=tmp_path,
+            all_slice_paths=["a.py"],
+            commit_message="chore: x",
+            expected_base_sha="other999",
+            run=runner,
+        )

package/skills/split-pr/scripts/test_split_pr_layer_order.py

@@ -0,0 +1,36 @@
+"""Layer order is deterministic and config-first."""
+
+from __future__ import annotations
+
+import sys
+from pathlib import Path
+
+_SCRIPTS_DIR = Path(__file__).resolve().parent
+if str(_SCRIPTS_DIR) not in sys.path:
+    sys.path.insert(0, str(_SCRIPTS_DIR))
+
+from config.plan_constants import SLICE_KEY_ID, SLICE_KEY_LAYER
+from split_pr_layer_order import layer_rank, sort_slices_by_layer_order
+
+
+def test_layer_rank_orders_config_before_docs() -> None:
+    assert layer_rank("config") < layer_rank("docs")
+    assert layer_rank("mystery") > layer_rank("other")
+
+
+def test_sort_places_config_before_docs() -> None:
+    all_slices = [
+        {SLICE_KEY_ID: "docs", SLICE_KEY_LAYER: "docs"},
+        {SLICE_KEY_ID: "config", SLICE_KEY_LAYER: "config"},
+    ]
+    all_ordered = sort_slices_by_layer_order(all_slices)
+    assert [each[SLICE_KEY_ID] for each in all_ordered] == ["config", "docs"]
+
+
+def test_unknown_layer_sorts_after_known() -> None:
+    all_slices = [
+        {SLICE_KEY_ID: "z", SLICE_KEY_LAYER: "mystery"},
+        {SLICE_KEY_ID: "a", SLICE_KEY_LAYER: "backend"},
+    ]
+    all_ordered = sort_slices_by_layer_order(all_slices)
+    assert [each[SLICE_KEY_ID] for each in all_ordered] == ["a", "z"]