claude-dev-env 2.16.0 → 2.18.0

package/hooks/blocking/pre_tool_use_dispatcher.py

@@ -26,16 +26,6 @@ from pathlib import Path
 
 import _path_setup  # noqa: F401
 
-from plain_language_blocker import (
-    build_allow_advisory_payload as build_plain_language_allow_advisory_payload,
-)
-from plain_language_blocker import (
-    build_deny_payload as build_plain_language_deny_payload,
-)
-from plain_language_blocker import evaluate as evaluate_plain_language
-from plain_language_blocker import (
-    evaluate_with_advisory as evaluate_plain_language_with_advisory,
-)
 from state_description_blocker import (
     build_deny_payload as build_state_description_deny_payload,
 )
@@ -50,7 +40,6 @@ from hooks_constants.pre_tool_use_dispatcher_constants import (
     DENY_DECISION,
     EXIT_CODE_TWO_DENY_REASON,
     HOOK_EVENT_NAME,
-    PLAIN_LANGUAGE_BLOCKER_MODULE_NAME,
     REASON_JOIN_SEPARATOR,
     STATE_DESCRIPTION_BLOCKER_MODULE_NAME,
     SYSTEM_MESSAGE_JOIN_SEPARATOR,
@@ -77,7 +66,7 @@ class NativeHook:
             additionalContext, and suppressOutput).
         evaluate_with_advisory: Optional evaluator that returns
             ``(deny_reason, advisory_system_message)`` so allow-path notices
-            match the standalone hook (plain_language OP-07D).
+            match the standalone hook.
         build_allow_advisory_payload: Optional builder for an allow payload that
             carries the advisory systemMessage without denying.
     """
@@ -93,12 +82,6 @@ _native_hook_by_module_name: dict[str, NativeHook] = {
         evaluate=evaluate_state_description,
         build_deny_payload=build_state_description_deny_payload,
     ),
-    PLAIN_LANGUAGE_BLOCKER_MODULE_NAME: NativeHook(
-        evaluate=evaluate_plain_language,
-        build_deny_payload=build_plain_language_deny_payload,
-        evaluate_with_advisory=evaluate_plain_language_with_advisory,
-        build_allow_advisory_payload=build_plain_language_allow_advisory_payload,
-    ),
 }
 
 
@@ -504,7 +487,7 @@ def _emit_allow_decision(decision: DispatcherDecision) -> None:
     Matches the shape a standalone hosted hook emits when it auto-approves the
     write, so a write a hosted hook allows explicitly is auto-approved under the
     dispatcher rather than falling back to the default permission flow. When a
-    hook also carried an advisory systemMessage (plain-language heavy words),
+    hook also carried an advisory systemMessage,
     that notice rides on the allow payload without denying.
     """
     allow_payload: dict[str, object] = {

package/hooks/blocking/state_description_blocker.py

@@ -351,7 +351,7 @@ def build_deny_payload(deny_reason: str) -> dict[str, object]:
                 "only the current state. For example:\n"
                 '  BAD: "Uses X instead of Y"  →  GOOD: "Uses X"\n'
                 '  BAD: "Previously configured via Z"  →  GOOD: "Configured via Z"\n'
-                "See ~/.claude/rules/doc-prose-cuts.md for full rules."
+                "Apply ~/.claude/rules/asd-ste100-language.md for user-facing language."
             ),
         },
         "systemMessage": "Agent wrote comparative/historical language - describe current state only",

package/hooks/blocking/test_ask_user_question_shape.py

@@ -0,0 +1,69 @@
+"""Production-path tests for the AskUserQuestion shape hook."""
+
+from __future__ import annotations
+
+import json
+import subprocess
+import sys
+from pathlib import Path
+
+HOOK_PATH = Path(__file__).parent / "ask_user_question_shape_blocker.py"
+
+
+def _payload(question_text: str, option_description: str) -> dict[str, object]:
+    return {
+        "tool_name": "AskUserQuestion",
+        "tool_input": {
+            "questions": [
+                {
+                    "question": question_text,
+                    "header": "Gate",
+                    "options": [{"label": "Run", "description": option_description}],
+                }
+            ]
+        },
+    }
+
+
+def _run_hook(payload_by_key: dict[str, object]) -> subprocess.CompletedProcess[str]:
+    return subprocess.run(
+        [sys.executable, str(HOOK_PATH)],
+        input=json.dumps(payload_by_key),
+        capture_output=True,
+        text=True,
+        check=False,
+    )
+
+
+def test_lean_question_passes_through_the_runtime_hook() -> None:
+    completed = _run_hook(_payload("Which gate should run first?", "Runs on write."))
+
+    assert completed.returncode == 0
+    assert completed.stdout == ""
+
+
+def test_question_with_list_detail_is_denied_by_the_runtime_hook() -> None:
+    completed = _run_hook(
+        _payload(
+            "Which gate should run first?\n- Write\n- Commit",
+            "Runs on write.",
+        )
+    )
+
+    parsed_payload = json.loads(completed.stdout)
+    hook_specific_output = parsed_payload["hookSpecificOutput"]
+    assert hook_specific_output["permissionDecision"] == "deny"
+    assert "list marker" in hook_specific_output["permissionDecisionReason"]
+    assert "question" in parsed_payload["systemMessage"].lower()
+
+
+def test_non_question_tool_passes_through_the_runtime_hook() -> None:
+    completed = _run_hook(
+        {
+            "tool_name": "Write",
+            "tool_input": {"file_path": "notes.md", "content": "Text."},
+        }
+    )
+
+    assert completed.returncode == 0
+    assert completed.stdout == ""

package/hooks/blocking/test_pre_tool_use_dispatcher.py

@@ -289,34 +289,6 @@ def test_clean_write_allows_on_multi_edit_tool() -> None:
     _assert_dispatcher_matches_individual_hooks(payload_text, MULTI_EDIT_TOOL_NAME)
 
 
-def test_plain_language_heavy_prose_allows_on_write_of_markdown_file() -> None:
-    """Dispatcher matches individual hooks: heavy prose allows (OP-07D advisory)."""
-    payload_text = _write_payload(
-        _MARKDOWN_FILE_PATH,
-        "# Guide\n\nPlease utilize this functionality to commence the process.\n",
-    )
-    _assert_dispatcher_matches_individual_hooks(payload_text, WRITE_TOOL_NAME)
-
-
-def test_plain_language_heavy_prose_allows_on_edit_of_markdown_file() -> None:
-    """Dispatcher matches individual hooks: heavy prose Edit allows (OP-07D)."""
-    payload_text = _edit_payload(
-        _MARKDOWN_FILE_PATH,
-        "old line",
-        "Please utilize this functionality to commence the process.\n",
-    )
-    _assert_dispatcher_matches_individual_hooks(payload_text, EDIT_TOOL_NAME)
-
-
-def test_plain_language_heavy_prose_allows_on_multi_edit_of_markdown_file() -> None:
-    """Dispatcher matches individual hooks: heavy prose MultiEdit allows (OP-07D)."""
-    payload_text = _multi_edit_payload(
-        _MARKDOWN_FILE_PATH,
-        [{"old_string": "old", "new_string": "Please utilize this functionality to commence."}],
-    )
-    _assert_dispatcher_matches_individual_hooks(payload_text, MULTI_EDIT_TOOL_NAME)
-
-
 def test_dispatcher_docstring_points_at_roster_not_hardcoded_counts() -> None:
     """The dispatcher docstring names the roster, not per-tool counts that drift."""
     dispatcher_source = Path(_DISPATCHER_SCRIPT).read_text(encoding="utf-8")
@@ -331,9 +303,8 @@ def test_multi_edit_runs_only_group_b_hooks() -> None:
 
     The write_existing_file_blocker (Group A only) must not run on MultiEdit,
     so a MultiEdit to any path that would trip a Group-A hook must still allow.
-    Heavy prose no longer denies (OP-07D); this test proves Group A is absent
-    from MultiEdit and that plain_language_blocker stays in the MultiEdit set
-    and still runs (allow-with-advisory on heavy prose).
+    This test proves Group A is absent from MultiEdit and the remaining Group-B
+    hooks stay in the applicable set.
     """
     all_multi_edit_entries = _applicable_entries_for_tool(MULTI_EDIT_TOOL_NAME)
     all_write_only_entries = [
@@ -349,20 +320,14 @@ def test_multi_edit_runs_only_group_b_hooks() -> None:
             f"Group-A hook {each_group_a_entry.script_relative_path!r} "
             "appears in the MultiEdit applicable set — it must not"
         )
-    assert "blocking/plain_language_blocker.py" in all_multi_edit_script_paths, (
-        "plain_language_blocker (Group B) must stay in the MultiEdit applicable set"
-    )
-    heavy_prose_payload = _multi_edit_payload(
+    clean_payload = _multi_edit_payload(
         _MARKDOWN_FILE_PATH,
-        [{"old_string": "old line", "new_string": "Utilize this to commence the process."}],
+        [{"old_string": "old line", "new_string": "New text."}],
     )
-    dispatcher_result = _run_dispatcher(heavy_prose_payload)
+    dispatcher_result = _run_dispatcher(clean_payload)
     dispatcher_is_deny, _reason = _parse_hook_decision(dispatcher_result)
     assert not dispatcher_is_deny, (
-        "Dispatcher should allow MultiEdit heavy prose (OP-07D advisory path)"
-    )
-    assert dispatcher_result.stdout.strip(), (
-        "plain_language_blocker should emit an allow advisory on MultiEdit heavy prose"
+        "Dispatcher should allow a clean MultiEdit payload"
     )
 
 
@@ -417,7 +382,7 @@ def test_write_existing_file_blocker_does_not_run_on_multi_edit() -> None:
 
     The dispatcher must allow a MultiEdit to an existing file path even though
     write_existing_file_blocker would deny the same path on a Write.
-    Uses a non-markdown file so plain_language_blocker stays silent.
+    Uses a non-markdown file so markdown-only hooks stay silent.
     """
     existing_file_path = str(Path(__file__).resolve())
     payload_text = _multi_edit_payload(
@@ -453,8 +418,7 @@ def test_all_deny_reasons_present_when_multiple_hooks_deny() -> None:
 
     Uses a Write to an existing markdown path with a historical phrase
     ("previously") so write_existing_file_blocker and state_description_blocker
-    both deny. Heavy words no longer hard-deny (OP-07D), so plain_language is
-    not a denier.
+    both deny.
     """
     existing_markdown_path = str(Path(__file__).resolve().parent / "CLAUDE.md")
     multi_deny_content = (
@@ -689,9 +653,8 @@ def test_later_hook_deny_survives_early_hook_exit() -> None:
     """Dispatcher denies even when an earlier hook exits cleanly before a later hook denies.
 
     state_description_blocker denies a markdown write with a historical phrase.
-    Earlier hooks exit 0 (allow). Heavy words no longer hard-deny (OP-07D). The
-    dispatcher must catch each hook's SystemExit and continue, so the later
-    denial reaches the aggregator.
+    Earlier hooks exit 0 (allow). The dispatcher must catch each hook's
+    SystemExit and continue, so the later denial reaches the aggregator.
     """
     payload_text = _write_payload(
         _MARKDOWN_FILE_PATH,
@@ -712,11 +675,8 @@ def test_dispatcher_write_applies_both_groups() -> None:
     assert "blocking/write_existing_file_blocker.py" in all_write_script_paths, (
         "write_existing_file_blocker (Group A) must be in Write applicable set"
     )
-    assert "blocking/plain_language_blocker.py" in all_write_script_paths, (
-        "plain_language_blocker (Group B) must be in Write applicable set"
-    )
-    assert len(all_write_entries) == 19, (
-        f"Write tool must apply to all 19 hosted hooks, got {len(all_write_entries)}"
+    assert len(all_write_entries) == 18, (
+        f"Write tool must apply to all 18 hosted hooks, got {len(all_write_entries)}"
     )
 
 
@@ -732,16 +692,16 @@ def test_dispatcher_edit_applies_both_groups() -> None:
     assert "advisory/refactor_guard.py" in all_edit_script_paths, (
         "refactor_guard is Edit-scoped and hosted, so it belongs in the Edit applicable set"
     )
-    assert len(all_edit_entries) == 22, (
-        f"expected 22 Edit entries, got {len(all_edit_entries)}"
+    assert len(all_edit_entries) == 21, (
+        f"expected 21 Edit entries, got {len(all_edit_entries)}"
     )
 
 
 def test_dispatcher_multi_edit_applies_only_group_b() -> None:
-    """MultiEdit tool triggers only Group B (10 hooks), not Group A."""
+    """MultiEdit tool triggers only Group B (8 hooks), not Group A."""
     all_multi_edit_entries = _applicable_entries_for_tool(MULTI_EDIT_TOOL_NAME)
-    assert len(all_multi_edit_entries) == 9, (
-        f"MultiEdit tool must apply to exactly 9 Group-B hooks, got {len(all_multi_edit_entries)}"
+    assert len(all_multi_edit_entries) == 8, (
+        f"MultiEdit tool must apply to exactly 8 Group-B hooks, got {len(all_multi_edit_entries)}"
     )
 
 
@@ -973,7 +933,6 @@ def test_hosted_hook_set_covers_all_write_edit_blocking_hooks() -> None:
         "blocking/claude_md_orphan_file_blocker.py",
         "blocking/pytest_testpaths_orphan_blocker.py",
         "blocking/open_questions_in_plans_blocker.py",
-        "blocking/plain_language_blocker.py",
     })
     for each_script_path in previously_registered_blocking_hooks:
         assert each_script_path in all_hosted_script_paths, (

package/hooks/blocking/test_pre_tool_use_dispatcher_native.py

@@ -1,10 +1,10 @@
 """Native-equivalence tests for the nativized PreToolUse hosted hooks.
 
-For each hook the dispatcher runs natively (state_description_blocker and
-plain_language_blocker), this suite asserts the native evaluate() call and the
-hook's standalone __main__ subprocess path decide identically on the same
-payload: same allow-or-deny, same deny-reason text. It also asserts the
-dispatcher reaches the same decision through its native path.
+For the state_description_blocker hook the dispatcher runs natively. This suite
+asserts the native evaluate() call and the hook's standalone __main__ subprocess
+path decide identically on the same payload: same allow-or-deny, same deny-reason
+text. It also asserts the dispatcher reaches the same decision through its native
+path.
 
 The corpus pairs allowing payloads with denying payloads for each hook so the
 equivalence holds across both outcomes.
@@ -21,9 +21,12 @@ from unittest.mock import patch
 
 import pytest
 
-_HOOKS_DIR = str(Path(__file__).resolve().parent.parent)
+_BLOCKING_DIR = Path(__file__).resolve().parent
+_HOOKS_DIR = str(_BLOCKING_DIR.parent)
 if _HOOKS_DIR not in sys.path:
     sys.path.insert(0, _HOOKS_DIR)
+if str(_BLOCKING_DIR) not in sys.path:
+    sys.path.insert(0, str(_BLOCKING_DIR))
 
 _PROSE_STYLE_ENFORCEMENT_ENVIRONMENT = {
     "CLAUDE_PROSE_STYLE_ENFORCEMENT": "1",
@@ -35,21 +38,14 @@ from hooks_constants.pre_tool_use_dispatcher_constants import (  # noqa: E402, I
     MULTI_EDIT_TOOL_NAME,
     WRITE_TOOL_NAME,
 )
-import plain_language_blocker  # noqa: E402, I001
 import state_description_blocker  # noqa: E402, I001
 
-_BLOCKING_DIR = Path(__file__).resolve().parent
 _STATE_DESCRIPTION_SCRIPT = str(_BLOCKING_DIR / "state_description_blocker.py")
-_PLAIN_LANGUAGE_SCRIPT = str(_BLOCKING_DIR / "plain_language_blocker.py")
 _DISPATCHER_SCRIPT = str(_BLOCKING_DIR / "pre_tool_use_dispatcher.py")
 
 _MARKDOWN_PATH = "docs/native_equivalence_probe.md"
-_PYTHON_PATH = "src/native_equivalence_probe.py"
-
 _STATE_DESCRIPTION_ALLOW_CONTENT = "# Guide\n\nThe API uses port 8080.\n"
 _STATE_DESCRIPTION_DENY_CONTENT = "# Guide\n\nPreviously the system used port 8080.\n"
-_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"
@@ -249,61 +245,6 @@ def test_state_description_native_non_target_tool_allows_match_script() -> None:
     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 = _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_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)
-    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_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_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"
-    )
-    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_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 = _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)
@@ -314,42 +255,6 @@ def test_dispatcher_native_path_denies_state_description() -> None:
     assert native_reason in dispatcher_reason
 
 
-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 = _evaluate_with_prose_style_opt_in(
-        plain_language_blocker.evaluate, payload_dictionary
-    )
-    dispatcher_reason = _deny_reason_from_dispatcher(payload_dictionary)
-    assert native_reason is None
-    assert dispatcher_reason is None
-
-
-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)
-    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 advisory_message in dispatcher_system_message
-
-
-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 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)

package/hooks/blocking/test_state_description_blocker.py

@@ -644,6 +644,7 @@ def test_additional_context_contains_examples():
     ctx = output["hookSpecificOutput"].get("additionalContext", "")
     assert "BAD:" in ctx
     assert "GOOD:" in ctx
+    assert "~/.claude/rules/asd-ste100-language.md" in ctx
 
 
 def test_handles_non_dict_stdin():

package/hooks/blocking/test_stop_dispatcher.py

@@ -110,7 +110,7 @@ def test_dispatch_re_emits_first_block_with_system_message_and_suppress(
         (
             "blocking/hedging_language_blocker.py",
             "blocking/question_to_user_enforcer.py",
-            "diagnostic/hook_log_stop_wrapper.py",
+            "blocking/intent_only_ending_blocker.py",
         ),
     )
     dispatch('{"session_id": "test"}')
@@ -175,31 +175,6 @@ 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_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": too_many_bullets_message,
-        }
-    )
-    completed = subprocess.run(
-        [sys.executable, _DISPATCHER_SCRIPT],
-        check=False,
-        input=payload_text,
-        capture_output=True,
-        text=True,
-        encoding="utf-8",
-    )
-    assert completed.returncode == 0
-    parsed = json.loads(completed.stdout)
-    assert parsed["decision"] == "block"
-    assert "ELI11 REPLY SHAPE" in parsed["reason"]
-
-
 def test_dispatcher_imports_standalone_with_only_blocking_on_the_path() -> None:
     """The dispatcher's bootstrap resolves hooks_constants without hooks/ on PYTHONPATH."""
     subprocess_environment = {**os.environ, "PYTHONPATH": str(_BLOCKING_DIR)}

package/hooks/hooks.json

@@ -82,7 +82,7 @@
         "hooks": [
           {
             "type": "command",
-            "command": "python3 ${CLAUDE_PLUGIN_ROOT}/hooks/blocking/plain_language_blocker.py",
+            "command": "python3 ${CLAUDE_PLUGIN_ROOT}/hooks/blocking/ask_user_question_shape_blocker.py",
             "timeout": 10
           }
         ]

package/hooks/hooks_constants/AGENTS.md

@@ -29,14 +29,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 (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 |
 | `hosted_hook_runner.py` | `run_hook_capturing_output()` — shared runner that runs one dispatcher-hosted hook in-process via runpy and returns its captured stdout and crash flag |
 | `inline_tuple_string_magic_constants.py` | Patterns for detecting magic strings in inline tuple literals |
@@ -55,7 +53,6 @@ Shared constant modules imported by hooks throughout the `hooks/` tree. Each fil
 | `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; 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 |
 | `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 |

package/hooks/hooks_constants/ask_user_question_shape.py

@@ -16,7 +16,7 @@ from __future__ import annotations
 from collections.abc import Mapping, Sequence
 from dataclasses import dataclass
 
-from hooks_constants.plain_language_blocker_constants import (
+from hooks_constants.ask_user_question_shape_constants import (
     ALL_CHAT_DETAIL_MARKERS,
     ALL_LINE_ENDING_REPLACEMENTS,
     COUNTABLE_WORD_PATTERN,

package/hooks/hooks_constants/ask_user_question_shape_constants.py

@@ -0,0 +1,73 @@
+"""Constants for AskUserQuestion field-shape validation."""
+
+from __future__ import annotations
+
+import re
+
+__all__ = [
+    "ALL_CHAT_DETAIL_MARKERS",
+    "ALL_LINE_ENDING_REPLACEMENTS",
+    "ASK_USER_QUESTION_TOOL_NAME",
+    "COUNTABLE_WORD_PATTERN",
+    "INLINE_CODE_PLACEHOLDER",
+    "INLINE_CODE_SPAN_PATTERN",
+    "LEAN_QUESTION_BLOCK_GUIDANCE",
+    "LEAN_QUESTION_BLOCK_PREFIX",
+    "LEAN_QUESTION_VIOLATION_SEPARATOR",
+    "MAXIMUM_OPTION_DESCRIPTION_SENTENCE_COUNT",
+    "MAXIMUM_OPTION_DESCRIPTION_WORD_COUNT",
+    "MAXIMUM_QUESTION_SENTENCE_COUNT",
+    "MAXIMUM_QUESTION_WORD_COUNT",
+    "OPTION_DESCRIPTION_SURFACE_NAME",
+    "QUESTION_SURFACE_NAME",
+    "SENTENCE_BOUNDARY_PATTERN",
+    "USER_FACING_LEAN_QUESTION_NOTICE",
+]
+
+ASK_USER_QUESTION_TOOL_NAME: str = "AskUserQuestion"
+
+ALL_CHAT_DETAIL_MARKERS: tuple[tuple[re.Pattern[str], str], ...] = (
+    (re.compile(r"^[ \t]*```", re.MULTILINE), "a fenced code block"),
+    (re.compile(r"^[ \t]*#{1,6}[ \t]+\S", re.MULTILINE), "a heading"),
+    (re.compile(r"^[ \t]*\|.*\|[ \t]*$", re.MULTILINE), "a table row"),
+    (
+        re.compile(r"^[ \t]*(?:[-*+][ \t]+|\d{1,2}[.)][ \t]+)\S", re.MULTILINE),
+        "a bullet or numbered list marker",
+    ),
+    (re.compile(r"\n[ \t]*\n"), "more than one paragraph"),
+)
+
+INLINE_CODE_SPAN_PATTERN: re.Pattern[str] = re.compile(r"`[^`\n]+`")
+INLINE_CODE_PLACEHOLDER: str = "code"
+
+ALL_LINE_ENDING_REPLACEMENTS: tuple[tuple[str, str], ...] = (
+    ("\r\n", "\n"),
+    ("\r", "\n"),
+)
+
+SENTENCE_BOUNDARY_PATTERN: re.Pattern[str] = re.compile(
+    r"[.!?]+(?=\s+[A-Z]|\s*$)"
+)
+COUNTABLE_WORD_PATTERN: re.Pattern[str] = re.compile(r"\S*[A-Za-z0-9]\S*")
+
+MAXIMUM_QUESTION_SENTENCE_COUNT: int = 2
+MAXIMUM_QUESTION_WORD_COUNT: int = 40
+MAXIMUM_OPTION_DESCRIPTION_SENTENCE_COUNT: int = 1
+MAXIMUM_OPTION_DESCRIPTION_WORD_COUNT: int = 15
+
+QUESTION_SURFACE_NAME: str = "the question"
+OPTION_DESCRIPTION_SURFACE_NAME: str = "an option description"
+
+LEAN_QUESTION_BLOCK_PREFIX: str = (
+    "BLOCKED: [LEAN_QUESTION] Question block carries chat detail -- "
+)
+LEAN_QUESTION_VIOLATION_SEPARATOR: str = "; "
+LEAN_QUESTION_BLOCK_GUIDANCE: str = (
+    "AskUserQuestion renders as one plain text block. Print the plan, the counts, "
+    "and the tradeoffs in chat text before the call, keep the question block to a "
+    "lean question and short options, and reach for an inline visualizer tool when "
+    "a choice needs formatting."
+)
+USER_FACING_LEAN_QUESTION_NOTICE: str = (
+    "Question-block check: move the detail into chat and ask a short question."
+)

package/hooks/hooks_constants/bot_mention_comment_blocker_constants.py

@@ -15,6 +15,5 @@ CORRECTIVE_MESSAGE_COPILOT: str = (
     "BLOCKED [bot-mention]: Invalid comment. "
     "To request a Copilot review, use the GitHub REST API:\n"
     "  gh api --method POST repos/<owner>/<repo>/pulls/<number>/requested_reviewers \\\n"
-    "    -f 'reviewers[]=copilot-pull-request-reviewer[bot]'\n"
-    "See ~/.claude/skills/pr-converge/reference/convergence-gates.md."
+    "    -f 'reviewers[]=copilot-pull-request-reviewer[bot]'"
 )

package/hooks/hooks_constants/code_rules_path_utils_constants.py

@@ -20,7 +20,6 @@ ALL_CONFIG_DIRECTORY_NAMES = frozenset(
         "skills_pr_loop_constants",
         "pr_converge_skill_constants",
         "pr_converge_scripts_constants",
-        "bugteam_scripts_constants",
         "usage_pause_constants",
         "prototype_scripts_constants",
         "codex_review_scripts_constants",

package/hooks/hooks_constants/pre_tool_use_dispatcher_constants.py

@@ -24,7 +24,6 @@ __all__ = [
     "ALL_WRITE_AND_EDIT_TOOL_NAMES",
     "ALL_WRITE_EDIT_MULTI_EDIT_TOOL_NAMES",
     "STATE_DESCRIPTION_BLOCKER_MODULE_NAME",
-    "PLAIN_LANGUAGE_BLOCKER_MODULE_NAME",
     "SYSTEM_MESSAGE_JOIN_SEPARATOR",
     "HostedHookEntry",
     "ALL_HOSTED_HOOK_ENTRIES",
@@ -51,7 +50,6 @@ ALL_WRITE_EDIT_MULTI_EDIT_TOOL_NAMES: frozenset[str] = frozenset(
 
 
 STATE_DESCRIPTION_BLOCKER_MODULE_NAME = "state_description_blocker"
-PLAIN_LANGUAGE_BLOCKER_MODULE_NAME = "plain_language_blocker"
 
 
 @dataclass(frozen=True)
@@ -155,11 +153,6 @@ ALL_HOSTED_HOOK_ENTRIES: tuple[HostedHookEntry, ...] = (
         script_relative_path="blocking/docstring_rule_gate_count_blocker.py",
         applicable_tool_names=ALL_WRITE_EDIT_MULTI_EDIT_TOOL_NAMES,
     ),
-    HostedHookEntry(
-        script_relative_path="blocking/plain_language_blocker.py",
-        applicable_tool_names=ALL_WRITE_EDIT_MULTI_EDIT_TOOL_NAMES,
-        native_module_name=PLAIN_LANGUAGE_BLOCKER_MODULE_NAME,
-    ),
     HostedHookEntry(
         script_relative_path="advisory/refactor_guard.py",
         applicable_tool_names=frozenset({EDIT_TOOL_NAME}),