claude-dev-env 2.2.1 → 2.4.0

package/hooks/blocking/test_volatile_path_in_post_blocker.py

@@ -41,7 +41,7 @@ def test_scan_detects_job_scratch_path_forward_slash() -> None:
 
 
 def test_scan_detects_worktree_path() -> None:
-    text = r"edited .claude\worktrees\feature\file.py"
+    text = r"edited C:\Users\me\.claude\worktrees\feature\file.py"
     assert scan_text_for_volatile_marker(text) == ".claude/worktrees/"
 
 
@@ -71,6 +71,103 @@ def test_scan_clean_body_returns_none() -> None:
     assert scan_text_for_volatile_marker(text) is None
 
 
+def test_scan_bare_backticked_worktree_mention_is_allowed() -> None:
+    text = "the `.claude/worktrees/` prefix sits in ALL_TOOLING_STATE_PREFIXES"
+    assert scan_text_for_volatile_marker(text) is None
+
+
+def test_scan_bare_start_of_text_worktree_mention_is_allowed() -> None:
+    text = ".claude/worktrees/ entries are skipped by the manifest"
+    assert scan_text_for_volatile_marker(text) is None
+
+
+def test_scan_windows_absolute_worktree_path_is_detected() -> None:
+    text = r"C:\Users\me\.claude\worktrees\wt-1\notes.md"
+    assert scan_text_for_volatile_marker(text) == ".claude/worktrees/"
+
+
+def test_scan_home_anchored_worktree_path_is_detected() -> None:
+    text = "~/.claude/worktrees/wt-2/file.py"
+    assert scan_text_for_volatile_marker(text) == ".claude/worktrees/"
+
+
+def test_scan_posix_absolute_job_scratch_path_is_detected() -> None:
+    text = "/home/me/.claude-editor/jobs/j1/log.txt"
+    assert scan_text_for_volatile_marker(text) == ".claude-editor/jobs/"
+
+
+def test_scan_bare_parenthesized_job_scratch_mention_is_allowed() -> None:
+    text = "(.claude-editor/jobs/) as a directory name in prose"
+    assert scan_text_for_volatile_marker(text) is None
+
+
+def test_scan_bare_mention_before_anchored_path_is_detected() -> None:
+    text = (
+        ".claude/worktrees/ is the manifest key; the live path is "
+        r"C:\Users\me\.claude\worktrees\wt-1\notes.md"
+    )
+    assert scan_text_for_volatile_marker(text) == ".claude/worktrees/"
+
+
+def test_scan_unchanged_bare_markers_still_detected() -> None:
+    assert scan_text_for_volatile_marker(r"saved to %TEMP%\x") == "%temp%"
+    assert scan_text_for_volatile_marker("log at /tmp/x") == "/tmp/"
+    assert (
+        scan_text_for_volatile_marker(r"C:\Users\x\AppData\Local\Temp\y")
+        == "appdata/local/temp"
+    )
+
+
+def test_scan_space_prefixed_relative_worktree_path_is_detected() -> None:
+    text = "see .claude/worktrees/wt-1/notes.md"
+    assert scan_text_for_volatile_marker(text) == ".claude/worktrees/"
+
+
+def test_scan_cd_relative_worktree_path_is_detected() -> None:
+    text = "cd .claude/worktrees/wt-199 && pytest"
+    assert scan_text_for_volatile_marker(text) == ".claude/worktrees/"
+
+
+def test_scan_start_of_text_relative_worktree_path_is_detected() -> None:
+    text = ".claude/worktrees/wt-1/notes.md"
+    assert scan_text_for_volatile_marker(text) == ".claude/worktrees/"
+
+
+def test_scan_markdown_link_relative_worktree_target_is_detected() -> None:
+    text = "[notes](.claude/worktrees/wt-1/notes.md)"
+    assert scan_text_for_volatile_marker(text) == ".claude/worktrees/"
+
+
+def test_scan_space_prefixed_relative_job_scratch_path_is_detected() -> None:
+    text = "see .claude-editor/jobs/j1/log.txt"
+    assert scan_text_for_volatile_marker(text) == ".claude-editor/jobs/"
+
+
+def test_scan_backslash_relative_worktree_path_is_detected() -> None:
+    text = r"see .claude\worktrees\wt-1\notes.md"
+    assert scan_text_for_volatile_marker(text) == ".claude/worktrees/"
+
+
+def test_scan_prose_child_token_after_marker_is_detected() -> None:
+    text = "the .claude/worktrees/wt-name pattern"
+    assert scan_text_for_volatile_marker(text) == ".claude/worktrees/"
+
+
+def test_scan_relative_worktree_path_with_hyphen_child_is_detected() -> None:
+    text = "see .claude/worktrees/-scratch/notes.md"
+    assert scan_text_for_volatile_marker(text) == ".claude/worktrees/"
+
+
+def test_scan_placeholder_child_segment_is_allowed() -> None:
+    text = "worktrees live under `.claude/worktrees/<name>`"
+    assert scan_text_for_volatile_marker(text) is None
+
+
+def test_scan_sentence_final_marker_period_is_allowed() -> None:
+    text = "the constant is `.claude/worktrees/`. Next."
+    assert scan_text_for_volatile_marker(text) is None
+
+
 def test_gh_comment_with_job_scratch_path_is_blocked() -> None:
     command = (
         'gh pr comment 669 --body "Contact sheet at '
@@ -147,7 +244,7 @@ def test_mcp_issue_comment_body_blocked() -> None:
 
 
 def test_mcp_review_comment_param_blocked() -> None:
-    tool_input: dict[str, object] = {"comment": r"see .claude\worktrees\x\file"}
+    tool_input: dict[str, object] = {"comment": r"see C:\Users\me\.claude\worktrees\x\file"}
     assert _body_names_volatile_path(
         "mcp__plugin_github_github__add_reply_to_pull_request_comment", tool_input
     )
@@ -177,6 +274,21 @@ def test_extract_gh_post_body_texts_returns_inline_and_file(tmp_path: pathlib.Pa
     assert "file body text" in all_texts
 
 
+def test_gh_issue_edit_quoting_bare_constant_is_allowed(tmp_path: pathlib.Path) -> None:
+    body_file = tmp_path / "issue_body.md"
+    body_file.write_text(
+        "The manifest skips these tooling-state prefixes:\n"
+        '    ".claude/worktrees/",\n'
+        '    ".claude-editor/jobs/",\n'
+        "Neither is a machine-local path.",
+        encoding="utf-8",
+    )
+    command = f"gh issue edit 134 --body-file {body_file}"
+    all_body_texts = extract_gh_post_body_texts(command)
+    assert all_body_texts
+    assert hook_module._first_volatile_marker(all_body_texts) is None
+
+
 def test_hook_subprocess_denies_volatile_gh_comment() -> None:
     payload = {
         "tool_name": "Bash",

package/hooks/blocking/verification_verdict_store.py

@@ -13,6 +13,7 @@ and reading/writing verdict files.
 from __future__ import annotations
 
 import ast
+import datetime
 import hashlib
 import json
 import re
@@ -20,6 +21,7 @@ import subprocess
 import sys
 import time
 from pathlib import Path
+from collections.abc import Mapping
 
 blocking_directory = str(Path(__file__).resolve().parent)
 if blocking_directory not in sys.path:
@@ -45,6 +47,15 @@ from config.verified_commit_constants import (
     ALL_FALLBACK_BASE_REFERENCES,
     EMPTY_SURFACE_GUARD_MESSAGE,
     GIT_TIMEOUT_SECONDS,
+    LEDGER_KEY_ALL_PASS,
+    LEDGER_KEY_BRANCH,
+    LEDGER_KEY_FINDING_CHECK_NAMES,
+    LEDGER_KEY_FINDING_COUNT,
+    LEDGER_KEY_MANIFEST_HASH,
+    LEDGER_KEY_MINTED_FROM_AGENT_ID,
+    LEDGER_KEY_REPO_ROOT,
+    LEDGER_KEY_TIMESTAMP,
+    LOGS_DIRECTORY_NAME,
     MANIFEST_HASH_CLI_FLAG,
     MANIFEST_HASH_FOR_BRANCH_CLI_FLAG,
     MINIMUM_STATUS_FIELD_COUNT,
@@ -65,10 +76,12 @@ from config.verified_commit_constants import (
     VERDICT_DIRECTORY_NAME,
     VERDICT_FENCE_PATTERN,
     VERDICT_FILE_GLOB,
+    VERDICT_FINDING_CHECK_KEY,
     VERDICT_JSON_INDENT,
     VERDICT_KEY_ALL_PASS,
     VERDICT_KEY_FINDINGS,
     VERDICT_KEY_MANIFEST_SHA256,
+    VERIFIER_VERDICTS_JSONL_FILENAME,
     WORKTREE_LIST_BRANCH_PREFIX,
     WORKTREE_LIST_PATH_PREFIX,
 )
@@ -377,12 +390,36 @@ def verdict_directory() -> Path:
     return Path.home() / CLAUDE_HOME_DIRECTORY_NAME / VERDICT_DIRECTORY_NAME
 
 
+def root_key_for_repo(repo_root: str) -> str:
+    """Derive the shared path-key that names a work tree's store file.
+
+    ::
+
+        root_key_for_repo("/repo")  == root_key_for_repo("/repo/sub")   (same tree)
+        root_key_for_repo("/Repo")  == root_key_for_repo("/repo")        (case-folded)
+
+    The path is resolved, forward-slashed, and lowercased before hashing, so a
+    subdirectory of a work tree keys to the same file as its root and case
+    differences fold together. Both the verdict store and the code-review stamp
+    store key their per-work-tree files by this one derivation, so the two never
+    drift and an existing verdict file still resolves.
+
+    Args:
+        repo_root: The repository top-level directory.
+
+    Returns:
+        The lowercased hex path-key, truncated to ``ROOT_KEY_HEX_LENGTH`` chars.
+    """
+    normalized_root = str(Path(repo_root).resolve()).replace("\\", "/").lower()
+    return hashlib.sha256(normalized_root.encode("utf-8")).hexdigest()[:ROOT_KEY_HEX_LENGTH]
+
+
 def verdict_path_for_repo(repo_root: str) -> Path:
     """Derive the verdict file path for a repository work tree.
 
     Verdicts live outside the repository (under the user's Claude home) so
-    no repo accumulates untracked files, keyed by a hash of the normalized
-    work-tree path so every worktree gets its own verdict.
+    no repo accumulates untracked files, keyed by the shared
+    ``root_key_for_repo`` derivation so every worktree gets its own verdict.
 
     Args:
         repo_root: The repository top-level directory.
@@ -390,9 +427,7 @@ def verdict_path_for_repo(repo_root: str) -> Path:
     Returns:
         The verdict file path for this work tree.
     """
-    normalized_root = str(Path(repo_root).resolve()).replace("\\", "/").lower()
-    root_key = hashlib.sha256(normalized_root.encode("utf-8")).hexdigest()[:ROOT_KEY_HEX_LENGTH]
-    return verdict_directory() / f"{root_key}.json"
+    return verdict_directory() / f"{root_key_for_repo(repo_root)}.json"
 
 
 def load_valid_verdict(repo_root: str, expected_manifest_sha256: str) -> dict | None:
@@ -654,6 +689,74 @@ def workflow_verdict_covers_surface(
     return False
 
 
+def _finding_check_names(all_findings: list) -> list[str]:
+    """Collect the ``check`` name from each finding mapping that carries one.
+
+    Args:
+        all_findings: The verifier's findings list (empty when clean).
+
+    Returns:
+        Ordered list of non-empty check name strings; entries without a
+        string ``check`` field are omitted.
+    """
+    all_check_names: list[str] = []
+    for each_finding in all_findings:
+        if not isinstance(each_finding, Mapping):
+            continue
+        check_name = each_finding.get(VERDICT_FINDING_CHECK_KEY)
+        if isinstance(check_name, str) and check_name:
+            all_check_names.append(check_name)
+    return all_check_names
+
+
+def _append_verdict_ledger_row(
+    repo_root: str,
+    bound_manifest_sha256: str,
+    is_all_pass: bool,
+    all_findings: list,
+    minted_from_agent_id: str,
+) -> None:
+    """Append one fail-safe JSONL row for a minted verdict.
+
+    Writes to ``~/.claude/logs/verifier-verdicts.jsonl``. Swallows home
+    resolution and IO errors so a ledger failure never changes the mint.
+
+    Args:
+        repo_root: The repository top-level directory.
+        bound_manifest_sha256: Hash of the surface the verdict covers.
+        is_all_pass: Whether the verifier reported a clean verdict.
+        all_findings: The verifier's findings list (empty when clean).
+        minted_from_agent_id: The subagent invocation id, kept for audit.
+    """
+    try:
+        home_directory = Path.home()
+    except RuntimeError:
+        return
+    try:
+        ledger_path = (
+            home_directory
+            / CLAUDE_HOME_DIRECTORY_NAME
+            / LOGS_DIRECTORY_NAME
+            / VERIFIER_VERDICTS_JSONL_FILENAME
+        )
+        ledger_path.parent.mkdir(parents=True, exist_ok=True)
+        branch_name = _head_branch_name(repo_root)
+        ledger_row = {
+            LEDGER_KEY_TIMESTAMP: datetime.datetime.now(datetime.timezone.utc).isoformat(),
+            LEDGER_KEY_REPO_ROOT: repo_root,
+            LEDGER_KEY_BRANCH: branch_name,
+            LEDGER_KEY_MANIFEST_HASH: bound_manifest_sha256,
+            LEDGER_KEY_ALL_PASS: is_all_pass,
+            LEDGER_KEY_FINDING_COUNT: len(all_findings),
+            LEDGER_KEY_FINDING_CHECK_NAMES: _finding_check_names(all_findings),
+            LEDGER_KEY_MINTED_FROM_AGENT_ID: minted_from_agent_id,
+        }
+        with ledger_path.open("a", encoding="utf-8") as ledger_file:
+            ledger_file.write(json.dumps(ledger_row) + "\n")
+    except OSError:
+        return
+
+
 def write_verdict(
     repo_root: str,
     bound_manifest_sha256: str,
@@ -663,6 +766,9 @@ def write_verdict(
 ) -> Path:
     """Write a verdict file binding a verification outcome to a surface hash.
 
+    Also appends one durable JSONL ledger row under the Claude logs directory.
+    A ledger write failure never changes the mint outcome.
+
     Args:
         repo_root: The repository top-level directory.
         bound_manifest_sha256: Hash of the surface manifest the verdict covers.
@@ -686,6 +792,13 @@ def write_verdict(
     verdict_file.write_text(
         json.dumps(verdict_record, indent=VERDICT_JSON_INDENT), encoding="utf-8"
     )
+    _append_verdict_ledger_row(
+        repo_root,
+        bound_manifest_sha256,
+        is_all_pass,
+        all_findings,
+        minted_from_agent_id,
+    )
     return verdict_file
 
 

package/hooks/blocking/verified_commit_gate_parts/gated_invocations.py

@@ -81,14 +81,15 @@ def _resolved_option_value(
     return value_after_option(all_following_tokens, option_index)
 
 
-def gated_invocation_directory(all_following_tokens: list[str]) -> tuple[bool, str | None]:
+def gated_invocation_directory(
+    all_following_tokens: list[str],
+    all_gated_subcommands: frozenset[str] = GATED_GIT_SUBCOMMANDS,
+) -> tuple[bool, str | None]:
     """Walk the quote-stripped tokens after a ``git`` word to its subcommand.
 
-    ``git stash push`` is not gated ("push" is an argument); ``git commit -m
-    x`` is gated ("commit" sits in subcommand position).
-
-    Returns:
-        Whether the subcommand is gated, and its ``-C``/``--work-tree`` directory.
+    Args:
+        all_following_tokens: Quote-stripped tokens after the ``git`` word.
+        all_gated_subcommands: Subcommand names that gate; defaults to commit+push.
     """
     repo_directory: str | None = None
     work_tree_directory: str | None = None
@@ -108,7 +109,7 @@ def gated_invocation_directory(all_following_tokens: list[str]) -> tuple[bool, s
         if each_token.startswith("-"):
             token_index += 1
             continue
-        return each_token.lower() in GATED_GIT_SUBCOMMANDS, repo_directory or work_tree_directory
+        return each_token.lower() in all_gated_subcommands, repo_directory or work_tree_directory
     return False, repo_directory or work_tree_directory
 
 
@@ -167,11 +168,16 @@ def _apply_directory_change(
 
 
 def _target_directory_for_match(
-    command_text: str, git_word_match: re.Match[str], active_directory: str
+    command_text: str,
+    git_word_match: re.Match[str],
+    active_directory: str,
+    all_gated_subcommands: frozenset[str],
 ) -> str | None:
     """Resolve the gated directory for one ``git`` word match, or None."""
     all_following_tokens = _following_tokens(command_text, git_word_match.end())
-    is_gated, flagged_directory = gated_invocation_directory(all_following_tokens)
+    is_gated, flagged_directory = gated_invocation_directory(
+        all_following_tokens, all_gated_subcommands
+    )
     if not is_gated:
         return None
     if flagged_directory is None:
@@ -179,18 +185,22 @@ def _target_directory_for_match(
     return resolve_against(active_directory, flagged_directory)
 
 
-def gated_repo_directories(command_text: str, fallback_directory: str) -> list[str]:
-    """Collect the directories of every git commit/push found in a command.
+def gated_repo_directories(
+    command_text: str,
+    fallback_directory: str,
+    all_gated_subcommands: frozenset[str] = GATED_GIT_SUBCOMMANDS,
+) -> list[str]:
+    """Collect the directories of every gated git call found in a command.
 
     Args:
         command_text: The raw command string from the tool payload.
-        fallback_directory: The session working directory, used as the
-            active directory until a directory-change verb changes it and
-            when the git call carries no ``-C`` flag.
+        fallback_directory: The session working directory, the active directory
+            until a directory-change verb or a ``-C`` flag overrides it.
+        all_gated_subcommands: Subcommand names that gate; defaults to commit+push.
 
     Returns:
-        One directory per detected commit/push invocation, in order; empty
-        when the command carries no gated git verb.
+        One directory per detected gated invocation, in order; empty when the
+        command carries no gated git verb.
     """
     command_text = collapse_line_continuations(command_text)
     active_directory = fallback_directory
@@ -199,7 +209,9 @@ def gated_repo_directories(command_text: str, fallback_directory: str) -> list[s
         if each_match.group().lower().strip("\"'") in DIRECTORY_CHANGE_VERBS:
             active_directory = _apply_directory_change(command_text, each_match, active_directory)
             continue
-        target_directory = _target_directory_for_match(command_text, each_match, active_directory)
+        target_directory = _target_directory_for_match(
+            command_text, each_match, active_directory, all_gated_subcommands
+        )
         if target_directory is not None:
             target_directories.append(target_directory)
     return target_directories

package/hooks/blocking/verified_commit_gate_parts/tests/test_gated_invocations.py

@@ -59,3 +59,38 @@ def test_gated_repo_directories_gates_an_empty_work_tree_against_the_session() -
     assert gated_repo_directories("git --work-tree= commit -m x", "/session") == [
         os.path.join("/session", "")
     ]
+
+
+def test_default_gated_subcommands_gates_both_commit_and_push() -> None:
+    assert gated_repo_directories("git commit -m x", "/session") == ["/session"]
+    assert gated_repo_directories("git push", "/session") == ["/session"]
+
+
+def test_push_only_subcommands_gate_push_but_not_commit() -> None:
+    push_only = frozenset({"push"})
+    assert gated_invocation_directory(["push"], push_only)[0] is True
+    assert gated_invocation_directory(["commit", "-m", "x"], push_only)[0] is False
+
+
+def test_commit_only_subcommands_gate_commit_but_not_push() -> None:
+    commit_only = frozenset({"commit"})
+    assert gated_invocation_directory(["commit", "-m", "x"], commit_only)[0] is True
+    assert gated_invocation_directory(["push"], commit_only)[0] is False
+
+
+def test_gated_repo_directories_threads_push_only_subcommands() -> None:
+    push_only = frozenset({"push"})
+    assert gated_repo_directories("git push", "/session", push_only) == ["/session"]
+    assert gated_repo_directories("git commit -m x", "/session", push_only) == []
+
+
+def test_gated_repo_directories_accepts_the_all_gated_subcommands_keyword() -> None:
+    push_only = frozenset({"push"})
+    assert gated_repo_directories(
+        "git push", "/session", all_gated_subcommands=push_only
+    ) == ["/session"]
+
+
+def test_gated_invocation_directory_accepts_the_all_gated_subcommands_keyword() -> None:
+    push_only = frozenset({"push"})
+    assert gated_invocation_directory(["push"], all_gated_subcommands=push_only)[0] is True

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 = (