claude-dev-env 8.78.3 → 8.80.0

package/hooks/hooks_constants/shell_command_evaluation_constants.py

@@ -0,0 +1,67 @@
+"""Names the programs that run a command held in their arguments rather than as a shell wrapper.
+
+``eval`` and PowerShell's ``Invoke-Expression`` run their joined arguments,
+``find -exec`` runs the tokens up to its terminator, and PowerShell's
+``-EncodedCommand`` runs a base64 string of UTF-16LE text. PowerShell accepts
+any prefix of ``-EncodedCommand`` from ``-e`` on, plus the ``-ec`` alias.
+``Start-Process`` runs its file path with its argument list, which may be
+comma-separated, and a parameter may carry its value after a colon, as in
+``-ArgumentList:'pr list'``; the values of its other parameters are not part
+of the command. Unwrapping stops past ``MAXIMUM_UNWRAP_DEPTH`` nested levels, so a
+deeply nested command cannot exhaust the parser.
+"""
+
+from __future__ import annotations
+
+__all__ = [
+    "ALL_STRING_EVALUATING_PROGRAM_NAMES",
+    "FIND_PROGRAM_NAME",
+    "ALL_FIND_EXEC_ACTIONS",
+    "ALL_FIND_EXEC_TERMINATORS",
+    "FIND_EXEC_COMMAND_SEPARATOR",
+    "ALL_POWERSHELL_PROGRAM_NAMES",
+    "ENCODED_COMMAND_OPTION",
+    "ENCODED_COMMAND_SHORT_ALIAS",
+    "MINIMUM_ENCODED_COMMAND_PREFIX_LENGTH",
+    "ENCODED_COMMAND_TEXT_ENCODING",
+    "ALL_START_PROCESS_PROGRAM_NAMES",
+    "ALL_START_PROCESS_NON_COMMAND_PARAMETERS",
+    "START_PROCESS_PARAMETER_PREFIX",
+    "START_PROCESS_ARGUMENT_SEPARATOR",
+    "START_PROCESS_PARAMETER_VALUE_SEPARATOR",
+    "MAXIMUM_UNWRAP_DEPTH",
+    "ALL_LINE_BREAK_CHARACTERS",
+    "QUOTED_LINE_BREAK_REPLACEMENT",
+]
+
+ALL_STRING_EVALUATING_PROGRAM_NAMES: frozenset[str] = frozenset(
+    {"eval", "invoke-expression", "iex"}
+)
+FIND_PROGRAM_NAME: str = "find"
+ALL_FIND_EXEC_ACTIONS: frozenset[str] = frozenset({"-exec", "-execdir", "-ok", "-okdir"})
+ALL_FIND_EXEC_TERMINATORS: frozenset[str] = frozenset({";", "\\;", "+"})
+FIND_EXEC_COMMAND_SEPARATOR: str = " ; "
+ALL_POWERSHELL_PROGRAM_NAMES: frozenset[str] = frozenset({"pwsh", "powershell"})
+ENCODED_COMMAND_OPTION: str = "-encodedcommand"
+ENCODED_COMMAND_SHORT_ALIAS: str = "-ec"
+MINIMUM_ENCODED_COMMAND_PREFIX_LENGTH: int = 2
+ENCODED_COMMAND_TEXT_ENCODING: str = "utf-16-le"
+ALL_START_PROCESS_PROGRAM_NAMES: frozenset[str] = frozenset({"start-process", "saps", "start"})
+ALL_START_PROCESS_NON_COMMAND_PARAMETERS: frozenset[str] = frozenset(
+    {
+        "-workingdirectory",
+        "-verb",
+        "-windowstyle",
+        "-credential",
+        "-redirectstandardinput",
+        "-redirectstandardoutput",
+        "-redirectstandarderror",
+        "-environment",
+    }
+)
+START_PROCESS_PARAMETER_PREFIX: str = "-"
+START_PROCESS_ARGUMENT_SEPARATOR: str = ","
+START_PROCESS_PARAMETER_VALUE_SEPARATOR: str = ":"
+MAXIMUM_UNWRAP_DEPTH: int = 16
+ALL_LINE_BREAK_CHARACTERS: frozenset[str] = frozenset({"\n", "\r"})
+QUOTED_LINE_BREAK_REPLACEMENT: str = " "

package/hooks/hooks_constants/shell_command_substitution_constants.py

@@ -0,0 +1,25 @@
+"""Characters the command substitution scan reads in a shell command."""
+
+from __future__ import annotations
+
+__all__ = [
+    "COMMAND_SUBSTITUTION_OPENER",
+    "BACKTICK",
+    "SINGLE_QUOTE",
+    "DOUBLE_QUOTE",
+    "SHELL_ESCAPE_CHARACTER",
+    "OPENING_PARENTHESIS",
+    "CLOSING_PARENTHESIS",
+    "ALL_PARENTHESIS_DEPTH_CHANGES",
+    "ALL_BACKTICK_ESCAPED_CHARACTERS",
+]
+
+COMMAND_SUBSTITUTION_OPENER: str = "$("
+BACKTICK: str = "`"
+SINGLE_QUOTE: str = "'"
+DOUBLE_QUOTE: str = '"'
+SHELL_ESCAPE_CHARACTER: str = "\\"
+OPENING_PARENTHESIS: str = "("
+CLOSING_PARENTHESIS: str = ")"
+ALL_PARENTHESIS_DEPTH_CHANGES: dict[str, int] = {OPENING_PARENTHESIS: 1, CLOSING_PARENTHESIS: -1}
+ALL_BACKTICK_ESCAPED_CHARACTERS: frozenset[str] = frozenset({"$", BACKTICK, SHELL_ESCAPE_CHARACTER})

package/hooks/hooks_constants/shell_command_wrappers.py

@@ -8,20 +8,57 @@ A wrapper either runs its own operands, as ``sudo``, ``xargs``, ``env``, and
     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
+    echo "$(git push)"                    "git push" 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.
+composes it into the answers a hook asks about any program.
 """
 
 from __future__ import annotations
 
-from hooks_constants.piped_pytest_blocker_constants import WINDOWS_EXECUTABLE_SUFFIX
+import base64
+import collections
+import itertools
+
+from hooks_constants.piped_pytest_blocker_constants import (
+    WINDOWS_EXECUTABLE_SUFFIX,
+    WRAPPED_COMMAND_TOKEN_JOIN,
+)
 from hooks_constants.pytest_invocation import (
     all_tokens_after_wrappers,
     string_exec_inner_command,
     unquoted_token,
 )
+from hooks_constants.shell_command_evaluation_constants import (
+    ALL_FIND_EXEC_ACTIONS,
+    ALL_FIND_EXEC_TERMINATORS,
+    ALL_POWERSHELL_PROGRAM_NAMES,
+    ALL_START_PROCESS_NON_COMMAND_PARAMETERS,
+    ALL_START_PROCESS_PROGRAM_NAMES,
+    ALL_STRING_EVALUATING_PROGRAM_NAMES,
+    ENCODED_COMMAND_OPTION,
+    ENCODED_COMMAND_SHORT_ALIAS,
+    ENCODED_COMMAND_TEXT_ENCODING,
+    FIND_EXEC_COMMAND_SEPARATOR,
+    FIND_PROGRAM_NAME,
+    ALL_LINE_BREAK_CHARACTERS,
+    MAXIMUM_UNWRAP_DEPTH,
+    MINIMUM_ENCODED_COMMAND_PREFIX_LENGTH,
+    QUOTED_LINE_BREAK_REPLACEMENT,
+    START_PROCESS_ARGUMENT_SEPARATOR,
+    START_PROCESS_PARAMETER_PREFIX,
+    START_PROCESS_PARAMETER_VALUE_SEPARATOR,
+)
 from hooks_constants.shell_command_pipeline import pipeline_segments_for_command
+from hooks_constants.shell_command_substitution_constants import (
+    ALL_BACKTICK_ESCAPED_CHARACTERS,
+    ALL_PARENTHESIS_DEPTH_CHANGES,
+    BACKTICK,
+    COMMAND_SUBSTITUTION_OPENER,
+    DOUBLE_QUOTE,
+    SHELL_ESCAPE_CHARACTER,
+    SINGLE_QUOTE,
+)
 from hooks_constants.shell_command_segments import (
     effective_leading_program,
     token_basename,
@@ -30,6 +67,9 @@ from hooks_constants.shell_command_segments import (
 __all__ = [
     "segment_program_and_arguments",
     "all_wrapped_command_texts",
+    "all_wrapped_command_segments",
+    "all_command_substitution_texts",
+    "evaluated_inner_command",
 ]
 
 
@@ -50,19 +90,294 @@ def segment_program_and_arguments(all_segment_tokens: list[str]) -> tuple[str, l
     return program_name, all_unwrapped_tokens[program_index + 1 :]
 
 
+def _quote_state_after(
+    character: str, is_in_single_quotes: bool, is_in_double_quotes: bool
+) -> tuple[bool, bool]:
+    """Return the single and double quote state after one character."""
+    if is_in_single_quotes:
+        return character != SINGLE_QUOTE, False
+    if character == SINGLE_QUOTE and not is_in_double_quotes:
+        return True, False
+    if character == DOUBLE_QUOTE:
+        return False, not is_in_double_quotes
+    return False, is_in_double_quotes
+
+
+def _closing_parenthesis_index(command: str, body_start_index: int) -> int:
+    """Return the index of the unquoted parenthesis that closes a substitution.
+
+    Returns the command length when no parenthesis closes it.
+    """
+    depth = 1
+    is_in_single_quotes = False
+    is_in_double_quotes = False
+    character_index = body_start_index
+    while character_index < len(command):
+        character = command[character_index]
+        if character == SHELL_ESCAPE_CHARACTER and not is_in_single_quotes:
+            character_index += 2
+            continue
+        if not (is_in_single_quotes or is_in_double_quotes):
+            depth += ALL_PARENTHESIS_DEPTH_CHANGES.get(character, 0)
+        if depth == 0:
+            return character_index
+        is_in_single_quotes, is_in_double_quotes = _quote_state_after(
+            character, is_in_single_quotes, is_in_double_quotes
+        )
+        character_index += 1
+    return len(command)
+
+
+def _backtick_body(command: str, body_start_index: int) -> tuple[str, int]:
+    """Return a backtick substitution's body with its escapes removed, and its closing index."""
+    all_body_characters: list[str] = []
+    character_index = body_start_index
+    while character_index < len(command) and command[character_index] != BACKTICK:
+        character = command[character_index]
+        next_character = command[character_index + 1 : character_index + 2]
+        if (
+            character == SHELL_ESCAPE_CHARACTER
+            and next_character in ALL_BACKTICK_ESCAPED_CHARACTERS
+        ):
+            all_body_characters.append(next_character)
+            character_index += 2
+            continue
+        all_body_characters.append(character)
+        character_index += 1
+    return "".join(all_body_characters), character_index
+
+
+def _substitution_at(command: str, character_index: int) -> tuple[str, int] | None:
+    """Return the body and closing index of a substitution that opens at the index, else None."""
+    if command.startswith(COMMAND_SUBSTITUTION_OPENER, character_index):
+        body_start_index = character_index + len(COMMAND_SUBSTITUTION_OPENER)
+        body_end_index = _closing_parenthesis_index(command, body_start_index)
+        return command[body_start_index:body_end_index], body_end_index
+    if command[character_index] != BACKTICK:
+        return None
+    return _backtick_body(command, character_index + 1)
+
+
+def all_command_substitution_texts(command: str) -> list[str]:
+    """Return the command text inside each ``$(...)`` and backtick pair outside single quotes.
+
+    ::
+
+        echo "$(gh pr list)"        ["gh pr list"]
+        x=`git push`                ["git push"]
+        echo '$(gh pr list)'        []
+    """
+    all_substitution_texts: list[str] = []
+    is_in_single_quotes = False
+    is_in_double_quotes = False
+    character_index = 0
+    while character_index < len(command):
+        substitution = None if is_in_single_quotes else _substitution_at(command, character_index)
+        if substitution is not None:
+            all_substitution_texts.append(substitution[0])
+            character_index = substitution[1] + 1
+            continue
+        if not is_in_single_quotes and command[character_index] == SHELL_ESCAPE_CHARACTER:
+            character_index += 2
+            continue
+        is_in_single_quotes, is_in_double_quotes = _quote_state_after(
+            command[character_index], is_in_single_quotes, is_in_double_quotes
+        )
+        character_index += 1
+    return all_substitution_texts
+
+
+def _find_exec_command(all_arguments: list[str]) -> str | None:
+    """Return the commands every ``find -exec`` action runs as one command list, else None."""
+    all_action_indexes = [
+        each_index
+        for each_index, each_argument in enumerate(all_arguments)
+        if unquoted_token(each_argument) in ALL_FIND_EXEC_ACTIONS
+    ]
+    if not all_action_indexes:
+        return None
+    return FIND_EXEC_COMMAND_SEPARATOR.join(
+        WRAPPED_COMMAND_TOKEN_JOIN.join(
+            itertools.takewhile(
+                lambda each_token: unquoted_token(each_token) not in ALL_FIND_EXEC_TERMINATORS,
+                all_arguments[each_action_index + 1 :],
+            )
+        )
+        for each_action_index in all_action_indexes
+    )
+
+
+def _is_encoded_command_option(argument: str) -> bool:
+    lowered_argument = unquoted_token(argument).lower()
+    return lowered_argument == ENCODED_COMMAND_SHORT_ALIAS or (
+        len(lowered_argument) >= MINIMUM_ENCODED_COMMAND_PREFIX_LENGTH
+        and ENCODED_COMMAND_OPTION.startswith(lowered_argument)
+    )
+
+
+def _decoded_utf16_base64_text(encoded_text: str) -> str | None:
+    """Return the UTF-16LE text a base64 string holds, else None."""
+    try:
+        return base64.b64decode("".join(encoded_text.split()), validate=True).decode(
+            ENCODED_COMMAND_TEXT_ENCODING
+        )
+    except ValueError:
+        return None
+
+
+def _decoded_powershell_command(all_arguments: list[str]) -> str | None:
+    """Return the text a PowerShell ``-EncodedCommand`` value decodes to, else None."""
+    for each_previous_argument, each_argument in itertools.pairwise(all_arguments):
+        if _is_encoded_command_option(each_previous_argument):
+            return _decoded_utf16_base64_text(unquoted_token(each_argument))
+    return None
+
+
+def _start_process_tokens(all_arguments: list[str]) -> list[str]:
+    """Return the ``Start-Process`` arguments with each ``-Name:value`` split in two."""
+    all_tokens: list[str] = []
+    for each_argument in all_arguments:
+        is_bound_parameter = each_argument.startswith(START_PROCESS_PARAMETER_PREFIX)
+        if is_bound_parameter and START_PROCESS_PARAMETER_VALUE_SEPARATOR in each_argument:
+            all_tokens.extend(each_argument.split(START_PROCESS_PARAMETER_VALUE_SEPARATOR, 1))
+            continue
+        all_tokens.append(each_argument)
+    return all_tokens
+
+
+def _start_process_command(all_arguments: list[str]) -> str | None:
+    """Return the program and arguments a ``Start-Process`` call runs, else None."""
+    all_start_process_tokens = _start_process_tokens(all_arguments)
+    all_command_words = [
+        unquoted_token(each_argument).replace(
+            START_PROCESS_ARGUMENT_SEPARATOR, WRAPPED_COMMAND_TOKEN_JOIN
+        )
+        for each_previous_argument, each_argument in itertools.pairwise(
+            ["", *all_start_process_tokens]
+        )
+        if not each_argument.startswith(START_PROCESS_PARAMETER_PREFIX)
+        and each_previous_argument.lower() not in ALL_START_PROCESS_NON_COMMAND_PARAMETERS
+    ]
+    return WRAPPED_COMMAND_TOKEN_JOIN.join(all_command_words) or None
+
+
+def evaluated_inner_command(all_segment_tokens: list[str]) -> str | None:
+    """Return the command that an evaluating program in the segment runs, else None.
+
+    ::
+
+        eval "gh pr list"                      gh pr list
+        iex 'gh pr list'                       gh pr list
+        find . -exec gh pr list +              gh pr list
+        pwsh -EncodedCommand ZwBoACAA...       the decoded text
+        Start-Process gh -ArgumentList 'pr list'   gh pr list
+        gh pr list                             None
+
+    The pipeline parser splits a ``find`` call at an escaped ``\\;``, so a
+    segment that starts with a ``-exec`` action is the rest of that call.
+    """
+    if all_segment_tokens and unquoted_token(all_segment_tokens[0]) in ALL_FIND_EXEC_ACTIONS:
+        return _find_exec_command(all_segment_tokens)
+    program_name, all_arguments = segment_program_and_arguments(all_segment_tokens)
+    normalized_program_name = program_name.lower()
+    if normalized_program_name in ALL_STRING_EVALUATING_PROGRAM_NAMES:
+        return WRAPPED_COMMAND_TOKEN_JOIN.join(
+            unquoted_token(each_argument) for each_argument in all_arguments
+        )
+    if normalized_program_name == FIND_PROGRAM_NAME:
+        return _find_exec_command(all_arguments)
+    if normalized_program_name in ALL_POWERSHELL_PROGRAM_NAMES:
+        return _decoded_powershell_command(all_arguments)
+    if normalized_program_name in ALL_START_PROCESS_PROGRAM_NAMES:
+        return _start_process_command(all_arguments)
+    return None
+
+
+def _quoted_line_breaks_joined(command: str) -> str:
+    """Return a copy of the command that holds a space at each quoted line break.
+
+    The pipeline parser splits a command at every line break, so a quoted
+    value that spans lines, such as an encoded PowerShell command, reads whole
+    only in this copy.
+    """
+    all_characters: list[str] = []
+    is_in_single_quotes = False
+    is_in_double_quotes = False
+    for each_character in command:
+        is_quoted = is_in_single_quotes or is_in_double_quotes
+        is_quoted_line_break = is_quoted and each_character in ALL_LINE_BREAK_CHARACTERS
+        all_characters.append(
+            QUOTED_LINE_BREAK_REPLACEMENT if is_quoted_line_break else each_character
+        )
+        is_in_single_quotes, is_in_double_quotes = _quote_state_after(
+            each_character, is_in_single_quotes, is_in_double_quotes
+        )
+    return "".join(all_characters)
+
+
+def _inner_commands(command: str, all_command_segments: list[list[str]]) -> list[str]:
+    """Return each command string that a wrapper, evaluating program or substitution runs.
+
+    A copy of the command with its quoted line breaks joined comes last when it differs.
+    """
+    joined_command = _quoted_line_breaks_joined(command)
+    all_inner_commands = [
+        joined_command if joined_command != command else None,
+        *(string_exec_inner_command(each_segment) for each_segment in all_command_segments),
+        *(evaluated_inner_command(each_segment) for each_segment in all_command_segments),
+        *all_command_substitution_texts(command),
+    ]
+    return [each_command for each_command in all_inner_commands if each_command is not None]
+
+
+def _all_wrapped_command_parses(command: str) -> list[tuple[str, list[list[str]]]]:
+    """Return each command text with its segments, the command first, each text parsed once.
+
+    The texts after the command are the command string every shell wrapper,
+    evaluating program and command substitution inside it runs, unwrapped in
+    turn to ``MAXIMUM_UNWRAP_DEPTH`` levels. A text met twice is parsed once.
+    """
+    all_parses: list[tuple[str, list[list[str]]]] = []
+    all_seen_texts: set[str] = set()
+    all_pending_texts = collections.deque([(command, 0)])
+    while all_pending_texts:
+        each_text, each_depth = all_pending_texts.popleft()
+        if each_text in all_seen_texts or each_depth > MAXIMUM_UNWRAP_DEPTH:
+            continue
+        all_seen_texts.add(each_text)
+        all_command_segments = [
+            each_segment
+            for each_segment, _following_operator in pipeline_segments_for_command(each_text)
+        ]
+        all_parses.append((each_text, all_command_segments))
+        all_pending_texts.extend(
+            (each_inner_command, each_depth + 1)
+            for each_inner_command in _inner_commands(each_text, all_command_segments)
+        )
+    return all_parses
+
+
 def all_wrapped_command_texts(command: str) -> list[str]:
-    """Return the command plus the command string every shell wrapper inside it runs.
+    """Return the command plus each command string a wrapper or substitution 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.
+    its own turn. Nested wrappers and ``$(...)`` or backtick substitutions
+    unwrap in turn.
     """
-    all_inner_commands = [
-        string_exec_inner_command(each_segment)
-        for each_segment, _following_operator in pipeline_segments_for_command(command)
+    return [each_text for each_text, _all_segments in _all_wrapped_command_parses(command)]
+
+
+def all_wrapped_command_segments(command: str) -> list[list[str]]:
+    """Return every segment of the command and of each command string a wrapper inside it runs.
+
+    Each command text goes through the pipeline parser once, and both this
+    function and ``all_wrapped_command_texts`` read that one parse, so a hook
+    that grades segments reads ``bash -c "gh pr list"`` as its outer segment
+    plus ``gh pr list``.
+    """
+    return [
+        each_segment
+        for _each_text, all_segments in _all_wrapped_command_parses(command)
+        for each_segment in all_segments
     ]
-    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_bash_pre_tool_use_dispatcher_constants.py

@@ -12,7 +12,7 @@ ALL_BASH_AND_POWERSHELL_TOOL_NAMES = ALL_CONSTANT_BINDINGS["ALL_BASH_AND_POWERSH
 BashHostedHookEntry = ALL_CONSTANT_BINDINGS["BashHostedHookEntry"]
 
 
-def test_roster_hosts_the_three_gates_and_hands_two_to_the_shell_guards_mod() -> None:
+def test_roster_hosts_the_four_gates_and_hands_two_to_the_shell_guards_mod() -> None:
     assert ALL_BASH_HOSTED_HOOK_ENTRIES == (
         BashHostedHookEntry(
             script_relative_path="blocking/msys_rev_path_rewriter.py",
@@ -28,4 +28,8 @@ def test_roster_hosts_the_three_gates_and_hands_two_to_the_shell_guards_mod() ->
             applicable_tool_names=ALL_BASH_AND_POWERSHELL_TOOL_NAMES,
             replaced_by_plugin_name="shell-guards",
         ),
+        BashHostedHookEntry(
+            script_relative_path="blocking/cloud_graphql_gate.py",
+            applicable_tool_names=ALL_BASH_AND_POWERSHELL_TOOL_NAMES,
+        ),
     )

package/hooks/hooks_constants/test_cloud_session.py

@@ -0,0 +1,27 @@
+"""Tests for the shared check that tells a hook it runs in a Claude Code cloud session."""
+
+from __future__ import annotations
+
+import pytest
+
+from hooks_constants.cloud_session import is_cloud_session
+
+
+@pytest.mark.parametrize("marker_value", ["true", "TRUE", " true "])
+def test_should_read_the_cloud_marker_case_and_space_blind(
+    monkeypatch: pytest.MonkeyPatch, marker_value: str
+) -> None:
+    monkeypatch.setenv("CLAUDE_CODE_REMOTE", marker_value)
+    assert is_cloud_session() is True
+
+
+@pytest.mark.parametrize("marker_value", ["false", "", "1"])
+def test_should_not_treat_another_marker_value_as_cloud(
+    monkeypatch: pytest.MonkeyPatch, marker_value: str
+) -> None:
+    monkeypatch.setenv("CLAUDE_CODE_REMOTE", marker_value)
+    assert is_cloud_session() is False
+
+
+def test_should_not_report_cloud_when_the_marker_is_unset() -> None:
+    assert is_cloud_session() is False

package/hooks/hooks_constants/test_gh_command_words.py

@@ -0,0 +1,45 @@
+"""Tests for the shared reader of gh command words and standalone options."""
+
+from __future__ import annotations
+
+import pytest
+
+from hooks_constants.gh_command_words import gh_command_words, gh_command_words_and_options
+
+
+@pytest.mark.parametrize(
+    ("all_arguments", "all_expected_words"),
+    [
+        (["pr", "list"], ["pr", "list"]),
+        (["-R", "o/r", "pr", "list"], ["pr", "list"]),
+        (["pr", "--repo", "o/r", "view", "12"], ["pr", "view", "12"]),
+        (["api", "-X", "POST", "graphql", "-f", "query=x"], ["api", "graphql"]),
+        (["api", "-H", "Accept: application/json", "graphql"], ["api", "graphql"]),
+        (["release", "view", "--json", "name"], ["release", "view"]),
+        (["api", "repos/o/r", "--preview", "graphql"], ["api", "repos/o/r"]),
+        (["pr", "merge", "12", "--body", "-h"], ["pr", "merge", "12"]),
+        (["pr", "list", "--repo=o/r"], ["pr", "list"]),
+    ],
+)
+def test_should_return_the_words_past_options_and_their_values(
+    all_arguments: list[str], all_expected_words: list[str]
+) -> None:
+    assert gh_command_words(all_arguments) == all_expected_words
+
+
+@pytest.mark.parametrize(
+    ("all_arguments", "all_expected_options"),
+    [
+        (["pr", "list", "--web"], ["--web"]),
+        (["pr", "list", "--search", "-w"], ["--search"]),
+        (["pr", "merge", "12", "--body", "-h"], ["--body"]),
+        (["pr", "view", "-w", "-h"], ["-w", "-h"]),
+        (["workflow", "run", "ci.yml", "--ref=main"], ["--ref"]),
+        (["api", "graphql", "-f", "-X"], ["-f"]),
+        (["repo", "create", "n", "-p", "o/t"], ["-p"]),
+    ],
+)
+def test_should_return_each_option_that_is_not_another_option_value(
+    all_arguments: list[str], all_expected_options: list[str]
+) -> None:
+    assert gh_command_words_and_options(all_arguments)[1] == all_expected_options

package/hooks/hooks_constants/test_hook_block_logger.py

@@ -39,6 +39,67 @@ def test_log_hook_block_writes_parseable_json_line(tmp_path: Path) -> None:
     assert parsed["preview"] == "echo hello"
 
 
+_PLACEHOLDER_VALUE = "placeholder"
+_AUTHORIZATION_HEADER_NAME = "Author" + "ization"
+_CLASSIC_TOKEN_PREFIX = "gh" + "p_"
+_FINE_GRAINED_TOKEN_PREFIX = "github" + "_pat_"
+
+
+@pytest.mark.parametrize(
+    ("command", "secret"),
+    [
+        (
+            f"gh api graphql -H '{_AUTHORIZATION_HEADER_NAME}: token {_PLACEHOLDER_VALUE}'",
+            _PLACEHOLDER_VALUE,
+        ),
+        (
+            f'wget --header "{_AUTHORIZATION_HEADER_NAME}: Bearer {_PLACEHOLDER_VALUE}"',
+            _PLACEHOLDER_VALUE,
+        ),
+        (
+            f"curl -H '{_AUTHORIZATION_HEADER_NAME}: Digest username={_PLACEHOLDER_VALUE}' x",
+            _PLACEHOLDER_VALUE,
+        ),
+        (
+            f'curl -H "{_AUTHORIZATION_HEADER_NAME}: {_PLACEHOLDER_VALUE}" x',
+            _PLACEHOLDER_VALUE,
+        ),
+        (
+            f"python -c \"h = {{'{_AUTHORIZATION_HEADER_NAME}': 'Bearer {_PLACEHOLDER_VALUE}'}}\"",
+            _PLACEHOLDER_VALUE,
+        ),
+        (
+            f"curl -H '{_AUTHORIZATION_HEADER_NAME}: \"Bearer {_PLACEHOLDER_VALUE}\"' x",
+            _PLACEHOLDER_VALUE,
+        ),
+        (
+            f"GH_TOKEN={_CLASSIC_TOKEN_PREFIX}{_PLACEHOLDER_VALUE} gh pr list",
+            _CLASSIC_TOKEN_PREFIX + _PLACEHOLDER_VALUE,
+        ),
+        (
+            f"echo {_FINE_GRAINED_TOKEN_PREFIX}{_PLACEHOLDER_VALUE} | gh auth login",
+            _FINE_GRAINED_TOKEN_PREFIX + _PLACEHOLDER_VALUE,
+        ),
+    ],
+)
+def test_log_hook_block_redacts_secrets_in_the_preview(
+    tmp_path: Path, command: str, secret: str
+) -> None:
+    with patch.object(Path, "home", return_value=tmp_path):
+        log_hook_block(
+            calling_hook_name="test_hook.py",
+            hook_event="PreToolUse",
+            block_reason="test block reason",
+            tool_name="Bash",
+            offending_input_preview=command,
+        )
+
+    log_path = tmp_path / ".claude" / "logs" / "hook-blocks.log"
+    preview = json.loads(log_path.read_text(encoding="utf-8").strip())["preview"]
+    assert secret not in preview
+    assert "[REDACTED]" in preview
+
+
 def test_log_hook_block_creates_logs_directory(tmp_path: Path) -> None:
     with patch.object(Path, "home", return_value=tmp_path):
         log_hook_block(

package/hooks/hooks_constants/test_mod_handoff.py

@@ -89,12 +89,13 @@ def test_should_let_local_project_settings_turn_a_user_plugin_off(
     assert is_mod_plugin_enabled("session-prompts") is False
 
 
+@pytest.mark.parametrize("marker_value", ["true", " TRUE "])
 def test_should_keep_the_hook_in_a_cloud_session_with_the_plugin_on(
-    settings_homes: tuple[Path, Path], monkeypatch: pytest.MonkeyPatch,
+    settings_homes: tuple[Path, Path], monkeypatch: pytest.MonkeyPatch, marker_value: str,
 ) -> None:
     _, project_directory = settings_homes
     _write_enabled_plugins(
         project_directory / ".claude" / "settings.json", {"session-prompts@market": True}
     )
-    monkeypatch.setenv("CLAUDE_CODE_REMOTE", "true")
+    monkeypatch.setenv("CLAUDE_CODE_REMOTE", marker_value)
     assert is_mod_plugin_enabled("session-prompts") is False

package/hooks/hooks_constants/test_piped_pytest_blocker_constants.py

@@ -12,3 +12,14 @@ def test_pipe_and_wrapper_tokens_preserve_command_boundaries() -> None:
     assert ";;" in constants.ALL_SEGMENT_RESET_OPERATOR_TOKENS
     assert "-u" in constants.ALL_WRAPPER_OPTION_GRAMMARS_BY_NAME["sudo"].all_value_taking_options
     assert constants.ALL_WRAPPER_OPTION_GRAMMARS_BY_NAME["timeout"].leading_operand_count == 1
+
+
+def test_shell_keywords_and_builtins_step_to_the_command_they_run() -> None:
+    assert {"if", "then", "do", "!"} <= constants.ALL_SHELL_KEYWORDS_BEFORE_A_COMMAND
+    for each_keyword in constants.ALL_SHELL_KEYWORDS_BEFORE_A_COMMAND:
+        assert (
+            constants.ALL_WRAPPER_OPTION_GRAMMARS_BY_NAME[each_keyword]
+            == constants.SHELL_KEYWORD_OPTION_GRAMMAR
+        )
+    assert "-a" in constants.ALL_WRAPPER_OPTION_GRAMMARS_BY_NAME["exec"].all_value_taking_options
+    assert "-p" in constants.ALL_WRAPPER_OPTION_GRAMMARS_BY_NAME["command"].all_flag_options