claude-dev-env 1.92.0 → 1.93.0

package/hooks/hooks_constants/local_identity.py

@@ -0,0 +1,182 @@
+"""Resolve the NAS host, ssh user, and ssh port for the NAS ssh enforcer hook.
+
+The enforcer ships into ``~/.claude/`` and cannot read a repository file, so it
+reads the real NAS values from the environment or a git-ignored file in the
+Claude home directory, and it composes the two deny messages that quote those
+values. The committed defaults are placeholders.
+
+::
+
+    CLAUDE_NAS_HOST set to a host   ->  nas_host() returns that host
+    CLAUDE_NAS_SSH_PORT set to 2200 ->  nas_ssh_port() returns 2200
+    (env unset, no file)            ->  nas_host() == "nas.example.local"
+                                        nas_ssh_port() == 22
+
+Each value comes from its ``CLAUDE_NAS_*`` environment variable, then
+``~/.claude/local-identity.json``, then the placeholder default.
+"""
+
+from __future__ import annotations
+
+import json
+import os
+from pathlib import Path
+
+NAS_HOST_ENV_VAR = "CLAUDE_NAS_HOST"
+NAS_SSH_USER_ENV_VAR = "CLAUDE_NAS_SSH_USER"
+NAS_SSH_PORT_ENV_VAR = "CLAUDE_NAS_SSH_PORT"
+NAS_JSON_KEY = "nas"
+NAS_HOST_JSON_KEY = "host"
+NAS_SSH_USER_JSON_KEY = "ssh_user"
+NAS_SSH_PORT_JSON_KEY = "ssh_port"
+CLAUDE_HOME_DIRECTORY_NAME = ".claude"
+LOCAL_IDENTITY_FILE_NAME = "local-identity.json"
+PLACEHOLDER_NAS_HOST = "nas.example.local"
+PLACEHOLDER_NAS_SSH_USER = "operator"
+PLACEHOLDER_NAS_SSH_PORT = 22
+OPENSSH_INVOCATION_EXAMPLE_BINARY = '"/c/Windows/System32/OpenSSH/ssh.exe"'
+NAS_SSH_RULE_REFERENCE = "~/.claude/rules/nas-ssh-invocation.md"
+
+
+def _local_identity_file_path() -> Path:
+    return Path.home() / CLAUDE_HOME_DIRECTORY_NAME / LOCAL_IDENTITY_FILE_NAME
+
+
+def _nas_section_from_local_file() -> dict[str, object]:
+    identity_path = _local_identity_file_path()
+    if not identity_path.is_file():
+        return {}
+    try:
+        parsed_identity = json.loads(identity_path.read_text(encoding="utf-8"))
+    except (OSError, ValueError, UnicodeDecodeError):
+        return {}
+    if not isinstance(parsed_identity, dict):
+        return {}
+    nas_section = parsed_identity.get(NAS_JSON_KEY, {})
+    return nas_section if isinstance(nas_section, dict) else {}
+
+
+def nas_host() -> str:
+    """Return the NAS host the ssh enforcer guards.
+
+    ::
+
+        CLAUDE_NAS_HOST set to a host  ->  that host
+        (env unset, no file)           ->  "nas.example.local"
+
+    The environment variable wins, then the git-ignored file, then the
+    placeholder default.
+
+    Returns:
+        The NAS hostname or address.
+    """
+    host_from_environment = os.environ.get(NAS_HOST_ENV_VAR)
+    if host_from_environment:
+        return host_from_environment
+    stored_host = _nas_section_from_local_file().get(NAS_HOST_JSON_KEY)
+    if isinstance(stored_host, str) and stored_host:
+        return stored_host
+    return PLACEHOLDER_NAS_HOST
+
+
+def nas_ssh_user() -> str:
+    """Return the ssh user the enforcer expects for the NAS.
+
+    ::
+
+        CLAUDE_NAS_SSH_USER set to a user  ->  that user
+        (env unset, no file)               ->  "operator"
+
+    The environment variable wins, then the git-ignored file, then the
+    placeholder default.
+
+    Returns:
+        The ssh login name for the NAS.
+    """
+    user_from_environment = os.environ.get(NAS_SSH_USER_ENV_VAR)
+    if user_from_environment:
+        return user_from_environment
+    stored_user = _nas_section_from_local_file().get(NAS_SSH_USER_JSON_KEY)
+    if isinstance(stored_user, str) and stored_user:
+        return stored_user
+    return PLACEHOLDER_NAS_SSH_USER
+
+
+def nas_ssh_port() -> int:
+    """Return the ssh port the enforcer expects for the NAS.
+
+    ::
+
+        CLAUDE_NAS_SSH_PORT set to 2200  ->  2200
+        (env unset, no file)             ->  22
+
+    The environment variable wins, then the git-ignored file, then the
+    placeholder default.
+
+    Returns:
+        The ssh port number for the NAS.
+    """
+    port_from_environment = os.environ.get(NAS_SSH_PORT_ENV_VAR)
+    if port_from_environment and port_from_environment.isdigit():
+        return int(port_from_environment)
+    stored_port = _nas_section_from_local_file().get(NAS_SSH_PORT_JSON_KEY)
+    if isinstance(stored_port, int):
+        return stored_port
+    return PLACEHOLDER_NAS_SSH_PORT
+
+
+def _openssh_invocation_example() -> str:
+    return (
+        f"{OPENSSH_INVOCATION_EXAMPLE_BINARY} -o BatchMode=yes -o ConnectTimeout=10 "
+        f'-p {nas_ssh_port()} {nas_ssh_user()}@{nas_host()} "<cmd>"'
+    )
+
+
+def bare_ssh_binary_deny_message() -> str:
+    """Return the deny message for a bare ssh-family word aimed at the NAS.
+
+    ::
+
+        ssh -p 22 operator@nas.example.local "ls"  ->  this message text
+        (the text quotes the resolved host, user, and port)
+
+    Names the Git Bash MSYS-ssh hang and points at the Windows OpenSSH binary
+    with batch mode on.
+
+    Returns:
+        The full deny-message text for the bare ssh-family case.
+    """
+    return (
+        f"BLOCKED [nas-ssh-binary]: Git Bash's MSYS ssh reads ~/.ssh/id_ed25519 as "
+        f"world-readable through its ACL mapping, rejects the key as bad permissions, "
+        f"and falls back to an interactive password prompt that hangs unattended "
+        f"sessions against the NAS at {nas_host()}.\n\n"
+        f"Use the Windows OpenSSH binary, which authenticates the key without prompting:\n"
+        f"  {_openssh_invocation_example()}\n\n"
+        f"See {NAS_SSH_RULE_REFERENCE} for full guidance."
+    )
+
+
+def missing_batch_mode_deny_message() -> str:
+    """Return the deny message for the OpenSSH binary without batch mode.
+
+    ::
+
+        "..ssh.exe" -p 22 operator@nas.example.local "ls"  ->  this message text
+        (the text quotes the resolved host, user, and port)
+
+    Names the interactive-prompt hang and asks for ``-o BatchMode=yes`` so a key
+    failure exits loudly.
+
+    Returns:
+        The full deny-message text for the missing-batch-mode case.
+    """
+    return (
+        f"BLOCKED [nas-ssh-binary]: this NAS ssh command uses the Windows OpenSSH binary "
+        f"but omits -o BatchMode=yes, so an authentication regression falls back to an "
+        f"interactive password prompt that hangs unattended sessions against the NAS at "
+        f"{nas_host()}.\n\n"
+        f"Add -o BatchMode=yes so a key failure exits loudly rather than prompting:\n"
+        f"  {_openssh_invocation_example()}\n\n"
+        f"See {NAS_SSH_RULE_REFERENCE} for full guidance."
+    )

package/hooks/hooks_constants/nas_ssh_binary_enforcer_constants.py

@@ -1,26 +1,15 @@
 """Constants for the NAS ssh binary enforcer hook.
 
-Holds the Bash tool name, the NAS host-token pattern, the ssh-family command
-basenames, the Windows OpenSSH binary path suffixes, the launcher-wrapper set, the
-shell control-operator tokens and their split pattern, the leading-assignment and
-launcher-duration patterns, the batch-mode pattern, and the two deny messages.
+Holds the Bash tool name, the ssh-family command basenames, the Windows OpenSSH
+binary path suffixes, the launcher-wrapper set, the shell control-operator tokens
+and their split pattern, the leading-assignment and launcher-duration patterns,
+and the batch-mode pattern.
 """
 
 import re
 
 BASH_TOOL_NAME = "Bash"
 
-NAS_HOST_TOKEN_PATTERN = re.compile(r"(?:^|@)192\.168\.1\.100(?::|$)")
-"""Match the NAS address only as a connection host.
-
-Anchored to token start or an ``@`` and followed by ``:`` or token end, so the
-address is matched as a bare host (``192.168.1.100``), a ``user@host``
-(``jon@192.168.1.100``), or a ``host:path`` target (``192.168.1.100:/vol1/``,
-``jon@192.168.1.100:/vol1/``). The address inside a remote-command argument
-(``"ping 192.168.1.100"``) or a remote path component on another host
-(``jon@other:/backup/192.168.1.100/``) does not count as a NAS connection.
-"""
-
 ALL_SSH_FAMILY_COMMAND_BASENAMES = frozenset(
     {"ssh", "scp", "sftp", "ssh.exe", "scp.exe", "sftp.exe"}
 )
@@ -35,25 +24,3 @@ CONTROL_OPERATOR_SPLIT_PATTERN = re.compile(r"(&&|\|\||;|\|&|\||(?<!>)&(?!>))")
 LEADING_ASSIGNMENT_PATTERN = re.compile(r"^[A-Za-z_][A-Za-z0-9_]*=")
 LAUNCHER_DURATION_PATTERN = re.compile(r"^\d+[a-z]*$", re.IGNORECASE)
 BATCH_MODE_PATTERN = re.compile(r"batchmode\s*=\s*yes", re.IGNORECASE)
-
-BARE_SSH_BINARY_MESSAGE = (
-    "BLOCKED [nas-ssh-binary]: Git Bash's MSYS ssh reads ~/.ssh/id_ed25519 as "
-    "world-readable through its ACL mapping, rejects the key as bad permissions, "
-    "and falls back to an interactive password prompt that hangs unattended "
-    "sessions against the NAS at 192.168.1.100.\n\n"
-    "Use the Windows OpenSSH binary, which authenticates the key without prompting:\n"
-    '  "/c/Windows/System32/OpenSSH/ssh.exe" -o BatchMode=yes -o ConnectTimeout=10 '
-    '-p 9222 jon@192.168.1.100 "<cmd>"\n\n'
-    "See ~/.claude/rules/nas-ssh-invocation.md for full guidance."
-)
-
-MISSING_BATCH_MODE_MESSAGE = (
-    "BLOCKED [nas-ssh-binary]: this NAS ssh command uses the Windows OpenSSH binary "
-    "but omits -o BatchMode=yes, so an authentication regression falls back to an "
-    "interactive password prompt that hangs unattended sessions against the NAS at "
-    "192.168.1.100.\n\n"
-    "Add -o BatchMode=yes so a key failure exits loudly rather than prompting:\n"
-    '  "/c/Windows/System32/OpenSSH/ssh.exe" -o BatchMode=yes -o ConnectTimeout=10 '
-    '-p 9222 jon@192.168.1.100 "<cmd>"\n\n'
-    "See ~/.claude/rules/nas-ssh-invocation.md for full guidance."
-)

package/hooks/hooks_constants/pii_prevention_constants.py

@@ -0,0 +1,299 @@
+"""Named constants imported by `pii_prevention_blocker` and `pii_scanner`."""
+
+from __future__ import annotations
+
+import re
+
+from hooks_constants.hardcoded_user_path_constants import HARDCODED_USER_PATH_PATTERN
+
+BASH_TOOL_NAME: str = "Bash"
+POWERSHELL_TOOL_NAME: str = "PowerShell"
+WRITE_TOOL_NAME: str = "Write"
+EDIT_TOOL_NAME: str = "Edit"
+MULTI_EDIT_TOOL_NAME: str = "MultiEdit"
+
+ALL_WRITE_EDIT_MULTI_EDIT_TOOL_NAMES: frozenset[str] = frozenset(
+    {WRITE_TOOL_NAME, EDIT_TOOL_NAME, MULTI_EDIT_TOOL_NAME}
+)
+
+ALL_SHELL_TOOL_NAMES: frozenset[str] = frozenset(
+    {BASH_TOOL_NAME, POWERSHELL_TOOL_NAME}
+)
+
+ALL_GIT_BINARY_BASENAMES: frozenset[str] = frozenset({"git", "git.exe"})
+GIT_COMMIT_SUBCOMMAND: str = "commit"
+GIT_WORKING_DIRECTORY_OPTION: str = "-C"
+ALL_VALUE_TAKING_GIT_OPTIONS: frozenset[str] = frozenset(
+    {GIT_WORKING_DIRECTORY_OPTION, "-c", "--git-dir", "--work-tree", "--namespace"}
+)
+GIT_OPTION_WITH_VALUE_STEP: int = 2
+ALL_SHELL_COMMAND_SEPARATOR_TOKENS: frozenset[str] = frozenset(
+    {"&&", "||", ";", "|", "&"}
+)
+ALL_SHELL_KEYWORD_TOKENS: frozenset[str] = frozenset(
+    {"then", "do", "else", "elif"}
+)
+ALL_COMMAND_WRAPPER_TOKENS: frozenset[str] = frozenset(
+    {
+        "sudo",
+        "doas",
+        "env",
+        "time",
+        "timeout",
+        "nice",
+        "ionice",
+        "chrt",
+        "xargs",
+        "command",
+        "stdbuf",
+        "nohup",
+        "setsid",
+        "flock",
+    }
+)
+ALL_LEADING_SKIPPABLE_COMMAND_TOKENS: frozenset[str] = (
+    ALL_SHELL_KEYWORD_TOKENS | ALL_COMMAND_WRAPPER_TOKENS
+)
+ALL_ONE_OPERAND_WRAPPER_TOKENS: frozenset[str] = frozenset({"timeout", "flock"})
+ALL_BASH_FAMILY_INTERPRETER_BASENAMES: frozenset[str] = frozenset(
+    {
+        "bash",
+        "sh",
+        "bash.exe",
+        "sh.exe",
+    }
+)
+ALL_POWERSHELL_INTERPRETER_BASENAMES: frozenset[str] = frozenset(
+    {
+        "pwsh",
+        "pwsh.exe",
+        "powershell",
+        "powershell.exe",
+    }
+)
+ALL_SHELL_INTERPRETER_BASENAMES: frozenset[str] = (
+    ALL_BASH_FAMILY_INTERPRETER_BASENAMES | ALL_POWERSHELL_INTERPRETER_BASENAMES
+)
+SUBSHELL_GROUP_OPEN_TOKEN: str = "("
+SHELL_INLINE_COMMAND_FLAG: str = "-c"
+POWERSHELL_INLINE_COMMAND_FLAG: str = "-command"
+INLINE_COMMAND_FLAG_CLUSTER_CHARACTER: str = "c"
+INLINE_COMMAND_TOKEN_JOINER: str = " "
+SINGLE_DASH_OPTION_PREFIX: str = "-"
+DOUBLE_DASH_OPTION_PREFIX: str = "--"
+ALL_SHELL_QUOTE_CHARACTERS: frozenset[str] = frozenset({'"', "'"})
+ALL_COMMAND_BOUNDARY_NEWLINE_CHARACTERS: frozenset[str] = frozenset({"\n", "\r"})
+ENVIRONMENT_ASSIGNMENT_PATTERN: re.Pattern[str] = re.compile(
+    r"^[A-Za-z_][A-Za-z0-9_]*="
+)
+LINE_CONTINUATION_PATTERN: re.Pattern[str] = re.compile(r"\\\r?\n")
+POWERSHELL_LINE_CONTINUATION_PATTERN: re.Pattern[str] = re.compile(r"`\r?\n")
+
+MCP_GITHUB_TOOL_PREFIX: str = "mcp__plugin_github_github__"
+
+HOOK_SCRIPT_BASENAME: str = "pii_prevention_blocker.py"
+
+ALL_EXACT_LEGAL_NOTICE_BASENAMES: frozenset[str] = frozenset(
+    {
+        "license",
+        "license.md",
+        "license.txt",
+        "copying",
+        "copying.md",
+        "copying.txt",
+        "notice",
+        "notice.md",
+        "notice.txt",
+    }
+)
+
+ALL_SELF_MODULE_PATH_SUFFIXES: tuple[str, ...] = (
+    "/hooks/blocking/pii_prevention_blocker.py",
+    "/hooks/blocking/pii_scanner.py",
+    "/hooks/hooks_constants/pii_prevention_constants.py",
+)
+
+PYTHON_SOURCE_FILE_SUFFIX: str = ".py"
+CONFTEST_BASENAME: str = "conftest.py"
+TEST_MODULE_BASENAME_PREFIX: str = "test_"
+TEST_MODULE_BASENAME_SUFFIX: str = "_test.py"
+TESTS_PATH_SEGMENT: str = "/tests/"
+TESTS_PATH_PREFIX: str = "tests/"
+SPEC_BASENAME_MARKER: str = ".spec."
+TEST_BASENAME_MARKER: str = ".test."
+ALL_SOURCE_TEST_FILE_SUFFIXES: tuple[str, ...] = (
+    ".py",
+    ".ts",
+    ".tsx",
+    ".js",
+    ".jsx",
+    ".mjs",
+    ".cjs",
+)
+ALL_SAFE_EMAIL_DOMAINS: frozenset[str] = frozenset(
+    {
+        "example.com",
+        "example.org",
+        "example.net",
+        "example.edu",
+        "localhost",
+        "invalid",
+        "test",
+        "local",
+        "test.local",
+    }
+)
+
+ALL_PLACEHOLDER_HOME_USERNAMES: frozenset[str] = frozenset(
+    {
+        "example",
+        "user",
+        "username",
+        "your-user",
+        "your_user",
+        "you",
+        "name",
+        "alice",
+        "bob",
+        "carol",
+        "dave",
+        "placeholder",
+        "path",
+        "me",
+        "someone",
+        "default",
+        "admin",
+        "runner",
+        "container",
+        "ubuntu",
+    }
+)
+
+ALL_ALLOWLISTED_PRIVATE_IP_ADDRESSES: frozenset[str] = frozenset(
+    {
+        "192.168.1.100",
+    }
+)
+
+MAXIMUM_FINDINGS_PER_SCAN: int = 12
+MAXIMUM_STAGED_FILE_BYTES: int = 1_000_000
+MAXIMUM_OFFENDING_PREVIEW_LENGTH: int = 80
+GIT_COMMAND_TIMEOUT_SECONDS: int = 10
+
+ALL_STAGED_FILES_COMMAND: tuple[str, ...] = (
+    "git",
+    "diff",
+    "--cached",
+    "--name-only",
+    "--diff-filter=ACMR",
+)
+
+ALL_STAGED_BLOB_SHOW_COMMAND_PREFIX: tuple[str, ...] = ("git", "show")
+STAGED_BLOB_PREFIX: str = ":"
+
+BODY_FILE_ENCODING: str = "utf-8"
+NULL_BYTE_MARKER: bytes = b"\x00"
+MESSAGE_LINE_SEPARATOR: str = "\n"
+MINIMUM_ENV_STYLE_USERNAME_LENGTH: int = 3
+IPV4_VERSION_NUMBER: int = 4
+
+ALL_RFC1918_NETWORK_CIDRS: tuple[str, ...] = (
+    "10.0.0.0/8",
+    "172.16.0.0/12",
+    "192.168.0.0/16",
+)
+
+CATEGORY_EMAIL: str = "email"
+CATEGORY_HOME_PATH: str = "home-path"
+CATEGORY_PRIVATE_IP: str = "private-ip"
+CATEGORY_SECRET: str = "secret"
+
+ALL_REDACTED_PREVIEW_CATEGORIES: frozenset[str] = frozenset(
+    {CATEGORY_EMAIL, CATEGORY_SECRET}
+)
+REDACTED_PREVIEW_PREFIX_LENGTH: int = 4
+REDACTED_PREVIEW_SUFFIX_LENGTH: int = 4
+REDACTED_PREVIEW_REVEALED_LENGTH: int = (
+    REDACTED_PREVIEW_PREFIX_LENGTH + REDACTED_PREVIEW_SUFFIX_LENGTH
+)
+REDACTED_PREVIEW_MINIMUM_HIDDEN_LENGTH: int = REDACTED_PREVIEW_REVEALED_LENGTH
+REDACTED_PREVIEW_ELLIPSIS: str = "…"
+REDACTED_SHORT_PREVIEW: str = "[redacted]"
+MINIMUM_LENGTH_FOR_PARTIAL_REDACTION: int = (
+    REDACTED_PREVIEW_REVEALED_LENGTH + REDACTED_PREVIEW_MINIMUM_HIDDEN_LENGTH
+)
+
+EMAIL_PATTERN: re.Pattern[str] = re.compile(
+    r"(?i)\b([A-Z0-9._%+\-]+@[A-Z0-9.\-]+\.[A-Z]{2,})\b"
+)
+
+IPV4_PATTERN: re.Pattern[str] = re.compile(
+    r"\b((?:25[0-5]|2[0-4]\d|1?\d?\d)\."
+    r"(?:25[0-5]|2[0-4]\d|1?\d?\d)\."
+    r"(?:25[0-5]|2[0-4]\d|1?\d?\d)\."
+    r"(?:25[0-5]|2[0-4]\d|1?\d?\d))\b"
+)
+
+GITHUB_TOKEN_PATTERN: re.Pattern[str] = re.compile(
+    r"\b(?:ghp|gho|ghu|ghs|ghr)_[A-Za-z0-9_]{20,}\b"
+)
+
+GITHUB_FINE_GRAINED_TOKEN_PATTERN: re.Pattern[str] = re.compile(
+    r"\bgithub_pat_[A-Za-z0-9_]{20,}\b"
+)
+
+AWS_ACCESS_KEY_PATTERN: re.Pattern[str] = re.compile(r"\bAKIA[0-9A-Z]{16}\b")
+
+PEM_PRIVATE_KEY_HEADER_PATTERN: re.Pattern[str] = re.compile(
+    r"-----BEGIN (?:RSA |OPENSSH |EC |DSA |ENCRYPTED )?PRIVATE KEY-----"
+)
+
+HOME_PATH_PATTERN: re.Pattern[str] = HARDCODED_USER_PATH_PATTERN
+
+ALL_HOME_DIRECTORY_PATH_MARKERS: tuple[str, ...] = ("/users/", "/home/")
+
+ALL_SECRET_PATTERNS: tuple[re.Pattern[str], ...] = (
+    GITHUB_TOKEN_PATTERN,
+    GITHUB_FINE_GRAINED_TOKEN_PATTERN,
+    AWS_ACCESS_KEY_PATTERN,
+    PEM_PRIVATE_KEY_HEADER_PATTERN,
+)
+
+ANGLE_BRACKET_PLACEHOLDER_PATTERN: re.Pattern[str] = re.compile(r"^<[^>]+>$")
+
+CORRECTIVE_MESSAGE_HEADER: str = (
+    "BLOCKED [pii_prevention_blocker]: high-confidence personal data or secret "
+    "material must not land in the repository or on a durable GitHub post."
+)
+
+CORRECTIVE_MESSAGE_FOOTER: str = (
+    "Remediate: replace with placeholders (user@example.com, C:/Users/example/), "
+    "move secrets to an env or secret store, and run the privacy-hygiene skill "
+    "for a full sweep. Add intentional LAN hosts to "
+    "ALL_ALLOWLISTED_PRIVATE_IP_ADDRESSES in hooks_constants when tooling must "
+    "keep a host such as a NAS."
+)
+
+FINDING_LINE_TEMPLATE: str = "  [{category}] {preview}"
+
+STAGED_LIST_FAILURE_REASON: str = (
+    "BLOCKED [pii_prevention_blocker]: could not list staged files for PII scan "
+    "(git diff --cached failed). Refuse commit until the index is readable."
+)
+
+REPOSITORY_ROOT_UNRESOLVED_REASON: str = (
+    "BLOCKED [pii_prevention_blocker]: could not resolve the git repository root "
+    "for a commit command (not a git work tree, git missing, or bad -C path). "
+    "Refuse commit until the repository root is resolvable."
+)
+
+STAGED_BLOB_UNSCANNABLE_REASON_TEMPLATE: str = (
+    "BLOCKED [pii_prevention_blocker]: staged file '{relative_path}' could not be "
+    "scanned for PII ({reason}). Refuse commit, shrink the blob, or keep binary "
+    "assets free of embedded secrets."
+)
+
+STAGED_BLOB_REASON_GIT_SHOW_FAILED: str = "git show of staged blob failed"
+STAGED_BLOB_REASON_OVERSIZED: str = "blob exceeds MAXIMUM_STAGED_FILE_BYTES"
+STAGED_BLOB_REASON_NULL_BYTES: str = "blob contains null bytes (binary/unscannable)"
+STAGED_BLOB_REASON_DECODE_FAILED: str = "blob is not valid UTF-8 text"

package/hooks/hooks_constants/pre_tool_use_dispatcher_constants.py

@@ -80,6 +80,10 @@ ALL_HOSTED_HOOK_ENTRIES: tuple[HostedHookEntry, ...] = (
         script_relative_path="blocking/sensitive_file_protector.py",
         applicable_tool_names=ALL_WRITE_AND_EDIT_TOOL_NAMES,
     ),
+    HostedHookEntry(
+        script_relative_path="blocking/pii_prevention_blocker.py",
+        applicable_tool_names=ALL_WRITE_EDIT_MULTI_EDIT_TOOL_NAMES,
+    ),
     HostedHookEntry(
         script_relative_path="validation/hook_format_validator.py",
         applicable_tool_names=ALL_WRITE_AND_EDIT_TOOL_NAMES,

package/hooks/hooks_constants/python_style_checks_constants.py

@@ -0,0 +1,15 @@
+"""Constants for the python-style checks validator.
+
+Two counts the checks compare against. One says how many blank lines belong
+between one top-level function and the next. The other says how many
+command-line arguments the runner needs before it has a file to check.
+"""
+
+__all__ = [
+    "EXPECTED_BLANK_LINES_BETWEEN_FUNCTIONS",
+    "MINIMUM_ARGUMENT_COUNT",
+]
+
+EXPECTED_BLANK_LINES_BETWEEN_FUNCTIONS: int = 2
+
+MINIMUM_ARGUMENT_COUNT: int = 2

package/hooks/hooks_constants/stop_dispatcher_constants.py

@@ -0,0 +1,26 @@
+"""Constants for the Stop-hook dispatcher.
+
+Holds the ordered hosted-hook roster for the Stop chain. The dispatcher imports
+this roster to run every Stop hook in registration order inside one process.
+"""
+
+from __future__ import annotations
+
+__all__ = [
+    "ALL_STOP_HOSTED_HOOK_PATHS",
+    "BLOCK_DECISION",
+    "DECISION_KEY",
+    "REASON_KEY",
+]
+
+BLOCK_DECISION = "block"
+DECISION_KEY = "decision"
+REASON_KEY = "reason"
+
+ALL_STOP_HOSTED_HOOK_PATHS: tuple[str, ...] = (
+    "blocking/hedging_language_blocker.py",
+    "blocking/question_to_user_enforcer.py",
+    "blocking/intent_only_ending_blocker.py",
+    "blocking/session_handoff_blocker.py",
+    "diagnostic/hook_log_stop_wrapper.py",
+)

package/hooks/hooks_constants/test_bash_pre_tool_use_dispatcher_constants.py

@@ -0,0 +1,87 @@
+"""Tests for the Bash and PowerShell dispatcher hosted-hook roster.
+
+The roster order and per-hook applicable-tool sets fix the firing sequence and
+tool coverage the dispatcher must reproduce, so these tests pin both against the
+registration order the standalone chain used.
+"""
+
+from __future__ import annotations
+
+import sys
+from pathlib import Path
+
+_HOOKS_DIR = str(Path(__file__).resolve().parent.parent)
+if _HOOKS_DIR not in sys.path:
+    sys.path.insert(0, _HOOKS_DIR)
+
+from hooks_constants.bash_pre_tool_use_dispatcher_constants import (  # noqa: E402
+    ALL_BASH_AND_POWERSHELL_TOOL_NAMES,
+    ALL_BASH_HOSTED_HOOK_ENTRIES,
+    BASH_TOOL_NAME,
+    POWERSHELL_TOOL_NAME,
+)
+
+_EXPECTED_BASH_ORDER = (
+    "blocking/es_exe_path_rewriter.py",
+    "blocking/destructive_command_blocker.py",
+    "blocking/gh_body_arg_blocker.py",
+    "blocking/nas_ssh_binary_enforcer.py",
+    "blocking/volatile_path_in_post_blocker.py",
+    "blocking/pii_prevention_blocker.py",
+    "blocking/conventional_pr_title_gate.py",
+    "blocking/reviewer_spawn_gate.py",
+    "blocking/block_main_commit.py",
+    "blocking/precommit_code_rules_gate.py",
+    "blocking/session_edit_stage_gate.py",
+    "blocking/pr_description_enforcer.py",
+    "blocking/test_preflight_check.py",
+    "blocking/convergence_gate_blocker.py",
+    "blocking/windows_rmtree_blocker.py",
+    "blocking/gh_pr_author_enforcer.py",
+    "blocking/verified_commit_gate.py",
+    "blocking/verdict_directory_write_blocker.py",
+)
+
+_POWERSHELL_APPLICABLE = (
+    "blocking/pii_prevention_blocker.py",
+    "blocking/verified_commit_gate.py",
+    "blocking/verdict_directory_write_blocker.py",
+)
+
+
+def test_roster_lists_all_bash_hooks_in_registration_order() -> None:
+    """The roster reproduces the standalone Bash chain order exactly."""
+    actual_order = tuple(
+        each_entry.script_relative_path for each_entry in ALL_BASH_HOSTED_HOOK_ENTRIES
+    )
+    assert actual_order == _EXPECTED_BASH_ORDER
+
+
+def test_every_hook_applies_to_the_bash_tool() -> None:
+    """Every hosted hook runs on a Bash tool call."""
+    for each_entry in ALL_BASH_HOSTED_HOOK_ENTRIES:
+        assert BASH_TOOL_NAME in each_entry.applicable_tool_names
+
+
+def test_powershell_applicable_hooks_include_pii_and_verified_commit_pair() -> None:
+    """PowerShell runs the PII gate plus the verified-commit pair."""
+    powershell_hooks = tuple(
+        each_entry.script_relative_path
+        for each_entry in ALL_BASH_HOSTED_HOOK_ENTRIES
+        if POWERSHELL_TOOL_NAME in each_entry.applicable_tool_names
+    )
+    assert powershell_hooks == _POWERSHELL_APPLICABLE
+
+
+def test_powershell_hooks_carry_the_shared_tool_set() -> None:
+    """The PowerShell-applicable hooks name both Bash and PowerShell."""
+    for each_entry in ALL_BASH_HOSTED_HOOK_ENTRIES:
+        if each_entry.script_relative_path in _POWERSHELL_APPLICABLE:
+            assert each_entry.applicable_tool_names == ALL_BASH_AND_POWERSHELL_TOOL_NAMES
+
+
+def test_every_roster_path_points_at_an_existing_hook() -> None:
+    """Each roster path names a hook script present on disk, catching a typo."""
+    hooks_root = Path(__file__).resolve().parent.parent
+    for each_entry in ALL_BASH_HOSTED_HOOK_ENTRIES:
+        assert (hooks_root / each_entry.script_relative_path).is_file()

package/hooks/hooks_constants/test_hardcoded_user_path_constants.py

@@ -13,9 +13,9 @@ from hooks_constants.hardcoded_user_path_constants import HARDCODED_USER_PATH_PA
 
 
 def test_pattern_matches_windows_user_home() -> None:
-    match = HARDCODED_USER_PATH_PATTERN.search("C:/Users/jon/notes")
+    match = HARDCODED_USER_PATH_PATTERN.search("C:/Users/example/notes")
     assert match is not None
-    assert match.group(0) == "C:/Users/jon"
+    assert match.group(0) == "C:/Users/example"
 
 
 def test_pattern_matches_macos_user_home() -> None: