claude-dev-env 2.3.0 → 2.5.0

package/hooks/blocking/volatile_path_in_post_blocker.py

@@ -18,6 +18,15 @@ and scanned, since that content is what gets embedded in the post). The ``gh``
 command is tokenized with ``shlex.split`` and the ``gh`` word must be the first
 command token, so a ``gh pr comment`` that only appears as quoted data inside
 another argument never classifies.
+
+The marker scan runs in two tiers over the normalized body. Five bare markers
+— the system temp locations and env tokens — match as a plain substring
+anywhere. Two dot-relative directory markers, ``.claude-editor/jobs/`` and
+``.claude/worktrees/``, match when either a slash sits immediately before the
+marker or a path segment follows it. A machine-local absolute path
+(``~/.claude/worktrees/wt/f.py``) and a relative path that names a child
+(``see .claude/worktrees/wt-1/notes.md``) both count; a bare directory-name
+mention with neither anchor posts cleanly.
 """
 
 import json
@@ -42,30 +51,79 @@ from blocking._gh_body_arg_utils import (  # noqa: E402
 )
 from hooks_constants.hook_block_logger import log_hook_block  # noqa: E402
 from hooks_constants.volatile_path_in_post_blocker_constants import (  # noqa: E402
+    ALL_BARE_VOLATILE_PATH_MARKERS,
     ALL_GH_POST_SUBCOMMANDS,
     ALL_MCP_BODY_PARAM_NAMES,
-    ALL_VOLATILE_PATH_MARKERS,
+    ALL_PATH_ANCHORED_VOLATILE_PATH_MARKERS,
     BASH_TOOL_NAME,
     BODY_FILE_ENCODING,
     CORRECTIVE_MESSAGE,
     GH_COMMAND_NAME,
     MCP_GITHUB_TOOL_PREFIX,
     MINIMUM_POST_SUBCOMMAND_TOKEN_COUNT,
+    PATH_ANCHOR_CHARACTER,
+    PATH_SEGMENT_START_CHARACTERS,
     TOKEN_JOIN_SEPARATOR,
 )
 
 
+def _character_starts_path_segment(character: str) -> bool:
+    """Return whether a character can open a path segment after a marker."""
+    return bool(character) and (
+        character.isalnum() or character in PATH_SEGMENT_START_CHARACTERS
+    )
+
+
+def _text_has_anchored_marker(normalized_text: str, marker: str) -> bool:
+    """Return whether the marker appears as part of a path.
+
+    A match counts when either a slash sits immediately before the marker or a
+    path segment follows it. Every occurrence is scanned, so a bare directory
+    mention earlier in the text never masks a path occurrence later::
+
+        ok:   ".claude/worktrees/ is the manifest key"      -> False
+        flag: "path c:/users/me/.claude/worktrees/wt/f.py"  -> True
+        flag: "see .claude/worktrees/wt-1/notes.md"         -> True
+
+    Args:
+        normalized_text: The body text with backslashes folded to forward
+            slashes and lowercased.
+        marker: A dot-relative directory marker to search for.
+
+    Returns:
+        True when at least one occurrence is path-anchored.
+    """
+    search_start = 0
+    while True:
+        found_index = normalized_text.find(marker, search_start)
+        if found_index < 0:
+            return False
+        preceding_character = normalized_text[found_index - 1 : found_index]
+        following_index = found_index + len(marker)
+        following_character = normalized_text[following_index : following_index + 1]
+        is_slash_before = preceding_character == PATH_ANCHOR_CHARACTER
+        is_segment_after = _character_starts_path_segment(following_character)
+        if is_slash_before or is_segment_after:
+            return True
+        search_start = found_index + 1
+
+
 def scan_text_for_volatile_marker(text: str) -> str | None:
     """Return the first volatile-path marker found in text, or None.
 
     Backslashes normalize to forward slashes and the text lowercases before the
-    scan, so a marker matches regardless of slash direction or letter case::
+    scan. The two dot-relative directory markers count when either a slash sits
+    immediately before them or a path segment follows them; the five bare
+    markers match anywhere::
 
-        ok:   "See the log table pasted below."        -> None
-        flag: r"C:\\Users\\me\\.claude-editor\\jobs\\x" -> ".claude-editor/jobs/"
+        ok:   "the `.claude/worktrees/` manifest key"    -> None
+        flag: r"C:\\Users\\me\\.claude-editor\\jobs\\x"   -> ".claude-editor/jobs/"
+        flag: "see .claude/worktrees/wt-1/notes.md"       -> ".claude/worktrees/"
+        flag: "saved to %TEMP%\\out.txt"                  -> "%temp%"
 
-    Env-token markers such as ``%TEMP%`` and ``$CLAUDE_JOB_DIR`` match on the
-    same lowercased text.
+    A dot-relative marker with neither a slash before it nor a path segment
+    after it — start of text naming the directory, a quoted config constant,
+    or a placeholder form such as ``.claude/worktrees/<name>`` — posts cleanly.
 
     Args:
         text: The post body text to scan.
@@ -73,8 +131,11 @@ def scan_text_for_volatile_marker(text: str) -> str | None:
     Returns:
         The matched marker string, or None when the text names no volatile path.
     """
-    normalized_text = text.replace("\\", "/").lower()
-    for each_marker in ALL_VOLATILE_PATH_MARKERS:
+    normalized_text = text.replace("\\", PATH_ANCHOR_CHARACTER).lower()
+    for each_marker in ALL_PATH_ANCHORED_VOLATILE_PATH_MARKERS:
+        if _text_has_anchored_marker(normalized_text, each_marker):
+            return each_marker
+    for each_marker in ALL_BARE_VOLATILE_PATH_MARKERS:
         if each_marker in normalized_text:
             return each_marker
     return None

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

@@ -49,6 +49,12 @@ NO_PARSEABLE_STDIN_LINES_MESSAGE: str = (
 )
 NO_PARSEABLE_STDIN_LINES_SENTINEL: str = "__no_parseable_stdin_lines__"
 LOCAL_BRANCH_REFERENCE_PREFIX: str = "refs/heads/"
+CODE_REVIEW_PUSH_GATE_PATH_OVERRIDE_ENV_VAR: str = "CODE_REVIEW_PUSH_GATE_PATH"
+CODE_REVIEW_PUSH_GATE_MODULE_NAME: str = "code_review_push_gate"
+CODE_REVIEW_PUSH_GATE_SCRIPT_FILENAME: str = "code_review_push_gate.py"
+CODE_REVIEW_DENY_REASON_FUNCTION_NAME: str = "deny_reason_for_directory"
+BLOCKING_DIRECTORY_NAME: str = "blocking"
+CODE_REVIEW_STAMP_BLOCK_EXIT_CODE: int = 1
 ALL_PROTECTED_BRANCH_PUSH_NAMES: tuple[str, ...] = ("main", "master")
 PROTECTED_BRANCH_PUSH_BLOCK_EXIT_CODE: int = 1
 PROTECTED_BRANCH_PUSH_BLOCK_MESSAGE: str = (

package/hooks/git-hooks/pre_push.py

@@ -30,6 +30,8 @@ Exit codes:
 
 from __future__ import annotations
 
+import importlib.util
+import os
 import subprocess
 import sys
 from pathlib import Path
@@ -38,6 +40,12 @@ from git_hooks_constants import (
     ALL_PROTECTED_BRANCH_PUSH_NAMES,
     ALL_ZEROS_OBJECT_NAME_CHARACTER,
     BASE_REFERENCE_ARGUMENT,
+    BLOCKING_DIRECTORY_NAME,
+    CODE_REVIEW_DENY_REASON_FUNCTION_NAME,
+    CODE_REVIEW_PUSH_GATE_MODULE_NAME,
+    CODE_REVIEW_PUSH_GATE_PATH_OVERRIDE_ENV_VAR,
+    CODE_REVIEW_PUSH_GATE_SCRIPT_FILENAME,
+    CODE_REVIEW_STAMP_BLOCK_EXIT_CODE,
     DEFAULT_REMOTE_BASE_REFERENCE,
     GATE_INFRASTRUCTURE_FAILURE_EXIT_CODE,
     INVOKE_GATE_FAILURE_MESSAGE,
@@ -158,6 +166,82 @@ def invoke_gate(gate_script_path: Path, base_reference: str) -> int:
     return completion.returncode
 
 
+def resolve_code_review_gate_path() -> tuple[Path, Path | None]:
+    """Return the code-review push gate script path and its exact-allow override.
+
+    The override environment variable, when set, names the only path the trust
+    check accepts; otherwise the gate script resolves to the ``blocking``
+    directory beside this hook's ``git-hooks`` directory, which holds in both
+    the repository layout and the installed ``~/.claude/hooks`` layout.
+
+    Returns:
+        A pair of the resolved gate script path and either the exact override
+        path (override set) or None (trust-root case).
+    """
+    override_path_raw = os.environ.get(
+        CODE_REVIEW_PUSH_GATE_PATH_OVERRIDE_ENV_VAR, ""
+    ).strip()
+    if override_path_raw:
+        exact_override = Path(override_path_raw).resolve()
+        return exact_override, exact_override
+    blocking_directory = Path(__file__).resolve().parent.parent / BLOCKING_DIRECTORY_NAME
+    return blocking_directory / CODE_REVIEW_PUSH_GATE_SCRIPT_FILENAME, None
+
+
+def load_code_review_deny_reason(gate_script_path: Path, work_tree_directory: str) -> str | None:
+    """Import the gate script and read its push deny reason for a work tree.
+
+    Any import or evaluation failure reads as no deny reason.
+
+    Args:
+        gate_script_path: The resolved code-review push gate script path.
+        work_tree_directory: The work tree the push targets.
+
+    Returns:
+        The gate's deny reason when the surface lacks a covering low stamp;
+        None when the gate allows the push or could not be evaluated.
+    """
+    try:
+        gate_specification = importlib.util.spec_from_file_location(
+            CODE_REVIEW_PUSH_GATE_MODULE_NAME, str(gate_script_path)
+        )
+        if gate_specification is None or gate_specification.loader is None:
+            return None
+        gate_module = importlib.util.module_from_spec(gate_specification)
+        gate_specification.loader.exec_module(gate_module)
+        deny_reason_function = getattr(gate_module, CODE_REVIEW_DENY_REASON_FUNCTION_NAME, None)
+        if deny_reason_function is None:
+            return None
+        deny_reason = deny_reason_function(work_tree_directory)
+    except Exception:
+        return None
+    if isinstance(deny_reason, str) and deny_reason:
+        return deny_reason
+    return None
+
+
+def code_review_stamp_block_exit_code() -> int:
+    """Block the push when no clean low code-review stamp covers the surface.
+
+    Runs the gate decision only when the gate script sits at a trusted
+    installed location (or the exact override path). When the gate is absent
+    from a trusted location, the check is skipped and the push is allowed,
+    matching the CODE_RULES gate's fail-open posture.
+
+    Returns:
+        The block exit code when a covering low stamp is missing; 0 when the
+        surface is covered or the gate is not installed at a trusted location.
+    """
+    gate_script_path, exact_allowed_path = resolve_code_review_gate_path()
+    if not is_safe_regular_file(gate_script_path, exact_allowed_path):
+        return 0
+    deny_reason = load_code_review_deny_reason(gate_script_path, os.getcwd())
+    if deny_reason is None:
+        return 0
+    sys.stderr.write(deny_reason + "\n")
+    return CODE_REVIEW_STAMP_BLOCK_EXIT_CODE
+
+
 def main() -> int:
     stdin_read_failure_message = STDIN_READ_FAILURE_MESSAGE
     gate_infrastructure_failure_exit_code = GATE_INFRASTRUCTURE_FAILURE_EXIT_CODE
@@ -191,14 +275,17 @@ def main() -> int:
             pre_push_gate_script_not_found_message.format(path=gate_script_path),
             file=sys.stderr,
         )
-        return 0
+        return code_review_stamp_block_exit_code()
     base_reference = resolve_base_reference_from_stdin(stdin_text)
     if base_reference is None:
         return 0
     if base_reference == no_parseable_stdin_lines_sentinel:
         print(no_parseable_stdin_lines_message, file=sys.stderr)
         return gate_infrastructure_failure_exit_code
-    return invoke_gate(gate_script_path, base_reference)
+    code_rules_exit_code = invoke_gate(gate_script_path, base_reference)
+    if code_rules_exit_code != 0:
+        return code_rules_exit_code
+    return code_review_stamp_block_exit_code()
 
 
 if __name__ == "__main__":

package/hooks/git-hooks/test_pre_push.py

@@ -28,6 +28,12 @@ NON_ZERO_REMOTE_SHA_ONE: str = "1" * 40
 NON_ZERO_REMOTE_SHA_TWO: str = "2" * 40
 
 
+def _isolate_code_review_gate(tmp_path: Path, monkeypatch: pytest.MonkeyPatch) -> None:
+    monkeypatch.setenv(
+        "CODE_REVIEW_PUSH_GATE_PATH", str(tmp_path / "no_code_review_gate.py")
+    )
+
+
 def test_resolve_base_reference_uses_remote_object_when_non_zero() -> None:
     stdin_text = (
         f"refs/heads/feature {NON_ZERO_LOCAL_SHA} refs/heads/feature {NON_ZERO_REMOTE_SHA_ONE}\n"
@@ -73,6 +79,7 @@ def test_main_exits_zero_when_gate_script_missing(
         "CODE_RULES_GATE_PATH",
         str(tmp_path / "does_not_exist.py"),
     )
+    _isolate_code_review_gate(tmp_path, monkeypatch)
     monkeypatch.setattr(sys, "stdin", io.StringIO(""))
 
     exit_code = pre_push.main()
@@ -94,6 +101,7 @@ def test_main_invokes_gate_with_resolved_base_reference(
         encoding="utf-8",
     )
     monkeypatch.setenv("CODE_RULES_GATE_PATH", str(recording_gate_script_path))
+    _isolate_code_review_gate(tmp_path, monkeypatch)
     remote_sha = "9" * 40
     monkeypatch.setattr(
         sys,
@@ -312,6 +320,7 @@ def test_invoke_gate_uses_resolved_path(
     symlink_gate_path.symlink_to(real_gate_path)
     resolved_path = symlink_gate_path.resolve()
     monkeypatch.setenv("CODE_RULES_GATE_PATH", str(symlink_gate_path))
+    _isolate_code_review_gate(tmp_path, monkeypatch)
     monkeypatch.setattr(sys, "stdin", io.StringIO(
         f"refs/heads/feature {NON_ZERO_LOCAL_SHA} refs/heads/feature {NON_ZERO_REMOTE_SHA_ONE}\n"
     ))
@@ -428,6 +437,7 @@ def test_main_allows_main_onto_main_push(
     passing_gate_path = tmp_path / "gate.py"
     passing_gate_path.write_text("import sys\nsys.exit(0)\n", encoding="utf-8")
     monkeypatch.setenv("CODE_RULES_GATE_PATH", str(passing_gate_path))
+    _isolate_code_review_gate(tmp_path, monkeypatch)
     monkeypatch.setattr(
         sys,
         "stdin",
@@ -439,3 +449,121 @@ def test_main_allows_main_onto_main_push(
     exit_code = pre_push.main()
 
     assert exit_code == 0
+
+
+CODE_REVIEW_STUB_BLOCK_REASON: str = "CODE_REVIEW_STUB_BLOCK_REASON"
+
+
+def _write_passing_code_rules_gate(tmp_path: Path, monkeypatch: pytest.MonkeyPatch) -> None:
+    passing_gate_path = tmp_path / "code_rules_gate.py"
+    passing_gate_path.write_text("import sys\nsys.exit(0)\n", encoding="utf-8")
+    monkeypatch.setenv("CODE_RULES_GATE_PATH", str(passing_gate_path))
+    monkeypatch.setattr(
+        sys,
+        "stdin",
+        io.StringIO(
+            f"refs/heads/feature {NON_ZERO_LOCAL_SHA} refs/heads/feature {NON_ZERO_REMOTE_SHA_ONE}\n"
+        ),
+    )
+
+
+def _write_code_review_gate_stub(tmp_path: Path, returned_reason_literal: str) -> Path:
+    stub_gate_path = tmp_path / "code_review_push_gate.py"
+    stub_gate_path.write_text(
+        "def deny_reason_for_directory(target_directory):\n"
+        f"    return {returned_reason_literal}\n",
+        encoding="utf-8",
+    )
+    return stub_gate_path
+
+
+def test_main_blocks_when_code_review_gate_returns_reason(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+    capsys: pytest.CaptureFixture[str],
+) -> None:
+    _write_passing_code_rules_gate(tmp_path, monkeypatch)
+    stub_gate_path = _write_code_review_gate_stub(
+        tmp_path, repr(CODE_REVIEW_STUB_BLOCK_REASON)
+    )
+    monkeypatch.setenv("CODE_REVIEW_PUSH_GATE_PATH", str(stub_gate_path))
+
+    exit_code = pre_push.main()
+
+    assert exit_code == git_hooks_constants.CODE_REVIEW_STAMP_BLOCK_EXIT_CODE
+    captured = capsys.readouterr()
+    assert CODE_REVIEW_STUB_BLOCK_REASON in captured.err
+
+
+def test_main_allows_when_code_review_gate_returns_none(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    _write_passing_code_rules_gate(tmp_path, monkeypatch)
+    stub_gate_path = _write_code_review_gate_stub(tmp_path, "None")
+    monkeypatch.setenv("CODE_REVIEW_PUSH_GATE_PATH", str(stub_gate_path))
+
+    exit_code = pre_push.main()
+
+    assert exit_code == 0
+
+
+def test_main_code_review_check_fails_open_when_gate_module_absent(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    _write_passing_code_rules_gate(tmp_path, monkeypatch)
+    monkeypatch.setenv(
+        "CODE_REVIEW_PUSH_GATE_PATH", str(tmp_path / "does_not_exist.py")
+    )
+
+    exit_code = pre_push.main()
+
+    assert exit_code == 0
+
+
+def test_main_allows_deletion_push_even_when_code_review_gate_would_block(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    passing_gate_path = tmp_path / "code_rules_gate.py"
+    passing_gate_path.write_text("import sys\nsys.exit(0)\n", encoding="utf-8")
+    monkeypatch.setenv("CODE_RULES_GATE_PATH", str(passing_gate_path))
+    stub_gate_path = _write_code_review_gate_stub(
+        tmp_path, repr(CODE_REVIEW_STUB_BLOCK_REASON)
+    )
+    monkeypatch.setenv("CODE_REVIEW_PUSH_GATE_PATH", str(stub_gate_path))
+    deletion_stdin = (
+        f"refs/heads/feature {ALL_ZEROS_OBJECT_NAME} "
+        f"refs/heads/feature {ALL_ZEROS_OBJECT_NAME}\n"
+    )
+    monkeypatch.setattr(sys, "stdin", io.StringIO(deletion_stdin))
+
+    exit_code = pre_push.main()
+
+    assert exit_code == 0
+
+
+def test_main_allows_when_code_review_enforcement_flag_is_off(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    """Native pre-push honors the real gate with enforcement off.
+
+    Points at the production push gate (not a reason stub). With the shipped
+    default `CODE_REVIEW_ENFORCEMENT_ENABLED = False`, the gate returns no
+    deny reason and the backstop allows the push — one path covering flag,
+    real gate load, and pre-push exit together.
+    """
+    _write_passing_code_rules_gate(tmp_path, monkeypatch)
+    real_gate_path = (
+        Path(__file__).resolve().parent.parent
+        / "blocking"
+        / "code_review_push_gate.py"
+    )
+    assert real_gate_path.is_file()
+    monkeypatch.setenv("CODE_REVIEW_PUSH_GATE_PATH", str(real_gate_path))
+
+    exit_code = pre_push.main()
+
+    assert exit_code == 0

package/hooks/hooks.json

@@ -57,6 +57,16 @@
           }
         ]
       },
+      {
+        "matcher": "mcp__plugin_github_github__create_pull_request",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "python3 ${CLAUDE_PLUGIN_ROOT}/hooks/blocking/code_review_pr_create_gate.py",
+            "timeout": 20
+          }
+        ]
+      },
       {
         "matcher": "mcp__plugin_github_github__.*",
         "hooks": [
@@ -79,7 +89,12 @@
             "type": "command",
             "command": "python3 ${CLAUDE_PLUGIN_ROOT}/hooks/blocking/pr_converge_bugteam_enforcer.py",
             "timeout": 10
-          },
+          }
+        ]
+      },
+      {
+        "matcher": "Agent|Task",
+        "hooks": [
           {
             "type": "command",
             "command": "python3 ${CLAUDE_PLUGIN_ROOT}/hooks/blocking/code_verifier_spawn_preflight_gate.py",
@@ -87,6 +102,16 @@
           }
         ]
       },
+      {
+        "matcher": "ScheduleWakeup|CronCreate",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "python3 ${CLAUDE_PLUGIN_ROOT}/hooks/blocking/orchestrator_refresh_reschedule_gate.py",
+            "timeout": 15
+          }
+        ]
+      },
       {
         "matcher": "Skill",
         "hooks": [

package/hooks/hooks_constants/CLAUDE.md

@@ -60,9 +60,11 @@ Shared constant modules imported by hooks throughout the `hooks/` tree. Each fil
 | `pre_tool_use_stdin.py` | `read_hook_input_dictionary_from_stdin()` — shared stdin parser for PreToolUse hooks |
 | `precommit_code_rules_gate_constants.py` | Scope argument and exit-code constants for the precommit gate |
 | `project_paths_reader.py` | Loads `~/.claude/project-paths.json` — the per-user project-path registry |
+| `pyproject_config_discovery_constants.py` | Table names (``tool`` key, ``mypy``, ``ruff``) for resolving a validator's config from a pyproject.toml `[tool.<name>]` table |
 | `pytest_testpaths_orphan_blocker_constants.py` | Marker filename, section and key names, test-file pattern, search budget, and block-message text for the pytest unregistered-test-directory blocker |
 | `python_style_checks_constants.py` | Command-line argument count and blank-line count between top-level functions for the style validator |
 | `reviewer_spawn_gate_constants.py` | Bash tool name, the sentinel marker, the Copilot and Bugbot trigger markers, the availability-script relative path and override env-var name, and the deny-message template for the reviewer-spawn gate |
+| `ruff_integration_constants.py` | ``NO_COLOR`` / ``FORCE_COLOR`` environment variable names for plain ruff diagnostics |
 | `send_user_file_open_locally_blocker_constants.py` | Tool name, proactive status, and the block message for the open-locally attach blocker |
 | `sensitive_file_protector_constants.py` | Sensitive filename patterns, the committed-template suffixes that earn an exemption, the write/edit tool names, and the deny decision and message template for `sensitive_file_protector` |
 | `session_edit_stage_gate_constants.py` | Tracker filename prefix/suffix, JSON payload key, edit tool name set, session-id sanitize pattern, lock filename suffix and lock-acquire timing, git diff command, commit flag escapes, and deny-message template shared by the session edit stage gate trio |
@@ -89,6 +91,6 @@ Shared constant modules imported by hooks throughout the `hooks/` tree. Each fil
 - Most files in this package are pure constants modules — no side effects, no I/O.
 - Hooks import from this package with `from hooks_constants.<module> import <CONSTANT>`.
 - Tests for these modules live beside them as `test_<module>.py`. Run with `python -m pytest hooks_constants/test_<name>.py`.
-- `dynamic_stderr_handler.py`, `pre_tool_use_stdin.py`, `multi_edit_reconstruction.py`, `hosted_hook_runner.py`, and `text_stripping.py` are utility modules (not pure constants) but live here because they are shared across many hooks.
+- `dynamic_stderr_handler.py`, `pre_tool_use_stdin.py`, `multi_edit_reconstruction.py`, `hosted_hook_runner.py`, and `text_stripping.py` are utility modules (not pure constants) but live here because they hold logic shared across hook surfaces.
 - `local_identity.py` is a loader: it reads the environment or `~/.claude/local-identity.json` (its path overridable via `CLAUDE_LOCAL_IDENTITY_PATH`) to resolve private NAS values (with committed placeholder defaults), the PII commit-scan exempt-repo slug set (`CLAUDE_PII_EXEMPT_REPOS` / `pii_exempt_repositories`), and the per-repository allowlisted-values mapping (`pii_allowlisted_values`).
 

package/hooks/hooks_constants/bash_pre_tool_use_dispatcher_constants.py

@@ -75,4 +75,12 @@ ALL_BASH_HOSTED_HOOK_ENTRIES: tuple[BashHostedHookEntry, ...] = (
     BashHostedHookEntry(
         "blocking/verdict_directory_write_blocker.py", ALL_BASH_AND_POWERSHELL_TOOL_NAMES
     ),
+    BashHostedHookEntry("blocking/code_review_push_gate.py", ALL_BASH_AND_POWERSHELL_TOOL_NAMES),
+    BashHostedHookEntry(
+        "blocking/code_review_pr_create_gate.py", ALL_BASH_AND_POWERSHELL_TOOL_NAMES
+    ),
+    BashHostedHookEntry(
+        "blocking/code_review_stamp_directory_write_blocker.py",
+        ALL_BASH_AND_POWERSHELL_TOOL_NAMES,
+    ),
 )

package/hooks/hooks_constants/code_rules_path_utils_constants.py

@@ -22,6 +22,7 @@ ALL_CONFIG_DIRECTORY_NAMES = frozenset(
         "pr_converge_scripts_constants",
         "bugteam_scripts_constants",
         "usage_pause_constants",
+        "prototype_scripts_constants",
         "codex_review_scripts_constants",
         "dev_env_scripts_constants",
         "fresh_branch_scripts_constants",

package/hooks/hooks_constants/code_verifier_spawn_preflight_gate_constants.py

@@ -1,21 +1,29 @@
 """Configuration constants for the code_verifier_spawn_preflight_gate hook.
 
-The gate denies an ``Agent`` spawn whose ``subagent_type`` is ``code-verifier``
-when the branch carries a merge conflict against its base ref or a CODE_RULES
-violation on a line added in the working tree since the merge base (committed on
-the branch or uncommitted). It runs two
-pre-flight checks before the expensive verification spawn and addresses its
-deny reason to the spawning agent so that agent fixes the named issues and
-re-spawns. Every literal the hook body reads lives here; the hook imports
-``AGENT_TOOL_NAME`` from ``pr_converge_bugteam_enforcer_constants`` rather than
-redefining it.
+The gate denies an ``Agent`` or ``Task`` spawn whose ``subagent_type`` is
+``code-verifier`` when the branch carries a merge conflict against its base
+ref, a CODE_RULES violation on a line added in the working tree since the merge
+base (committed on the branch or uncommitted), or a CODE_RULES engine
+import/load failure. It runs those pre-flight checks before the expensive
+verification spawn and addresses its deny reason to the spawning agent so that
+agent fixes the named issues and re-spawns. Environmental git failures stay
+fail-open; engine import/load failure is fail-closed. Every literal the hook
+body reads lives here; ``AGENT_TOOL_NAME`` comes from
+``pr_converge_bugteam_enforcer_constants`` and joins ``TASK_TOOL_NAME`` in
+``ALL_CODE_VERIFIER_SPAWN_TOOL_NAMES`` so both spawn tool names share one source.
 """
 
 from __future__ import annotations
 
 from pathlib import Path
 
+from hooks_constants.pr_converge_bugteam_enforcer_constants import AGENT_TOOL_NAME
+
 CODE_VERIFIER_SUBAGENT_TYPE: str = "code-verifier"
+TASK_TOOL_NAME: str = "Task"
+ALL_CODE_VERIFIER_SPAWN_TOOL_NAMES: frozenset[str] = frozenset(
+    {AGENT_TOOL_NAME, TASK_TOOL_NAME}
+)
 
 ALL_MERGE_TREE_COMMAND_FLAGS: tuple[str, ...] = (
     "merge-tree",
@@ -39,11 +47,18 @@ ALL_NAME_ONLY_WORKTREE_DIFF_FLAGS: tuple[str, ...] = (
 ALL_UNIFIED_ZERO_DIFF_FLAGS: tuple[str, ...] = ("diff", "--unified=0")
 
 DENY_REASON_LEAD: str = (
-    "BLOCKED [code-verifier-spawn-preflight]: an Agent spawn with subagent_type "
-    "code-verifier is blocked because the branch is not in a committable state. "
+    "BLOCKED [code-verifier-spawn-preflight]: a code-verifier spawn "
+    "(Agent or Task tool, subagent_type code-verifier) is blocked because "
+    "the branch is not in a committable state. "
     "Fix these, then re-spawn the code-verifier:"
 )
 MERGE_CONFLICT_SECTION_HEADER: str = "Merge conflicts vs {base_ref}:"
 CODE_RULES_SECTION_HEADER: str = "CODE_RULES violations on changed lines:"
+ENGINE_LOAD_FAILURE_SECTION: str = (
+    "CODE_RULES engine failed to load:\n"
+    "  The CODE_RULES validate_content engine could not be imported or loaded "
+    "(package import/load failure). Repair the enforcer so load_validate_content "
+    "succeeds, then re-spawn code-verifier."
+)
 
 GATE_SCRIPTS_RELATIVE_PATH: Path = Path("_shared") / "pr-loop" / "scripts"

package/hooks/hooks_constants/convergence_gate_blocker_constants.py

@@ -25,12 +25,29 @@ chained command does not bind the gate to the wrong PR::
 
 GH_PR_READY_ANCHOR_PATTERN: str = r"\bgh\s+pr\s+ready\b(?![^&|;\n]*--undo)"
 
-COMMAND_SEPARATOR_PATTERN: str = r"&&|\|\||;|\||\n"
+COMMAND_SEPARATOR_PATTERN: str = r"&&|\|\||;|\||\n|(?<![>&])&(?![>&])"
+
+BASH_LINE_CONTINUATION_PATTERN: str = r"\\\r?\n[ \t]*"
 
 PR_URL_OWNER_REPO_NUMBER_PATTERN: str = (
-    r"https://github\.com/(?P<owner>[\w.-]+)/(?P<repo>[\w.-]+)/pull/(?P<number>\d+)"
+    r"https?://[^/]+/(?P<owner>[\w.-]+)/(?P<repo>[\w.-]+)/pull/(?P<number>\d+)"
 )
 
 REPO_OVERRIDE_FLAG_PATTERN: str = (
-    r"(?:^|\s)(?:--repo|-R)(?:=|\s+)(?:[\w.-]+/)*(?P<owner>[\w.-]+)/(?P<repo>[\w.-]+)"
+    r"(?:^|\s)(?:--repo(?:=|\s+)|-R(?:=|\s+)?)"
+    r"(?:https?://[^/\s]+/|git@[^:\s]+:|(?:[\w.-]+/)*)"
+    r"(?P<owner>[\w.-]+)/(?P<repo>[\w.-]+)"
+)
+
+ALL_GH_PR_VIEW_NUMBER_COMMAND: tuple[str, ...] = (
+    "gh",
+    "pr",
+    "view",
+    "--json",
+    "number",
+    "--jq",
+    ".number",
 )
+GH_REPO_FLAG: str = "--repo"
+REPO_SLUG_TEMPLATE: str = "{owner}/{repo}"
+GIT_URL_SUFFIX: str = ".git"

package/hooks/hooks_constants/destructive_command_segment_constants.py

@@ -1,4 +1,4 @@
-"""Segment-splitting and command-name constants for the destructive command blocker compound rm guard."""
+"""Segment-splitting, command-name, and deny-mode constants for the destructive command blocker."""
 
 ALL_SHELL_CONTROL_OPERATOR_TOKENS: frozenset[str] = frozenset({"&&", "||", ";", "|&", "|", "&", "\n", "\r"})
 ALL_COMMAND_LAUNCHER_WRAPPER_COMMANDS: frozenset[str] = frozenset(
@@ -191,3 +191,5 @@ ALL_KNOWN_TEMPORARY_ENVIRONMENT_VARIABLE_NAMES: frozenset[str] = frozenset(
         "CLAUDE_JOB_DIR",
     }
 )
+DESTRUCTIVE_DENY_MODE_ENV_VAR: str = "CLAUDE_DESTRUCTIVE_DENY_MODE"
+ALL_TRUTHY_ENV_VALUES: frozenset[str] = frozenset({"1", "true", "yes", "on"})

package/hooks/hooks_constants/enter_worktree_prefetch_constants.py

@@ -1,18 +1,18 @@
-"""Configuration constants for the ``enter_worktree_origin_prefetch`` hook.
-
-The hook keeps a freshly created worktree from starting on a stale cached
-``refs/remotes/origin/<default-branch>`` value: it fetches that ref right
-before ``EnterWorktree`` resolves its base.
-"""
-
-from __future__ import annotations
-
-ENTER_WORKTREE_TOOL_NAME: str = "EnterWorktree"
-ENTER_WORKTREE_PATH_INPUT_KEY: str = "path"
-
-ORIGIN_REMOTE_NAME: str = "origin"
-ORIGIN_HEAD_SYMBOLIC_REF: str = "refs/remotes/origin/HEAD"
-ORIGIN_REMOTE_REF_PREFIX: str = "refs/remotes/origin/"
-
-GIT_SYMBOLIC_REF_TIMEOUT_SECONDS: int = 5
-GIT_FETCH_TIMEOUT_SECONDS: int = 15
+"""Configuration constants for the ``enter_worktree_origin_prefetch`` hook.
+
+The hook keeps a freshly created worktree from starting on a stale cached
+``refs/remotes/origin/<default-branch>`` value: it fetches that ref right
+before ``EnterWorktree`` resolves its base.
+"""
+
+from __future__ import annotations
+
+ENTER_WORKTREE_TOOL_NAME: str = "EnterWorktree"
+ENTER_WORKTREE_PATH_INPUT_KEY: str = "path"
+
+ORIGIN_REMOTE_NAME: str = "origin"
+ORIGIN_HEAD_SYMBOLIC_REF: str = "refs/remotes/origin/HEAD"
+ORIGIN_REMOTE_REF_PREFIX: str = "refs/remotes/origin/"
+
+GIT_SYMBOLIC_REF_TIMEOUT_SECONDS: int = 5
+GIT_FETCH_TIMEOUT_SECONDS: int = 15