claude-dev-env 2.5.0 → 2.7.0

package/hooks/blocking/test_unscoped_search_blocker.py

@@ -0,0 +1,102 @@
+"""Tests for unscoped_search_blocker hook."""
+
+import json
+import subprocess
+import sys
+from pathlib import Path
+
+import pytest
+
+
+SCRIPT_PATH = Path(__file__).parent / "unscoped_search_blocker.py"
+
+ALL_DENIED_COMMANDS = [
+    "find / -iname code_rules_gate.py",
+    "find /c -name '*.py'",
+    "find ~ -name README.md",
+    "find $HOME -type f",
+    "ls -R /",
+    "ls -laR /",
+    "ls -Rl /",
+    "find //server/share -name x",
+    "find \\\\server\\share -name x",
+    "bash -c 'find / -name x'",
+]
+
+ALL_ALLOWED_COMMANDS = [
+    "find . -iname '*.py'",
+    "find packages/claude-dev-env -name code_rules_gate.py",
+    "find /c/Users/example/repo -iname SKILL.md",
+    "ls -r /",
+    "ls -la /tmp/x",
+    "find //server/share/project/src -name x",
+    "es.exe path:C:\\dev\\repo ext:py gate",
+    "git status --short",
+]
+
+
+def _run_hook(payload: dict) -> subprocess.CompletedProcess[str]:
+    return subprocess.run(
+        [sys.executable, str(SCRIPT_PATH)],
+        input=json.dumps(payload),
+        text=True,
+        capture_output=True,
+        check=False,
+    )
+
+
+def _bash_payload(command: str) -> dict:
+    return {"tool_name": "Bash", "tool_input": {"command": command}}
+
+
+def _powershell_payload(command: str) -> dict:
+    return {"tool_name": "PowerShell", "tool_input": {"command": command}}
+
+
+@pytest.mark.parametrize("each_command", ALL_DENIED_COMMANDS)
+def test_denies_unscoped_root_walk(each_command: str) -> None:
+    response = json.loads(_run_hook(_bash_payload(each_command)).stdout)
+    assert response["hookSpecificOutput"]["permissionDecision"] == "deny"
+
+
+@pytest.mark.parametrize("each_command", ALL_ALLOWED_COMMANDS)
+def test_allows_scoped_search(each_command: str) -> None:
+    assert _run_hook(_bash_payload(each_command)).stdout == ""
+
+
+def test_denies_recursive_listing_on_windows_drive_root() -> None:
+    response = json.loads(
+        _run_hook(_powershell_payload("Get-ChildItem -Path C:\\ -Recurse")).stdout
+    )
+    assert response["hookSpecificOutput"]["permissionDecision"] == "deny"
+
+
+def test_allows_recursive_listing_under_project_directory() -> None:
+    assert _run_hook(_powershell_payload("Get-ChildItem -Path .\\src -Recurse")).stdout == ""
+
+
+def test_allows_recursive_listing_without_recurse_flag() -> None:
+    assert _run_hook(_powershell_payload("Get-ChildItem -Path C:\\")).stdout == ""
+
+
+def test_denies_find_root_in_a_chained_segment() -> None:
+    response = json.loads(
+        _run_hook(_bash_payload("cd /tmp && find / -name x.py")).stdout
+    )
+    assert response["hookSpecificOutput"]["permissionDecision"] == "deny"
+
+
+def test_ignores_unsupported_tool_name() -> None:
+    payload = {"tool_name": "Edit", "tool_input": {"command": "find / -name x"}}
+    assert _run_hook(payload).stdout == ""
+
+
+def test_ignores_payload_without_a_command() -> None:
+    payload = {"tool_name": "Bash", "tool_input": {}}
+    assert _run_hook(payload).stdout == ""
+
+
+def test_deny_message_names_the_scoped_alternative() -> None:
+    response = json.loads(_run_hook(_bash_payload("find / -name x.py")).stdout)
+    deny_reason = response["hookSpecificOutput"]["permissionDecisionReason"]
+    assert "scope" in deny_reason.lower()

package/hooks/blocking/test_verdict_directory_write_blocker.py

@@ -741,20 +741,16 @@ def _assert_bash_dispatcher_registered_for_matcher(matcher_substring: str) -> No
     )
 
 
-def test_guard_is_registered_on_bash() -> None:
+def test_guard_is_not_registered_on_bash() -> None:
     _assert_bash_dispatcher_registered_for_matcher("Bash")
     matching_entries = _verdict_guard_hosted_entries()
-    assert len(matching_entries) == 1
-    assert matching_entries[0].applicable_tool_names == ALL_BASH_AND_POWERSHELL_TOOL_NAMES
-    assert BASH_TOOL_NAME in matching_entries[0].applicable_tool_names
+    assert matching_entries == []
 
 
-def test_guard_is_registered_on_powershell() -> None:
+def test_guard_is_not_registered_on_powershell() -> None:
     _assert_bash_dispatcher_registered_for_matcher("PowerShell")
     matching_entries = _verdict_guard_hosted_entries()
-    assert len(matching_entries) == 1
-    assert matching_entries[0].applicable_tool_names == ALL_BASH_AND_POWERSHELL_TOOL_NAMES
-    assert POWERSHELL_TOOL_NAME in matching_entries[0].applicable_tool_names
+    assert matching_entries == []
 
 
 def test_hook_subprocess_imports_real_config_when_parent_holds_shadowing_config(

package/hooks/blocking/unscoped_search_blocker.py

@@ -0,0 +1,391 @@
+#!/usr/bin/env python3
+"""PreToolUse hook: deny drive-root, bare-home, and share-root filesystem searches.
+
+Blocks Bash/PowerShell commands that walk from an unscoped root — ``find /``,
+``find C:\\``, ``find ~``, ``find //server/share``, recursive ``Get-ChildItem``
+on a drive root — so a session cannot thrash the host with millions of handles.
+Scoped walks under a project path stay allowed. Parallel shell storms are out of
+scope for this detector; the deny message still steers agents to batch shell work.
+
+::
+
+    find / -iname code_rules_gate.py          flag: unscoped root
+    find . -iname code_rules_gate.py          ok:   cwd scope
+    find //server/share -name x               flag: network share root
+    find //server/share/project -name x       ok:   scoped under the share
+    Get-ChildItem -Path C:\\ -Recurse         flag: recursive drive root
+    Get-ChildItem -Path .\\src -Recurse       ok:   project scope
+    ls -r /                                   ok:   reverse sort, not recurse
+    ls -R /                                   flag: recursive root listing
+    ls -laR /                                 flag: clustered short options
+    bash -c 'find / -name x'                  flag: string-exec unwrap
+"""
+
+from __future__ import annotations
+
+import json
+import shlex
+import sys
+from pathlib import Path
+
+_hooks_dir = str(Path(__file__).resolve().parent.parent)
+if _hooks_dir not in sys.path:
+    sys.path.insert(0, _hooks_dir)
+
+from hooks_constants.hook_block_logger import log_hook_block  # noqa: E402
+from hooks_constants.shell_command_segments import (  # noqa: E402
+    effective_leading_program,
+    split_into_segments,
+    token_basename,
+)
+from hooks_constants.unscoped_search_blocker_constants import (  # noqa: E402
+    ALL_FIND_EXPRESSION_INTRODUCER_TOKENS,
+    ALL_FIND_GLOBAL_OPTION_FLAGS_TAKING_A_VALUE,
+    ALL_FIND_GLOBAL_OPTION_FLAGS_WITHOUT_VALUE,
+    ALL_FIND_PROGRAM_BASENAMES,
+    ALL_LISTING_PROGRAM_BASENAMES,
+    ALL_POWERSHELL_PATH_FLAG_PREFIXES,
+    ALL_POWERSHELL_PATH_FLAGS,
+    ALL_POWERSHELL_RECURSE_FLAG_PREFIXES,
+    ALL_POWERSHELL_RECURSE_FLAGS,
+    ALL_STRING_EXEC_COMMAND_FLAGS,
+    ALL_STRING_EXECUTING_SHELL_BASENAMES,
+    ALL_SUPPORTED_TOOL_NAMES,
+    ALL_TRUTHY_RECURSE_COLON_VALUES,
+    ALL_UNIX_LS_PROGRAM_BASENAMES,
+    ALL_UNIX_LS_RECURSE_FLAGS,
+    ALL_UNSCOPED_HOME_LITERALS_CASEFOLD,
+    CALLING_HOOK_NAME,
+    CLUSTERED_SHORT_OPTION_PATTERN,
+    CORRECTIVE_MESSAGE,
+    DENY_DECISION,
+    FIND_OPTIMIZATION_LEVEL_OPTION_PREFIX,
+    FLAG_AND_VALUE_TOKEN_STRIDE,
+    GIT_BASH_DRIVE_ROOT_PATTERN,
+    HOOK_EVENT_NAME,
+    POSIX_ROOT_ALIAS_PATTERN,
+    UNC_SHARE_ROOT_PATTERN,
+    UNIX_LS_RECURSE_SHORT_OPTION_LETTER,
+    WINDOWS_DRIVE_ROOT_PATTERN,
+)
+
+
+def is_unscoped_search_root(path_token: str) -> bool:
+    """Return True when a path token is a drive, home, or network-share root.
+
+    ::
+
+        /                     flag
+        /.                    flag  (posix root alias)
+        /c/                   flag  (Git Bash drive root)
+        C:\\                   flag
+        ~                     flag
+        //server/share        flag  (UNC share root)
+        //server/share/src    ok    (scoped under the share)
+        ./src                 ok
+        /c/Users/x            ok
+
+    Args:
+        path_token: One shell token treated as a search start path.
+
+    Returns:
+        True when the token names an unscoped filesystem root.
+    """
+    stripped_path = path_token.strip().strip("\"'")
+    if not stripped_path:
+        return False
+    if stripped_path.casefold() in ALL_UNSCOPED_HOME_LITERALS_CASEFOLD:
+        return True
+    forward_slash_path = stripped_path.replace("\\", "/")
+    if POSIX_ROOT_ALIAS_PATTERN.fullmatch(forward_slash_path):
+        return True
+    if GIT_BASH_DRIVE_ROOT_PATTERN.fullmatch(forward_slash_path):
+        return True
+    if UNC_SHARE_ROOT_PATTERN.fullmatch(forward_slash_path):
+        return True
+    if WINDOWS_DRIVE_ROOT_PATTERN.fullmatch(stripped_path):
+        return True
+    windows_drive_alias = stripped_path.rstrip(".\\/")
+    if WINDOWS_DRIVE_ROOT_PATTERN.fullmatch(windows_drive_alias + "\\"):
+        return True
+    if WINDOWS_DRIVE_ROOT_PATTERN.fullmatch(windows_drive_alias):
+        return True
+    return False
+
+
+def _tokens_after_leading_program(
+    all_segment_tokens: list[str], leading_program: str | None
+) -> list[str]:
+    if leading_program is None:
+        return []
+    leading_index = all_segment_tokens.index(leading_program)
+    return all_segment_tokens[leading_index + 1 :]
+
+
+def _is_find_expression_token(token: str) -> bool:
+    if token in ALL_FIND_EXPRESSION_INTRODUCER_TOKENS:
+        return True
+    return token.startswith("-")
+
+
+def _collect_find_starting_points(all_argument_tokens: list[str]) -> list[str]:
+    all_starting_points: list[str] = []
+    token_index = 0
+    while token_index < len(all_argument_tokens):
+        each_token = all_argument_tokens[token_index]
+        if each_token in ALL_FIND_GLOBAL_OPTION_FLAGS_WITHOUT_VALUE:
+            token_index += 1
+            continue
+        if each_token in ALL_FIND_GLOBAL_OPTION_FLAGS_TAKING_A_VALUE:
+            if token_index + 1 >= len(all_argument_tokens):
+                token_index += 1
+                continue
+            next_token = all_argument_tokens[token_index + 1]
+            if is_unscoped_search_root(next_token) or _is_find_expression_token(
+                next_token
+            ):
+                token_index += 1
+                continue
+            token_index += FLAG_AND_VALUE_TOKEN_STRIDE
+            continue
+        if each_token.startswith(FIND_OPTIMIZATION_LEVEL_OPTION_PREFIX):
+            token_index += 1
+            continue
+        if _is_find_expression_token(each_token):
+            break
+        all_starting_points.append(each_token)
+        token_index += 1
+    return all_starting_points
+
+
+def _segment_has_unscoped_find(all_segment_tokens: list[str]) -> bool:
+    leading_program = effective_leading_program(all_segment_tokens)
+    if leading_program is None:
+        return False
+    if token_basename(leading_program) not in ALL_FIND_PROGRAM_BASENAMES:
+        return False
+    all_starting_points = _collect_find_starting_points(
+        _tokens_after_leading_program(all_segment_tokens, leading_program)
+    )
+    return any(
+        is_unscoped_search_root(each_start) for each_start in all_starting_points
+    )
+
+
+def _token_is_unix_ls_recurse_flag(token: str) -> bool:
+    """Return True for an ls token that turns the listing recursive.
+
+    ::
+
+        -R           flag
+        -laR         flag  (clustered short options)
+        -Rl          flag
+        --recursive  flag
+        -r           ok    (reverse sort, not recurse)
+        -la          ok
+
+    Args:
+        token: One argument token from an ``ls`` segment.
+
+    Returns:
+        True when the token carries the recursive option.
+    """
+    if token in ALL_UNIX_LS_RECURSE_FLAGS:
+        return True
+    if not CLUSTERED_SHORT_OPTION_PATTERN.fullmatch(token):
+        return False
+    return UNIX_LS_RECURSE_SHORT_OPTION_LETTER in token
+
+
+def _token_is_recurse_flag(token: str, program_basename: str) -> bool:
+    if program_basename in ALL_UNIX_LS_PROGRAM_BASENAMES:
+        return _token_is_unix_ls_recurse_flag(token)
+    lowered_token = token.lower()
+    if lowered_token in ALL_POWERSHELL_RECURSE_FLAGS:
+        return True
+    for each_prefix in ALL_POWERSHELL_RECURSE_FLAG_PREFIXES:
+        if lowered_token.startswith(each_prefix):
+            colon_value = lowered_token[len(each_prefix) :]
+            return colon_value in ALL_TRUTHY_RECURSE_COLON_VALUES
+    return False
+
+
+def _path_value_from_path_flag_token(token: str) -> str | None:
+    lowered_token = token.lower()
+    for each_prefix in ALL_POWERSHELL_PATH_FLAG_PREFIXES:
+        if lowered_token.startswith(each_prefix):
+            return token[len(each_prefix) :]
+    return None
+
+
+def _collect_get_child_item_path_tokens(all_argument_tokens: list[str]) -> list[str]:
+    all_path_tokens: list[str] = []
+    token_index = 0
+    while token_index < len(all_argument_tokens):
+        each_token = all_argument_tokens[token_index]
+        lowered_token = each_token.lower()
+        path_from_glued_flag = _path_value_from_path_flag_token(each_token)
+        if path_from_glued_flag is not None:
+            if path_from_glued_flag:
+                all_path_tokens.append(path_from_glued_flag)
+            token_index += 1
+            continue
+        if lowered_token in ALL_POWERSHELL_PATH_FLAGS:
+            if token_index + 1 < len(all_argument_tokens):
+                all_path_tokens.append(all_argument_tokens[token_index + 1])
+                token_index += FLAG_AND_VALUE_TOKEN_STRIDE
+                continue
+        if lowered_token == "/s" or each_token.startswith("-"):
+            token_index += 1
+            continue
+        all_path_tokens.append(each_token)
+        token_index += 1
+    return all_path_tokens
+
+
+def _segment_has_unscoped_recursive_listing(all_segment_tokens: list[str]) -> bool:
+    leading_program = effective_leading_program(all_segment_tokens)
+    if leading_program is None:
+        return False
+    program_basename = token_basename(leading_program)
+    if program_basename not in ALL_LISTING_PROGRAM_BASENAMES:
+        return False
+    all_argument_tokens = _tokens_after_leading_program(
+        all_segment_tokens, leading_program
+    )
+    has_recurse_flag = any(
+        _token_is_recurse_flag(each_token, program_basename)
+        for each_token in all_argument_tokens
+    )
+    if not has_recurse_flag:
+        return False
+    all_path_tokens = _collect_get_child_item_path_tokens(all_argument_tokens)
+    if not all_path_tokens:
+        return False
+    return any(
+        is_unscoped_search_root(each_path) for each_path in all_path_tokens
+    )
+
+
+def _string_exec_inner_command(all_segment_tokens: list[str]) -> str | None:
+    leading_program = effective_leading_program(all_segment_tokens)
+    if leading_program is None:
+        return None
+    if token_basename(leading_program) not in ALL_STRING_EXECUTING_SHELL_BASENAMES:
+        return None
+    all_argument_tokens = _tokens_after_leading_program(
+        all_segment_tokens, leading_program
+    )
+    token_index = 0
+    while token_index < len(all_argument_tokens):
+        each_token = all_argument_tokens[token_index]
+        if each_token.lower() in ALL_STRING_EXEC_COMMAND_FLAGS:
+            if token_index + 1 < len(all_argument_tokens):
+                return all_argument_tokens[token_index + 1]
+            return None
+        token_index += 1
+    return None
+
+
+def _all_command_tokenizations(command: str) -> list[list[str]]:
+    """Return POSIX and non-POSIX tokenizations so Windows paths stay intact.
+
+    Git Bash commands need POSIX splitting (quote rules). PowerShell paths like
+    ``C:\\`` need non-POSIX splitting so the backslash is not an escape. Both
+    are tried; an empty or failed split is dropped.
+    """
+    all_tokenizations: list[list[str]] = []
+    for each_posix_mode in (True, False):
+        try:
+            all_tokens = shlex.split(command, posix=each_posix_mode)
+        except ValueError:
+            continue
+        if all_tokens:
+            all_tokenizations.append(all_tokens)
+    return all_tokenizations
+
+
+def find_unscoped_search_violation(command: str) -> str | None:
+    """Return the deny message for an unscoped tree walk, or None to allow.
+
+    ::
+
+        find / -iname x.py                     flag
+        find packages -iname x.py              ok
+        Get-ChildItem -Path C:\\ -Recurse       flag
+        Get-ChildItem -Path .\\src -Recurse     ok
+        find //server/share -name x            flag
+        find //server/share/project -name x    ok
+        bash -c 'find / -name x'               flag
+        ls -r /                                ok
+        ls -R /                                flag
+        ls -laR /                              flag
+
+    Tokenizes the command under POSIX and non-POSIX shlex modes, splits on shell
+    control operators, and evaluates each simple-command segment. A ``find``
+    segment with an unscoped starting point denies. A recursive listing segment
+    (PowerShell ``Get-ChildItem``/``gci``/``dir`` or Unix ``ls -R``, including a
+    clustered short-option token such as ``-laR``) with an unscoped path denies.
+    A ``bash -c`` / ``pwsh -Command`` wrapper re-runs the check on its string
+    argument. Returns None when neither tokenization yields tokens.
+
+    Args:
+        command: The raw Bash or PowerShell command string from the tool input.
+
+    Returns:
+        The corrective deny message when a segment walks from an unscoped root,
+        else None.
+    """
+    for each_tokenization in _all_command_tokenizations(command):
+        for each_segment in split_into_segments(each_tokenization):
+            if _segment_has_unscoped_find(each_segment):
+                return CORRECTIVE_MESSAGE
+            if _segment_has_unscoped_recursive_listing(each_segment):
+                return CORRECTIVE_MESSAGE
+            inner_command = _string_exec_inner_command(each_segment)
+            if inner_command is not None:
+                nested_denial = find_unscoped_search_violation(inner_command)
+                if nested_denial is not None:
+                    return nested_denial
+    return None
+
+
+def main() -> None:
+    try:
+        hook_input = json.load(sys.stdin)
+    except json.JSONDecodeError:
+        sys.exit(0)
+
+    tool_name = hook_input.get("tool_name", "")
+    if tool_name not in ALL_SUPPORTED_TOOL_NAMES:
+        sys.exit(0)
+
+    command = hook_input.get("tool_input", {}).get("command", "")
+    if not command:
+        sys.exit(0)
+
+    deny_reason = find_unscoped_search_violation(command)
+    if deny_reason is None:
+        sys.exit(0)
+
+    deny_payload = {
+        "hookSpecificOutput": {
+            "hookEventName": HOOK_EVENT_NAME,
+            "permissionDecision": DENY_DECISION,
+            "permissionDecisionReason": deny_reason,
+        }
+    }
+    log_hook_block(
+        calling_hook_name=CALLING_HOOK_NAME,
+        hook_event=HOOK_EVENT_NAME,
+        block_reason=deny_reason,
+        tool_name=tool_name,
+        offending_input_preview=command,
+    )
+    print(json.dumps(deny_payload))
+    sys.stdout.flush()
+    sys.exit(0)
+
+
+if __name__ == "__main__":
+    main()

package/hooks/git-hooks/CLAUDE.md

@@ -8,12 +8,15 @@ Native git hooks that run outside the Claude Code lifecycle — invoked directly
 |---|---|---|
 | `pre_commit.py` | `pre-commit` | Runs the CODE_RULES gate (`precommit_code_rules_gate.py`) over staged changes; exits 1 when any staged file has a blocking violation |
 | `pre_push.py` | `pre-push` | Blocks a push that would land a non-`main` local branch onto remote `main` (or `master`), then runs the CODE_RULES gate over the commits about to be pushed |
+| `pre_push_base_reference.py` | — | Resolves the gate base for `pre_push.py`: reads the pushed remote name from git's arguments, then names that remote's default branch from its symbolic ref or its candidate default branches |
 | `post_commit.py` | `post-commit` | Runs after a commit lands; performs any post-commit bookkeeping |
 | `gate_utils.py` | — | Shared helpers: resolves the gate script path, checks that the path is a safe regular file |
 | `test_config.py` | — | Test configuration helpers |
 | `test_gate_utils.py` | — | Tests for `gate_utils.py` |
 | `test_pre_commit.py` | — | Tests for `pre_commit.py` |
 | `test_pre_push.py` | — | Tests for `pre_push.py` |
+| `test_pre_push_base_reference.py` | — | Tests for the gate base resolution in `pre_push.py` |
+| `conftest.py` | — | Puts this directory on `sys.path` and clears cached `config` modules, so each test module imports the hooks at the top of the file |
 
 ## Subdirectory
 

package/hooks/git-hooks/conftest.py

@@ -0,0 +1,30 @@
+"""Put this directory on ``sys.path`` before the git-hook test modules import.
+
+The git-hook entry points sit beside their constants package rather than inside
+an installed package, so ``import pre_push`` resolves only once this directory
+leads ``sys.path``. Pytest loads a conftest before the test modules it covers,
+so doing the insertion here lets each test module import the hooks at the top
+of the file.
+"""
+
+from __future__ import annotations
+
+import importlib
+import sys
+from pathlib import Path
+
+
+_GIT_HOOKS_DIRECTORY_STRING = str(Path(__file__).resolve().parent)
+_CONFIG_PACKAGE_NAME = "config"
+_CONFIG_PACKAGE_PREFIX = "config."
+
+while _GIT_HOOKS_DIRECTORY_STRING in sys.path:
+    sys.path.remove(_GIT_HOOKS_DIRECTORY_STRING)
+sys.path.insert(0, _GIT_HOOKS_DIRECTORY_STRING)
+
+for each_module_name in list(sys.modules):
+    if each_module_name == _CONFIG_PACKAGE_NAME or each_module_name.startswith(
+        _CONFIG_PACKAGE_PREFIX
+    ):
+        del sys.modules[each_module_name]
+importlib.invalidate_caches()

package/hooks/git-hooks/gate_utils.py

@@ -7,10 +7,10 @@ import stat
 from pathlib import Path
 
 from git_hooks_constants import (
+    ALL_GATE_SCRIPT_RELATIVE_PATH,
     CLAUDE_HOME_DEFAULT_SUBDIRECTORY,
     CLAUDE_HOME_ENV_VAR,
     GATE_PATH_OVERRIDE_ENV_VAR,
-    GATE_SCRIPT_RELATIVE_PATH,
 )
 
 
@@ -34,7 +34,7 @@ def resolve_gate_script_path() -> tuple[Path, Path | None]:
         claude_home_directory = Path(claude_home_override).resolve()
     else:
         claude_home_directory = Path.home() / CLAUDE_HOME_DEFAULT_SUBDIRECTORY
-    gate_path = claude_home_directory.joinpath(*GATE_SCRIPT_RELATIVE_PATH)
+    gate_path = claude_home_directory.joinpath(*ALL_GATE_SCRIPT_RELATIVE_PATH)
     return gate_path, None
 
 

package/hooks/git-hooks/git_hooks_constants/__init__.py

@@ -9,7 +9,6 @@ import ...`` resolve against this file both inside the repo and under
 
 from __future__ import annotations
 
-
 STAGED_SCOPE_ARGUMENT: str = "--staged"
 BASE_REFERENCE_ARGUMENT: str = "--base"
 DEFAULT_REMOTE_BASE_REFERENCE: str = "origin/HEAD"
@@ -21,7 +20,7 @@ REMOTE_REFERENCE_FIELD_INDEX: int = 2
 GATE_PATH_OVERRIDE_ENV_VAR: str = "CODE_RULES_GATE_PATH"
 CLAUDE_HOME_ENV_VAR: str = "CLAUDE_HOME"
 CLAUDE_HOME_DEFAULT_SUBDIRECTORY: str = ".claude"
-GATE_SCRIPT_RELATIVE_PATH: tuple[str, ...] = (
+ALL_GATE_SCRIPT_RELATIVE_PATH: tuple[str, ...] = (
     "_shared",
     "pr-loop",
     "scripts",
@@ -65,3 +64,43 @@ PROTECTED_BRANCH_PUSH_BLOCK_MESSAGE: str = (
     "To push the feature branch to its own ref, name the destination: "
     "git push origin {local_branch}:refs/heads/{local_branch}"
 )
+GIT_EXECUTABLE_NAME: str = "git"
+GIT_COMMAND_SUCCESS_EXIT_CODE: int = 0
+GIT_OUTPUT_ENCODING_NAME: str = "utf-8"
+GIT_OUTPUT_DECODE_ERRORS_POLICY: str = "replace"
+GIT_COMMAND_UNAVAILABLE_MESSAGE: str = (
+    "claude-dev-env pre-push: could not run git ({error}), aborting"
+)
+GIT_REV_PARSE_SUBCOMMAND: str = "rev-parse"
+GIT_REV_PARSE_VERIFY_FLAG: str = "--verify"
+GIT_QUIET_FLAG: str = "--quiet"
+GIT_SYMBOLIC_REFERENCE_SUBCOMMAND: str = "symbolic-ref"
+GIT_COMMAND_TIMEOUT_SECONDS: int = 30
+GIT_FOR_EACH_REF_SUBCOMMAND: str = "for-each-ref"
+GIT_REFERENCE_SHORT_NAME_FORMAT_ARGUMENT: str = "--format=%(refname:short)"
+COMMIT_OBJECT_NAME_SUFFIX: str = "^{commit}"
+REMOTE_REFERENCE_NAME_PREFIX: str = "refs/remotes/"
+REMOTE_HEAD_SYMBOLIC_REFERENCE_TEMPLATE: str = "refs/remotes/{remote}/HEAD"
+REMOTE_HEAD_BRANCH_NAME: str = "HEAD"
+REMOTE_BRANCH_SHORT_NAME_TEMPLATE: str = "{remote}/{branch}"
+DEFAULT_REMOTE_NAME: str = "origin"
+REMOTE_NAME_ARGUMENT_INDEX: int = 1
+ALL_REJECTED_REMOTE_NAME_CHARACTERS: tuple[str, ...] = (
+    ":",
+    "/",
+    "*",
+    "?",
+    "[",
+    "\\",
+)
+ALL_FALLBACK_REMOTE_DEFAULT_BRANCH_NAMES: tuple[str, ...] = (
+    "main",
+    "master",
+    "trunk",
+    "develop",
+)
+UNRESOLVABLE_BASE_REFERENCE_MESSAGE: str = (
+    "claude-dev-env pre-push: no usable gate base -- {reference} names no commit and "
+    "the default branch of remote {remote!r} could not be read.\n"
+    "Set the remote head so the gate has a base: git remote set-head {remote} --auto"
+)