claude-dev-env 2.9.0 → 2.11.0

package/hooks/blocking/test_hedging_language_blocker.py

@@ -1,12 +1,15 @@
 """Tests for hedging_language_blocker hook response shape."""
 
 import importlib.util
+import io
 import json
 import os
 import subprocess
 import sys
 import tempfile
 
+import pytest
+
 HOOK_SCRIPT_PATH = os.path.join(os.path.dirname(__file__), "hedging_language_blocker.py")
 _HOOKS_DIR = os.path.dirname(HOOK_SCRIPT_PATH)
 _HOOKS_ROOT = os.path.join(_HOOKS_DIR, "..")
@@ -30,14 +33,22 @@ CLEAN_MESSAGE = "This is verified by the source document."
 EMPTY_MESSAGE = ""
 
 
-def run_hook_with_message(assistant_message: str) -> subprocess.CompletedProcess:
+def run_hook_with_message(
+    assistant_message: str, *, is_prose_style_enabled: bool = True
+) -> subprocess.CompletedProcess:
     hook_input_payload = json.dumps({"last_assistant_message": assistant_message})
+    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=hook_input_payload,
         capture_output=True,
         text=True,
         check=False,
+        env=environment_by_key,
     )
 
 
@@ -58,6 +69,8 @@ def run_hook_with_patched_search_paths(
         wrapper_file_path = wrapper_file.name
 
     hook_input_payload = json.dumps({"last_assistant_message": assistant_message})
+    environment_by_key = os.environ.copy()
+    environment_by_key["CLAUDE_PROSE_STYLE_ENFORCEMENT"] = "1"
     try:
         completed_process = subprocess.run(
             [sys.executable, wrapper_file_path],
@@ -65,6 +78,7 @@ def run_hook_with_patched_search_paths(
             capture_output=True,
             text=True,
             check=False,
+            env=environment_by_key,
         )
     finally:
         os.unlink(wrapper_file_path)
@@ -80,6 +94,49 @@ def test_user_facing_notice_matches_config_messages_module():
     assert module.USER_FACING_NOTICE == USER_FACING_NOTICE
 
 
+def test_hedging_scan_is_default_off() -> None:
+    completed_process = run_hook_with_message(
+        HEDGING_MESSAGE, is_prose_style_enabled=False
+    )
+
+    assert completed_process.returncode == 0
+    assert completed_process.stdout == ""
+
+
+def test_default_off_emits_privacy_safe_advisory_candidates(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    all_emitted: list[tuple[str, str, str]] = []
+
+    def _record_advisory(
+        matcher_id: str, surface: str, context_text: str, **_kwargs: object
+    ) -> dict[str, object]:
+        all_emitted.append((matcher_id, surface, context_text))
+        return {}
+
+    monkeypatch.setattr(
+        hedging_language_blocker, "emit_advisory_candidate", _record_advisory
+    )
+    monkeypatch.setattr(
+        hedging_language_blocker,
+        "prose_style_enforcement_enabled_in_environment",
+        lambda: False,
+    )
+    monkeypatch.setattr(
+        hedging_language_blocker.sys,
+        "stdin",
+        io.StringIO(json.dumps({"last_assistant_message": HEDGING_MESSAGE})),
+    )
+    with pytest.raises(SystemExit) as exit_info:
+        hedging_language_blocker.main()
+    assert exit_info.value.code == 0
+    assert all_emitted
+    matcher_id, surface, context_text = all_emitted[0]
+    assert matcher_id == "hedging_word"
+    assert surface == "Stop"
+    assert "likely" in context_text
+
+
 def test_hedging_message_emits_block_with_short_user_notice():
     completed_process = run_hook_with_message(HEDGING_MESSAGE)
 
@@ -140,3 +197,65 @@ def test_empty_message_passes_through_with_no_output():
 
     assert completed_process.returncode == 0
     assert completed_process.stdout == ""
+
+
+def test_explicit_unverified_label_in_same_sentence_passes() -> None:
+    completed_process = run_hook_with_message(
+        "This claim is unverified; the deploy is probably blocked."
+    )
+
+    assert completed_process.returncode == 0
+    assert completed_process.stdout == ""
+
+
+def test_i_dont_know_label_in_same_sentence_passes() -> None:
+    completed_process = run_hook_with_message(
+        "I don't know whether the port is probably open."
+    )
+
+    assert completed_process.returncode == 0
+    assert completed_process.stdout == ""
+
+
+def test_supported_probability_without_hedge_word_passes() -> None:
+    completed_process = run_hook_with_message(
+        "The suite reports 0.92 precision on the labeled fixture set in "
+        "test_prose_matcher_advisory.py."
+    )
+
+    assert completed_process.returncode == 0
+    assert completed_process.stdout == ""
+
+
+def test_label_in_one_sentence_does_not_exempt_bare_hedge_in_another() -> None:
+    completed_process = run_hook_with_message(
+        "This claim is unverified. The deploy is probably blocked."
+    )
+
+    assert completed_process.returncode == 0
+    parsed_response = json.loads(completed_process.stdout)
+    assert parsed_response["decision"] == "block"
+    assert "probably" in parsed_response["reason"]
+    assert "explicit uncertainty label" in parsed_response["reason"]
+
+
+def test_bare_probably_still_blocks_with_positive_corrective() -> None:
+    completed_process = run_hook_with_message("The deploy is probably blocked.")
+
+    assert completed_process.returncode == 0
+    parsed_response = json.loads(completed_process.stdout)
+    assert parsed_response["decision"] == "block"
+    assert "probably" in parsed_response["reason"]
+    assert "label that claim unverified" in parsed_response["reason"]
+    assert "AskUserQuestion" in parsed_response["reason"]
+
+
+def test_find_blocking_hedging_terms_is_sentence_scoped() -> None:
+    bare = hedging_language_blocker.find_blocking_hedging_terms(
+        "This claim is unverified. The deploy is probably blocked."
+    )
+    labeled = hedging_language_blocker.find_blocking_hedging_terms(
+        "This claim is unverified; the deploy is probably blocked."
+    )
+    assert bare == ["probably"]
+    assert labeled == []

package/hooks/blocking/test_hook_prose_detector_consistency.py

@@ -3,6 +3,7 @@
 import importlib.util
 import io
 import json
+import os
 import pathlib
 import sys
 from unittest import mock
@@ -192,14 +193,33 @@ def test_written_content_reads_edit_new_string() -> None:
     assert written_content("Edit", edit_input) == "edited body"
 
 
-def _run_main_with_io(input_text: str) -> str:
-    with mock.patch("sys.stdin", io.StringIO(input_text)):
-        with mock.patch("sys.stdout", new_callable=io.StringIO) as mock_stdout:
-            try:
-                hook_module.main()
-            except SystemExit:
-                pass
-            return mock_stdout.getvalue()
+def _run_main_with_io(
+    input_text: str, *, is_prose_style_enabled: bool = True
+) -> str:
+    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)
+    with mock.patch.dict(os.environ, environment_by_key, clear=True):
+        with mock.patch("sys.stdin", io.StringIO(input_text)):
+            with mock.patch("sys.stdout", new_callable=io.StringIO) as mock_stdout:
+                try:
+                    hook_module.main()
+                except SystemExit:
+                    pass
+                return mock_stdout.getvalue()
+
+
+def test_main_is_default_off_for_overstated_hook_module_write() -> None:
+    hook_input = {
+        "tool_name": "Write",
+        "tool_input": {
+            "file_path": "/repo/hooks/hooks_constants/some_blocker_constants.py",
+            "content": _OVERSTATED_MESSAGE_MODULE,
+        },
+    }
+    assert _run_main_with_io(json.dumps(hook_input), is_prose_style_enabled=False) == ""
 
 
 def test_main_blocks_overstated_hook_module_write() -> None:

package/hooks/blocking/test_intent_only_ending_blocker.py

@@ -42,24 +42,40 @@ USER_DIRECTED_NEXT_STEPS_MESSAGE = (
 EMPTY_MESSAGE = ""
 
 
-def run_hook_with_message(assistant_message: str) -> subprocess.CompletedProcess:
+def run_hook_with_message(
+    assistant_message: str, *, is_prose_style_enabled: bool = True
+) -> subprocess.CompletedProcess:
     hook_input_payload = json.dumps({"last_assistant_message": assistant_message})
+    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=hook_input_payload,
         capture_output=True,
         text=True,
         check=False,
+        env=environment_by_key,
     )
 
 
-def run_hook_with_payload(hook_input_payload: dict) -> subprocess.CompletedProcess:
+def run_hook_with_payload(
+    hook_input_payload: dict, *, is_prose_style_enabled: bool = True
+) -> subprocess.CompletedProcess:
+    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=json.dumps(hook_input_payload),
         capture_output=True,
         text=True,
         check=False,
+        env=environment_by_key,
     )
 
 
@@ -76,6 +92,15 @@ def test_user_facing_notice_matches_config_messages_module():
     )
 
 
+def test_intent_scan_is_default_off() -> None:
+    completed_process = run_hook_with_message(
+        INTENT_ENDING_MESSAGE, is_prose_style_enabled=False
+    )
+
+    assert completed_process.returncode == 0
+    assert completed_process.stdout == ""
+
+
 def test_intent_ending_message_emits_block_with_short_user_notice():
     completed_process = run_hook_with_message(INTENT_ENDING_MESSAGE)
 

package/hooks/blocking/test_package_inventory_stale_blocker.py

@@ -367,9 +367,16 @@ def test_find_stale_inventory_returns_survey_for_omission(tmp_path: Path):
     assert survey.named_basenames == {"dialer_compose.py", "compose_dialer_cli.py"}
 
 
-def test_find_stale_inventory_skips_prose_only_directory():
-    audit_rubrics_directory = (
-        Path(__file__).resolve().parent.parent.parent / "audit-rubrics"
+def test_find_stale_inventory_skips_directory_below_minimum_named_entries(
+    tmp_path: Path,
+) -> None:
+    """Skip a package inventory that names fewer than the minimum on-disk siblings."""
+    package_directory = tmp_path / "prose_package"
+    package_directory.mkdir()
+    (package_directory / "CLAUDE.md").write_text(
+        "| File | Role |\n|---|---|\n| `only_one.py` | sole entry |\n",
+        encoding="utf-8",
     )
-    new_file_path = audit_rubrics_directory / "new_helper.py"
+    (package_directory / "only_one.py").write_text("FLAG = 1\n", encoding="utf-8")
+    new_file_path = package_directory / "new_helper.py"
     assert find_stale_inventory(str(new_file_path)) is None

package/hooks/blocking/test_plain_language_blocker.py

@@ -42,18 +42,31 @@ strip_non_prose_regions = hook_module.strip_non_prose_regions
 build_block_reason = hook_module.build_block_reason
 find_question_block_violations = hook_module.find_question_block_violations
 build_lean_block_reason = hook_module.build_lean_block_reason
-evaluate = hook_module.evaluate
+
+
+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 hook_module.evaluate(payload_by_key)
 
 from pre_tool_use_dispatcher import NativeHook, run_native_hook  # noqa: E402
 
 
-def _run_hook_with_payload(payload: dict) -> subprocess.CompletedProcess[str]:
+def _run_hook_with_payload(
+    payload: dict, *, is_prose_style_enabled: bool = True
+) -> subprocess.CompletedProcess[str]:
+    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, str(HOOK_SCRIPT_PATH)],
         input=json.dumps(payload),
         capture_output=True,
         text=True,
         check=False,
+        env=environment_by_key,
     )
 
 
@@ -64,10 +77,81 @@ def _decision_from(completed: subprocess.CompletedProcess[str]) -> str | None:
     return parsed.get("hookSpecificOutput", {}).get("permissionDecision")
 
 
+def _system_message_from(completed: subprocess.CompletedProcess[str]) -> str | None:
+    if not completed.stdout:
+        return None
+    parsed = json.loads(completed.stdout)
+    system_message = parsed.get("systemMessage")
+    return system_message if isinstance(system_message, str) else None
+
+
 def test_canonical_hook_script_exists_at_expected_path() -> None:
     assert HOOK_SCRIPT_PATH.is_file()
 
 
+def test_heavy_word_scan_is_default_off(monkeypatch: pytest.MonkeyPatch) -> None:
+    monkeypatch.delenv("CLAUDE_PROSE_STYLE_ENFORCEMENT", raising=False)
+    payload = {
+        "tool_name": "Write",
+        "tool_input": {
+            "file_path": "notes.md",
+            "content": "We initiate the worker pool at boot.",
+        },
+    }
+    assert hook_module.evaluate(payload) is None
+    completed = _run_hook_with_payload(payload, is_prose_style_enabled=False)
+    assert _decision_from(completed) is None
+
+
+def test_default_off_emits_privacy_safe_advisory_candidates(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    monkeypatch.delenv("CLAUDE_PROSE_STYLE_ENFORCEMENT", raising=False)
+    all_emitted: list[tuple[str, str, str]] = []
+
+    def _record_advisory(
+        matcher_id: str, surface: str, context_text: str, **_kwargs: object
+    ) -> dict[str, object]:
+        all_emitted.append((matcher_id, surface, context_text))
+        return {}
+
+    monkeypatch.setattr(hook_module, "emit_advisory_candidate", _record_advisory)
+    payload = {
+        "tool_name": "Write",
+        "tool_input": {
+            "file_path": "notes.md",
+            "content": "We initiate the worker pool at boot.",
+        },
+    }
+    assert hook_module.evaluate(payload) is None
+    assert all_emitted
+    matcher_id, surface, context_text = all_emitted[0]
+    assert matcher_id == "plain_language_heavy_word"
+    assert surface == "Write"
+    assert "initiate" in context_text
+
+
+def test_heavy_word_scan_opt_in_allows_with_system_message_swaps() -> None:
+    payload = {
+        "tool_name": "Write",
+        "tool_input": {
+            "file_path": "notes.md",
+            "content": "We initiate the worker pool at boot.",
+        },
+    }
+    assert evaluate(payload) is None
+    with patch.dict(os.environ, {"CLAUDE_PROSE_STYLE_ENFORCEMENT": "1"}):
+        deny_reason, advisory_message = hook_module.evaluate_with_advisory(payload)
+    assert deny_reason is None
+    assert advisory_message is not None
+    assert 'use "start" instead of "initiate"' in advisory_message
+    completed = _run_hook_with_payload(payload, is_prose_style_enabled=True)
+    assert _decision_from(completed) == "allow"
+    system_message = _system_message_from(completed)
+    assert system_message is not None
+    assert 'use "start" instead of "initiate"' in system_message
+
+
 def test_bare_prose_banned_term_is_detected() -> None:
     matched = find_banned_terms("We initiate the worker pool at boot.")
     assert any(each_term == "initiate" for each_term, _replacement in matched)
@@ -127,7 +211,7 @@ def test_block_reason_names_term_and_replacement() -> None:
     assert "start" in reason
 
 
-def test_ask_user_question_with_banned_term_is_denied() -> None:
+def test_ask_user_question_with_banned_term_is_advisory_allow() -> None:
     payload = {
         "tool_name": "AskUserQuestion",
         "tool_input": {
@@ -141,10 +225,13 @@ def test_ask_user_question_with_banned_term_is_denied() -> None:
         },
     }
     completed = _run_hook_with_payload(payload)
-    assert _decision_from(completed) == "deny"
+    assert _decision_from(completed) == "allow"
+    system_message = _system_message_from(completed)
+    assert system_message is not None
+    assert "utilize" in system_message
 
 
-def test_ask_user_question_banned_term_in_option_label_is_denied() -> None:
+def test_ask_user_question_banned_term_in_option_label_is_advisory_allow() -> None:
     payload = {
         "tool_name": "AskUserQuestion",
         "tool_input": {
@@ -158,7 +245,10 @@ def test_ask_user_question_banned_term_in_option_label_is_denied() -> None:
         },
     }
     completed = _run_hook_with_payload(payload)
-    assert _decision_from(completed) == "deny"
+    assert _decision_from(completed) == "allow"
+    system_message = _system_message_from(completed)
+    assert system_message is not None
+    assert "utilize" in system_message
 
 
 def test_clean_ask_user_question_passes_through() -> None:
@@ -178,7 +268,7 @@ def test_clean_ask_user_question_passes_through() -> None:
     assert _decision_from(completed) is None
 
 
-def test_write_markdown_with_banned_term_is_denied(tmp_path: Path) -> None:
+def test_write_markdown_with_banned_term_is_advisory_allow(tmp_path: Path) -> None:
     target = tmp_path / "notes.md"
     payload = {
         "tool_name": "Write",
@@ -188,7 +278,10 @@ def test_write_markdown_with_banned_term_is_denied(tmp_path: Path) -> None:
         },
     }
     completed = _run_hook_with_payload(payload)
-    assert _decision_from(completed) == "deny"
+    assert _decision_from(completed) == "allow"
+    system_message = _system_message_from(completed)
+    assert system_message is not None
+    assert "utilize" in system_message
 
 
 def test_write_markdown_at_ephemeral_path_is_allowed(monkeypatch: pytest.MonkeyPatch) -> None:
@@ -230,7 +323,7 @@ def test_edit_markdown_clean_content_passes_through(tmp_path: Path) -> None:
     assert _decision_from(completed) is None
 
 
-def test_multiedit_markdown_with_banned_term_is_denied(tmp_path: Path) -> None:
+def test_multiedit_markdown_with_banned_term_is_advisory_allow(tmp_path: Path) -> None:
     target = tmp_path / "notes.md"
     payload = {
         "tool_name": "MultiEdit",
@@ -243,7 +336,10 @@ def test_multiedit_markdown_with_banned_term_is_denied(tmp_path: Path) -> None:
         },
     }
     completed = _run_hook_with_payload(payload)
-    assert _decision_from(completed) == "deny"
+    assert _decision_from(completed) == "allow"
+    system_message = _system_message_from(completed)
+    assert system_message is not None
+    assert "utilize" in system_message
 
 
 def test_other_tool_is_ignored() -> None:
@@ -270,19 +366,24 @@ def test_real_file_path_is_still_stripped() -> None:
 
 
 def test_native_dispatch_path_logs_the_block(tmp_path: Path) -> None:
-    """A deny routed through the dispatcher's native path logs one record.
+    """A lean-block deny routed through the dispatcher's native path logs once.
 
     On the Write|Edit|MultiEdit surface this hook runs only through
     pre_tool_use_dispatcher's native path, which calls evaluate() and
-    build_deny_payload() — never _emit_deny() or main(). The block must still
-    land in the hook-blocks log, so the log call lives on build_deny_payload,
-    the function the native path executes.
+    build_deny_payload() — never _emit_deny() or main(). Heavy words no longer
+    deny (OP-07D), so this probe uses AskUserQuestion lean-block chat detail.
+    The log call still lives on build_deny_payload.
     """
     deny_payload = {
-        "tool_name": "Edit",
+        "tool_name": "AskUserQuestion",
         "tool_input": {
-            "file_path": str(tmp_path / "notes.md"),
-            "new_string": "This guide explains how to utilize the new cache layer.",
+            "questions": [
+                {
+                    "question": "Which gate should run first?\n\nPlan the whole stack.",
+                    "header": "Gate",
+                    "options": [{"label": "Write", "description": "Runs on write."}],
+                }
+            ]
         },
     }
     native_hook = NativeHook(
@@ -291,7 +392,9 @@ def test_native_dispatch_path_logs_the_block(tmp_path: Path) -> None:
     )
 
     with patch.object(Path, "home", return_value=tmp_path):
-        hosted_result = run_native_hook(native_hook, deny_payload, is_blocking=True)
+        hosted_result = run_native_hook(
+            native_hook, deny_payload, is_blocking=True
+        )
 
     assert hosted_result.captured_stdout
     log_path = tmp_path / ".claude" / "logs" / "hook-blocks.log"
@@ -527,7 +630,14 @@ def test_markdown_write_keeps_its_bullets_and_tables(tmp_path: Path) -> None:
         "tool_input": {"file_path": target_path, "content": bulleted_prose},
     }
 
-    assert evaluate(heavy_payload) is not None
+    assert evaluate(heavy_payload) is None
+    with patch.dict(os.environ, {"CLAUDE_PROSE_STYLE_ENFORCEMENT": "1"}):
+        _deny_reason, advisory_message = hook_module.evaluate_with_advisory(
+            heavy_payload
+        )
+    assert _deny_reason is None
+    assert advisory_message is not None
+    assert "utilize" in advisory_message
     assert evaluate(clean_payload) is None