claude-dev-env 8.44.0 → 8.44.2

package/hooks/blocking/reply_length_gate.py

@@ -19,7 +19,8 @@ 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.
+The banned-word check also reads the prose of a decision card: its question,
+its context, and each option's label and consequence.
 A decision card gets no length check.
 
 Each non-empty line counts as its own sentence, so a list counts one
@@ -47,6 +48,8 @@ from hooks_constants.hook_block_logger import log_hook_block
 from hooks_constants.pre_tool_use_stdin import read_hook_input_dictionary_from_stdin
 from hooks_constants.reply_length_gate_constants import (
     ALL_CHECKED_TOOL_NAMES,
+    ALL_DECISION_CARD_PROSE_KEYS,
+    ALL_DECISION_OPTION_PROSE_KEYS,
     ALL_DEFAULT_BANNED_WORDS,
     ALLOW_EXIT_CODE,
     BANNED_WORD_MESSAGE,
@@ -59,6 +62,7 @@ from hooks_constants.reply_length_gate_constants import (
     CARD_TEXT_SEPARATOR,
     CLAUDE_HOME_DIRECTORY_NAME,
     CONFIG_FILE_ENCODING,
+    DECISION_CARD_OPTIONS_KEY,
     DECISION_CARD_TOOL_NAME,
     FENCED_BLOCK_PATTERN,
     HOOK_EVENT_NAME,
@@ -169,19 +173,21 @@ 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 all_card_texts(all_card_input: dict[str, object]) -> list[str]:
+    """Collect the prose fields of a decision card: question, context, and each option's text."""
+    all_options = all_card_input.get(DECISION_CARD_OPTIONS_KEY)
+    all_option_fields = [
+        each_option.get(each_key)
+        for each_option in (all_options if isinstance(all_options, list) else [])
+        if isinstance(each_option, dict)
+        for each_key in ALL_DECISION_OPTION_PROSE_KEYS
+    ]
+    all_card_fields = [all_card_input.get(each_key) for each_key in ALL_DECISION_CARD_PROSE_KEYS]
+    return [
+        each_field
+        for each_field in all_card_fields + all_option_fields
+        if isinstance(each_field, str)
+    ]
 
 
 def tool_violation(tool_name: object, all_tool_input: dict[str, object]) -> tuple[str, str] | None:

package/hooks/blocking/test_reply_length_gate.py

@@ -377,3 +377,68 @@ def test_should_deny_the_hedges_the_default_list_adds(
 ) -> None:
     exit_code, _ = run_gate(monkeypatch, capsys, REPLY_TOOL_NAME, {"text": reply_text})
     assert exit_code == 2
+
+
+def test_should_ignore_a_banned_word_in_a_card_field_that_holds_no_prose(
+    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": [
+                {"id": "maybe", "label": "Exclude it", "consequence": "Seven themes pass."},
+                {"id": "leave", "label": "Leave it", "consequence": "Seven themes keep a warning."},
+            ],
+            "kind": "maybe",
+            "recommended": 0,
+        },
+    )
+    assert (exit_code, stderr_text) == (0, "")
+
+
+@pytest.mark.parametrize(
+    "card_field_name",
+    ["question", "context", "label", "consequence"],
+)
+def test_should_deny_a_banned_word_in_each_card_prose_field(
+    monkeypatch: pytest.MonkeyPatch, capsys: pytest.CaptureFixture[str], card_field_name: str
+) -> None:
+    option = {"label": "Exclude it", "consequence": "Seven themes pass."}
+    card: dict[str, object] = {
+        "question": "Exclude the call button?",
+        "context": "Crops show the call button flagged.",
+        "options": [option],
+    }
+    if card_field_name in option:
+        option[card_field_name] = "It maybe passes."
+    else:
+        card[card_field_name] = "It maybe passes."
+    exit_code, stderr_text = run_gate(monkeypatch, capsys, DECISION_TOOL_NAME, card)
+    assert exit_code == 2
+    assert '"maybe"' in stderr_text
+
+
+def test_should_apply_the_configured_list_to_decision_cards(
+    monkeypatch: pytest.MonkeyPatch, capsys: pytest.CaptureFixture[str], tmp_path: Path
+) -> None:
+    config_path = tmp_path / ".claude" / "reply-banned-words.json"
+    config_path.parent.mkdir()
+    config_path.write_text(json.dumps({"banned_words": ["synergy"]}), encoding="utf-8")
+    probably_exit_code, _ = run_gate(
+        monkeypatch,
+        capsys,
+        DECISION_TOOL_NAME,
+        {"question": "Ship it?", "context": "It probably passes."},
+    )
+    synergy_exit_code, stderr_text = run_gate(
+        monkeypatch,
+        capsys,
+        DECISION_TOOL_NAME,
+        {"question": "Ship it?", "context": "Synergy shipped."},
+    )
+    assert (probably_exit_code, synergy_exit_code) == (0, 2)
+    assert 'Banned word "synergy"' in stderr_text

package/hooks/hooks_constants/reply_length_gate_constants.py

@@ -7,6 +7,9 @@ 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"
+ALL_DECISION_CARD_PROSE_KEYS = ("question", "context")
+DECISION_CARD_OPTIONS_KEY = "options"
+ALL_DECISION_OPTION_PROSE_KEYS = ("label", "consequence")
 TOOL_NAME_KEY = "tool_name"
 TOOL_INPUT_KEY = "tool_input"
 TEXT_KEY = "text"

package/hooks/hooks_constants/test_reply_length_gate_constants.py

@@ -19,3 +19,29 @@ def test_default_banned_words_hold_the_hedges_and_intensifiers() -> None:
     assert {"likely", "probably", "seems", "real", "actually", "genuine"} <= set(
         constants.ALL_DEFAULT_BANNED_WORDS
     )
+
+
+def test_gate_checks_the_project_decision_card_tool() -> None:
+    assert constants.DECISION_CARD_TOOL_NAME == "mcp__hearthbot__ask_decision"
+
+
+def test_default_banned_words_hold_the_added_hedge_phrases() -> None:
+    assert {
+        "maybe",
+        "perhaps",
+        "presumably",
+        "might be",
+        "may be",
+        "appears to",
+        "i believe",
+        "not sure",
+        "unsure",
+    } <= set(constants.ALL_DEFAULT_BANNED_WORDS)
+
+
+def test_gate_reads_only_the_prose_fields_of_a_decision_card() -> None:
+    assert (
+        constants.ALL_DECISION_CARD_PROSE_KEYS,
+        constants.DECISION_CARD_OPTIONS_KEY,
+        constants.ALL_DECISION_OPTION_PROSE_KEYS,
+    ) == (("question", "context"), "options", ("label", "consequence"))

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "claude-dev-env",
-    "version": "8.44.0",
+    "version": "8.44.2",
     "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: