claude-dev-env 8.32.2 → 8.33.0

package/hooks/hooks_constants/shell_command_mutation.py

@@ -0,0 +1,202 @@
+"""Decide whether a shell command writes, sends, or changes state.
+
+Every command string a wrapper runs is scanned, and each segment is read as
+its program plus arguments after the wrappers in front of it::
+
+    sudo git push                      writes
+    bash -c "gh pr merge 12"           writes
+    pwsh -Command git push; echo done  writes
+    rg 'gh pr merge' docs              reads
+    grep "a|cp b" notes.md             reads
+
+A write counts only when the POSIX tokenization and the raw tokenization of a
+line agree on it, so a quoted literal never reads as a command.
+"""
+
+from __future__ import annotations
+
+import itertools
+
+from hooks_constants.pytest_invocation import unquoted_token
+from hooks_constants.shell_command_pipeline import (
+    all_operator_aware_tokenizations,
+    join_line_continuations,
+    scannable_command_lines,
+    segments_with_following_operator,
+)
+from hooks_constants.shell_command_segments import git_subcommand_tokens, token_basename
+from hooks_constants.shell_command_wrappers import (
+    all_wrapped_command_texts,
+    segment_program_and_arguments,
+)
+from hooks_constants.verify_before_acting_constants import (
+    ALL_FILE_WRITING_PROGRAM_NAMES,
+    ALL_GH_API_METHOD_OPTIONS,
+    ALL_HTTP_WRITE_METHODS,
+    ALL_MUTATING_GH_SUBCOMMANDS,
+    ALL_MUTATING_GIT_SUBCOMMAND_PREFIXES,
+    ALL_NON_FILE_REDIRECTION_TARGETS,
+    ALL_POWERSHELL_WRITE_CMDLET_NAMES,
+    ALL_PULL_REQUEST_SCRIPT_WRITE_ACTIONS,
+    ALL_WRITE_REDIRECTION_OPERATORS,
+    DESCRIPTOR_CLOSE_TARGET,
+    DESCRIPTOR_DUPLICATION_OPERATOR,
+    GH_API_ATTACHED_METHOD_PATTERN,
+    GH_API_FIELD_OPTION_PATTERN,
+    GH_API_SUBCOMMAND,
+    GH_PROGRAM_NAME,
+    GH_SUBCOMMAND_DEPTH,
+    GIT_PROGRAM_NAME,
+    POWERSHELL_SCRIPT_BLOCK_OPENER,
+    POWERSHELL_WORD_BRACKETS,
+    PULL_REQUEST_SCRIPT_NAME,
+    REDIRECTION_TARGET_QUOTES,
+    SED_IN_PLACE_OPTION_PATTERN,
+    SED_PROGRAM_NAME,
+)
+
+__all__ = ["is_mutating_shell_command"]
+
+
+def _is_mutating_git_arguments(all_arguments: list[str]) -> bool:
+    all_subcommand_tokens = git_subcommand_tokens(all_arguments)
+    return any(
+        tuple(all_subcommand_tokens[: len(each_prefix)]) == each_prefix
+        for each_prefix in ALL_MUTATING_GIT_SUBCOMMAND_PREFIXES
+    )
+
+
+def _gh_api_method(all_api_arguments: list[str]) -> str | None:
+    for each_option, each_method_argument in itertools.pairwise(all_api_arguments):
+        if each_option in ALL_GH_API_METHOD_OPTIONS:
+            return each_method_argument.upper()
+    for each_argument in all_api_arguments:
+        attached_match = GH_API_ATTACHED_METHOD_PATTERN.fullmatch(each_argument)
+        if attached_match is not None:
+            return attached_match.group("method").upper()
+    return None
+
+
+def _is_mutating_gh_api(all_api_arguments: list[str]) -> bool:
+    """Return True when ``gh api`` sends a write method, or fields or ``--input`` with no method named."""
+    method = _gh_api_method(all_api_arguments)
+    if method is not None:
+        return method in ALL_HTTP_WRITE_METHODS
+    return any(
+        GH_API_FIELD_OPTION_PATTERN.fullmatch(each_argument) for each_argument in all_api_arguments
+    )
+
+
+def _is_mutating_gh_arguments(all_arguments: list[str]) -> bool:
+    if tuple(all_arguments[:GH_SUBCOMMAND_DEPTH]) in ALL_MUTATING_GH_SUBCOMMANDS:
+        return True
+    return all_arguments[:1] == [GH_API_SUBCOMMAND] and _is_mutating_gh_api(all_arguments[1:])
+
+
+def _program_mutates(program_name: str, all_arguments: list[str]) -> bool:
+    if program_name in ALL_FILE_WRITING_PROGRAM_NAMES:
+        return True
+    if program_name == SED_PROGRAM_NAME:
+        return any(
+            SED_IN_PLACE_OPTION_PATTERN.fullmatch(each_argument) for each_argument in all_arguments
+        )
+    if program_name == GIT_PROGRAM_NAME:
+        return _is_mutating_git_arguments(all_arguments)
+    return program_name == GH_PROGRAM_NAME and _is_mutating_gh_arguments(all_arguments)
+
+
+def _runs_a_pull_request_script_write(all_segment_tokens: list[str]) -> bool:
+    for each_index, each_token in enumerate(all_segment_tokens):
+        if token_basename(unquoted_token(each_token)) == PULL_REQUEST_SCRIPT_NAME:
+            return any(
+                unquoted_token(each_later_token) in ALL_PULL_REQUEST_SCRIPT_WRITE_ACTIONS
+                for each_later_token in all_segment_tokens[each_index + 1 :]
+            )
+    return False
+
+
+def _powershell_command_words(program_name: str, all_segment_tokens: list[str]) -> list[str]:
+    """Return the words a segment runs as commands: its program and each script block's first word.
+
+    ``ForEach-Object { Remove-Item $_ }`` runs ``Remove-Item`` as a command, while
+    ``Get-Command Remove-Item`` passes it as an argument.
+    """
+    all_command_words = [program_name]
+    for each_previous_token, each_token in itertools.pairwise(all_segment_tokens):
+        if each_previous_token.endswith(POWERSHELL_SCRIPT_BLOCK_OPENER):
+            all_command_words.append(each_token)
+    all_command_words.extend(
+        each_token.rpartition(POWERSHELL_SCRIPT_BLOCK_OPENER)[2]
+        for each_token in all_segment_tokens
+        if POWERSHELL_SCRIPT_BLOCK_OPENER in each_token
+    )
+    return all_command_words
+
+
+def _runs_a_powershell_write_cmdlet(program_name: str, all_segment_tokens: list[str]) -> bool:
+    return any(
+        each_word.strip(POWERSHELL_WORD_BRACKETS).lower() in ALL_POWERSHELL_WRITE_CMDLET_NAMES
+        for each_word in _powershell_command_words(program_name, all_segment_tokens)
+    )
+
+
+def _redirect_target_is_a_file(operator: str, target: str) -> bool:
+    """Return True when a redirect writes a file.
+
+    A digit or ``-`` after ``>&`` duplicates or closes a descriptor, as in
+    ``2>&1`` and ``>&-``. After any other operator it names a file, so
+    ``echo hi > 1`` writes one.
+    """
+    target_text = target.strip(REDIRECTION_TARGET_QUOTES).lower()
+    if target_text in ALL_NON_FILE_REDIRECTION_TARGETS:
+        return False
+    return not (
+        operator == DESCRIPTOR_DUPLICATION_OPERATOR
+        and (target_text.isdigit() or target_text == DESCRIPTOR_CLOSE_TARGET)
+    )
+
+
+def _segment_redirects_into_a_file(all_segment_tokens: list[str]) -> bool:
+    return any(
+        each_operator in ALL_WRITE_REDIRECTION_OPERATORS
+        and _redirect_target_is_a_file(each_operator, each_target)
+        for each_operator, each_target in itertools.pairwise(all_segment_tokens)
+    )
+
+
+def _segment_is_mutating(all_segment_tokens: list[str]) -> bool:
+    program_name, all_arguments = segment_program_and_arguments(all_segment_tokens)
+    return (
+        _program_mutates(program_name, all_arguments)
+        or _runs_a_pull_request_script_write(all_segment_tokens)
+        or _runs_a_powershell_write_cmdlet(program_name, all_segment_tokens)
+        or _segment_redirects_into_a_file(all_segment_tokens)
+    )
+
+
+def _line_is_mutating(command_line: str) -> bool:
+    """Return True when every quote-aware tokenization of the line has a mutating segment.
+
+    The POSIX tokenization strips the quotes from ``rg 'Remove-Item' docs`` and
+    the raw one splits ``--format='%h > %s'`` mid-quote, so a write counts only
+    when both spellings agree on it.
+    """
+    all_tokenizations = all_operator_aware_tokenizations(command_line)
+    return bool(all_tokenizations) and all(
+        any(
+            _segment_is_mutating(each_segment)
+            for each_segment, _following_operator in segments_with_following_operator(
+                each_tokenization
+            )
+        )
+        for each_tokenization in all_tokenizations
+    )
+
+
+def is_mutating_shell_command(command: str) -> bool:
+    """Return True when any line of the command, or of a command string it wraps, writes."""
+    return any(
+        _line_is_mutating(each_line)
+        for each_command_text in all_wrapped_command_texts(command)
+        for each_line in scannable_command_lines(join_line_continuations(each_command_text))
+    )

package/hooks/hooks_constants/shell_command_segments.py

@@ -14,21 +14,28 @@ bodies dropped, parenthesis groups joined — lives in
 from __future__ import annotations
 
 import re
+import shlex
 
 __all__ = [
     "ALL_LAUNCHER_WRAPPER_COMMANDS",
     "ALL_SHELL_CONTROL_OPERATOR_TOKENS",
+    "ALL_GIT_GLOBAL_OPTIONS_WITH_VALUE",
     "CONTROL_OPERATOR_SPLIT_PATTERN",
     "LEADING_ASSIGNMENT_PATTERN",
     "LAUNCHER_DURATION_PATTERN",
     "token_basename",
     "split_into_segments",
     "effective_leading_program",
+    "command_tokens",
+    "git_subcommand_tokens",
 ]
 
 ALL_LAUNCHER_WRAPPER_COMMANDS: frozenset[str] = frozenset(
     {"timeout", "nohup", "nice", "stdbuf", "setsid", "env", "time"}
 )
+ALL_GIT_GLOBAL_OPTIONS_WITH_VALUE: frozenset[str] = frozenset(
+    {"-C", "-c", "--git-dir", "--work-tree", "--namespace"}
+)
 ALL_SHELL_CONTROL_OPERATOR_TOKENS: frozenset[str] = frozenset(
     {"&&", "||", ";", "|", "&", "|&"}
 )
@@ -85,3 +92,35 @@ def effective_leading_program(all_segment_tokens: list[str]) -> str | None:
             continue
         return each_token
     return None
+
+
+def command_tokens(command: str) -> list[str]:
+    """Return the POSIX shlex tokens of a command, or its whitespace split when quoting is unbalanced."""
+    try:
+        return shlex.split(command, posix=True)
+    except ValueError:
+        return command.split()
+
+
+def git_subcommand_tokens(all_arguments: list[str]) -> list[str]:
+    """Return git's subcommand and the tokens after it, past git's global options.
+
+    ``git -C <path> push`` and ``git --git-dir <path> push`` carry an option
+    value before the subcommand; ``--git-dir=<path>`` and ``--no-pager`` carry
+    none. The first token left after those starts the result, so
+    ``git stash push`` yields ``["stash", "push"]`` and ``git log --grep push``
+    yields ``["log", "--grep", "push"]``. A command with no subcommand yields
+    an empty list.
+    """
+    should_skip_next_token = False
+    for each_index, each_argument in enumerate(all_arguments):
+        if should_skip_next_token:
+            should_skip_next_token = False
+            continue
+        if each_argument in ALL_GIT_GLOBAL_OPTIONS_WITH_VALUE:
+            should_skip_next_token = True
+            continue
+        if each_argument.startswith("-"):
+            continue
+        return all_arguments[each_index:]
+    return []

package/hooks/hooks_constants/shell_command_wrappers.py

@@ -0,0 +1,68 @@
+"""Step over the wrappers in front of a shell command to reach the command it runs.
+
+A wrapper either runs its own operands, as ``sudo``, ``xargs``, ``env``, and
+``timeout`` do, or runs a command string, as ``bash -c``, ``sh -lc``, and
+``pwsh -Command`` do::
+
+    sudo git push                         git, ["push"]
+    env GIT_DIR=x git push                git, ["push"]
+    echo origin | xargs git push          git, ["push"]
+    bash -lc "git commit -F m.txt"        "git commit -F m.txt" unwraps in turn
+
+``pytest_invocation`` owns the wrapper and string-exec parsing, and this module
+composes it into the two answers a hook asks about any program.
+"""
+
+from __future__ import annotations
+
+from hooks_constants.piped_pytest_blocker_constants import WINDOWS_EXECUTABLE_SUFFIX
+from hooks_constants.pytest_invocation import (
+    all_tokens_after_wrappers,
+    string_exec_inner_command,
+    unquoted_token,
+)
+from hooks_constants.shell_command_pipeline import pipeline_segments_for_command
+from hooks_constants.shell_command_segments import (
+    effective_leading_program,
+    token_basename,
+)
+
+__all__ = [
+    "segment_program_and_arguments",
+    "all_wrapped_command_texts",
+]
+
+
+def segment_program_and_arguments(all_segment_tokens: list[str]) -> tuple[str, list[str]]:
+    """Return a segment's program basename past its wrappers and the tokens after it.
+
+    The basename drops a ``.exe`` suffix, so ``git.exe push`` reads as ``git``.
+    Returns an empty pair when the segment names no program.
+    """
+    all_unwrapped_tokens = all_tokens_after_wrappers(all_segment_tokens)
+    program_token = effective_leading_program(all_unwrapped_tokens)
+    if program_token is None:
+        return "", []
+    program_index = all_unwrapped_tokens.index(program_token)
+    program_name = token_basename(unquoted_token(program_token)).removesuffix(
+        WINDOWS_EXECUTABLE_SUFFIX
+    )
+    return program_name, all_unwrapped_tokens[program_index + 1 :]
+
+
+def all_wrapped_command_texts(command: str) -> list[str]:
+    """Return the command plus the command string every shell wrapper inside it runs.
+
+    The segments come from the quote-aware pipeline parser, so the quoted
+    script in ``powershell -Command "git add -A; git push"`` stays whole until
+    its own turn. Nested wrappers unwrap in turn.
+    """
+    all_inner_commands = [
+        string_exec_inner_command(each_segment)
+        for each_segment, _following_operator in pipeline_segments_for_command(command)
+    ]
+    all_command_texts = [command]
+    for each_inner_command in all_inner_commands:
+        if each_inner_command is not None:
+            all_command_texts.extend(all_wrapped_command_texts(each_inner_command))
+    return all_command_texts

package/hooks/hooks_constants/test_pr_done_reminder_constants.py

@@ -12,17 +12,6 @@ def test_gh_probe_asks_for_every_field_the_checklist_reads() -> None:
         assert each_field in all_requested_fields
 
 
-def test_git_global_options_that_take_a_value_are_named() -> None:
-    assert constants.ALL_GIT_OPTIONS_WITH_VALUE == frozenset({"-C", "-c"})
-
-
-def test_powershell_wrappers_and_their_command_flags_are_named() -> None:
-    assert "pwsh" in constants.ALL_POWERSHELL_PROGRAM_NAMES
-    assert "powershell" in constants.ALL_POWERSHELL_PROGRAM_NAMES
-    assert "-command" in constants.ALL_POWERSHELL_COMMAND_FLAGS
-    assert "-c" in constants.ALL_POWERSHELL_COMMAND_FLAGS
-
-
 def test_checklist_lines_join_on_a_single_newline() -> None:
     assert constants.REMINDER_LINE_SEPARATOR == "\n"
 

package/hooks/hooks_constants/test_pytest_invocation.py

@@ -36,6 +36,12 @@ def _first_segment_tokens(command: str) -> list[str]:
         ["sudo", "pytest", "tests"],
         ["sudo", "-u", "ci", "pytest", "tests"],
         ["sudo", "-nu", "ci", "pytest", "tests"],
+        ["xargs", "pytest"],
+        ["xargs", "-0", "pytest"],
+        ["xargs", "-r", "pytest"],
+        ["xargs", "-n", "1", "pytest"],
+        ["env", "-u", "HOME", "pytest"],
+        ["timeout", "--signal", "KILL", "60", "pytest"],
         ["uv", "run", "pytest", "tests"],
         ["uv", "run", "--frozen", "pytest", "tests"],
         ["uv", "tool", "run", "pytest", "tests"],

package/hooks/hooks_constants/test_shell_command_mutation.py

@@ -0,0 +1,37 @@
+"""Pin which shell commands the mutation check reads as writes."""
+
+from __future__ import annotations
+
+import pytest
+
+from hooks_constants.shell_command_mutation import is_mutating_shell_command
+
+
+@pytest.mark.parametrize(
+    "command",
+    [
+        "sudo git push",
+        'bash -c "git commit -F m.txt"',
+        "pwsh -Command git push origin HEAD; echo done",
+        "gh api repos/o/r/issues -f title=x",
+        "Get-ChildItem | ForEach-Object { Remove-Item $_ }",
+        "echo hi > notes.txt",
+    ],
+)
+def test_should_read_a_write_as_mutating(command: str) -> None:
+    assert is_mutating_shell_command(command) is True
+
+
+@pytest.mark.parametrize(
+    "command",
+    [
+        "rg 'gh pr merge' docs",
+        "rg 'Remove-Item' docs",
+        'grep "a|cp b" notes.md',
+        "gh api -X GET search/issues -f q=x",
+        'bash -c "git status"',
+        "git log --format='%h > %s'",
+    ],
+)
+def test_should_read_a_check_as_not_mutating(command: str) -> None:
+    assert is_mutating_shell_command(command) is False

package/hooks/hooks_constants/test_shell_command_segments.py

@@ -0,0 +1,29 @@
+"""Pin git global-option parsing in the shared segment helpers."""
+
+from __future__ import annotations
+
+import pytest
+
+from hooks_constants import shell_command_segments
+
+
+@pytest.mark.parametrize(
+    ("all_arguments", "all_expected_tokens"),
+    [
+        (["push", "origin", "HEAD"], ["push", "origin", "HEAD"]),
+        (["-C", "/repo", "push"], ["push"]),
+        (["-c", "user.name=x", "commit", "-F", "m.txt"], ["commit", "-F", "m.txt"]),
+        (["--git-dir=/repo/.git", "push"], ["push"]),
+        (["--git-dir", "/repo/.git", "push"], ["push"]),
+        (["--work-tree", "/repo", "commit"], ["commit"]),
+        (["--namespace", "n", "push"], ["push"]),
+        (["--no-pager", "log"], ["log"]),
+        (["stash", "push", "-u"], ["stash", "push", "-u"]),
+        (["log", "--grep", "push"], ["log", "--grep", "push"]),
+        (["--version"], []),
+    ],
+)
+def test_should_return_the_subcommand_tokens_past_global_options(
+    all_arguments: list[str], all_expected_tokens: list[str]
+) -> None:
+    assert shell_command_segments.git_subcommand_tokens(all_arguments) == all_expected_tokens

package/hooks/hooks_constants/test_shell_command_wrappers.py

@@ -0,0 +1,61 @@
+"""Pin wrapper stepping and command-string unwrapping in the shared wrapper helpers."""
+
+from __future__ import annotations
+
+import pytest
+
+from hooks_constants import shell_command_wrappers
+
+
+@pytest.mark.parametrize(
+    ("command", "inner_command"),
+    [
+        ('pwsh -NoProfile -Command "git add -A; git push"', "git add -A; git push"),
+        ("pwsh -Command git push origin HEAD; echo done", "git push origin HEAD"),
+        ('bash -c "git push"', "git push"),
+        ("sh -c 'git commit -F m.txt'", "git commit -F m.txt"),
+        ("bash -lc 'git push'", "git push"),
+        ("sudo bash -c 'git push'", "git push"),
+        ("bash -c \"pwsh -Command 'git push'\"", "git push"),
+    ],
+)
+def test_should_return_the_command_string_a_shell_wrapper_runs(
+    command: str, inner_command: str
+) -> None:
+    all_command_texts = shell_command_wrappers.all_wrapped_command_texts(command)
+    assert all_command_texts[0] == command
+    assert inner_command in all_command_texts
+
+
+def test_should_return_only_the_command_when_no_wrapper_runs() -> None:
+    assert shell_command_wrappers.all_wrapped_command_texts("git push") == ["git push"]
+
+
+@pytest.mark.parametrize(
+    ("all_segment_tokens", "expected_program_and_arguments"),
+    [
+        (["git", "push"], ("git", ["push"])),
+        (["sudo", "git", "push"], ("git", ["push"])),
+        (["sudo", "-u", "root", "git", "push"], ("git", ["push"])),
+        (["env", "VAR=x", "git", "push"], ("git", ["push"])),
+        (["xargs", "git", "push"], ("git", ["push"])),
+        (["xargs", "-r", "rm"], ("rm", [])),
+        (["xargs", "-I", "{}", "rm", "{}"], ("rm", ["{}"])),
+        (["xargs", "-n", "1", "git", "push"], ("git", ["push"])),
+        (["env", "-u", "HOME", "git", "push"], ("git", ["push"])),
+        (["env", "-i", "VAR=x", "git", "push"], ("git", ["push"])),
+        (["timeout", "--signal", "KILL", "5", "git", "push"], ("git", ["push"])),
+        (["timeout", "--signal=KILL", "5", "git", "push"], ("git", ["push"])),
+        (["sudo", "-nu", "ci", "env", "-u", "HOME", "git", "push"], ("git", ["push"])),
+        (["time", "sudo", "git", "push"], ("git", ["push"])),
+        (["'/usr/bin/git'", "push"], ("git", ["push"])),
+        (["VAR=x"], ("", [])),
+    ],
+)
+def test_should_return_the_program_past_its_wrappers(
+    all_segment_tokens: list[str], expected_program_and_arguments: tuple[str, list[str]]
+) -> None:
+    assert (
+        shell_command_wrappers.segment_program_and_arguments(all_segment_tokens)
+        == expected_program_and_arguments
+    )

package/hooks/hooks_constants/verify_before_acting_constants.py

@@ -0,0 +1,170 @@
+"""Constants for the verify-before-acting PostToolUse hook."""
+
+import re
+
+from hooks_constants.tool_names import APPLY_PATCH_TOOL_NAME
+
+ALLOW_EXIT_CODE = 0
+TOOL_NAME_KEY = "tool_name"
+TOOL_INPUT_KEY = "tool_input"
+TOOL_USE_ID_KEY = "tool_use_id"
+TRANSCRIPT_PATH_KEY = "transcript_path"
+COMMAND_KEY = "command"
+MESSAGE_KEY = "message"
+MESSAGE_ID_KEY = "id"
+CONTENT_KEY = "content"
+BLOCK_TYPE_KEY = "type"
+BLOCK_ID_KEY = "id"
+THINKING_BLOCK_TYPE = "thinking"
+THINKING_TEXT_KEY = "thinking"
+TOOL_USE_BLOCK_TYPE = "tool_use"
+TRANSCRIPT_ENCODING = "utf-8"
+TRANSCRIPT_DECODE_ERRORS = "replace"
+THINKING_JOINER = "\n"
+TRANSCRIPT_POLL_INTERVAL_SECONDS = 0.05
+TRANSCRIPT_POLL_LIMIT_SECONDS = 5.0
+
+ALL_ALWAYS_MUTATING_TOOL_NAMES = frozenset(
+    {"Write", "Edit", "MultiEdit", "NotebookEdit", "Agent", "Task", APPLY_PATCH_TOOL_NAME}
+)
+ALL_SHELL_TOOL_NAMES = frozenset({"Bash", "PowerShell"})
+MCP_TOOL_PREFIX = "mcp__"
+MCP_SEGMENT_SEPARATOR = "__"
+MCP_ACTION_WORD_SPLIT_PATTERN = re.compile(r"_+|(?<=[a-z0-9])(?=[A-Z])")
+ALL_MCP_MUTATING_VERBS = frozenset(
+    {
+        "create",
+        "update",
+        "delete",
+        "send",
+        "post",
+        "reply",
+        "write",
+        "merge",
+        "set",
+        "add",
+        "remove",
+        "edit",
+        "trash",
+        "archive",
+    }
+)
+ALL_MCP_READ_VERBS = frozenset({"get", "list", "search", "read", "view", "fetch", "find", "query"})
+ALL_MCP_MUTATING_ACTION_NAMES = frozenset({"request_copilot_review"})
+
+GIT_PROGRAM_NAME = "git"
+ALL_MUTATING_GIT_SUBCOMMAND_PREFIXES = frozenset(
+    {
+        ("commit",),
+        ("push",),
+        ("merge",),
+        ("rebase",),
+        ("reset",),
+        ("checkout", "-b"),
+        ("switch", "-c"),
+        ("worktree", "add"),
+    }
+)
+ALL_WRITE_REDIRECTION_OPERATORS = frozenset({">", ">>", "&>", "&>>", ">&", ">|"})
+ALL_NON_FILE_REDIRECTION_TARGETS = frozenset({"/dev/null", "$null", "nul"})
+DESCRIPTOR_DUPLICATION_OPERATOR = ">&"
+DESCRIPTOR_CLOSE_TARGET = "-"
+REDIRECTION_TARGET_QUOTES = "'\""
+
+ALL_FILE_WRITING_PROGRAM_NAMES = frozenset(
+    {"rm", "rmdir", "unlink", "touch", "cp", "mv", "mkdir", "tee", "ln"}
+)
+SED_PROGRAM_NAME = "sed"
+SED_IN_PLACE_OPTION_PATTERN = re.compile(r"-[a-zA-Z]*i.*|--in-place(?:=.*)?")
+GH_PROGRAM_NAME = "gh"
+GH_SUBCOMMAND_DEPTH = 2
+ALL_MUTATING_GH_SUBCOMMANDS = frozenset(
+    {
+        ("pr", "create"),
+        ("pr", "edit"),
+        ("pr", "merge"),
+        ("pr", "comment"),
+        ("pr", "ready"),
+        ("pr", "close"),
+        ("pr", "review"),
+        ("issue", "create"),
+        ("issue", "edit"),
+        ("issue", "comment"),
+        ("issue", "close"),
+        ("run", "rerun"),
+        ("workflow", "run"),
+    }
+)
+GH_API_SUBCOMMAND = "api"
+ALL_GH_API_METHOD_OPTIONS = frozenset({"-X", "--method"})
+GH_API_ATTACHED_METHOD_PATTERN = re.compile(r"(?:-X|--method=)(?P<method>.+)")
+GH_API_FIELD_OPTION_PATTERN = re.compile(r"-[fF].*|--(?:field|raw-field|input)(?:=.*)?")
+ALL_HTTP_WRITE_METHODS = frozenset({"POST", "PATCH", "PUT", "DELETE"})
+PULL_REQUEST_SCRIPT_NAME = "pull_request.py"
+ALL_PULL_REQUEST_SCRIPT_WRITE_ACTIONS = frozenset({"create", "edit", "comment", "review"})
+ALL_POWERSHELL_WRITE_CMDLET_NAMES = frozenset(
+    {
+        "remove-item",
+        "set-content",
+        "add-content",
+        "out-file",
+        "copy-item",
+        "move-item",
+        "new-item",
+        "rename-item",
+    }
+)
+POWERSHELL_WORD_BRACKETS = "{}();"
+POWERSHELL_SCRIPT_BLOCK_OPENER = "{"
+
+ALL_HEDGE_PHRASES = (
+    "probably",
+    "likely",
+    "maybe",
+    "perhaps",
+    "presumably",
+    "might be",
+    "may be",
+    "seems",
+    "appears to",
+    "i suspect",
+    "i guess",
+    "i believe",
+    "my guess",
+    "my theory",
+    "not sure",
+    "unsure",
+)
+HEDGE_PATTERN = re.compile(
+    r"\b(?:"
+    + "|".join(r"\s+".join(each_phrase.split()) for each_phrase in ALL_HEDGE_PHRASES)
+    + r")\b",
+    re.IGNORECASE,
+)
+SENTENCE_SPLIT_PATTERN = re.compile(r"(?<=[.!?])\s+|\n+")
+WHITESPACE_RUN_PATTERN = re.compile(r"\s+")
+WORD_SEPARATOR = " "
+MAXIMUM_QUOTE_LENGTH = 160
+QUOTE_LEAD_LENGTH = MAXIMUM_QUOTE_LENGTH // 2
+TRIM_MARKER = "..."
+
+DECISION_KEY = "decision"
+BLOCK_DECISION = "block"
+REASON_KEY = "reason"
+BLOCK_REASON_TEMPLATE = (
+    'The reasoning behind this {tool_name} call hedges: "{hedge_sentence}" '
+    "Check that claim now with a read-only tool, then continue. "
+    "If the check contradicts it, undo this change first."
+)
+
+DECISION_LOG_RELATIVE_PATH = ".claude/logs/verify-before-acting.jsonl"
+LOG_APPEND_MODE = "a"
+LOG_LINE_END = "\n"
+LOG_TIMESTAMP_KEY = "timestamp"
+LOG_TOOL_NAME_KEY = "tool_name"
+LOG_TOOL_USE_ID_KEY = "tool_use_id"
+LOG_OUTCOME_KEY = "outcome"
+LOG_HEDGE_SENTENCE_KEY = "hedge_sentence"
+OUTCOME_BLOCKED = "blocked"
+OUTCOME_ALLOWED_CLEAN = "allowed_clean"
+OUTCOME_REASONING_UNSEEN = "reasoning_unseen"

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "claude-dev-env",
-    "version": "8.32.2",
+    "version": "8.33.0",
     "description": "Claude Code development standards — rules, hooks, agents, commands, and skills",
     "type": "module",
     "bin": {