claude-dev-env 2.7.1 → 2.9.0

package/hooks/hooks.json

@@ -8,7 +8,7 @@
           {
             "type": "command",
             "command": "python3 -c \"import sys; sys.path.insert(0, r'${CLAUDE_PLUGIN_ROOT}/hooks'); from validators.run_all_validators import main; sys.exit(main())\" --pre-tool-use",
-            "timeout": 15
+            "timeout": 30
           }
         ]
       },
@@ -22,21 +22,6 @@
           }
         ]
       },
-      {
-        "matcher": "Edit",
-        "hooks": [
-          {
-            "type": "command",
-            "command": "python3 ${CLAUDE_PLUGIN_ROOT}/hooks/advisory/refactor_guard.py",
-            "timeout": 15
-          },
-          {
-            "type": "command",
-            "command": "python3 ${CLAUDE_PLUGIN_ROOT}/hooks/advisory/migration_safety_advisor.py",
-            "timeout": 15
-          }
-        ]
-      },
       {
         "matcher": "Bash|PowerShell",
         "hooks": [
@@ -99,6 +84,11 @@
             "type": "command",
             "command": "python3 ${CLAUDE_PLUGIN_ROOT}/hooks/blocking/code_verifier_spawn_preflight_gate.py",
             "timeout": 30
+          },
+          {
+            "type": "command",
+            "command": "python3 ${CLAUDE_PLUGIN_ROOT}/hooks/blocking/fable_spawn_gate.py",
+            "timeout": 10
           }
         ]
       },
@@ -248,7 +238,7 @@
           {
             "type": "command",
             "command": "python3 ${CLAUDE_PLUGIN_ROOT}/hooks/observability/session_file_edit_tracker.py",
-            "timeout": 10
+            "timeout": 30
           }
         ]
       },
@@ -258,7 +248,7 @@
           {
             "type": "command",
             "command": "python3 ${CLAUDE_PLUGIN_ROOT}/hooks/workflow/investigation_tracker_reset.py",
-            "timeout": 10
+            "timeout": 30
           }
         ]
       },
@@ -268,7 +258,7 @@
           {
             "type": "command",
             "command": "python3 ${CLAUDE_PLUGIN_ROOT}/hooks/blocking/gh_pr_author_restore.py",
-            "timeout": 20
+            "timeout": 60
           }
         ]
       }

package/hooks/hooks_constants/CLAUDE.md

@@ -32,6 +32,7 @@ Shared constant modules imported by hooks throughout the `hooks/` tree. Each fil
 | `duplicate_rmtree_helper_blocker_constants.py` | Sanctioned Windows-safe rmtree helper names, the definition pattern, and the exempt-path set for the duplicate-rmtree-helper blocker |
 | `dynamic_stderr_handler.py` | `DynamicStderrHandler` — a logging handler that resolves `sys.stderr` at emit time (for testability) |
 | `eli11_reply_enforcer_constants.py` | Reply-shape thresholds (word cap, enforced word floor, bullet cap, lead-line window, per-line word cap, over-packed line cap), the `Long form:` escape prefix, the bullet / numbered-step / table-row / link-target / word patterns, the imperative instruction verbs, and the user-facing notice for the ELI11 reply-shape Stop hook |
+| `fable_spawn_gate_constants.py` | The spawn tool-name set, the fable model alias and the model-id segment split pattern, the `FABLE-SPAWN-AUTHORIZED` authorization token, the advisor-protocol document path, payload field names, the deny message, and the deny `additionalContext` recovery text for the fable-tier spawn gate |
 | `gh_pr_author_swap_constants.py` | Constants for the PR-author swap enforcement hooks |
 | `hardcoded_user_path_constants.py` | Patterns for detecting hardcoded home-directory paths |
 | `harness_scratchpad_constants.py` | Fixed path components (`claude` / `claude-` user-directory name and prefix, `scratchpad` leaf name), the PreToolUse session-id payload key, and the `CLAUDE_CODE_SESSION_ID` environment variable name that the code-rules and TDD gates use to recognize an existing harness session scratchpad directory |
@@ -53,6 +54,7 @@ Shared constant modules imported by hooks throughout the `hooks/` tree. Each fil
 | `paired_test_coverage_constants.py` | Test-directory name, stem-test filename affixes, test-file globs, exempt public-function names, scan budget, coverage threshold, and guidance text for the public-function paired-test coverage check |
 | `path_rewriter_constants.py` | Path rewriting patterns for the Everything-search path rewriter |
 | `pii_prevention_constants.py` | Patterns, allowlists, path exemptions, and deny-message text for `pii_prevention_blocker` |
+| `piped_pytest_blocker_constants.py` | Bash tool name, pytest program basenames and the python-interpreter basename pattern, the pipe and segment-reset operator token sets, and the deny message for the piped-pytest blocker |
 | `plain_language_blocker_constants.py` | The list of heavy words and their everyday replacements |
 | `pr_converge_bugteam_enforcer_constants.py` | State keys and timing config for the bugteam-parallel enforcer |
 | `pr_converge_bugteam_enforcer_state.py` | State-file helpers for the bugteam enforcer |

package/hooks/hooks_constants/bash_pre_tool_use_dispatcher_constants.py

@@ -57,6 +57,7 @@ ALL_BASH_HOSTED_HOOK_ENTRIES: tuple[BashHostedHookEntry, ...] = (
     BashHostedHookEntry("blocking/destructive_command_blocker.py", ALL_BASH_ONLY_TOOL_NAMES),
     BashHostedHookEntry("blocking/gh_body_arg_blocker.py", ALL_BASH_ONLY_TOOL_NAMES),
     BashHostedHookEntry("blocking/shell_substitution_blocker.py", ALL_BASH_ONLY_TOOL_NAMES),
+    BashHostedHookEntry("blocking/piped_pytest_blocker.py", ALL_BASH_ONLY_TOOL_NAMES),
     BashHostedHookEntry(
         "blocking/unscoped_search_blocker.py", ALL_BASH_AND_POWERSHELL_TOOL_NAMES
     ),

package/hooks/hooks_constants/code_rules_path_utils_constants.py

@@ -24,6 +24,7 @@ ALL_CONFIG_DIRECTORY_NAMES = frozenset(
         "usage_pause_constants",
         "prototype_scripts_constants",
         "codex_review_scripts_constants",
+        "e_code_review_scripts_constants",
         "dev_env_scripts_constants",
         "fresh_branch_scripts_constants",
     }

package/hooks/hooks_constants/fable_spawn_gate_constants.py

@@ -0,0 +1,62 @@
+"""Constants for the fable-tier subagent spawn gate.
+
+The gate denies an ``Agent`` or ``Task`` spawn at the fable tier whose
+``prompt`` lacks ``FABLE_SPAWN_AUTHORIZATION_MARKER``. ``DENY_REASON`` points
+at the protocol document rather than quoting the token, so pasting a denial
+into a retry prompt authorizes nothing.
+``MODEL_SEGMENT_SPLIT_PATTERN`` finds that tier in a full model id too::
+
+    fable           -> ['fable']                  flag: fable tier
+    claude-fable-5  -> ['claude', 'fable', '5']   flag: fable tier
+    claude-sonnet-4 -> ['claude', 'sonnet', '4']  ok:   another tier
+
+Every literal the gate body reads lives here. ``AGENT_TOOL_NAME`` and
+``TASK_TOOL_NAME`` come from the sibling spawn-gate constants, so the spawn
+gates share one source for both tool names.
+"""
+
+from __future__ import annotations
+
+import re
+
+from hooks_constants.code_verifier_spawn_preflight_gate_constants import TASK_TOOL_NAME
+from hooks_constants.pr_converge_bugteam_enforcer_constants import AGENT_TOOL_NAME
+
+ALL_SPAWN_TOOL_NAMES: frozenset[str] = frozenset({AGENT_TOOL_NAME, TASK_TOOL_NAME})
+
+FABLE_MODEL_ALIAS: str = "fable"
+MODEL_SEGMENT_SPLIT_PATTERN: re.Pattern[str] = re.compile(r"[^a-z0-9]+")
+FABLE_SPAWN_AUTHORIZATION_MARKER: str = "FABLE-SPAWN-AUTHORIZED"
+ADVISOR_PROTOCOL_DOCUMENT_PATH: str = "_shared/advisor/advisor-protocol.md"
+
+TOOL_NAME_FIELD_NAME: str = "tool_name"
+TOOL_INPUT_FIELD_NAME: str = "tool_input"
+MODEL_FIELD_NAME: str = "model"
+PROMPT_FIELD_NAME: str = "prompt"
+
+CALLING_HOOK_NAME: str = "fable_spawn_gate.py"
+HOOK_EVENT_NAME: str = "PreToolUse"
+
+DENY_REASON: str = (
+    "BLOCKED [fable-spawn-gate]: this subagent spawn names the fable tier in "
+    "its model field and carries no authorization marker. To authorize a "
+    f"fable bind, put the token named in {ADVISOR_PROTOCOL_DOCUMENT_PATH} as "
+    "plain text in the spawn prompt (substring match). Otherwise set model "
+    "to opus, sonnet, or haiku. The gate checks only model tier and marker "
+    "presence — it does not verify which session placed the token."
+)
+
+DENY_ADDITIONAL_CONTEXT: str = (
+    "[fable-spawn-gate] This Agent/Task spawn was denied: the model field "
+    "names the fable tier and the spawn prompt carries no authorization "
+    "marker. Preferred recovery: re-spawn at model opus, or an "
+    "opus-equivalent tier (sonnet/haiku when opus is unavailable) — those "
+    "tiers need no marker. Authorized fable bind only: put the token named "
+    f"in {ADVISOR_PROTOCOL_DOCUMENT_PATH} as plain text in the spawn prompt "
+    "(substring match), then retry. The gate checks only model tier and "
+    "marker presence. Do not paste this denial into a retry prompt — it "
+    "does not authorize the spawn."
+)
+
+DENY_PREVIEW_TEMPLATE: str = "model={model_text} marker_present=False"
+MAXIMUM_PREVIEW_MODEL_LENGTH: int = 40

package/hooks/hooks_constants/piped_pytest_blocker_constants.py

@@ -0,0 +1,360 @@
+"""Constants for the piped-pytest PreToolUse Bash blocker.
+
+Holds the tool names, the pytest program basenames and the python-interpreter
+basename pattern, the module-run flag and module name, the pipe and
+segment-reset operator token sets, the line-continuation and physical-line
+patterns, the heredoc-opener pattern that marks a script body, the
+comment-start pattern that ends a line early, the parenthesis-group counters
+that join a multi-line subshell, the group-closing reserved words a pipe reads
+a group's status through, the body-introducing reserved words that stand ahead
+of the command whose status a compound reports, the single characters the hot
+path tests before it parses, the option-token pattern that separates a wrapper's
+flags from its first operand, the wrapper commands whose run passes through to
+the program behind them, the separator that rejoins a wrapper's argument
+tokens, the empty commenter set that leaves ``#`` to the comment-start pattern,
+the quote characters stripped before a basename read, and the deny message.
+Segment helpers come from ``shell_command_segments.py``.
+
+Two wrapper shapes reach the program behind them differently. ``sudo`` and
+``uvx`` take their own option flags and then the command, so the step-over drops
+the flags. ``uv``, ``poetry``, ``pipenv``, ``pdm``, ``hatch``, ``rye``, and
+``coverage`` take the literal ``run`` subcommand first, so the step-over reads
+that word and passes only when it is there — ``uv sync`` and ``coverage report``
+keep the wrapper as its own program. ``uv`` spells the same pass-through as
+``uv tool run`` too, so ``TOOL_SUBCOMMAND_NAME`` names the word the step-over
+reads before it looks for ``run``. A ``run`` subcommand takes its own flags too,
+so the step-over drops those before it reads the program.
+
+An option that takes a separate value swallows the token after it, so
+``sudo -u someone pytest`` runs pytest while ``uv run --with pytest mypy .``
+runs mypy. ``ALL_VALUE_TAKING_WRAPPER_OPTION_FLAGS`` names those flags so the
+operand scan reads past the value rather than mistaking it for the program, and
+``ALL_VALUE_TAKING_SHELL_OPTION_FLAGS`` does the same for the shells that run a
+command string, so the ``-c`` behind ``bash -o pipefail`` stays visible. POSIX
+lets short options cluster, and a cluster's value is the next token only when
+the value-taking letter ends the cluster — ``sudo -nu ci`` takes ``ci`` while
+``sudo -nuci`` carries the value glued on. ``SHORT_OPTION_CLUSTER_PATTERN``
+marks the tokens that walk letter by letter for that reading.
+``--`` ends an option list outright: every token after it is an operand however
+it is spelled, so ``bash -- -c script`` runs a script named ``-c`` rather than a
+command string.
+
+A POSIX shell reads ``-c`` inside a cluster as well, so ``bash -euc 'pytest'``
+runs the command string the same way ``bash -c 'pytest'`` does.
+``ALL_CLUSTERED_STRING_EXEC_OPTION_LETTERS`` names the letters that carry that
+reading, and ``ALL_SHORT_OPTION_CLUSTERING_SHELL_BASENAMES`` limits it to the
+shells that cluster: PowerShell spells its options as words, where the ``c`` in
+``-NonInteractive`` is a letter of a name rather than an option of its own. The
+letter check reads the token in its own case, because ``-C`` is bash's noclobber
+switch while ``-c`` takes the command string.
+
+A shell ends a pipeable compound command with a reserved word as well as with
+``)`` or ``}``: ``fi``, ``done``, and ``esac``. ``ALL_GROUP_CLOSE_TOKENS`` names
+all five, so a pipe after one steps back to the command whose exit status the
+compound reports. The body of such a compound opens with a reserved word of its
+own — ``then``, ``do``, or ``else`` — which stands ahead of the command rather
+than being part of it, so ``ALL_COMPOUND_BODY_INTRODUCER_TOKENS`` names the
+words a status read drops off the front. Both sets match a whole token only, so
+``ls done`` and ``echo fi`` name a path and a word rather than a keyword.
+
+Such a compound reports the status of whichever branch ran, not of its last
+branch alone, so ``if x; then pytest; else echo skip; fi`` exits with pytest's
+code whenever ``x`` succeeds. ``ALL_BRANCH_CONTINUATION_TOKENS`` names ``else``
+and ``elif``, the words that open the next branch and so mark the command
+before them as the one its own branch ends on.
+
+A redirection binds to the command it follows rather than being part of it, so
+``fi 2>&1`` and ``done < list`` still close their compound. Reading the closer
+past one means dropping the redirection operator together with the file
+descriptor written ahead of it, which ``FILE_DESCRIPTOR_TOKEN_PATTERN`` marks —
+``2>&1`` lexes as ``2``, ``>&``, ``1``.
+
+An interpreter takes options of its own before its first operand, and a few of
+them carry a separate value: ``ALL_VALUE_TAKING_INTERPRETER_OPTION_FLAGS`` names
+those, so ``python -X dev -m pytest`` reads the ``-m`` behind the value while
+``python myscript.py -m pytest`` reads the script as the operand that ends the
+options. The set covers PyPy's ``--jit`` as well as CPython's own, because the
+interpreter pattern takes ``pypy3`` and an unnamed value-taking flag would read
+its value as the operand that ends the options.
+
+``PIPE_CHARACTER``, ``COMMENT_START_CHARACTER``, and
+``HEREDOC_OPENER_OPERATOR`` are the substrings the hot path tests before it does
+the matching parse. Every pipe operator spelling — ``|`` and ``|&`` — carries
+``PIPE_CHARACTER``, and no transform in the blocker inserts one, so a command
+without it can hold no violation.
+
+A heredoc delimiter is any shell word, so the opener pattern takes one written
+bare, quoted, or backslash-escaped (``<<\\EOF`` quotes the delimiter the way
+``<<'EOF'`` does). ``<<<`` is a here-string rather than a heredoc, so the
+pattern refuses to read one as an opener and leave the lines below it unread.
+The opener also reports its own ``-``, because ``<<`` closes on a line spelling
+the delimiter exactly while ``<<-`` closes on one carrying leading tabs.
+
+The string-executing shell basenames and command flags start from the shared
+``unscoped_search_blocker_constants.py`` sets and add the Windows command shell
+(``cmd /c "…"``) on top, locally. Widening the shared sets themselves would hand
+``cmd`` unwrapping to ``unscoped_search_blocker`` as a side effect of a
+piped-pytest fix, so the addition stays in this module and that blocker keeps
+its current behavior.
+
+The operator sets partition ``ALL_SHELL_CONTROL_OPERATOR_TOKENS``. That
+derivation covers the operator inventory only; quote-awareness stays local to
+the blocker's own lexer.
+"""
+
+from __future__ import annotations
+
+import re
+
+from hooks_constants.shell_command_segments import ALL_SHELL_CONTROL_OPERATOR_TOKENS
+from hooks_constants.unscoped_search_blocker_constants import (
+    ALL_STRING_EXEC_COMMAND_FLAGS as _ALL_SHARED_STRING_EXEC_COMMAND_FLAGS,
+)
+from hooks_constants.unscoped_search_blocker_constants import (
+    ALL_STRING_EXECUTING_SHELL_BASENAMES as _ALL_SHARED_STRING_EXECUTING_SHELL_BASENAMES,
+)
+
+__all__ = [
+    "BASH_TOOL_NAME",
+    "ALL_SUPPORTED_TOOL_NAMES",
+    "ALL_PYTEST_PROGRAM_BASENAMES",
+    "PYTHON_INTERPRETER_BASENAME_PATTERN",
+    "MODULE_RUN_FLAG",
+    "PYTEST_MODULE_NAME",
+    "ALL_PIPE_OPERATOR_TOKENS",
+    "ALL_SEGMENT_RESET_OPERATOR_TOKENS",
+    "ALL_OPERATOR_TOKENS_LONGEST_FIRST",
+    "PUNCTUATION_ONLY_TOKEN_PATTERN",
+    "ALL_REDIRECTION_SUFFIX_CHARACTERS",
+    "ALL_STRING_EXECUTING_SHELL_BASENAMES",
+    "ALL_STRING_EXEC_COMMAND_FLAGS",
+    "ALL_CLUSTERED_STRING_EXEC_OPTION_LETTERS",
+    "ALL_SHORT_OPTION_CLUSTERING_SHELL_BASENAMES",
+    "COMMAND_OPTION_TOKEN_PATTERN",
+    "SHORT_OPTION_CLUSTER_PATTERN",
+    "SHORT_OPTION_PREFIX",
+    "END_OF_OPTIONS_TOKEN",
+    "ALL_VALUE_TAKING_WRAPPER_OPTION_FLAGS",
+    "ALL_VALUE_TAKING_SHELL_OPTION_FLAGS",
+    "ALL_VALUE_TAKING_INTERPRETER_OPTION_FLAGS",
+    "ALL_FLAG_TAKING_WRAPPER_COMMANDS",
+    "ALL_RUN_SUBCOMMAND_WRAPPER_COMMANDS",
+    "RUN_SUBCOMMAND_NAME",
+    "TOOL_SUBCOMMAND_NAME",
+    "WRAPPED_COMMAND_TOKEN_JOIN",
+    "DISABLED_LEXER_COMMENTERS",
+    "LINE_CONTINUATION_PATTERN",
+    "LINE_CONTINUATION_JOIN",
+    "COMMAND_LINE_SPLIT_PATTERN",
+    "QUOTED_REGION_PATTERN",
+    "QUOTED_REGION_REPLACEMENT",
+    "COMMENT_START_SCAN_PATTERN",
+    "COMMENT_START_GROUP",
+    "PIPE_CHARACTER",
+    "COMMENT_START_CHARACTER",
+    "HEREDOC_OPENER_OPERATOR",
+    "GROUP_OPEN_CHARACTER",
+    "GROUP_CLOSE_CHARACTER",
+    "ALL_GROUP_CLOSE_TOKENS",
+    "ALL_COMPOUND_BODY_INTRODUCER_TOKENS",
+    "ALL_BRANCH_CONTINUATION_TOKENS",
+    "FILE_DESCRIPTOR_TOKEN_PATTERN",
+    "PAREN_GROUP_LINE_JOIN",
+    "CLOSED_GROUP_DEPTH",
+    "HEREDOC_OPENER_PATTERN",
+    "HEREDOC_TAB_STRIP_GROUP",
+    "HEREDOC_QUOTE_GROUP",
+    "HEREDOC_TERMINATOR_GROUP",
+    "HEREDOC_TAB_STRIP_MARKER",
+    "HEREDOC_STRIPPED_INDENT_CHARACTERS",
+    "NO_FOLLOWING_OPERATOR",
+    "ALL_QUOTE_CHARACTERS",
+    "HOOK_EVENT_NAME",
+    "DENY_DECISION",
+    "CALLING_HOOK_NAME",
+    "CORRECTIVE_MESSAGE",
+]
+
+BASH_TOOL_NAME = "Bash"
+ALL_SUPPORTED_TOOL_NAMES: frozenset[str] = frozenset({BASH_TOOL_NAME})
+
+ALL_PYTEST_PROGRAM_BASENAMES: frozenset[str] = frozenset(
+    {
+        "pytest",
+        "pytest.exe",
+        "pytest.bat",
+        "pytest.cmd",
+        "py.test",
+        "py.test.exe",
+        "py.test.bat",
+        "py.test.cmd",
+    }
+)
+PYTHON_INTERPRETER_BASENAME_PATTERN = re.compile(
+    r"^(?:(?:python|pypy)w?[0-9._]*t?|pyw?)(?:\.exe|\.bat|\.cmd)?$"
+)
+MODULE_RUN_FLAG = "-m"
+PYTEST_MODULE_NAME = "pytest"
+
+_ALL_PIPE_OPERATOR_SPELLINGS: frozenset[str] = frozenset({"|", "|&"})
+_ALL_LOCAL_SEGMENT_RESET_EXTRAS: frozenset[str] = frozenset({";;", "(", "{"})
+
+ALL_PIPE_OPERATOR_TOKENS: frozenset[str] = (
+    ALL_SHELL_CONTROL_OPERATOR_TOKENS & _ALL_PIPE_OPERATOR_SPELLINGS
+)
+ALL_SEGMENT_RESET_OPERATOR_TOKENS: frozenset[str] = (
+    ALL_SHELL_CONTROL_OPERATOR_TOKENS - ALL_PIPE_OPERATOR_TOKENS
+) | _ALL_LOCAL_SEGMENT_RESET_EXTRAS
+
+ALL_OPERATOR_TOKENS_LONGEST_FIRST: tuple[str, ...] = tuple(
+    sorted(
+        ALL_PIPE_OPERATOR_TOKENS | ALL_SEGMENT_RESET_OPERATOR_TOKENS,
+        key=len,
+        reverse=True,
+    )
+)
+PUNCTUATION_ONLY_TOKEN_PATTERN = re.compile(r"[();<>|&]+")
+ALL_REDIRECTION_SUFFIX_CHARACTERS: tuple[str, ...] = ("<", ">")
+
+_ALL_WINDOWS_COMMAND_SHELL_BASENAMES: frozenset[str] = frozenset({"cmd", "cmd.exe"})
+_ALL_WINDOWS_COMMAND_SHELL_FLAGS: frozenset[str] = frozenset({"/c", "/k"})
+ALL_STRING_EXECUTING_SHELL_BASENAMES: frozenset[str] = (
+    _ALL_SHARED_STRING_EXECUTING_SHELL_BASENAMES | _ALL_WINDOWS_COMMAND_SHELL_BASENAMES
+)
+ALL_STRING_EXEC_COMMAND_FLAGS: frozenset[str] = (
+    _ALL_SHARED_STRING_EXEC_COMMAND_FLAGS | _ALL_WINDOWS_COMMAND_SHELL_FLAGS
+)
+ALL_CLUSTERED_STRING_EXEC_OPTION_LETTERS: frozenset[str] = frozenset({"c"})
+ALL_SHORT_OPTION_CLUSTERING_SHELL_BASENAMES: frozenset[str] = frozenset(
+    {"bash", "bash.exe", "sh", "sh.exe"}
+)
+COMMAND_OPTION_TOKEN_PATTERN = re.compile(r"^(?:-.*|/[A-Za-z])$")
+SHORT_OPTION_CLUSTER_PATTERN = re.compile(r"-[A-Za-z]{2,}")
+SHORT_OPTION_PREFIX = "-"
+END_OF_OPTIONS_TOKEN = "--"
+ALL_VALUE_TAKING_WRAPPER_OPTION_FLAGS: frozenset[str] = frozenset(
+    {
+        "-C",
+        "-D",
+        "-R",
+        "-T",
+        "-U",
+        "-g",
+        "-h",
+        "-p",
+        "-r",
+        "-t",
+        "-u",
+        "--concurrency",
+        "--context",
+        "--data-file",
+        "--directory",
+        "--env-file",
+        "--extra",
+        "--from",
+        "--group",
+        "--include",
+        "--omit",
+        "--package",
+        "--project",
+        "--python",
+        "--rcfile",
+        "--source",
+        "--user",
+        "--with",
+    }
+)
+ALL_VALUE_TAKING_INTERPRETER_OPTION_FLAGS: frozenset[str] = frozenset(
+    {"-Q", "-W", "-X", "--check-hash-based-pycs", "--jit"}
+)
+ALL_VALUE_TAKING_SHELL_OPTION_FLAGS: frozenset[str] = frozenset(
+    {
+        "-o",
+        "--rcfile",
+        "--init-file",
+        "-configurationname",
+        "-custompipename",
+        "-executionpolicy",
+        "-inputformat",
+        "-outputformat",
+        "-settingsfile",
+        "-version",
+        "-windowstyle",
+        "-workingdirectory",
+    }
+)
+
+ALL_FLAG_TAKING_WRAPPER_COMMANDS: frozenset[str] = frozenset(
+    {"sudo", "sudo.exe", "uvx", "uvx.exe"}
+)
+ALL_RUN_SUBCOMMAND_WRAPPER_COMMANDS: frozenset[str] = frozenset(
+    {
+        "uv",
+        "uv.exe",
+        "poetry",
+        "poetry.exe",
+        "pipenv",
+        "pipenv.exe",
+        "pdm",
+        "pdm.exe",
+        "hatch",
+        "hatch.exe",
+        "rye",
+        "rye.exe",
+        "coverage",
+        "coverage.exe",
+    }
+)
+RUN_SUBCOMMAND_NAME = "run"
+TOOL_SUBCOMMAND_NAME = "tool"
+WRAPPED_COMMAND_TOKEN_JOIN = " "
+DISABLED_LEXER_COMMENTERS = ""
+
+LINE_CONTINUATION_PATTERN = re.compile(r"\\(?:\r\n|[\r\n])")
+LINE_CONTINUATION_JOIN = ""
+COMMAND_LINE_SPLIT_PATTERN = re.compile(r"[\n\r]+")
+QUOTED_REGION_PATTERN = re.compile(r"'[^']*'|\"(?:\\.|[^\"\\])*\"|\\.")
+QUOTED_REGION_REPLACEMENT = ""
+PIPE_CHARACTER = "|"
+COMMENT_START_CHARACTER = "#"
+HEREDOC_OPENER_OPERATOR = "<<"
+COMMENT_START_GROUP = "comment_start"
+COMMENT_START_SCAN_PATTERN = re.compile(
+    rf"'[^']*'|\"(?:\\.|[^\"\\])*\"|\\.|(?P<{COMMENT_START_GROUP}>(?<![^\s])#)"
+)
+GROUP_OPEN_CHARACTER = "("
+GROUP_CLOSE_CHARACTER = ")"
+_BRACE_GROUP_CLOSE_TOKEN = "}"
+_ALL_COMPOUND_CLOSE_KEYWORDS: frozenset[str] = frozenset({"fi", "done", "esac"})
+ALL_GROUP_CLOSE_TOKENS: frozenset[str] = (
+    frozenset({GROUP_CLOSE_CHARACTER, _BRACE_GROUP_CLOSE_TOKEN}) | _ALL_COMPOUND_CLOSE_KEYWORDS
+)
+ALL_COMPOUND_BODY_INTRODUCER_TOKENS: frozenset[str] = frozenset({"then", "do", "else"})
+ALL_BRANCH_CONTINUATION_TOKENS: frozenset[str] = frozenset({"else", "elif"})
+FILE_DESCRIPTOR_TOKEN_PATTERN = re.compile(r"[0-9]+")
+PAREN_GROUP_LINE_JOIN = " "
+CLOSED_GROUP_DEPTH = 0
+_HEREDOC_DELIMITER_CHARACTER_CLASS = r"[^\s'\"<>|&;()`$\\]"
+HEREDOC_TAB_STRIP_GROUP = "heredoc_tab_strip"
+HEREDOC_QUOTE_GROUP = "heredoc_quote"
+HEREDOC_TERMINATOR_GROUP = "heredoc_terminator"
+HEREDOC_OPENER_PATTERN = re.compile(
+    rf"(?<!<)<<(?!<)(?P<{HEREDOC_TAB_STRIP_GROUP}>-?)\s*(?P<{HEREDOC_QUOTE_GROUP}>['\"]?)\\?"
+    rf"(?P<{HEREDOC_TERMINATOR_GROUP}>{_HEREDOC_DELIMITER_CHARACTER_CLASS}+)"
+    rf"(?P={HEREDOC_QUOTE_GROUP})"
+)
+HEREDOC_TAB_STRIP_MARKER = "-"
+HEREDOC_STRIPPED_INDENT_CHARACTERS = "\t"
+NO_FOLLOWING_OPERATOR = ""
+ALL_QUOTE_CHARACTERS = "\"'"
+
+HOOK_EVENT_NAME = "PreToolUse"
+DENY_DECISION = "deny"
+CALLING_HOOK_NAME = "piped_pytest_blocker.py"
+
+CORRECTIVE_MESSAGE = (
+    "Piped pytest run blocked. Run pytest alone; the pipe makes the tool report "
+    "the downstream command's exit code, so a failing suite reads as a pass. "
+    "When you need the output on disk, redirect it "
+    "(`python -m pytest tests > run.log 2>&1`) and read the file."
+)

package/hooks/hooks_constants/plain_language_blocker_constants.py

@@ -1,4 +1,25 @@
-"""Configuration constants for the plain_language_blocker PreToolUse hook."""
+"""Configuration constants for the plain_language_blocker PreToolUse hook.
+
+::
+
+    ALL_CHAT_DETAIL_MARKERS
+        ok:   "Which gate should run first?"
+        flag: "Which gate should run first?\\n- write\\n- commit"
+    INLINE_CODE_SPAN_PATTERN
+        ok:   "Should we pass `--dry-run` here?" -> one word toward the caps
+    ALL_LINE_ENDING_REPLACEMENTS
+        flag: a blank line spelled "\\r\\n\\r\\n" reads as a paragraph break
+    MAXIMUM_OPTION_DESCRIPTION_WORD_COUNT
+        ok:   "Runs on every write."
+        flag: a 30-word paragraph of tradeoffs
+
+Holds the heavy words and their everyday replacements, the prose-region
+strippers the word scan runs first, and the lean-question-block tunables: the
+block-level chat-detail markers that belong in chat text, the line-ending
+spellings normalized before those markers run, the inline-code span the length
+counts collapse to one word, and the sentence and word caps a question and an
+option description each answer to.
+"""
 
 from __future__ import annotations
 
@@ -298,3 +319,45 @@ USER_FACING_PLAIN_LANGUAGE_NOTICE: str = (
     "Plain-language check: replace each flagged formal word with the simpler "
     "word named in the reason."
 )
+
+ALL_CHAT_DETAIL_MARKERS: tuple[tuple[re.Pattern[str], str], ...] = (
+    (re.compile(r"^[ \t]*```", re.MULTILINE), "a fenced code block"),
+    (re.compile(r"^[ \t]*#{1,6}[ \t]+\S", re.MULTILINE), "a heading"),
+    (re.compile(r"^[ \t]*\|.*\|[ \t]*$", re.MULTILINE), "a table row"),
+    (
+        re.compile(r"^[ \t]*(?:[-*+][ \t]+|\d{1,2}[.)][ \t]+)\S", re.MULTILINE),
+        "a bullet or numbered list marker",
+    ),
+    (re.compile(r"\n[ \t]*\n"), "more than one paragraph"),
+)
+
+INLINE_CODE_SPAN_PATTERN: re.Pattern[str] = re.compile(r"`[^`\n]+`")
+INLINE_CODE_PLACEHOLDER: str = "code"
+
+ALL_LINE_ENDING_REPLACEMENTS: tuple[tuple[str, str], ...] = (
+    ("\r\n", "\n"),
+    ("\r", "\n"),
+)
+
+SENTENCE_BOUNDARY_PATTERN: re.Pattern[str] = re.compile(r"[.!?]+(?=\s+[A-Z]|\s*$)")
+COUNTABLE_WORD_PATTERN: re.Pattern[str] = re.compile(r"\S*[A-Za-z0-9]\S*")
+
+MAXIMUM_QUESTION_SENTENCE_COUNT: int = 2
+MAXIMUM_QUESTION_WORD_COUNT: int = 40
+MAXIMUM_OPTION_DESCRIPTION_SENTENCE_COUNT: int = 1
+MAXIMUM_OPTION_DESCRIPTION_WORD_COUNT: int = 15
+
+QUESTION_SURFACE_NAME: str = "the question"
+OPTION_DESCRIPTION_SURFACE_NAME: str = "an option description"
+
+LEAN_QUESTION_BLOCK_PREFIX: str = "BLOCKED: [LEAN_QUESTION] Question block carries chat detail -- "
+LEAN_QUESTION_VIOLATION_SEPARATOR: str = "; "
+LEAN_QUESTION_BLOCK_GUIDANCE: str = (
+    "AskUserQuestion renders as one plain text block. Print the plan, the counts, "
+    "and the tradeoffs in chat text before the call, keep the question block to a "
+    "lean question and short options, and reach for an inline visualizer tool when "
+    "a choice needs formatting."
+)
+USER_FACING_LEAN_QUESTION_NOTICE: str = (
+    "Question-block check: move the detail into chat and ask a short question."
+)

package/hooks/hooks_constants/pre_tool_use_dispatcher_constants.py

@@ -162,4 +162,14 @@ ALL_HOSTED_HOOK_ENTRIES: tuple[HostedHookEntry, ...] = (
         applicable_tool_names=ALL_WRITE_EDIT_MULTI_EDIT_TOOL_NAMES,
         native_module_name=PLAIN_LANGUAGE_BLOCKER_MODULE_NAME,
     ),
+    HostedHookEntry(
+        script_relative_path="advisory/refactor_guard.py",
+        applicable_tool_names=frozenset({EDIT_TOOL_NAME}),
+        is_blocking=False,
+    ),
+    HostedHookEntry(
+        script_relative_path="advisory/migration_safety_advisor.py",
+        applicable_tool_names=frozenset({EDIT_TOOL_NAME}),
+        is_blocking=False,
+    ),
 )

package/hooks/hooks_constants/shell_command_segments.py

@@ -22,7 +22,7 @@ __all__ = [
 ]
 
 ALL_LAUNCHER_WRAPPER_COMMANDS: frozenset[str] = frozenset(
-    {"timeout", "nohup", "nice", "stdbuf", "setsid", "env"}
+    {"timeout", "nohup", "nice", "stdbuf", "setsid", "env", "time"}
 )
 ALL_SHELL_CONTROL_OPERATOR_TOKENS: frozenset[str] = frozenset(
     {"&&", "||", ";", "|", "&", "|&"}

package/hooks/hooks_constants/test_bash_pre_tool_use_dispatcher_constants.py

@@ -26,6 +26,7 @@ _EXPECTED_BASH_ORDER = (
     "blocking/destructive_command_blocker.py",
     "blocking/gh_body_arg_blocker.py",
     "blocking/shell_substitution_blocker.py",
+    "blocking/piped_pytest_blocker.py",
     "blocking/unscoped_search_blocker.py",
     "blocking/nas_ssh_binary_enforcer.py",
     "blocking/volatile_path_in_post_blocker.py",

package/hooks/hooks_constants/test_pre_tool_use_dispatcher_constants.py

@@ -87,6 +87,33 @@ def test_blocking_hook_crash_deny_reason_surfaces_the_constant() -> None:
     assert BLOCKING_CRASH_DENY_REASON in decision.all_deny_reasons
 
 
+def test_refactor_guard_is_hosted_as_an_edit_only_advisory_hook() -> None:
+    entry = _entry_for("advisory/refactor_guard.py")
+    assert entry is not None, (
+        "refactor_guard must be hosted by the dispatcher rather than spawning its own process"
+    )
+    assert entry.applicable_tool_names == frozenset({EDIT_TOOL_NAME})
+    assert entry.is_blocking is False
+
+
+def test_migration_safety_advisor_is_hosted_as_an_edit_only_advisory_hook() -> None:
+    entry = _entry_for("advisory/migration_safety_advisor.py")
+    assert entry is not None, (
+        "migration_safety_advisor must be hosted by the dispatcher rather than "
+        "spawning its own process"
+    )
+    assert entry.applicable_tool_names == frozenset({EDIT_TOOL_NAME})
+    assert entry.is_blocking is False
+
+
+def test_every_hosted_script_path_exists_under_the_hooks_root() -> None:
+    for each_entry in ALL_HOSTED_HOOK_ENTRIES:
+        hosted_script_path = _HOOKS_ROOT / each_entry.script_relative_path
+        assert hosted_script_path.is_file(), (
+            f"{each_entry.script_relative_path} is on the roster but missing from the hooks tree"
+        )
+
+
 def test_every_native_module_exposes_a_callable_evaluate() -> None:
     nativized_entries = [
         each_entry