claude-dev-env 8.44.1 → 8.44.3

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/blocking/test_step_note_gate.py

@@ -1,6 +1,6 @@
 import io
 import json
-import threading
+from collections.abc import Callable
 from pathlib import Path
 
 import pytest
@@ -160,6 +160,24 @@ def test_should_allow_every_parallel_call_under_one_note(
     assert (first_exit_code, second_exit_code) == (0, 0)
 
 
+class HarnessWritesDuringFirstSleep:
+    """Stand-in for the time module that runs the harness write on the first poll sleep."""
+
+    def __init__(self, write_late_lines: Callable[[], None]) -> None:
+        self.write_late_lines = write_late_lines
+        self.elapsed_seconds = 0.0
+        self.sleep_count = 0
+
+    def monotonic(self) -> float:
+        return self.elapsed_seconds
+
+    def sleep(self, seconds: float) -> None:
+        if self.sleep_count == 0:
+            self.write_late_lines()
+        self.sleep_count += 1
+        self.elapsed_seconds += seconds
+
+
 def test_should_see_a_note_the_harness_writes_after_the_hook_starts(
     tmp_path: Path, monkeypatch: pytest.MonkeyPatch, capsys: pytest.CaptureFixture[str]
 ) -> None:
@@ -174,12 +192,11 @@ def test_should_see_a_note_the_harness_writes_after_the_hook_starts(
         with transcript.open("a", encoding="utf-8") as transcript_file:
             transcript_file.write(late_lines)
 
-    writer = threading.Timer(0.15, append_late_lines)
-    writer.start()
+    harness_clock = HarnessWritesDuringFirstSleep(append_late_lines)
+    monkeypatch.setattr(step_note_gate, "time", harness_clock)
     exit_code, _ = run_gate(monkeypatch, capsys, transcript, "call_1")
-    writer.join()
 
-    assert exit_code == 0
+    assert (exit_code, harness_clock.sleep_count) == (0, 1)
 
 
 def test_should_block_a_bare_call_the_harness_writes_after_the_hook_starts(
@@ -192,12 +209,11 @@ def test_should_block_a_bare_call_the_harness_writes_after_the_hook_starts(
         with transcript.open("a", encoding="utf-8") as transcript_file:
             transcript_file.write(json.dumps(call_entry("m1", "call_1")) + "\n")
 
-    writer = threading.Timer(0.15, append_late_call)
-    writer.start()
+    harness_clock = HarnessWritesDuringFirstSleep(append_late_call)
+    monkeypatch.setattr(step_note_gate, "time", harness_clock)
     exit_code, _ = run_gate(monkeypatch, capsys, transcript, "call_1")
-    writer.join()
 
-    assert exit_code == 2
+    assert (exit_code, harness_clock.sleep_count) == (2, 1)
 
 
 def test_should_allow_a_call_that_never_reaches_the_transcript(

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.1",
+    "version": "8.44.3",
     "description": "Claude Code development standards — rules, hooks, agents, commands, and skills",
     "type": "module",
     "bin": {