claude-dev-env 2.9.0 → 2.10.0

package/skills/show/workflows/create-visual.md

@@ -0,0 +1,13 @@
+# Create a visual
+
+1. Restate the visual goal in one sentence.
+2. Choose a route by intent, not by subject.
+3. Load shared references and the route references listed in `routing.yaml`.
+4. Build the subject inventory per `references/subject-inventory.md`.
+5. Sketch the smallest useful structure before writing markup.
+6. Keep labels short and put explanation in surrounding prose.
+7. Build from the route template.
+8. Run package and artifact validators.
+9. Inspect the rendered result for clipping, overlap, legibility, and contrast.
+
+Use an overview plus detail visuals when the content exceeds the route limits.

package/skills/show/workflows/review-visual.md

@@ -0,0 +1,20 @@
+# Review a visual
+
+1. Identify the route and expected output type.
+2. Check accessibility metadata and host compatibility.
+3. Walk the A–E checklist below in order. Accuracy outranks style, so a finding at A–D outranks a finding at E.
+4. Run `validate-artifact.py` and the relevant render inspection.
+5. Repair verified defects and rerun all checks.
+6. Report the remaining limitation when a module lacks dedicated guidance.
+
+## A–E checklist
+
+- **A — instant readability.** A stranger gets the story in 10 seconds.
+- **B — literalness.** Ideas are drawn as objects rather than written as labels.
+- **C — visual hierarchy.** The most important object is the largest and strongest.
+- **D — accuracy against the source.** Every arrow matches a citable `path:line`.
+- **E — craft.** Layout bounds hold, geometry connects, references resolve, color meaning is consistent, and text reads at display scale.
+
+## Optional advisor audit
+
+One pass, no loop. Hand one subagent the artifact plus the A–E checklist above, ask for ranked issues each with a fix, apply the fixes once, then run step 4 again.

package/skills/split-pr/SKILL.md

@@ -0,0 +1,85 @@
+---
+name: split-pr
+description: >-
+  Source-owned PR analyzer for the hand-written line metric and 200/600 split
+  gates. Triggers: /split-pr analyze, split analysis, hand-written lines,
+  200/600 PR split.
+---
+
+# split-pr (analyzer)
+
+**Source-owned analyzer** for the locked hand-written line metric and the 200 /
+600 split gates. Reports hand-written churn separately from excluded churn
+(generated, vendor, minified, lockfile). File count informs judgment and is
+never a hard gate.
+
+## Gotchas
+
+- **Hand-written lines are additions plus deletions** on non-excluded paths.
+- **200 hand-written lines** require a recorded `split_analysis` document.
+- **600 hand-written lines** default to multiple PR slices (`default_split`).
+- **Atomic exception** at 600+ needs a recorded unsplittable reason and a
+  standing Fable verdict token — never stay one PR silently.
+- **File count is context only.** It never blocks analysis.
+
+## When this applies
+
+- User asks for a split analysis or hand-written line report on a PR or file list.
+- A PR approaches or exceeds the 200 / 600 hand-written line surfaces.
+
+## Process
+
+1. Run `python scripts/analyze_pr.py --files-json <path> --pretty` (or `--pr N`).
+2. Read `hand_written_lines`, `excluded_churn_lines`, `requires_split_analysis`,
+   `default_split`, and optional `atomic_exception`.
+3. At 200+ without a prior analysis artifact, record the analyzer JSON before
+   shipping further commits on that surface.
+4. At 600+ with `default_split=true`, plan multiple PR slices unless
+   `atomic_exception` carries a Fable-approved reason.
+
+## File index
+
+| File | Purpose |
+|---|---|
+| `SKILL.md` | Analyzer contract and 200/600 gates |
+| `scripts/analyze_pr.py` | Emit analysis JSON from gh or offline files |
+| `scripts/categorize_files.py` | Path churn class (hand-written vs excluded) |
+| `scripts/split_pr_script_types.py` | Canonical split-plan build and path-assignment validation |
+| `scripts/split_pr_title.py` | Collapse titles to exactly one conventional prefix |
+| `scripts/split_pr_layer_order.py` | Deterministic config→other layer sort |
+| `scripts/split_pr_paginate.py` | Paginated PR file intake via gh api --slurp |
+| `scripts/pack_files_into_slices.py` | Pack annotated files into ≤200 hand-written-line slices by layer |
+| `scripts/config/packing_constants.py` | Review budget, hard cap, path→layer markers for packing |
+| `scripts/test_categorize_files_packing.py` | Budget packing and layer inference tests |
+| `scripts/verify_plan.py` | Coverage verification: unique path assignment, path normalization, title contract |
+| `scripts/test_verify_plan.py` | Full-coverage and gap rejection tests |
+| `scripts/test_verify_plan_contract.py` | source_commit and title-normalization contract tests |
+| `scripts/test_verify_plan_path_normalization.py` | Unsafe-path fail-closed tests |
+| `scripts/split_pr_dependency_graph.py` | Deterministic layer-rank dependency graph over slices |
+| `scripts/config/dependency_constants.py` | Graph key names and layer ranks |
+| `scripts/test_split_pr_dependency_graph.py` | Graph order, duplicate-id, unknown-layer tests |
+| `scripts/verify_dependency_graph.py` | CLI + shape/order checks for a dependency graph document |
+| `scripts/test_verify_dependency_graph.py` | Rebuild-order accept/reject and CLI exit tests |
+| `scripts/config/split_pr_constants.py` | Thresholds and excluded path markers |
+| `scripts/config/plan_constants.py` | Plan schema keys, layer order, title-prefix tokens |
+| `scripts/test_analyze_pr.py` | Boundary tests at 199/200/599/600 |
+| `scripts/test_categorize_files.py` | Exclusion classification tests |
+| `scripts/test_split_pr_script_types.py` | Plan schema and full path assignment |
+| `scripts/test_split_pr_title.py` | One-prefix title normalization |
+| `scripts/test_split_pr_layer_order.py` | Layer order ranking |
+| `scripts/test_split_pr_paginate.py` | Slurp page flattening |
+| `scripts/split_pr_process_runner.py` | Captured subprocess runner for Git ops |
+| `scripts/split_pr_git_operations.py` | Safe local slice commit + restore via git_operations_constants |
+| `scripts/execute_split_slices.py` | Materialize full plan in topo order |
+| `scripts/config/git_operations_constants.py` | Git argv tokens and error strings |
+| `scripts/test_split_pr_git_operations.py` | Dirty-tree, path staging, restore tests |
+| `scripts/test_execute_split_slices.py` | Plan walk order and failure restore |
+| `reference/proposal-format.md` | Human-readable plan field contract |
+| `reference/splitting-principles.md` | Vertical-slice invariants |
+| `reference/path-layers.md` | Layer hints (context only) |
+| `reference/split-further-loop.md` | Re-split loop until leaves fit review |
+
+## Folder map
+
+- `scripts/` — analyzer, categorize helpers, plan verifier, plan contract, constants, tests
+- `reference/` — vertical-slice principles, layer hints, plan field contract

package/skills/split-pr/reference/path-layers.md

@@ -0,0 +1,16 @@
+# Path layers — context only
+
+Path-layer labels (database, contracts, backend, frontend, tests, config) are
+**judgment aids**, not hard gates. Vertical slice assignment overrides layer
+buckets when tests must travel with the modules they cover.
+
+| Layer hint | Typical paths |
+|---|---|
+| database | `**/migrations/**`, `**/schema.prisma` |
+| contracts | `**/api/**/types*`, OpenAPI specs |
+| backend | `**/services/**`, `**/handlers/**` |
+| frontend | `**/components/**`, `**/*.tsx` |
+| tests | `**/test_*.py`, `**/*_test.py`, `**/*.test.*` |
+| config | lockfiles, `package.json`, CI workflows |
+
+File count and layer count inform review; they never alone block a plan.

package/skills/split-pr/reference/proposal-format.md

@@ -0,0 +1,15 @@
+# Split-plan proposal format
+
+Machine-readable plan documents use `schema_version` `1` with:
+
+| Field | Meaning |
+|---|---|
+| `source_commit` | Exact SHA the changed-file list was taken from |
+| `all_changed_paths` | Full path set for that commit |
+| `all_slices` | Ordered slices after layer sort |
+
+Each slice carries `id`, `title` (exactly one conventional prefix), `layer`
+(one of `config` / `backend` / `frontend` / `tests` / `docs` / `other`), and
+`all_paths`. Every path in `all_changed_paths` is assigned to exactly one
+slice. Titles are normalized with `split_pr_title.normalize_split_title`.
+Layer tokens follow `ALL_LAYER_ORDER` in `packages/claude-dev-env/skills/split-pr/scripts/config/plan_constants.py`.

package/skills/split-pr/reference/split-further-loop.md

@@ -0,0 +1,10 @@
+# Split-further loop
+
+After the first vertical plan lands as draft slices, re-check each leaf PR:
+
+1. Run the hand-written line analyzer (`scripts/analyze_pr.py`).
+2. If hand-written lines ≥ 200, record a split-analysis artifact.
+3. If hand-written lines ≥ 600 and no atomic exception, propose a further
+   vertical split (tests still co-located with behavior).
+4. Stop when every leaf fits review or carries a Fable-approved atomic
+   exception.

package/skills/split-pr/reference/splitting-principles.md

@@ -0,0 +1,26 @@
+# Splitting principles — vertical slices
+
+A split plan groups changed paths into **semantic vertical slices**, not layer
+silos. Each slice tells one reviewable story and keeps related tests beside the
+behavior they cover.
+
+## Invariants
+
+1. **Test co-location.** A behavior change and its related tests share one
+   slice. Tests do not land in a later dedicated-test slice by default.
+2. **One story per slice.** Each slice has a single review focus (one vertical
+   capability or one coherent subsystem story).
+3. **Unique path ownership.** Every changed path appears in exactly one slice.
+4. **Green intermediate.** Each stacked intermediate must collect and run the
+   tests that belong to that slice and its bases.
+5. **Preparatory refactors first.** Substantial refactors that do not change
+   product behavior occupy earlier preparatory slices, not mixed with behavior.
+6. **Dependency bases encode merge order.** Slice N+1 bases on slice N when it
+   depends on N's definitions.
+
+## Fable gates
+
+Standing Fable approval is required for:
+
+- a semantic re-bucket that moves paths across slices after the first plan
+- an oversized atomic exception that keeps an unsplittable surface as one PR

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

@@ -0,0 +1,279 @@
+#!/usr/bin/env python3
+"""Analyze PR churn with the hand-written line metric and 200/600 gates.
+
+::
+
+    python analyze_pr.py --files-json files.json --pretty
+    {"hand_written_lines": 200, "requires_split_analysis": true, ...}
+
+Uses paginated ``gh api .../pulls/N/files`` unless ``--files-json`` is offline.
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+import subprocess
+import sys
+from pathlib import Path
+
+from categorize_files import annotate_files, sum_churn_by_class
+from config.split_pr_constants import (
+    CHURN_CLASS_HAND_WRITTEN,
+    DEFAULT_SPLIT_HAND_WRITTEN_LINE_THRESHOLD,
+    EXIT_CODE_FAILURE,
+    EXIT_CODE_SUCCESS,
+    FILE_KEY_ADDITIONS,
+    FILE_KEY_CHANGED_LINES,
+    FILE_KEY_CHURN_CLASS,
+    FILE_KEY_DELETIONS,
+    FILE_KEY_PATH,
+    GH_API_SUBCOMMAND,
+    GH_COMMAND,
+    GH_FILE_ADDITIONS,
+    GH_FILE_DELETIONS,
+    GH_FILE_FILENAME,
+    GH_FILE_PATH,
+    GH_JSON_FLAG,
+    GH_NAME_WITH_OWNER_FIELD,
+    GH_PAGINATE_FLAG,
+    GH_PULLS_FILES_PATH_TEMPLATE,
+    GH_REPO_SUBCOMMAND,
+    GH_SLURP_FLAG,
+    GH_VIEW,
+    JSON_INDENT_SPACES,
+    PAYLOAD_KEY_ALL_FILES,
+    PAYLOAD_KEY_ATOMIC_EXCEPTION,
+    PAYLOAD_KEY_DEFAULT_SPLIT,
+    PAYLOAD_KEY_ERROR,
+    PAYLOAD_KEY_EXCLUDED_CHURN_LINES,
+    PAYLOAD_KEY_FABLE_VERDICT,
+    PAYLOAD_KEY_FILE_COUNT,
+    PAYLOAD_KEY_HAND_WRITTEN_LINES,
+    PAYLOAD_KEY_REASON,
+    PAYLOAD_KEY_REQUIRES_SPLIT_ANALYSIS,
+    SPLIT_ANALYSIS_HAND_WRITTEN_LINE_THRESHOLD,
+    UTF8_ENCODING,
+)
+
+JsonObject = dict[str, object]
+
+
+def build_analysis_from_files(
+    all_file_records: list[JsonObject],
+    *,
+    atomic_exception_reason: str | None = None,
+    fable_verdict: str | None = None,
+) -> JsonObject:
+    """Build the hand-written line analysis document.
+
+    Args:
+        all_file_records: Raw path/additions/deletions maps.
+        atomic_exception_reason: When set at 600+, records an atomic exception.
+        fable_verdict: Standing Fable verdict token required with the exception.
+
+    Returns:
+        Analysis payload with thresholds and optional atomic_exception.
+
+    Raises:
+        ValueError: When an atomic exception is set without a Fable verdict.
+    """
+    all_annotated = annotate_files(all_file_records)
+    hand_written_lines = sum_churn_by_class(
+        all_annotated, churn_class=CHURN_CLASS_HAND_WRITTEN
+    )
+    excluded_churn_lines = 0
+    for each_record in all_annotated:
+        if each_record.get(FILE_KEY_CHURN_CLASS) != CHURN_CLASS_HAND_WRITTEN:
+            excluded_churn_lines += int(
+                each_record.get(FILE_KEY_CHANGED_LINES, 0) or 0
+            )
+    file_count = len(all_annotated)
+    requires_split_analysis = (
+        hand_written_lines >= SPLIT_ANALYSIS_HAND_WRITTEN_LINE_THRESHOLD
+    )
+    default_split = hand_written_lines >= DEFAULT_SPLIT_HAND_WRITTEN_LINE_THRESHOLD
+    analysis: JsonObject = {
+        PAYLOAD_KEY_HAND_WRITTEN_LINES: hand_written_lines,
+        PAYLOAD_KEY_EXCLUDED_CHURN_LINES: excluded_churn_lines,
+        PAYLOAD_KEY_FILE_COUNT: file_count,
+        PAYLOAD_KEY_REQUIRES_SPLIT_ANALYSIS: requires_split_analysis,
+        PAYLOAD_KEY_DEFAULT_SPLIT: default_split,
+        PAYLOAD_KEY_ALL_FILES: all_annotated,
+        PAYLOAD_KEY_ATOMIC_EXCEPTION: None,
+    }
+    if default_split and atomic_exception_reason:
+        if not fable_verdict:
+            raise ValueError(
+                "atomic exception at 600+ hand-written lines requires a "
+                "standing Fable verdict"
+            )
+        analysis[PAYLOAD_KEY_ATOMIC_EXCEPTION] = {
+            PAYLOAD_KEY_REASON: atomic_exception_reason,
+            PAYLOAD_KEY_FABLE_VERDICT: fable_verdict,
+        }
+        analysis[PAYLOAD_KEY_DEFAULT_SPLIT] = False
+    return analysis
+
+
+def _file_records_from_gh(raw_files: object) -> list[JsonObject]:
+    if not isinstance(raw_files, list):
+        return []
+    all_file_records: list[JsonObject] = []
+    for each_file in raw_files:
+        if not isinstance(each_file, dict):
+            continue
+        path = each_file.get(GH_FILE_PATH) or each_file.get(GH_FILE_FILENAME)
+        if not path:
+            continue
+        all_file_records.append(
+            {
+                FILE_KEY_PATH: str(path),
+                FILE_KEY_ADDITIONS: int(each_file.get(GH_FILE_ADDITIONS, 0) or 0),
+                FILE_KEY_DELETIONS: int(each_file.get(GH_FILE_DELETIONS, 0) or 0),
+            }
+        )
+    return all_file_records
+
+
+def _flatten_paginated_file_pages(payload: object) -> list[object]:
+    if not isinstance(payload, list):
+        return []
+    all_files: list[object] = []
+    for each_page in payload:
+        if isinstance(each_page, list):
+            all_files.extend(each_page)
+        elif isinstance(each_page, dict):
+            all_files.append(each_page)
+    return all_files
+
+
+def _load_files_json(files_json_path: Path) -> list[JsonObject]:
+    payload = json.loads(files_json_path.read_text(encoding=UTF8_ENCODING))
+    if not isinstance(payload, list):
+        raise ValueError("files-json must be a JSON array")
+    return _file_records_from_gh(payload)
+
+
+def _resolve_repo_name(repo: str | None) -> str:
+    if repo:
+        return repo
+    completed = subprocess.run(
+        [
+            GH_COMMAND,
+            GH_REPO_SUBCOMMAND,
+            GH_VIEW,
+            GH_JSON_FLAG,
+            GH_NAME_WITH_OWNER_FIELD,
+        ],
+        capture_output=True,
+        text=True,
+        check=False,
+        encoding=UTF8_ENCODING,
+    )
+    if completed.returncode != EXIT_CODE_SUCCESS:
+        raise RuntimeError(
+            completed.stderr.strip()
+            or "gh repo view failed; pass --repo owner/name"
+        )
+    payload = json.loads(completed.stdout)
+    name_with_owner = payload.get(GH_NAME_WITH_OWNER_FIELD)
+    if not name_with_owner:
+        raise RuntimeError("gh repo view returned no nameWithOwner; pass --repo")
+    return str(name_with_owner)
+
+
+def _fetch_pr_files(pr_number: int, repo: str | None) -> list[JsonObject]:
+    resolved_repo = _resolve_repo_name(repo)
+    api_path = GH_PULLS_FILES_PATH_TEMPLATE.format(
+        repo=resolved_repo,
+        pr_number=pr_number,
+    )
+    all_command = [
+        GH_COMMAND,
+        GH_API_SUBCOMMAND,
+        api_path,
+        GH_PAGINATE_FLAG,
+        GH_SLURP_FLAG,
+    ]
+    completed = subprocess.run(
+        all_command,
+        capture_output=True,
+        text=True,
+        check=False,
+        encoding=UTF8_ENCODING,
+    )
+    if completed.returncode != EXIT_CODE_SUCCESS:
+        raise RuntimeError(completed.stderr.strip() or "gh api pulls files failed")
+    payload = json.loads(completed.stdout)
+    return _file_records_from_gh(_flatten_paginated_file_pages(payload))
+
+
+def _analysis_for_cli(
+    all_file_records: list[JsonObject],
+    exception_reason: str | None,
+    standing_verdict: str | None,
+) -> JsonObject:
+    """Map CLI flag values onto the analysis builder kwargs."""
+    return build_analysis_from_files(
+        all_file_records,
+        atomic_exception_reason=exception_reason,
+        fable_verdict=standing_verdict,
+    )
+
+
+def main() -> int:
+    """CLI entry: emit analysis JSON to stdout.
+
+    Returns:
+        Process exit code.
+
+    Raises:
+        Does not raise; converts analysis failures into a JSON error payload.
+    """
+    parser = argparse.ArgumentParser(description="Hand-written line PR analyzer")
+    parser.add_argument("--pr", type=int, default=0, help="PR number for gh fetch")
+    parser.add_argument("--repo", default=None, help="owner/name for gh")
+    parser.add_argument(
+        "--files-json",
+        type=Path,
+        default=None,
+        help="Offline files payload (tests); skips gh",
+    )
+    parser.add_argument(
+        "--atomic-exception-reason",
+        default=None,
+        help="Unsplittable reason when keeping one PR at 600+",
+    )
+    parser.add_argument(
+        "--fable-verdict",
+        default=None,
+        help="Standing Fable verdict token for the atomic exception",
+    )
+    parser.add_argument("--pretty", action="store_true", help="Indent JSON output")
+    parsed = parser.parse_args()
+    try:
+        if parsed.files_json is not None:
+            all_file_records = _load_files_json(parsed.files_json)
+        elif parsed.pr > 0:
+            all_file_records = _fetch_pr_files(parsed.pr, parsed.repo)
+        else:
+            raise ValueError("provide --pr or --files-json")
+        analysis = _analysis_for_cli(
+            all_file_records,
+            parsed.atomic_exception_reason,
+            parsed.fable_verdict,
+        )
+    except (OSError, ValueError, RuntimeError, json.JSONDecodeError) as error:
+        print(
+            json.dumps({PAYLOAD_KEY_ERROR: str(error)}),
+            file=sys.stdout,
+        )
+        return EXIT_CODE_FAILURE
+    indent = JSON_INDENT_SPACES if parsed.pretty else None
+    print(json.dumps(analysis, indent=indent))
+    return EXIT_CODE_SUCCESS
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

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

@@ -0,0 +1,106 @@
+"""Classify changed files as hand-written or excluded churn.
+
+::
+
+    classify_path_churn("src/app.py")           # hand_written
+    classify_path_churn("package-lock.json")    # lockfile
+    classify_path_churn("vendor/lib.js")        # vendor
+"""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+from config.split_pr_constants import (
+    ALL_GENERATED_PATH_MARKERS,
+    ALL_LOCKFILE_NAMES,
+    ALL_MINIFIED_SUFFIXES,
+    ALL_VENDOR_PATH_MARKERS,
+    CHURN_CLASS_GENERATED,
+    CHURN_CLASS_HAND_WRITTEN,
+    CHURN_CLASS_LOCKFILE,
+    CHURN_CLASS_MINIFIED,
+    CHURN_CLASS_VENDOR,
+    FILE_KEY_ADDITIONS,
+    FILE_KEY_CHANGED_LINES,
+    FILE_KEY_CHURN_CLASS,
+    FILE_KEY_DELETIONS,
+    FILE_KEY_PATH,
+)
+
+JsonObject = dict[str, object]
+
+
+def classify_path_churn(file_path: str) -> str:
+    """Return the churn class for a repository-relative path.
+
+    Args:
+        file_path: Path relative to the repository root.
+
+    Returns:
+        One of hand_written, generated, vendor, minified, or lockfile.
+    """
+    normalized = file_path.replace("\\", "/")
+    basename = Path(normalized).name
+    if basename in ALL_LOCKFILE_NAMES:
+        return CHURN_CLASS_LOCKFILE
+    lowered = normalized.lower()
+    for each_suffix in ALL_MINIFIED_SUFFIXES:
+        if lowered.endswith(each_suffix):
+            return CHURN_CLASS_MINIFIED
+    path_with_slashes = f"/{lowered}/"
+    for each_marker in ALL_VENDOR_PATH_MARKERS:
+        if each_marker in path_with_slashes:
+            return CHURN_CLASS_VENDOR
+    for each_marker in ALL_GENERATED_PATH_MARKERS:
+        if each_marker in lowered or each_marker.strip("/") in lowered.split("/"):
+            return CHURN_CLASS_GENERATED
+    return CHURN_CLASS_HAND_WRITTEN
+
+
+def annotate_files(all_file_records: list[JsonObject]) -> list[JsonObject]:
+    """Annotate each file record with churn class and changed line count.
+
+    Args:
+        all_file_records: Maps with path, additions, deletions.
+
+    Returns:
+        Annotated records (new list; inputs not mutated).
+    """
+    all_annotated: list[JsonObject] = []
+    for each_record in all_file_records:
+        path = str(each_record.get(FILE_KEY_PATH, "") or "")
+        additions = int(each_record.get(FILE_KEY_ADDITIONS, 0) or 0)
+        deletions = int(each_record.get(FILE_KEY_DELETIONS, 0) or 0)
+        changed_lines = max(0, additions) + max(0, deletions)
+        all_annotated.append(
+            {
+                FILE_KEY_PATH: path,
+                FILE_KEY_ADDITIONS: max(0, additions),
+                FILE_KEY_DELETIONS: max(0, deletions),
+                FILE_KEY_CHANGED_LINES: changed_lines,
+                FILE_KEY_CHURN_CLASS: classify_path_churn(path),
+            }
+        )
+    return all_annotated
+
+
+def sum_churn_by_class(
+    all_annotated: list[JsonObject],
+    *,
+    churn_class: str,
+) -> int:
+    """Sum changed lines for records matching ``churn_class``.
+
+    Args:
+        all_annotated: Annotated file records.
+        churn_class: Target class name.
+
+    Returns:
+        Total changed lines in that class.
+    """
+    total = 0
+    for each_record in all_annotated:
+        if each_record.get(FILE_KEY_CHURN_CLASS) == churn_class:
+            total += int(each_record.get(FILE_KEY_CHANGED_LINES, 0) or 0)
+    return total

package/skills/split-pr/scripts/config/__init__.py

@@ -0,0 +1 @@
+"""Config package for split-pr analyzer constants."""

package/skills/split-pr/scripts/config/dependency_constants.py

@@ -0,0 +1,14 @@
+"""Constants for deterministic split-slice dependency graphs."""
+
+from __future__ import annotations
+
+from config.plan_constants import ALL_LAYER_ORDER
+
+GRAPH_KEY_NODES: str = "nodes"
+GRAPH_KEY_EDGES: str = "edges"
+GRAPH_KEY_ORDER: str = "topological_order"
+EDGE_KEY_FROM: str = "from"
+EDGE_KEY_TO: str = "to"
+ALL_LAYER_RANK_BY_NAME: dict[str, int] = {
+    each_layer: each_index for each_index, each_layer in enumerate(ALL_LAYER_ORDER)
+}

package/skills/split-pr/scripts/config/git_operations_constants.py

@@ -0,0 +1,36 @@
+"""Constants for safe local Git slice materialization."""
+
+from __future__ import annotations
+
+GIT_COMMAND: str = "git"
+ALL_GIT_STATUS_PORCELAIN: tuple[str, ...] = ("status", "--porcelain")
+ALL_GIT_REV_PARSE_HEAD: tuple[str, ...] = ("rev-parse", "HEAD")
+GIT_CHECKOUT: str = "checkout"
+GIT_ADD: str = "add"
+GIT_COMMIT: str = "commit"
+GIT_COMMIT_MESSAGE_FLAG: str = "-m"
+ALL_GIT_RESTORE_STAGED_WORKTREE: tuple[str, ...] = (
+    "restore",
+    "--staged",
+    "--worktree",
+    ".",
+)
+ALL_GIT_CLEAN_FORCE_DIR: tuple[str, ...] = ("clean", "-fd")
+RECORD_KEY_COMMIT_SHA: str = "commit_sha"
+RECORD_KEY_BASE_SHA: str = "base_sha"
+RECORD_KEY_ALL_PATHS: str = "all_paths"
+RECORD_KEY_EXIT_CODE: str = "exit_code"
+ERROR_DIRTY_TREE: str = "working tree is dirty; refuse materialization"
+ERROR_COMMIT_FAILED: str = "git commit failed for slice"
+ERROR_CHECKOUT_FAILED: str = "git checkout restore failed"
+ERROR_ADD_FAILED: str = "git add failed for slice paths"
+ERROR_EMPTY_SLICE_PATHS: str = "slice path list is empty"
+ERROR_REV_PARSE_FAILED: str = "rev-parse HEAD failed"
+ERROR_STATUS_FAILED: str = "git status failed"
+ERROR_RESTORE_FAILED: str = "git restore failed"
+ERROR_CLEAN_FAILED: str = "git clean failed"
+ERROR_BASE_MISMATCH_TEMPLATE: str = (
+    "HEAD {head_sha} does not match expected base {expected_base_sha}"
+)
+GIT_FORCE_FLAG: str = "--force"
+GIT_PATHSPEC_SEPARATOR: str = "--"