claude-dev-env 8.43.6 → 8.44.1

package/hooks/blocking/reply_length_gate.py

@@ -18,6 +18,10 @@ It denies a banned word or phrase, matched whole and case-insensitive::
 The gate uses the ``banned_words`` list in ``~/.claude/reply-banned-words.json``,
 or in the file that CLAUDE_REPLY_BANNED_WORDS_PATH names. Without a valid
 list there, it uses ALL_DEFAULT_BANNED_WORDS.
+
+The banned-word check also reads every text field of a decision card.
+A decision card gets no length check.
+
 Each non-empty line counts as its own sentence, so a list counts one
 sentence per item. URLs, markdown link targets, inline code spans, and
 fenced blocks carry no words.
@@ -52,8 +56,10 @@ from hooks_constants.reply_length_gate_constants import (
     BANNED_WORDS_JSON_KEY,
     BANNED_WORDS_PATH_ENV_VAR,
     BLOCK_EXIT_CODE,
+    CARD_TEXT_SEPARATOR,
     CLAUDE_HOME_DIRECTORY_NAME,
     CONFIG_FILE_ENCODING,
+    DECISION_CARD_TOOL_NAME,
     FENCED_BLOCK_PATTERN,
     HOOK_EVENT_NAME,
     INLINE_CODE_PATTERN,
@@ -163,26 +169,52 @@ def banned_word_violation(reply_text: str, all_banned_words: tuple[str, ...]) ->
     return None
 
 
+def all_card_texts(card_value: object) -> list[str]:
+    """Collect every string inside a decision card's input, in order."""
+    if isinstance(card_value, str):
+        return [card_value]
+    if isinstance(card_value, dict):
+        return [
+            each_text
+            for each_value in card_value.values()
+            for each_text in all_card_texts(each_value)
+        ]
+    if isinstance(card_value, list):
+        return [each_text for each_value in card_value for each_text in all_card_texts(each_value)]
+    return []
+
+
+def tool_violation(tool_name: object, all_tool_input: dict[str, object]) -> tuple[str, str] | None:
+    """Return the deny reason and the checked text for one call, or None when it passes."""
+    if tool_name == DECISION_CARD_TOOL_NAME:
+        card_text = CARD_TEXT_SEPARATOR.join(all_card_texts(all_tool_input))
+        card_violation = banned_word_violation(card_text, configured_banned_words())
+        return None if card_violation is None else (card_violation, card_text)
+    if tool_name not in ALL_CHECKED_TOOL_NAMES:
+        return None
+    reply_text = all_tool_input.get(TEXT_KEY)
+    if not isinstance(reply_text, str):
+        return None
+    violation = (
+        length_violation(reply_text)
+        or unlinked_pull_request_violation(reply_text)
+        or banned_word_violation(reply_text, configured_banned_words())
+    )
+    return None if violation is None else (violation, reply_text)
+
+
 def main() -> int:
     hook_input = read_hook_input_dictionary_from_stdin()
     if hook_input is None:
         return ALLOW_EXIT_CODE
     tool_name = hook_input.get(TOOL_NAME_KEY)
-    if tool_name not in ALL_CHECKED_TOOL_NAMES:
-        return ALLOW_EXIT_CODE
     tool_input = hook_input.get(TOOL_INPUT_KEY)
     if not isinstance(tool_input, dict):
         return ALLOW_EXIT_CODE
-    reply_text = tool_input.get(TEXT_KEY)
-    if not isinstance(reply_text, str):
-        return ALLOW_EXIT_CODE
-    violation = (
-        length_violation(reply_text)
-        or unlinked_pull_request_violation(reply_text)
-        or banned_word_violation(reply_text, configured_banned_words())
-    )
-    if violation is None:
+    checked = tool_violation(tool_name, tool_input)
+    if checked is None:
         return ALLOW_EXIT_CODE
+    violation, reply_text = checked
     block_reason = violation + RETRY_INSTRUCTION
     log_hook_block(
         Path(__file__).name,

package/hooks/blocking/test_reply_length_gate.py

@@ -322,3 +322,58 @@ def test_should_keep_the_defaults_when_the_config_file_is_malformed(
     config_path.write_text("{not json", encoding="utf-8")
     exit_code, _ = run_gate(monkeypatch, capsys, REPLY_TOOL_NAME, {"text": "It likely passed."})
     assert exit_code == 2
+
+
+DECISION_TOOL_NAME = "mcp__hearthbot__ask_decision"
+
+
+def test_should_deny_a_decision_card_that_hedges_in_an_option(
+    monkeypatch: pytest.MonkeyPatch, capsys: pytest.CaptureFixture[str]
+) -> None:
+    exit_code, stderr_text = run_gate(
+        monkeypatch,
+        capsys,
+        DECISION_TOOL_NAME,
+        {
+            "question": "Exclude the call button?",
+            "context": "Crops show the call button flagged in 7 themes.",
+            "options": [
+                {"label": "Exclude it", "consequence": "Three themes probably pass."},
+                {"label": "Leave it", "consequence": "Three themes keep a warning."},
+            ],
+            "recommended": 0,
+        },
+    )
+    assert exit_code == 2
+    assert '"probably"' in stderr_text
+
+
+def test_should_allow_a_long_decision_card_with_no_hedge(
+    monkeypatch: pytest.MonkeyPatch, capsys: pytest.CaptureFixture[str]
+) -> None:
+    exit_code, stderr_text = run_gate(
+        monkeypatch,
+        capsys,
+        DECISION_TOOL_NAME,
+        {
+            "question": "Exclude the call button?",
+            "context": " ".join([FIFTEEN_WORD_SENTENCE] * 5),
+            "options": [
+                {"label": "Exclude it", "consequence": SIXTEEN_WORD_SENTENCE},
+                {"label": "Leave it", "consequence": "Three themes keep a warning."},
+            ],
+            "recommended": 0,
+        },
+    )
+    assert (exit_code, stderr_text) == (0, "")
+
+
+@pytest.mark.parametrize(
+    "reply_text",
+    ["It maybe passed.", "Perhaps it passed.", "It might be the cache.", "I am not sure it passed."],
+)
+def test_should_deny_the_hedges_the_default_list_adds(
+    monkeypatch: pytest.MonkeyPatch, capsys: pytest.CaptureFixture[str], reply_text: str
+) -> None:
+    exit_code, _ = run_gate(monkeypatch, capsys, REPLY_TOOL_NAME, {"text": reply_text})
+    assert exit_code == 2

package/hooks/hooks.json

@@ -83,7 +83,7 @@
         ]
       },
       {
-        "matcher": "mcp__hearthbot__reply|mcp__hearthbot__post_message",
+        "matcher": "mcp__hearthbot__reply|mcp__hearthbot__post_message|mcp__hearthbot__ask_decision",
         "hooks": [
           {
             "type": "command",

package/hooks/hooks_constants/reply_length_gate_constants.py

@@ -5,6 +5,8 @@ import re
 MAXIMUM_SENTENCE_COUNT = 3
 MAXIMUM_WORDS_PER_SENTENCE = 15
 ALL_CHECKED_TOOL_NAMES = frozenset({"mcp__hearthbot__reply", "mcp__hearthbot__post_message"})
+DECISION_CARD_TOOL_NAME = "mcp__hearthbot__ask_decision"
+CARD_TEXT_SEPARATOR = "\n"
 TOOL_NAME_KEY = "tool_name"
 TOOL_INPUT_KEY = "tool_input"
 TEXT_KEY = "text"
@@ -45,6 +47,15 @@ ALL_DEFAULT_BANNED_WORDS = (
     "suspect",
     "guess",
     "my theory",
+    "maybe",
+    "perhaps",
+    "presumably",
+    "might be",
+    "may be",
+    "appears to",
+    "i believe",
+    "not sure",
+    "unsure",
 )
 BANNED_WORD_PART_SEPARATOR = r"\s+"
 BANNED_WORD_PATTERN_TEMPLATE = r"(?<![A-Za-z0-9]){word_pattern}(?![A-Za-z0-9])"

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "claude-dev-env",
-    "version": "8.43.6",
+    "version": "8.44.1",
     "description": "Claude Code development standards — rules, hooks, agents, commands, and skills",
     "type": "module",
     "bin": {

package/rules/bdd.md

@@ -9,6 +9,8 @@ paths:
 
 # BDD (discovery-driven development)
 
+**When:** Starting a non-trivial feature.
+
 For every non-trivial feature, discover what you do not know, illustrate it with concrete examples in chat, formulate each behavior as a narrow "should ..." specification, then build each one through the TDD loop (CODE_RULES §8). Name developer-facing specs and tests as should sentences.
 
 **Full text:** [`docs/rule-guides/bdd.md`](../docs/rule-guides/bdd.md), with the long-form BDD references.

package/rules/code-standards.md

@@ -10,6 +10,8 @@ paths:
 
 # Code Standards
 
+**When:** Writing, reviewing, or generating code.
+
 [`CODE_RULES.md`](../docs/CODE_RULES.md) is the review contract for code quality. Load it when you review a pull request, resolve a policy conflict, or generate code. Red, green, refactor is the default loop (CODE_RULES §8). Keep engineering right-sized (CODE_RULES §7).
 
 **Enforcement:** the staged policy lint runs `hooks/blocking/code_rules_enforcer.py` over each changed file, and CI runs it against the merge base.

package/rules/doc-inventory-integrity.md

@@ -11,6 +11,8 @@ paths:
 
 # Documentation Inventory Integrity
 
+**When:** Changing code that a document inventories.
+
 A doc that inventories code stays in step with the code, in the same change:
 
 1. Every bare filename a per-directory `CLAUDE.md` names in a table cell or a fenced run command exists in its subtree.

package/rules/windows-filesystem-safe.md

@@ -8,6 +8,8 @@ paths:
 
 # Windows Filesystem Safety
 
+**When:** Removing a directory tree or creating a directory in Python or Node.
+
 Call `shutil.rmtree` with an `onexc` (Python 3.12 and later) or `onerror` handler that runs `os.chmod(target_path, stat.S_IWRITE)` and retries. `ignore_errors=True` leaves read-only trees on disk. In Node, call `mkdirSync(targetPath, { recursive: true })` on a path that may exist. Import the shared `force_rmtree` handler trio from its one shared Windows-filesystem module.
 
 **Enforcement:** the staged policy lint's `rmtree-safety` rule, which returns the full `force_rmtree` code. CI runs it against the merge base.

package/scripts/tests/test_rule_index_shape.py

@@ -22,6 +22,7 @@ FULL_TEXT_LINK_PATTERN = re.compile(
     r"^\*\*Full text:\*\*.*?\]\((\.\./docs/rule-guides/[^)#\s]+\.md)\)", re.MULTILINE
 )
 TITLE_PATTERN = re.compile(r"^# \S", re.MULTILINE)
+WHEN_LINE_PATTERN = re.compile(r"^\*\*When(?: this applies)?:\*\* \S", re.MULTILINE)
 
 MAXIMUM_ENTRY_BYTES = 1_500
 MAXIMUM_ALWAYS_ON_BYTES = 12_000
@@ -88,6 +89,16 @@ def test_each_entry_opens_with_a_title_after_its_frontmatter() -> None:
     assert untitled == []
 
 
+def test_each_entry_states_when_it_applies() -> None:
+    without_when_line = [
+        each_path.name
+        for each_path in _entry_paths()
+        if each_path.name not in POINTER_ENTRY_NAMES | CODEX_VERBATIM_ENTRY_NAMES
+        and not WHEN_LINE_PATTERN.search(_entry_text(each_path))
+    ]
+    assert without_when_line == []
+
+
 def _full_text_link_problems(entry_path: Path) -> list[str]:
     all_guide_names = _linked_guide_names(_entry_text(entry_path))
     if not all_guide_names: