claude-dev-env 2.30.1 → 2.31.1

package/hooks/blocking/shell_substitution_blocker.py

@@ -54,53 +54,31 @@ import json
 import sys
 from pathlib import Path
 
-try:
-    from hooks_constants.shell_substitution_blocker_constants import (
-        BASH_TOOL_NAME,
-        CLOSE_PAREN_CHARACTER,
-        COMMAND_KEY,
-        CORRECTIVE_MESSAGE,
-        DENY_DECISION,
-        DOLLAR_PAREN_PATTERN,
-        EVEN_BACKSLASH_BACKTICK_PATTERN,
-        HOOK_EVENT_NAME,
-        HOOK_EVENT_NAME_KEY,
-        HOOK_SPECIFIC_OUTPUT_KEY,
-        OPEN_PAREN_CHARACTER,
-        PAREN_DEPTH_AFTER_DOUBLE_OPEN,
-        PERMISSION_DECISION_KEY,
-        PERMISSION_DECISION_REASON_KEY,
-        PROCESS_SUBSTITUTION_PATTERN,
-        SINGLE_QUOTED_RUN_PATTERN,
-        STRIPPED_RUN_REPLACEMENT,
-        TOOL_INPUT_KEY,
-        TOOL_NAME_KEY,
-    )
-except ModuleNotFoundError:
-    _hooks_dir = str(Path(__file__).resolve().parent.parent)
-    if _hooks_dir not in sys.path:
-        sys.path.insert(0, _hooks_dir)
-    from hooks_constants.shell_substitution_blocker_constants import (
-        BASH_TOOL_NAME,
-        CLOSE_PAREN_CHARACTER,
-        COMMAND_KEY,
-        CORRECTIVE_MESSAGE,
-        DENY_DECISION,
-        DOLLAR_PAREN_PATTERN,
-        EVEN_BACKSLASH_BACKTICK_PATTERN,
-        HOOK_EVENT_NAME,
-        HOOK_EVENT_NAME_KEY,
-        HOOK_SPECIFIC_OUTPUT_KEY,
-        OPEN_PAREN_CHARACTER,
-        PAREN_DEPTH_AFTER_DOUBLE_OPEN,
-        PERMISSION_DECISION_KEY,
-        PERMISSION_DECISION_REASON_KEY,
-        PROCESS_SUBSTITUTION_PATTERN,
-        SINGLE_QUOTED_RUN_PATTERN,
-        STRIPPED_RUN_REPLACEMENT,
-        TOOL_INPUT_KEY,
-        TOOL_NAME_KEY,
-    )
+_hooks_dir = str(Path(__file__).resolve().parent.parent)
+if _hooks_dir not in sys.path:
+    sys.path.insert(0, _hooks_dir)
+
+from hooks_constants.shell_substitution_blocker_constants import (  # noqa: E402
+    BASH_TOOL_NAME,
+    CLOSE_PAREN_CHARACTER,
+    COMMAND_KEY,
+    CORRECTIVE_MESSAGE,
+    DENY_DECISION,
+    DOLLAR_PAREN_PATTERN,
+    EVEN_BACKSLASH_BACKTICK_PATTERN,
+    HOOK_EVENT_NAME,
+    HOOK_EVENT_NAME_KEY,
+    HOOK_SPECIFIC_OUTPUT_KEY,
+    OPEN_PAREN_CHARACTER,
+    PAREN_DEPTH_AFTER_DOUBLE_OPEN,
+    PERMISSION_DECISION_KEY,
+    PERMISSION_DECISION_REASON_KEY,
+    PROCESS_SUBSTITUTION_PATTERN,
+    SINGLE_QUOTED_RUN_PATTERN,
+    STRIPPED_RUN_REPLACEMENT,
+    TOOL_INPUT_KEY,
+    TOOL_NAME_KEY,
+)
 
 
 def _strip_single_quoted_runs(command: str) -> str:

package/hooks/blocking/stale_comment_reference_blocker.py

@@ -11,28 +11,95 @@ directly above it, denying the edit when that line is a standalone ``#``
 comment naming an identifier ``old_string`` carries and ``new_string`` drops.
 """
 
+import functools
 import json
 import re
 import sys
 from pathlib import Path
 from typing import TextIO
 
-_hooks_dir = str(Path(__file__).resolve().parent.parent)
-if _hooks_dir not in sys.path:
-    sys.path.insert(0, _hooks_dir)
+try:
+    _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.pre_tool_use_dispatcher_constants import EDIT_TOOL_NAME  # noqa: E402
-from hooks_constants.pre_tool_use_stdin import read_hook_input_dictionary_from_stdin  # noqa: E402
-from hooks_constants.stale_comment_reference_blocker_constants import (  # noqa: E402
-    ALL_COMMENT_STOPWORDS,
-    COMMENT_IDENTIFIER_PATTERN,
-    COMMENT_LINE_PREFIX,
-    PYTHON_FILE_SUFFIX,
-    STALE_COMMENT_ADDITIONAL_CONTEXT,
-    STALE_COMMENT_DENY_TEMPLATE,
-    STALE_COMMENT_SYSTEM_MESSAGE,
-)
+    from hooks_constants.hook_block_logger import log_hook_block
+    from hooks_constants.multi_edit_reconstruction import edits_for_tool
+    from hooks_constants.pre_tool_use_dispatcher_constants import (
+        EDIT_TOOL_NAME,
+        MULTI_EDIT_TOOL_NAME,
+    )
+    from hooks_constants.pre_tool_use_stdin import read_hook_input_dictionary_from_stdin
+    from hooks_constants.stale_comment_reference_blocker_constants import (
+        ALL_COMMENT_STOPWORDS,
+        COMMENT_IDENTIFIER_PATTERN,
+        COMMENT_LINE_PREFIX,
+        PYTHON_FILE_SUFFIX,
+        STALE_COMMENT_ADDITIONAL_CONTEXT,
+        STALE_COMMENT_DENY_TEMPLATE,
+        STALE_COMMENT_SYSTEM_MESSAGE,
+    )
+except ImportError as import_error:
+    raise ImportError(
+        "stale_comment_reference_blocker: cannot import its sibling modules; "
+        "ensure the hooks directory is importable."
+    ) from import_error
+
+
+def _edit_step_fields(each_edit: object) -> tuple[str, str, bool] | None:
+    """Return (old_string, new_string, is_replace_all) for one usable MultiEdit step."""
+    if not isinstance(each_edit, dict):
+        return None
+    old_string = each_edit.get("old_string", "")
+    new_string = each_edit.get("new_string", "")
+    if not isinstance(old_string, str) or not isinstance(new_string, str) or not old_string:
+        return None
+    return old_string, new_string, each_edit.get("replace_all") is True
+
+
+def _evaluate_multi_edit(file_path: str, all_tool_input: dict[str, object]) -> str | None:
+    """Judge each MultiEdit step against the content the prior steps already left.
+
+    Args:
+        file_path: The destination path the MultiEdit targets.
+        all_tool_input: The MultiEdit payload's input mapping.
+
+    Returns:
+        The deny-reason text for the first step whose kept comment orphans an
+        identifier, or None when every step stays consistent.
+    """
+    try:
+        current_content = Path(file_path).read_text(encoding="utf-8")
+    except (OSError, UnicodeDecodeError):
+        return None
+    for each_edit in edits_for_tool(MULTI_EDIT_TOOL_NAME, all_tool_input):
+        edit_fields = _edit_step_fields(each_edit)
+        if edit_fields is None:
+            continue
+        old_string, new_string, is_replace_all = edit_fields
+        if old_string not in current_content:
+            continue
+        deny_reason = _find_stale_comment_reference(
+            current_content, old_string, new_string, is_replace_all, file_path
+        )
+        if deny_reason is not None:
+            return deny_reason
+        current_content = current_content.replace(old_string, new_string, -1 if is_replace_all else 1)
+    return None
+
+
+@functools.lru_cache
+def _bounded_identifier_pattern(identifier: str) -> re.Pattern[str]:
+    """Return the compiled whole-word pattern for one comment-named identifier.
+
+    Args:
+        identifier: The identifier the comment names.
+
+    Returns:
+        The compiled pattern matching identifier with no adjoining word
+        character on either side.
+    """
+    return re.compile("(?<![A-Za-z0-9_])" + re.escape(identifier) + "(?![A-Za-z0-9_])")
 
 
 def _first_orphaned_identifier(
@@ -57,9 +124,7 @@ def _first_orphaned_identifier(
     for each_identifier in COMMENT_IDENTIFIER_PATTERN.findall(words_in_comment):
         if each_identifier.lower() in ALL_COMMENT_STOPWORDS:
             continue
-        bounded_pattern = re.compile(
-            "(?<![A-Za-z0-9_])" + re.escape(each_identifier) + "(?![A-Za-z0-9_])"
-        )
+        bounded_pattern = _bounded_identifier_pattern(each_identifier)
         if bounded_pattern.search(original_block_text) and not bounded_pattern.search(
             revised_block_text
         ):
@@ -159,13 +224,15 @@ def _find_stale_comment_reference(
 
 
 def evaluate(payload_by_key: dict[str, object]) -> str | None:
-    """Decide whether an Edit payload orphans a comment above a changed line.
+    """Decide whether an Edit or MultiEdit payload orphans a comment above a changed line.
 
     Reads the target file from disk and checks the line directly above each
-    occurrence the edit rewrites for a kept standalone comment whose named
-    identifier the edit removes from the line below it. Non-Edit tools,
-    non-Python targets, unreadable files, and an old_string absent from the
-    file all pass.
+    occurrence a step rewrites for a kept standalone comment whose named
+    identifier the step carries and drops. A MultiEdit's steps are judged in
+    order against the content the prior steps already left, so a step that
+    only reads as stale once an earlier step in the same payload has run is
+    still caught. Non-Edit/MultiEdit tools, non-Python targets, unreadable
+    files, and an old_string absent from the file all pass.
 
     Args:
         payload_by_key: The PreToolUse payload with tool_name and tool_input.
@@ -175,7 +242,7 @@ def evaluate(payload_by_key: dict[str, object]) -> str | None:
     """
     raw_tool_name = payload_by_key.get("tool_name", "")
     tool_name = raw_tool_name if isinstance(raw_tool_name, str) else ""
-    if tool_name != EDIT_TOOL_NAME:
+    if tool_name not in (EDIT_TOOL_NAME, MULTI_EDIT_TOOL_NAME):
         return None
 
     raw_tool_input = payload_by_key.get("tool_input", {})
@@ -185,6 +252,9 @@ def evaluate(payload_by_key: dict[str, object]) -> str | None:
     if not isinstance(file_path, str) or not file_path.endswith(PYTHON_FILE_SUFFIX):
         return None
 
+    if tool_name == MULTI_EDIT_TOOL_NAME:
+        return _evaluate_multi_edit(file_path, tool_input)
+
     raw_old_string = tool_input.get("old_string", "")
     raw_new_string = tool_input.get("new_string", "")
     old_string = raw_old_string if isinstance(raw_old_string, str) else ""

package/hooks/blocking/state_description_blocker.py

@@ -15,28 +15,43 @@ import sys
 from pathlib import Path
 from typing import TextIO
 
-_hooks_dir = str(Path(__file__).resolve().parent.parent)
-if _hooks_dir not in sys.path:
-    sys.path.insert(0, _hooks_dir)
-
-from blocking.code_rules_shared import is_ephemeral_path  # noqa: E402
-from hooks_constants.hook_block_logger import log_hook_block  # noqa: E402
-from hooks_constants.pre_tool_use_stdin import read_hook_input_dictionary_from_stdin  # noqa: E402
-from hooks_constants.state_description_blocker_constants import (  # noqa: E402
-    ALL_BLOCK_COMMENT_EXTENSIONS,
-    ALL_BLOCK_COMMENT_ONLY_EXTENSIONS,
-    ALL_COMMENT_BEARING_EXTENSIONS,
-    ALL_COMMENT_TRANSITION_PATTERNS,
-    ALL_DEFINITION_HEADER_PREFIXES,
-    ALL_HASH_AND_SLASH_EXTENSIONS,
-    ALL_HASH_ONLY_EXTENSIONS,
-    ALL_MARKDOWN_EXTENSIONS,
-    CODE_FENCE_PATTERN,
-    DOUBLE_QUOTED_SPAN_PATTERN,
-    INLINE_CODE_PATTERN,
-    PYTHON_EXTENSION,
-    TRIPLE_QUOTED_BLOCK_PATTERN,
-)
+try:
+    _hooks_dir = str(Path(__file__).resolve().parent.parent)
+    if _hooks_dir not in sys.path:
+        sys.path.insert(0, _hooks_dir)
+
+    from blocking.code_rules_shared import is_ephemeral_path
+    from hooks_constants.hook_block_logger import log_hook_block
+    from hooks_constants.multi_edit_reconstruction import joined_new_strings
+    from hooks_constants.pre_tool_use_stdin import read_hook_input_dictionary_from_stdin
+    from hooks_constants.state_description_blocker_constants import (
+        ALL_BLOCK_COMMENT_EXTENSIONS,
+        ALL_BLOCK_COMMENT_ONLY_EXTENSIONS,
+        ALL_COMMENT_BEARING_EXTENSIONS,
+        ALL_COMMENT_TRANSITION_PATTERNS,
+        ALL_DEFINITION_HEADER_PREFIXES,
+        ALL_HASH_AND_SLASH_EXTENSIONS,
+        ALL_HASH_ONLY_EXTENSIONS,
+        ALL_MARKDOWN_EXTENSIONS,
+        CODE_FENCE_PATTERN,
+        DOUBLE_QUOTED_SPAN_PATTERN,
+        INLINE_CODE_PATTERN,
+        PYTHON_EXTENSION,
+        TRIPLE_QUOTED_BLOCK_PATTERN,
+    )
+except ImportError as import_error:
+    raise ImportError(
+        "state_description_blocker: cannot import its sibling modules"
+    ) from import_error
+
+
+def _content_to_check(tool_name: str, all_tool_input: dict) -> str:
+    """Return the text a Write, Edit, or MultiEdit payload introduces."""
+    if tool_name == "MultiEdit":
+        return joined_new_strings(all_tool_input)
+    content_key = "content" if tool_name == "Write" else "new_string"
+    raw_content = all_tool_input.get(content_key, "")
+    return raw_content if isinstance(raw_content, str) else ""
 
 
 def _get_file_extension(file_path: str) -> str:
@@ -289,7 +304,7 @@ def evaluate(payload_by_key: dict[str, object]) -> str | None:
     """
     raw_tool_name = payload_by_key.get("tool_name", "")
     tool_name = raw_tool_name if isinstance(raw_tool_name, str) else ""
-    if tool_name not in ("Write", "Edit"):
+    if tool_name not in ("Write", "Edit", "MultiEdit"):
         return None
 
     raw_tool_input = payload_by_key.get("tool_input", {})
@@ -303,9 +318,7 @@ def evaluate(payload_by_key: dict[str, object]) -> str | None:
     if not (is_markdown_file(file_path) or is_comment_bearing_file(file_path)):
         return None
 
-    content_key = "content" if tool_name == "Write" else "new_string"
-    raw_content = tool_input.get(content_key, "")
-    content_to_check = raw_content if isinstance(raw_content, str) else ""
+    content_to_check = _content_to_check(tool_name, tool_input)
     if not content_to_check:
         return None
 

package/hooks/blocking/subprocess_budget_completeness.py

@@ -42,55 +42,29 @@ if _blocking_dir not in sys.path:
 if _hooks_dir not in sys.path:
     sys.path.insert(0, _hooks_dir)
 
-from code_rules_shared import is_test_file  # noqa: E402
-
-from hooks_constants.hook_block_logger import log_hook_block  # noqa: E402
-from hooks_constants.pre_tool_use_stdin import (  # noqa: E402
-    read_hook_input_dictionary_from_stdin,
-)
-from hooks_constants.subprocess_budget_completeness_constants import (  # noqa: E402
-    ALL_BUDGET_NAME_MARKERS,
-    BUDGET_ENTRY_POINT_FUNCTION_NAME,
-    SUBPROCESS_TIMEOUT_KEYWORD,
-)
-from hooks_constants.windows_rmtree_blocker_constants import (  # noqa: E402
-    PYTHON_FILE_EXTENSION,
-)
+try:
+    from code_rules_shared import is_test_file
+
+    from hooks_constants.hook_block_logger import log_hook_block
+    from hooks_constants.pre_tool_use_stdin import read_hook_input_dictionary_from_stdin
+    from hooks_constants.subprocess_budget_completeness_constants import (
+        ALL_BUDGET_NAME_MARKERS,
+        BUDGET_ENTRY_POINT_FUNCTION_NAME,
+        SUBPROCESS_TIMEOUT_KEYWORD,
+    )
+    from hooks_constants.subprocess_budget_completeness_content import resolved_content
+    from hooks_constants.windows_rmtree_blocker_constants import PYTHON_FILE_EXTENSION
+except ImportError as import_error:
+    raise ImportError(
+        "subprocess_budget_completeness: cannot import its sibling modules; "
+        "ensure the hooks directory is importable."
+    ) from import_error
 
 
 def is_python_target(file_path: str) -> bool:
     return file_path.endswith(PYTHON_FILE_EXTENSION)
 
 
-def resolved_content(all_tool_input_fields: dict[str, object]) -> str:
-    written_content = all_tool_input_fields.get("content")
-    if isinstance(written_content, str):
-        return written_content
-    return reconstructed_edit_content(all_tool_input_fields)
-
-
-def reconstructed_edit_content(all_tool_input_fields: dict[str, object]) -> str:
-    file_path = all_tool_input_fields.get("file_path")
-    old_string = all_tool_input_fields.get("old_string")
-    new_string = all_tool_input_fields.get("new_string")
-    if not isinstance(file_path, str) or not isinstance(old_string, str):
-        return ""
-    if not isinstance(new_string, str) or not old_string:
-        return ""
-    existing_content = existing_file_content(file_path)
-    if existing_content is None or old_string not in existing_content:
-        return ""
-    return existing_content.replace(old_string, new_string, 1)
-
-
-def existing_file_content(file_path: str) -> str | None:
-    try:
-        with open(file_path, "r", encoding="utf-8") as existing_file:
-            return existing_file.read()
-    except (FileNotFoundError, OSError, UnicodeDecodeError):
-        return None
-
-
 def integer_literal_value(node: ast.expr) -> int | None:
     if (
         isinstance(node, ast.Constant)

package/hooks/blocking/tdd_enforcer.py

@@ -2,6 +2,9 @@
 
 Blocks a write to a production source file when no matching test was modified
 within the freshness window, enforcing "TDD IS NON-NEGOTIABLE" from CLAUDE.md.
+The gate records each candidate test's content hash at every sighting and
+compares that hash on the next write. A first sighting requires content that
+differs from HEAD.
 Each concern lives in a ``tdd_enforcer_parts`` submodule; this entry wires them
 into one PreToolUse gate and re-exports their surface for the test suite.
 """
@@ -21,9 +24,14 @@ try:
         is_ephemeral_script_path,
         is_under_session_scratchpad,
     )
+    from codex_apply_patch import (
+        payload_patch_target_paths,
+    )
+    from hooks_constants.pre_tool_use_dispatcher_constants import APPLY_PATCH_TOOL_NAME
     from tdd_enforcer_parts import (
         candidate_paths,
         content_analysis,
+        content_hash_store,
         decisions,
         freshness,
         git_tracking,
@@ -56,8 +64,8 @@ candidate_test_paths_for = candidate_paths.candidate_test_paths_for
 _ancestor_tests_directories = candidate_paths._ancestor_tests_directories
 _parent_walk_limit = candidate_paths._parent_walk_limit
 _freshness_seconds = freshness._freshness_seconds
-has_fresh_test = freshness.has_fresh_test
 _read_candidate_text = freshness._read_candidate_text
+has_recorded_or_fresh_test = content_hash_store.has_recorded_or_fresh_test
 _is_constants_only_python_content = content_analysis._is_constants_only_python_content
 _is_post_edit_import_only = content_analysis._is_post_edit_import_only
 _is_post_edit_constants_only = content_analysis._is_post_edit_constants_only
@@ -72,8 +80,12 @@ def _resolve_payload(input_data: dict) -> tuple[str, dict, str]:
     return input_data.get("tool_name", ""), tool_input, tool_input.get("file_path", "")
 
 
-def _is_silently_skipped(file_path: str, extension: str, path: Path) -> bool:
-    if _is_inside_dotclaude_segment(file_path) or is_ephemeral_script_path(file_path):
+def _is_silently_skipped(
+    file_path: str, extension: str, path: Path, repository_root: str = ""
+) -> bool:
+    if _is_inside_dotclaude_segment(file_path) or is_ephemeral_script_path(
+        file_path, repository_root
+    ):
         return True
     if _is_agent_home_tooling_write(file_path):
         return True
@@ -117,29 +129,64 @@ def _write_is_exempt(
     return _edit_is_constants_or_import_only(tool_name, tool_input, path, extension)
 
 
+def _decide_for_target(
+    tool_name: str, tool_input: dict, file_path: str, input_data: dict
+) -> tuple[bool, str] | None:
+    """Return (is_allowed, deny_reason) for one target file, or None to skip silently."""
+    if not file_path:
+        return None
+    if _is_session_scratchpad_write(file_path, input_data):
+        return None
+    path = Path(file_path)
+    extension = path.suffix.lower()
+    repository_root = str(input_data.get("cwd") or "")
+    if _is_silently_skipped(file_path, extension, path, repository_root):
+        return None
+    if _write_is_exempt(tool_name, tool_input, path, extension):
+        return True, ""
+    all_candidates = candidate_test_paths_for(path)
+    session_id = str(input_data.get("session_id") or "")
+    is_recorded_or_fresh = has_recorded_or_fresh_test(
+        all_candidates, session_id, repository_root, _freshness_seconds()
+    )
+    if is_recorded_or_fresh:
+        return True, ""
+    return False, build_deny_reason(path, all_candidates)
+
+
+def _decide_apply_patch(input_data: dict, tool_input: dict) -> None:
+    """Run the TDD gate over every file a Codex apply_patch payload touches."""
+    for each_file_path in payload_patch_target_paths(input_data, tool_input):
+        decision = _decide_for_target(
+            APPLY_PATCH_TOOL_NAME, tool_input, each_file_path, input_data
+        )
+        if decision is None:
+            continue
+        is_allowed, deny_reason = decision
+        if not is_allowed:
+            emit_deny(deny_reason)
+            return
+    emit_allow()
+
+
 def main() -> None:
-    """Run the TDD gate over one PreToolUse Write, Edit, or MultiEdit payload."""
+    """Run the TDD gate over one PreToolUse Write, Edit, MultiEdit, or apply_patch payload."""
     try:
         input_data = json.load(sys.stdin)
     except json.JSONDecodeError:
         sys.exit(0)
     tool_name, tool_input, file_path = _resolve_payload(input_data)
-    if not file_path:
-        sys.exit(0)
-    if _is_session_scratchpad_write(file_path, input_data):
-        sys.exit(0)
-    path = Path(file_path)
-    extension = path.suffix.lower()
-    if _is_silently_skipped(file_path, extension, path):
+    if tool_name == APPLY_PATCH_TOOL_NAME:
+        _decide_apply_patch(input_data, tool_input)
         sys.exit(0)
-    if _write_is_exempt(tool_name, tool_input, path, extension):
-        emit_allow()
+    decision = _decide_for_target(tool_name, tool_input, file_path, input_data)
+    if decision is None:
         sys.exit(0)
-    all_candidates = candidate_test_paths_for(path)
-    if has_fresh_test(all_candidates, _freshness_seconds()):
+    is_allowed, deny_reason = decision
+    if is_allowed:
         emit_allow()
         sys.exit(0)
-    emit_deny(build_deny_reason(path, all_candidates))
+    emit_deny(deny_reason)
     sys.exit(0)
 
 

package/hooks/blocking/tdd_enforcer_parts/config/tdd_enforcer_constants.py

@@ -1,7 +1,8 @@
 """Constants for the TDD-enforcer hook and its decomposed parts modules.
 
 Centralizes the freshness window, the ancestor-walk limit, the git-tracking
-command tokens, the source-file extension sets, and the join separator.
+and git-diff command tokens, the source-file extension sets, the join
+separator, and the last-observed-hash store's filename shape and JSON keys.
 """
 
 from __future__ import annotations
@@ -9,9 +10,18 @@ from __future__ import annotations
 FRESHNESS_WINDOW_SECONDS: int = 600
 PARENT_WALK_LIMIT: int = 10
 GIT_LS_FILES_TIMEOUT_SECONDS: int = 10
+GIT_DIFF_TIMEOUT_SECONDS: int = 10
 GIT_EXECUTABLE_NAME: str = "git"
 GIT_LS_FILES_SUBCOMMAND: str = "ls-files"
+GIT_DIFF_SUBCOMMAND: str = "diff"
+GIT_DIFF_QUIET_FLAG: str = "--quiet"
+GIT_HEAD_REVISION: str = "HEAD"
 GIT_PATHSPEC_SEPARATOR: str = "--"
+HASH_STATE_FILE_PREFIX: str = "claude-tdd-test-hashes-"
+HASH_STATE_FILE_SUFFIX: str = ".json"
+REPOSITORY_ROOT_DIGEST_LENGTH: int = 16
+STORED_CONTENT_HASH_KEY: str = "hash"
+STORED_CHANGED_AT_KEY: str = "changed_at"
 PYTHON_SOURCE_EXTENSION: str = ".py"
 ENTRY_HOOK_FILE_NAME: str = "tdd_enforcer.py"
 NEWLINE_JOIN_SEPARATOR: str = "\n"