claude-dev-env 2.9.0 → 2.11.0

package/hooks/blocking/test_pre_tool_use_dispatcher_native.py

@@ -13,14 +13,22 @@ equivalence holds across both outcomes.
 from __future__ import annotations
 
 import json
+import os
 import subprocess
 import sys
 from pathlib import Path
+from unittest.mock import patch
+
+import pytest
 
 _HOOKS_DIR = str(Path(__file__).resolve().parent.parent)
 if _HOOKS_DIR not in sys.path:
     sys.path.insert(0, _HOOKS_DIR)
 
+_PROSE_STYLE_ENFORCEMENT_ENVIRONMENT = {
+    "CLAUDE_PROSE_STYLE_ENFORCEMENT": "1",
+}
+
 from hooks_constants.pre_tool_use_dispatcher_constants import (  # noqa: E402, I001
     DENY_DECISION,
     EDIT_TOOL_NAME,
@@ -43,6 +51,19 @@ _STATE_DESCRIPTION_DENY_CONTENT = "# Guide\n\nPreviously the system used port 80
 _PLAIN_LANGUAGE_ALLOW_CONTENT = "# Guide\n\nStart the build to make the report.\n"
 _PLAIN_LANGUAGE_DENY_CONTENT = "# Guide\n\nUtilize this to commence the process.\n"
 
+_PROSE_STYLE_ENV_VAR = "CLAUDE_PROSE_STYLE_ENFORCEMENT"
+_PROSE_STYLE_ENV_VALUE = "1"
+
+@pytest.fixture(autouse=True)
+def enable_prose_style_enforcement(monkeypatch: pytest.MonkeyPatch) -> None:
+    """Opinionated prose gates are default-off; native-equivalence tests arm them."""
+    monkeypatch.setenv(_PROSE_STYLE_ENV_VAR, _PROSE_STYLE_ENV_VALUE)
+
+def _subprocess_environment() -> dict[str, str]:
+    """Return process env with opinionated prose gates enabled."""
+    environment_by_key = os.environ.copy()
+    environment_by_key[_PROSE_STYLE_ENV_VAR] = _PROSE_STYLE_ENV_VALUE
+    return environment_by_key
 
 def _write_payload_dictionary(file_path: str, content: str) -> dict[str, object]:
     """Build a Write tool payload dict.
@@ -59,7 +80,6 @@ def _write_payload_dictionary(file_path: str, content: str) -> dict[str, object]
         "tool_input": {"file_path": file_path, "content": content},
     }
 
-
 def _edit_payload_dictionary(file_path: str, new_string: str) -> dict[str, object]:
     """Build an Edit tool payload dict.
 
@@ -79,7 +99,6 @@ def _edit_payload_dictionary(file_path: str, new_string: str) -> dict[str, objec
         },
     }
 
-
 def _multi_edit_payload_dictionary(file_path: str, new_string: str) -> dict[str, object]:
     """Build a MultiEdit tool payload dict.
 
@@ -99,6 +118,14 @@ def _multi_edit_payload_dictionary(file_path: str, new_string: str) -> dict[str,
     }
 
 
+def _evaluate_with_prose_style_opt_in(
+    evaluate_callable: object, payload_dictionary: dict[str, object]
+) -> str | None:
+    """Call a native evaluate with opinionated prose enforcement enabled."""
+    with patch.dict(os.environ, _PROSE_STYLE_ENFORCEMENT_ENVIRONMENT):
+        return evaluate_callable(payload_dictionary)  # type: ignore[operator]
+
+
 def _run_script_subprocess(script_path: str, payload_dictionary: dict[str, object]) -> str:
     """Run a hook script as a subprocess and return its stripped stdout.
 
@@ -116,10 +143,10 @@ def _run_script_subprocess(script_path: str, payload_dictionary: dict[str, objec
         capture_output=True,
         text=True,
         encoding="utf-8",
+        env=_subprocess_environment(),
     )
     return completed_process.stdout.strip()
 
-
 def _deny_reason_from_script_stdout(stdout_text: str) -> str | None:
     """Parse a script's stdout into its deny-reason text, or None for allow.
 
@@ -139,7 +166,6 @@ def _deny_reason_from_script_stdout(stdout_text: str) -> str | None:
     reason_text = hook_specific.get("permissionDecisionReason", "")
     return reason_text if isinstance(reason_text, str) else None
 
-
 def _deny_reason_from_dispatcher(payload_dictionary: dict[str, object]) -> str | None:
     """Run the dispatcher as a subprocess and return its deny-reason text.
 
@@ -157,10 +183,10 @@ def _deny_reason_from_dispatcher(payload_dictionary: dict[str, object]) -> str |
         capture_output=True,
         text=True,
         encoding="utf-8",
+        env=_subprocess_environment(),
     )
     return _deny_reason_from_script_stdout(completed_process.stdout.strip())
 
-
 def _deny_payload_from_dispatcher(payload_dictionary: dict[str, object]) -> dict[str, object]:
     """Run the dispatcher as a subprocess and return its parsed deny payload.
 
@@ -177,145 +203,157 @@ def _deny_payload_from_dispatcher(payload_dictionary: dict[str, object]) -> dict
         capture_output=True,
         text=True,
         encoding="utf-8",
+        env=_subprocess_environment(),
     )
     parsed_payload = json.loads(completed_process.stdout.strip())
     assert isinstance(parsed_payload, dict)
     return parsed_payload
 
-
 def test_state_description_native_allows_match_script() -> None:
     """state_description_blocker native allow matches the script's allow."""
     payload_dictionary = _write_payload_dictionary(_MARKDOWN_PATH, _STATE_DESCRIPTION_ALLOW_CONTENT)
-    native_reason = state_description_blocker.evaluate(payload_dictionary)
+    native_reason = _evaluate_with_prose_style_opt_in(state_description_blocker.evaluate, payload_dictionary)
     script_stdout = _run_script_subprocess(_STATE_DESCRIPTION_SCRIPT, payload_dictionary)
     script_reason = _deny_reason_from_script_stdout(script_stdout)
     assert native_reason is None
     assert script_reason is None
 
-
 def test_state_description_native_deny_matches_script_reason() -> None:
     """state_description_blocker native deny reason matches the script's reason."""
     payload_dictionary = _write_payload_dictionary(_MARKDOWN_PATH, _STATE_DESCRIPTION_DENY_CONTENT)
-    native_reason = state_description_blocker.evaluate(payload_dictionary)
+    native_reason = _evaluate_with_prose_style_opt_in(state_description_blocker.evaluate, payload_dictionary)
     script_stdout = _run_script_subprocess(_STATE_DESCRIPTION_SCRIPT, payload_dictionary)
     script_reason = _deny_reason_from_script_stdout(script_stdout)
     assert native_reason is not None
     assert native_reason == script_reason
 
-
 def test_state_description_native_edit_deny_matches_script_reason() -> None:
     """state_description_blocker native and script agree on an Edit denial."""
     payload_dictionary = _edit_payload_dictionary(
         _MARKDOWN_PATH, "Previously this used the old client.\n"
     )
-    native_reason = state_description_blocker.evaluate(payload_dictionary)
+    native_reason = _evaluate_with_prose_style_opt_in(state_description_blocker.evaluate, payload_dictionary)
     script_stdout = _run_script_subprocess(_STATE_DESCRIPTION_SCRIPT, payload_dictionary)
     script_reason = _deny_reason_from_script_stdout(script_stdout)
     assert native_reason is not None
     assert native_reason == script_reason
 
-
 def test_state_description_native_non_target_tool_allows_match_script() -> None:
     """state_description_blocker native allows MultiEdit, matching the script."""
     payload_dictionary = _multi_edit_payload_dictionary(
         _MARKDOWN_PATH, _STATE_DESCRIPTION_DENY_CONTENT
     )
-    native_reason = state_description_blocker.evaluate(payload_dictionary)
+    native_reason = _evaluate_with_prose_style_opt_in(state_description_blocker.evaluate, payload_dictionary)
     script_stdout = _run_script_subprocess(_STATE_DESCRIPTION_SCRIPT, payload_dictionary)
     script_reason = _deny_reason_from_script_stdout(script_stdout)
     assert native_reason is None
     assert script_reason is None
 
-
 def test_plain_language_native_allows_match_script() -> None:
     """plain_language_blocker native allow matches the script's allow."""
     payload_dictionary = _write_payload_dictionary(_MARKDOWN_PATH, _PLAIN_LANGUAGE_ALLOW_CONTENT)
-    native_reason = plain_language_blocker.evaluate(payload_dictionary)
+    native_reason = _evaluate_with_prose_style_opt_in(plain_language_blocker.evaluate, payload_dictionary)
     script_stdout = _run_script_subprocess(_PLAIN_LANGUAGE_SCRIPT, payload_dictionary)
     script_reason = _deny_reason_from_script_stdout(script_stdout)
     assert native_reason is None
     assert script_reason is None
 
 
-def test_plain_language_native_deny_matches_script_reason() -> None:
-    """plain_language_blocker native deny reason matches the script's reason."""
+def test_plain_language_native_heavy_word_advisory_matches_script() -> None:
+    """plain_language_blocker native and script agree: no deny, allow advisory."""
     payload_dictionary = _write_payload_dictionary(_MARKDOWN_PATH, _PLAIN_LANGUAGE_DENY_CONTENT)
-    native_reason = plain_language_blocker.evaluate(payload_dictionary)
+    with patch.dict(os.environ, _PROSE_STYLE_ENFORCEMENT_ENVIRONMENT):
+        native_deny, native_advisory = plain_language_blocker.evaluate_with_advisory(
+            payload_dictionary
+        )
     script_stdout = _run_script_subprocess(_PLAIN_LANGUAGE_SCRIPT, payload_dictionary)
     script_reason = _deny_reason_from_script_stdout(script_stdout)
-    assert native_reason is not None
-    assert native_reason == script_reason
+    assert native_deny is None
+    assert script_reason is None
+    assert native_advisory is not None
+    assert "utilize" in native_advisory.lower() or "commence" in native_advisory.lower()
+    script_payload = json.loads(script_stdout)
+    assert script_payload["hookSpecificOutput"]["permissionDecision"] == "allow"
+    assert native_advisory in script_payload["systemMessage"]
 
 
-def test_plain_language_native_multi_edit_deny_matches_script_reason() -> None:
-    """plain_language_blocker native and script agree on a MultiEdit denial."""
+def test_plain_language_native_multi_edit_heavy_word_advisory_matches_script() -> None:
+    """plain_language_blocker native and script agree on MultiEdit heavy-word allow."""
     payload_dictionary = _multi_edit_payload_dictionary(
         _MARKDOWN_PATH, "Utilize this to commence the process.\n"
     )
-    native_reason = plain_language_blocker.evaluate(payload_dictionary)
+    with patch.dict(os.environ, _PROSE_STYLE_ENFORCEMENT_ENVIRONMENT):
+        native_deny, native_advisory = plain_language_blocker.evaluate_with_advisory(
+            payload_dictionary
+        )
     script_stdout = _run_script_subprocess(_PLAIN_LANGUAGE_SCRIPT, payload_dictionary)
     script_reason = _deny_reason_from_script_stdout(script_stdout)
-    assert native_reason is not None
-    assert native_reason == script_reason
-
+    assert native_deny is None
+    assert script_reason is None
+    assert native_advisory is not None
+    script_payload = json.loads(script_stdout)
+    assert script_payload["hookSpecificOutput"]["permissionDecision"] == "allow"
+    assert native_advisory in script_payload["systemMessage"]
 
 def test_plain_language_native_non_markdown_allows_match_script() -> None:
     """plain_language_blocker native allows a non-markdown Write, matching the script."""
     payload_dictionary = _write_payload_dictionary(_PYTHON_PATH, _PLAIN_LANGUAGE_DENY_CONTENT)
-    native_reason = plain_language_blocker.evaluate(payload_dictionary)
+    native_reason = _evaluate_with_prose_style_opt_in(plain_language_blocker.evaluate, payload_dictionary)
     script_stdout = _run_script_subprocess(_PLAIN_LANGUAGE_SCRIPT, payload_dictionary)
     script_reason = _deny_reason_from_script_stdout(script_stdout)
     assert native_reason is None
     assert script_reason is None
 
-
 def test_dispatcher_native_path_denies_state_description() -> None:
     """The dispatcher's native path denies a state_description_blocker violation."""
     payload_dictionary = _write_payload_dictionary(_MARKDOWN_PATH, _STATE_DESCRIPTION_DENY_CONTENT)
-    native_reason = state_description_blocker.evaluate(payload_dictionary)
+    native_reason = _evaluate_with_prose_style_opt_in(state_description_blocker.evaluate, payload_dictionary)
     dispatcher_reason = _deny_reason_from_dispatcher(payload_dictionary)
     assert native_reason is not None
     assert dispatcher_reason is not None
     assert native_reason in dispatcher_reason
 
 
-def test_dispatcher_native_path_denies_plain_language() -> None:
-    """The dispatcher's native path denies a plain_language_blocker violation."""
+def test_dispatcher_native_path_allows_plain_language_heavy_word() -> None:
+    """The dispatcher's native path allows heavy words and does not deny."""
     payload_dictionary = _multi_edit_payload_dictionary(
         _MARKDOWN_PATH, "Utilize this to commence the process.\n"
     )
-    native_reason = plain_language_blocker.evaluate(payload_dictionary)
+    native_reason = _evaluate_with_prose_style_opt_in(
+        plain_language_blocker.evaluate, payload_dictionary
+    )
     dispatcher_reason = _deny_reason_from_dispatcher(payload_dictionary)
-    assert native_reason is not None
-    assert dispatcher_reason is not None
-    assert native_reason in dispatcher_reason
+    assert native_reason is None
+    assert dispatcher_reason is None
 
 
-def test_dispatcher_native_plain_language_carries_system_message() -> None:
-    """The dispatcher's plain-language deny carries the standalone systemMessage."""
+def test_dispatcher_native_plain_language_carries_advisory_system_message() -> None:
+    """The dispatcher's plain-language allow carries the advisory systemMessage."""
     payload_dictionary = _write_payload_dictionary(_MARKDOWN_PATH, _PLAIN_LANGUAGE_DENY_CONTENT)
-    deny_reason = plain_language_blocker.evaluate(payload_dictionary)
-    assert deny_reason is not None
-    standalone_payload = plain_language_blocker.build_deny_payload(deny_reason)
-    expected_system_message = standalone_payload["systemMessage"]
-    assert isinstance(expected_system_message, str)
+    with patch.dict(os.environ, _PROSE_STYLE_ENFORCEMENT_ENVIRONMENT):
+        deny_reason, advisory_message = plain_language_blocker.evaluate_with_advisory(
+            payload_dictionary
+        )
+    assert deny_reason is None
+    assert advisory_message is not None
     dispatcher_payload = _deny_payload_from_dispatcher(payload_dictionary)
+    assert dispatcher_payload["hookSpecificOutput"]["permissionDecision"] == "allow"
     dispatcher_system_message = dispatcher_payload.get("systemMessage")
     assert isinstance(dispatcher_system_message, str)
-    assert expected_system_message in dispatcher_system_message
+    assert advisory_message in dispatcher_system_message
 
 
-def test_dispatcher_native_plain_language_carries_suppress_output() -> None:
-    """The dispatcher's plain-language deny carries the standalone suppressOutput flag."""
+def test_dispatcher_native_plain_language_allow_does_not_suppress_output() -> None:
+    """The dispatcher's plain-language advisory allow leaves suppressOutput off."""
     payload_dictionary = _write_payload_dictionary(_MARKDOWN_PATH, _PLAIN_LANGUAGE_DENY_CONTENT)
     dispatcher_payload = _deny_payload_from_dispatcher(payload_dictionary)
-    assert dispatcher_payload.get("suppressOutput") is True
-
+    assert dispatcher_payload.get("suppressOutput") is not True
+    assert dispatcher_payload["hookSpecificOutput"]["permissionDecision"] == "allow"
 
 def test_dispatcher_native_state_description_carries_additional_context() -> None:
     """The dispatcher's state-description deny carries the standalone additionalContext."""
     payload_dictionary = _write_payload_dictionary(_MARKDOWN_PATH, _STATE_DESCRIPTION_DENY_CONTENT)
-    deny_reason = state_description_blocker.evaluate(payload_dictionary)
+    deny_reason = _evaluate_with_prose_style_opt_in(state_description_blocker.evaluate, payload_dictionary)
     assert deny_reason is not None
     standalone_payload = state_description_blocker.build_deny_payload(deny_reason)
     standalone_hook_specific = standalone_payload["hookSpecificOutput"]
@@ -326,11 +364,10 @@ def test_dispatcher_native_state_description_carries_additional_context() -> Non
     assert isinstance(dispatcher_hook_specific, dict)
     assert dispatcher_hook_specific.get("additionalContext") == expected_additional_context
 
-
 def test_dispatcher_native_state_description_carries_system_message() -> None:
     """The dispatcher's state-description deny carries the standalone systemMessage."""
     payload_dictionary = _write_payload_dictionary(_MARKDOWN_PATH, _STATE_DESCRIPTION_DENY_CONTENT)
-    deny_reason = state_description_blocker.evaluate(payload_dictionary)
+    deny_reason = _evaluate_with_prose_style_opt_in(state_description_blocker.evaluate, payload_dictionary)
     assert deny_reason is not None
     standalone_payload = state_description_blocker.build_deny_payload(deny_reason)
     expected_system_message = standalone_payload["systemMessage"]

package/hooks/blocking/test_state_description_blocker.py

@@ -19,8 +19,8 @@ if _HOOKS_ROOT not in sys.path:
 from pre_tool_use_dispatcher import NativeHook, run_native_hook  # noqa: E402
 from state_description_blocker import (  # noqa: E402
     build_deny_payload,
-    evaluate,
 )
+from state_description_blocker import evaluate as _evaluate_without_opt_in  # noqa: E402
 
 HOOK_SCRIPT_PATH = os.path.join(
     os.path.dirname(__file__), "state_description_blocker.py"
@@ -39,23 +39,66 @@ VIOLATION_MD_PREVIOUSLY = "# Config\n\nPreviously set via env var."
 VIOLATION_MD_NOW_USES = "# Auth\n\nNow uses OAuth2."
 
 
+def evaluate(payload_by_key: dict[str, object]) -> str | None:
+    """Call evaluate with opinionated prose enforcement enabled."""
+    with patch.dict(os.environ, {"CLAUDE_PROSE_STYLE_ENFORCEMENT": "1"}):
+        return _evaluate_without_opt_in(payload_by_key)
+
+
 class _RunHook:
     """Helper to test the hook via subprocess."""
 
-    def __call__(self, tool_name: str, tool_input: dict) -> subprocess.CompletedProcess:
+    def __call__(
+        self,
+        tool_name: str,
+        tool_input: dict,
+        *,
+        is_prose_style_enabled: bool = True,
+    ) -> subprocess.CompletedProcess:
         payload = json.dumps({"tool_name": tool_name, "tool_input": tool_input})
+        environment_by_key = os.environ.copy()
+        if is_prose_style_enabled:
+            environment_by_key["CLAUDE_PROSE_STYLE_ENFORCEMENT"] = "1"
+        else:
+            environment_by_key.pop("CLAUDE_PROSE_STYLE_ENFORCEMENT", None)
         return subprocess.run(
             [sys.executable, HOOK_SCRIPT_PATH],
             input=payload,
             capture_output=True,
             text=True,
             check=False,
+            env=environment_by_key,
         )
 
 
 _run_hook = _RunHook()
 
 
+def test_historical_phrase_scan_is_default_off(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    monkeypatch.delenv("CLAUDE_PROSE_STYLE_ENFORCEMENT", raising=False)
+    result = _run_hook(
+        "Write",
+        {
+            "file_path": "src/main.py",
+            "content": VIOLATION_INSTEAD_OF_COMMENT,
+        },
+        is_prose_style_enabled=False,
+    )
+    assert result.returncode == 0
+    assert result.stdout == ""
+    assert _evaluate_without_opt_in(
+        {
+            "tool_name": "Write",
+            "tool_input": {
+                "file_path": "src/main.py",
+                "content": VIOLATION_INSTEAD_OF_COMMENT,
+            },
+        }
+    ) is None
+
+
 def test_block_clean_python_comment_passes():
     result = _run_hook(
         "Write",

package/hooks/blocking/test_stop_dispatcher.py

@@ -156,9 +156,10 @@ def test_dispatcher_blocks_hedging_message_matching_standalone() -> None:
     payload_text = json.dumps(
         {
             "stop_hook_active": False,
-            "last_assistant_message": "This is probably correct without a source.",
+            "last_assistant_message": "This is probably correct.",
         }
     )
+    environment_by_key = {**os.environ, "CLAUDE_PROSE_STYLE_ENFORCEMENT": "1"}
     completed = subprocess.run(
         [sys.executable, _DISPATCHER_SCRIPT],
         check=False,
@@ -166,6 +167,7 @@ def test_dispatcher_blocks_hedging_message_matching_standalone() -> None:
         capture_output=True,
         text=True,
         encoding="utf-8",
+        env=environment_by_key,
     )
     assert completed.returncode == 0
     parsed = json.loads(completed.stdout)
@@ -173,14 +175,16 @@ def test_dispatcher_blocks_hedging_message_matching_standalone() -> None:
     assert "probably" in parsed["reason"].lower() or "hedging" in parsed["reason"].lower()
 
 
-def test_dispatcher_blocks_overlong_reply_matching_standalone() -> None:
-    """An overlong last_assistant_message blocks through the dispatcher."""
-    overlong_message = "\n".join(
-        " ".join(f"finding{each_index}" for each_index in range(10))
-        for _ in range(30)
+def test_dispatcher_blocks_eli11_shape_violation_matching_standalone() -> None:
+    """An ELI11 shape violation (too many bullets) blocks through the dispatcher."""
+    too_many_bullets_message = "\n".join(
+        f"- finding{each_index} detail for this line" for each_index in range(7)
     )
     payload_text = json.dumps(
-        {"stop_hook_active": False, "last_assistant_message": overlong_message}
+        {
+            "stop_hook_active": False,
+            "last_assistant_message": too_many_bullets_message,
+        }
     )
     completed = subprocess.run(
         [sys.executable, _DISPATCHER_SCRIPT],

package/hooks/blocking/test_volatile_path_in_post_blocker.py

@@ -31,13 +31,13 @@ def _body_names_volatile_path(tool_name: str, tool_input: dict[str, object]) ->
 
 
 def test_scan_detects_job_scratch_path_backslash() -> None:
-    text = r"See C:\Users\example\.claude-editor\jobs\95762cea\tmp\staging\contact_sheet.png"
-    assert scan_text_for_volatile_marker(text) == ".claude-editor/jobs/"
+    text = r"See C:\Users\example\.claude-profile-a\jobs\95762cea\tmp\staging\contact_sheet.png"
+    assert scan_text_for_volatile_marker(text) == ".claude-profile-a/jobs/"
 
 
 def test_scan_detects_job_scratch_path_forward_slash() -> None:
-    text = "artifact at /home/user/.claude-editor/jobs/abc/tmp/out.png"
-    assert scan_text_for_volatile_marker(text) == ".claude-editor/jobs/"
+    text = "artifact at /home/user/.claude-profile-a/jobs/abc/tmp/out.png"
+    assert scan_text_for_volatile_marker(text) == ".claude-profile-a/jobs/"
 
 
 def test_scan_detects_worktree_path() -> None:
@@ -92,12 +92,12 @@ def test_scan_home_anchored_worktree_path_is_detected() -> None:
 
 
 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/"
+    text = "/home/me/.claude-profile-a/jobs/j1/log.txt"
+    assert scan_text_for_volatile_marker(text) == ".claude-profile-a/jobs/"
 
 
 def test_scan_bare_parenthesized_job_scratch_mention_is_allowed() -> None:
-    text = "(.claude-editor/jobs/) as a directory name in prose"
+    text = "(.claude-profile-a/jobs/) as a directory name in prose"
     assert scan_text_for_volatile_marker(text) is None
 
 
@@ -139,8 +139,8 @@ def test_scan_markdown_link_relative_worktree_target_is_detected() -> None:
 
 
 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/"
+    text = "see .claude-profile-a/jobs/j1/log.txt"
+    assert scan_text_for_volatile_marker(text) == ".claude-profile-a/jobs/"
 
 
 def test_scan_backslash_relative_worktree_path_is_detected() -> None:
@@ -171,7 +171,7 @@ def test_scan_sentence_final_marker_period_is_allowed() -> None:
 def test_gh_comment_with_job_scratch_path_is_blocked() -> None:
     command = (
         'gh pr comment 669 --body "Contact sheet at '
-        r'C:\Users\example\.claude-editor\jobs\95762cea\tmp\staging\contact_sheet.png"'
+        r'C:\Users\example\.claude-profile-a\jobs\95762cea\tmp\staging\contact_sheet.png"'
     )
     assert _body_names_volatile_path("Bash", {"command": command})
 
@@ -223,7 +223,7 @@ def test_substring_mention_of_gh_post_does_not_classify() -> None:
 
 
 def test_gh_word_not_first_token_does_not_classify() -> None:
-    command = r'echo gh pr comment 42 --body "see C:\.claude-editor\jobs\x"'
+    command = r'echo gh pr comment 42 --body "see C:\.claude-profile-a\jobs\x"'
     assert not _body_names_volatile_path("Bash", {"command": command})
 
 
@@ -279,7 +279,7 @@ def test_gh_issue_edit_quoting_bare_constant_is_allowed(tmp_path: pathlib.Path)
     body_file.write_text(
         "The manifest skips these tooling-state prefixes:\n"
         '    ".claude/worktrees/",\n'
-        '    ".claude-editor/jobs/",\n'
+        '    ".claude-profile-a/jobs/",\n'
         "Neither is a machine-local path.",
         encoding="utf-8",
     )

package/hooks/blocking/volatile_path_in_post_blocker.py

@@ -21,7 +21,7 @@ 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
+anywhere. Two dot-relative directory markers, ``.claude-profile-a/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
@@ -117,7 +117,7 @@ def scan_text_for_volatile_marker(text: str) -> str | None:
     markers match anywhere::
 
         ok:   "the `.claude/worktrees/` manifest key"    -> None
-        flag: r"C:\\Users\\me\\.claude-editor\\jobs\\x"   -> ".claude-editor/jobs/"
+        flag: r"C:\\Users\\me\\.claude-profile-a\\jobs\\x"   -> ".claude-profile-a/jobs/"
         flag: "see .claude/worktrees/wt-1/notes.md"       -> ".claude/worktrees/"
         flag: "saved to %TEMP%\\out.txt"                  -> "%temp%"
 

package/hooks/hooks.json

@@ -176,6 +176,21 @@
             "type": "command",
             "command": "python3 ${CLAUDE_PLUGIN_ROOT}/hooks/session/task_list_loop_starter.py",
             "timeout": 10
+          },
+          {
+            "type": "command",
+            "command": "python3 ${CLAUDE_PLUGIN_ROOT}/hooks/session/working_style_prompt.py",
+            "timeout": 10
+          },
+          {
+            "type": "command",
+            "command": "python3 ${CLAUDE_PLUGIN_ROOT}/hooks/session/orchestrator_auto_starter.py",
+            "timeout": 10
+          },
+          {
+            "type": "command",
+            "command": "python3 ${CLAUDE_PLUGIN_ROOT}/hooks/session/issue_tracker_session_starter.py",
+            "timeout": 10
           }
         ]
       }

package/hooks/hooks_constants/CLAUDE.md

@@ -8,6 +8,7 @@ Shared constant modules imported by hooks throughout the `hooks/` tree. Each fil
 |---|---|
 | `__init__.py` | Package marker (`# pragma: no-tdd-gate`) |
 | `any_type_config.py` | Config for the `Any`-type escape-hatch check |
+| `ask_user_question_shape.py` | Pure AskUserQuestion lean-block shape analyzer: grades question and option-description prose against shared chat-detail markers and sentence/word caps with no hook I/O |
 | `banned_identifiers_constants.py` | The set of banned short identifiers and banned function-name prefixes |
 | `bash_pre_tool_use_dispatcher_constants.py` | Permission outcomes, tool-name sets, and the ordered hosted-hook roster for the Bash PreToolUse dispatcher (also covers PowerShell-shared gates) |
 | `blocking_check_limits.py` | Max issue counts and preview lengths for blocking hooks |
@@ -31,11 +32,12 @@ Shared constant modules imported by hooks throughout the `hooks/` tree. Each fil
 | `duplicate_function_body_constants.py` | Hashing and comparison config for the duplicate-body check |
 | `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 |
+| `eli11_reply_enforcer_constants.py` | Reply-shape thresholds (bullet cap, lead-line window, per-list-line word cap, overpacked list-line cap), 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 |
+| `hedging_uncertainty_constants.py` | Sentence-boundary pattern, explicit uncertainty label patterns, hedge-term list separator, and positive corrective block text for OP-07C sentence-scoped hedging |
 | `hook_block_logger.py` | `log_hook_block()` — shared fail-safe logger every blocking hook calls to append a JSON record of each block decision to `~/.claude/logs/hook-blocks.log` |
 | `hook_log_extractor_constants.py` | Neon table name, offset state file path, timeouts, and outcome-type mapping for the hook-log extractor |
 | `hook_prose_detector_consistency_constants.py` | Trigger patterns and corrective messages for the hook-prose consistency checker |
@@ -54,15 +56,17 @@ 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 |
+| `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; classification that consumes those program and wrapper constants lives in `pytest_invocation.py` |
+| `pytest_invocation.py` | Pure parsed-segment classifier for pytest runs through interpreters, shims, wrappers, and shell string-exec forms; no pipeline deny decision |
 | `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 |
 | `pr_description_enforcer_constants.py` | PR-description shape rules and command patterns |
 | `pr_description_proof_of_work_constants.py` | Proof-part detection patterns, gh command tokens, and corrective messages for the proof-of-work comment audit |
+| `prose_matcher_precision_constants.py` | Sample floor, keep/narrow precision floors, matcher ids, label decisions, advisory log path, emit caps, and context fingerprint length for OP-07B prose-matcher advisory telemetry |
 | `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 |
+| project_paths_reader.py | Loads ~/.claude/project-paths.json and finds a home-bounded git root for registry checks |
 | `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 |
@@ -72,8 +76,14 @@ Shared constant modules imported by hooks throughout the `hooks/` tree. Each fil
 | `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 |
 | `session_env_cleanup_constants.py` | Stale-age threshold and directory names for the session-env cleanup hook |
+| `session_start_injector.py` | Pure SessionStart context injector: normalize `source` (`startup`/`resume`/`clear`/`compact`), honor enable/timeout, return structured injection results for starter hooks |
+| `session_start_injector_constants.py` | Known SessionStart source values, injection status codes, enable env var, default timeout for the shared injector |
+| `test_session_start_injector.py` | Behavioral tests for every known source, disabled, timeout, and unknown-source paths |
+| `orchestrator_auto_starter_constants.py` | Opt-in env var, enable values, timeout, and SessionStart directive text for the orchestrator auto-starter |
+| `issue_tracker_session_starter_constants.py` | Opt-in env var, enable values, timeout, and SessionStart directive text for the repository-gated issue-tracker starter |
 | `session_handoff_blocker_constants.py` | Trigger phrases for the session-handoff blocker |
 | `setup_project_paths_constants.py` | Encoding policy, BOM marker, and registry meta-key used across multiple hooks |
+| `shell_command_pipeline.py` | Quote-aware shell pipeline parsing: operator-paired segments after line-continuation join, comment strip, heredoc body drop, and parenthesis-group join |
 | `shell_command_segments.py` | Shell tokenization helpers shared by the segment-walking blockers: segment splitting on control operators, a segment's effective leading program, and a token's basename |
 | `shell_substitution_blocker_constants.py` | Tool name, payload keys, the four substitution-detection patterns, the deny decision shape, and the corrective message for the shell-substitution blocker |
 | `stale_comment_reference_blocker_constants.py` | Identifier pattern, comment stopwords, and denial text for the stale-comment-reference blocker |
@@ -91,6 +101,7 @@ Shared constant modules imported by hooks throughout the `hooks/` tree. Each fil
 | `volatile_path_in_post_blocker_constants.py` | Volatile path markers, affected `gh` post subcommands, MCP body param names, and the corrective message for the volatile-path post blocker |
 | `windows_rmtree_blocker_constants.py` | The unsafe `shutil.rmtree` pattern and the safe replacement pattern |
 | `workflow_substitution_slot_blocker_constants.py` | Per-iteration token patterns for the workflow-slot blocker |
+| `working_style_prompt_constants.py` | The fixed multi-paragraph working-style prompt text for the SessionStart working_style_prompt hook |
 
 ## Conventions