claude-dev-env 1.83.0 → 1.85.0

package/hooks/blocking/test_code_rules_enforcer_docstring_prose_wall_illustration.py

@@ -0,0 +1,197 @@
+"""Behavioural checks for the show-don't-tell narrative gate.
+
+A readable summary earns its place by painting a concrete scene: a sample
+input, an annotated outcome, an OK/FLAG contrast a reader pictures at once. A
+summary that runs many short sentences with no worked example tells without
+showing. The gate flags that wall in a top-level, class, or callable summary,
+and stays quiet the moment the narrative carries a '::' listing or a '>>>'
+doctest.
+"""
+
+from __future__ import annotations
+
+import importlib.util
+import sys
+from pathlib import Path
+from types import ModuleType
+
+_HOOKS_DIRECTORY = str(Path(__file__).resolve().parent.parent)
+if _HOOKS_DIRECTORY not in sys.path:
+    sys.path.insert(0, _HOOKS_DIRECTORY)
+
+
+def _load_enforcer_module() -> ModuleType:
+    enforcer_module_name = "code_rules_enforcer"
+    enforcer_path = Path(__file__).parent / (enforcer_module_name + ".py")
+    spec = importlib.util.spec_from_file_location(enforcer_module_name, enforcer_path)
+    assert spec is not None
+    assert spec.loader is not None
+    loaded_module = importlib.util.module_from_spec(spec)
+    spec.loader.exec_module(loaded_module)
+    return loaded_module
+
+
+code_rules_enforcer = _load_enforcer_module()
+
+
+def check_docstring_prose_wall_without_illustration(content: str, file_path: str) -> list[str]:
+    return code_rules_enforcer.check_docstring_prose_wall_without_illustration(content, file_path)
+
+
+def validate_content(content: str, file_path: str, old_content: str) -> list[str]:
+    return code_rules_enforcer.validate_content(content, file_path, old_content)
+
+
+PRODUCTION_FILE_PATH = "/project/src/tally.py"
+SUITE_FILE_PATH = "/project/src/test_tally.py"
+INFRA_PATH = "/home/user/.claude/hooks/blocking/example.py"
+
+
+def _fixture_top_level_wall() -> str:
+    return (
+        '"""Assemble the nightly voyage tally from the harbor scans.\n'
+        "\n"
+        "A scan names one vessel and where it dropped anchor.\n"
+        "The tally walks the scans in arrival order and keeps that order.\n"
+        "A calm voyage ends well for every vessel it carried.\n"
+        "A halted voyage marks the vessel it was near when the storm arrived.\n"
+        "A wrecked voyage marks the vessel that sank and stops the walk there.\n"
+        "The tally groups the vessels by their final port for the harbor.\n"
+        "The harbor reads the tally and sees every arrival at a glance.\n"
+        '"""\n'
+        "\n"
+        "def emit_tally() -> None:\n"
+        "    return None\n"
+    )
+
+
+def _fixture_callable_wall() -> str:
+    return (
+        "def emit_tally() -> None:\n"
+        '    """Post the voyage tally to the harbor board.\n'
+        "\n"
+        "    A scan names one vessel and where it dropped anchor.\n"
+        "    The tally walks the scans in arrival order and keeps that order.\n"
+        "    A calm voyage ends well for every vessel it carried.\n"
+        "    A halted voyage marks the vessel it was near when the storm arrived.\n"
+        "    A wrecked voyage marks the vessel that sank and stops the walk there.\n"
+        "    The tally groups the vessels by their final port for the reader.\n"
+        "    The reader reads the whole tally at a single glance.\n"
+        '    """\n'
+        "    return None\n"
+    )
+
+
+def _fixture_wall_with_listing() -> str:
+    return (
+        "def emit_tally() -> None:\n"
+        '    """Post the voyage tally to the harbor board.\n'
+        "\n"
+        "    A scan names one vessel and where it dropped anchor::\n"
+        "\n"
+        "        vessel 42 -- halted -> marked mid-voyage\n"
+        "        OK:   a calm voyage ends well for every vessel\n"
+        "        FLAG: a wrecked voyage reads the same as a calm one\n"
+        "\n"
+        "    The reader reads the whole tally at a single glance.\n"
+        '    """\n'
+        "    return None\n"
+    )
+
+
+def _fixture_wall_with_doctest() -> str:
+    return (
+        "def emit_tally() -> None:\n"
+        '    """Post the voyage tally to the harbor board.\n'
+        "\n"
+        "    A calm voyage ends well for every vessel it carried.\n"
+        "    A halted voyage marks the vessel it was near when the storm arrived.\n"
+        "    A wrecked voyage marks the vessel that sank and stops the walk there.\n"
+        "\n"
+        "    >>> emit_tally()\n"
+        "    vessel 42 halted\n"
+        "    vessel 43 calm\n"
+        "\n"
+        "    The reader reads the whole tally at a single glance.\n"
+        '    """\n'
+        "    return None\n"
+    )
+
+
+def _fixture_short_summary() -> str:
+    return (
+        "def emit_tally() -> None:\n"
+        '    """Post the voyage tally to the harbor board.\n'
+        "\n"
+        "    A scan names one vessel and where it dropped anchor.\n"
+        "    A calm voyage ends well for every vessel it carried.\n"
+        "    A halted voyage marks the vessel it was near when it stopped.\n"
+        "    The reader reads the whole tally at a single glance.\n"
+        '    """\n'
+        "    return None\n"
+    )
+
+
+def test_should_flag_prose_wall_with_no_illustration() -> None:
+    issues = check_docstring_prose_wall_without_illustration(
+        _fixture_top_level_wall(), PRODUCTION_FILE_PATH
+    )
+    assert any("worked example" in each for each in issues), (
+        f"A top-level wall must flag, got: {issues!r}"
+    )
+    assert any("module" in each for each in issues)
+    assert len(issues) == 1
+
+
+def test_should_flag_function_prose_wall() -> None:
+    issues = check_docstring_prose_wall_without_illustration(
+        _fixture_callable_wall(), PRODUCTION_FILE_PATH
+    )
+    assert any("emit_tally" in each for each in issues), (
+        f"A callable wall must flag, got: {issues!r}"
+    )
+    assert len(issues) == 1
+
+
+def test_should_not_flag_wall_with_literal_block() -> None:
+    issues = check_docstring_prose_wall_without_illustration(
+        _fixture_wall_with_listing(), PRODUCTION_FILE_PATH
+    )
+    assert issues == [], f"A '::' listing must pass, got: {issues!r}"
+
+
+def test_should_not_flag_wall_with_doctest() -> None:
+    issues = check_docstring_prose_wall_without_illustration(
+        _fixture_wall_with_doctest(), PRODUCTION_FILE_PATH
+    )
+    assert issues == [], f"A '>>>' doctest must pass, got: {issues!r}"
+
+
+def test_should_not_flag_short_narrative() -> None:
+    issues = check_docstring_prose_wall_without_illustration(
+        _fixture_short_summary(), PRODUCTION_FILE_PATH
+    )
+    assert issues == [], f"A summary at the sentence limit must pass, got: {issues!r}"
+
+
+def test_should_skip_test_file() -> None:
+    issues = check_docstring_prose_wall_without_illustration(_fixture_top_level_wall(), SUITE_FILE_PATH)
+    assert issues == [], f"A suite path stays exempt, got: {issues!r}"
+
+
+def test_should_skip_hook_infrastructure() -> None:
+    issues = check_docstring_prose_wall_without_illustration(
+        _fixture_top_level_wall(), INFRA_PATH
+    )
+    assert issues == [], f"An infra path stays exempt, got: {issues!r}"
+
+
+def test_should_handle_syntax_error_gracefully() -> None:
+    issues = check_docstring_prose_wall_without_illustration("def broken(\n", PRODUCTION_FILE_PATH)
+    assert issues == [], f"A syntax error yields no issues, got: {issues!r}"
+
+
+def test_validate_content_surfaces_prose_wall() -> None:
+    issues = validate_content(_fixture_top_level_wall(), PRODUCTION_FILE_PATH, old_content="")
+    matching_issues = [each for each in issues if "worked example" in each]
+    assert matching_issues, f"validate_content must surface the wall, got: {issues!r}"

package/hooks/blocking/test_code_rules_enforcer_docstring_runon_sentence.py

@@ -252,6 +252,33 @@ def test_should_flag_spaced_double_hyphen_joiner() -> None:
     assert len(issues) == 1
 
 
+def _diagram_first_literal_block() -> str:
+    return (
+        "def emit_tally() -> None:\n"
+        '    """Post the voyage tally so the reader sees how the run ended.\n'
+        "\n"
+        "    A calm voyage versus a halted one::\n"
+        "\n"
+        "        vessel 42 -- halted -> marked mid-voyage while it sailed\n"
+        "        calm — every vessel it carried shows a clean recorded outcome\n"
+        "        OK:   a calm run and a sunk run read differently in the log\n"
+        "        FLAG: a sunk run looks identical to a calm finished run here\n"
+        "    The reader reads the final outcome at a glance.\n"
+        '    """\n'
+        "    return None\n"
+    )
+
+
+def test_should_not_flag_diagram_first_literal_block() -> None:
+    issues = check_docstring_runon_sentence(
+        _diagram_first_literal_block(), PRODUCTION_FILE_PATH
+    )
+    assert issues == [], (
+        "A '::' listing's arrow, em-dash, and OK/FLAG rows sit outside the "
+        f"narrative and must not inflate the run-on count, got: {issues!r}"
+    )
+
+
 def test_docstring_names_every_inspected_section_header() -> None:
     docstring = code_rules_enforcer.check_docstring_runon_sentence.__doc__
     assert docstring is not None

package/hooks/blocking/test_code_rules_enforcer_naive_datetime.py

@@ -181,6 +181,30 @@ def test_utcfromtimestamp_remediation_uses_generic_placeholder() -> None:
     assert "stamp, tz=" not in issues[0]
 
 
+def test_utcnow_remediation_is_import_agnostic() -> None:
+    content = (
+        "import datetime\n"
+        "def stamp() -> object:\n"
+        "    return datetime.datetime.utcnow()\n"
+    )
+    issues = check_naive_datetime_construction(content, PRODUCTION_FILE_PATH)
+    assert len(issues) == 1
+    assert "use datetime.now(" not in issues[0]
+    assert "on the same datetime class" in issues[0]
+
+
+def test_utcfromtimestamp_remediation_is_import_agnostic() -> None:
+    content = (
+        "import datetime\n"
+        "def build(stamp: float) -> object:\n"
+        "    return datetime.datetime.utcfromtimestamp(stamp)\n"
+    )
+    issues = check_naive_datetime_construction(content, PRODUCTION_FILE_PATH)
+    assert len(issues) == 1
+    assert "use datetime.fromtimestamp(" not in issues[0]
+    assert "on the same datetime class" in issues[0]
+
+
 def test_remediation_does_not_mandate_astimezone() -> None:
     content = (
         "from datetime import datetime\n"

package/hooks/blocking/test_code_rules_enforcer_split_constants_config.py

@@ -177,6 +177,39 @@ def test_advisory_should_flag_outer_constants_after_nested_def() -> None:
     )
 
 
+def test_scan_function_body_constants_skips_docstring_contrast_line() -> None:
+    source = (
+        "def demo(label):\n"
+        '    """Flag a boolean assignment whose target and callee clash.\n'
+        "\n"
+        "    ::\n"
+        "\n"
+        "        FLAG: ready = make_stale(...)\n"
+        '    """\n'
+        "    return label\n"
+    )
+    advisory_issues = code_rules_enforcer._scan_function_body_constants(source)
+    assert advisory_issues == [], (
+        f"Expected no function-local constant issue on an illustrative row, got: {advisory_issues}"
+    )
+
+
+def test_scan_function_body_constants_still_flags_real_function_body_constant() -> None:
+    source = (
+        "def demo(label):\n"
+        '    """Flag a boolean assignment whose target and callee clash.\n'
+        "\n"
+        "        FLAG: ready = make_stale(...)\n"
+        '    """\n'
+        "    SOME_CONST = 3\n"
+        "    return SOME_CONST\n"
+    )
+    advisory_issues = code_rules_enforcer._scan_function_body_constants(source)
+    assert any("SOME_CONST" in issue for issue in advisory_issues), (
+        f"Expected the real function-body constant SOME_CONST to stay flagged, got: {advisory_issues}"
+    )
+
+
 def test_check_constants_outside_config_flags_annotated_assignment() -> None:
     source = "TEXT_FILE_ENCODING: str = 'utf-8'\n"
     issues = code_rules_enforcer.check_constants_outside_config(

package/hooks/blocking/test_code_rules_enforcer_split_shared.py

@@ -18,14 +18,37 @@ from code_rules_enforcer import (  # noqa: E402
 )
 from code_rules_shared import (  # noqa: E402
     changed_line_numbers,
+    docstring_line_numbers,
 )
 
 code_rules_enforcer = SimpleNamespace(
     changed_line_numbers=changed_line_numbers,
+    docstring_line_numbers=docstring_line_numbers,
     prior_and_post_edit_content=prior_and_post_edit_content,
 )
 
 
+def test_docstring_line_numbers_spans_a_multi_line_function_docstring() -> None:
+    source = (
+        "def describe():\n"
+        '    """First row.\n'
+        "\n"
+        "    Third row.\n"
+        '    """\n'
+        "    return 1\n"
+    )
+    assert code_rules_enforcer.docstring_line_numbers(source) == {2, 3, 4, 5}
+
+
+def test_docstring_line_numbers_excludes_real_code_lines() -> None:
+    source = "def compute():\n    counter = 41\n    return counter\n"
+    assert code_rules_enforcer.docstring_line_numbers(source) == set()
+
+
+def test_docstring_line_numbers_returns_empty_set_on_syntax_error() -> None:
+    assert code_rules_enforcer.docstring_line_numbers("def broken(:\n") == set()
+
+
 def test_readable_prior_yields_consistent_prior_and_reconstruction(tmp_path) -> None:
     """When the prior reads cleanly, the helper returns the same prior content it
     reconstructed the post-edit view from, so the two never diverge across two

package/hooks/blocking/test_code_rules_magic_values.py

@@ -0,0 +1,54 @@
+"""Behavior tests for the code_rules_magic_values check module.
+
+A diagram-first docstring may carry a bare number on an illustrative row
+(``at line 2``). That number is prose, not a code literal, so the magic-value
+check skips docstring rows while still flagging a real magic number in an
+actual code statement.
+"""
+
+from __future__ import annotations
+
+import sys
+from pathlib import Path
+
+_BLOCKING_DIRECTORY = str(Path(__file__).resolve().parent)
+_HOOKS_DIRECTORY = str(Path(__file__).resolve().parent.parent)
+if _BLOCKING_DIRECTORY not in sys.path:
+    sys.path.insert(0, _BLOCKING_DIRECTORY)
+if _HOOKS_DIRECTORY not in sys.path:
+    sys.path.insert(0, _HOOKS_DIRECTORY)
+
+from code_rules_magic_values import check_magic_values  # noqa: E402
+
+PRODUCTION_FILE_PATH = "packages/app/rendering.py"
+
+
+def test_magic_value_check_skips_bare_number_inside_docstring_illustration() -> None:
+    source = (
+        "def summarize(record):\n"
+        '    """Summarize how a run ended.\n'
+        "\n"
+        "    A finished run shows a clean outcome::\n"
+        "\n"
+        "        marked in-flight at row 2\n"
+        '    """\n'
+        "    return record\n"
+    )
+    issues = check_magic_values(source, PRODUCTION_FILE_PATH)
+    assert issues == [], f"Expected no magic-value issue on an illustrative row, got: {issues}"
+
+
+def test_magic_value_check_still_flags_real_magic_number_in_code_statement() -> None:
+    source = (
+        "def summarize(record):\n"
+        '    """Summarize how a run ended.\n'
+        "\n"
+        "        marked in-flight at row 2\n"
+        '    """\n'
+        "    threshold = record.score * 42\n"
+        "    return threshold\n"
+    )
+    issues = check_magic_values(source, PRODUCTION_FILE_PATH)
+    assert any(issue.endswith("Magic value 42 - extract to named constant") for issue in issues), (
+        f"Expected the real magic number 42 to stay flagged, got: {issues}"
+    )

package/hooks/blocking/test_duplicate_rmtree_helper_blocker.py

@@ -142,12 +142,6 @@ def test_path_exempts_existing_session_env_cleanup_definition_site() -> None:
     assert path_is_exempt("packages/claude-dev-env/hooks/session/session_env_cleanup.py")
 
 
-def test_path_exempts_existing_md_to_html_test_support_definition_site() -> None:
-    assert path_is_exempt(
-        "packages/claude-dev-env/hooks/blocking/_md_to_html_blocker_test_support.py"
-    )
-
-
 def test_path_exempts_existing_teardown_worktrees_definition_site() -> None:
     assert path_is_exempt(
         "packages/claude-dev-env/skills/_shared/pr-loop/scripts/teardown_worktrees.py"

package/hooks/blocking/test_pr_converge_bugteam_enforcer_state_tolerance.py

@@ -0,0 +1,184 @@
+"""Unit tests: persistent-agent state keys leave both pr-converge hooks unchanged.
+
+pr-converge-state.json carries `agents_session_id` and `persistent_agents`
+(the persistent per-step agent map with a `fix_executor` entry). Neither the
+enforcer (`pr_converge_bugteam_enforcer`) nor the tracker
+(`pr_converge_bugteam_skill_tracker`) reads these keys, so their allow/block
+decisions and stamped fields match a state file without them, and the tracker
+preserves the keys unchanged on its stamp write.
+"""
+
+from __future__ import annotations
+
+import importlib.util
+import io
+import json
+import pathlib
+import sys
+from types import ModuleType
+from typing import Any
+from unittest import mock
+
+import pytest
+
+_BLOCKING_DIR = pathlib.Path(__file__).parent
+_HOOKS_TREE = _BLOCKING_DIR.parent
+_LIFECYCLE_DIR = _HOOKS_TREE / "lifecycle"
+for each_path in (str(_BLOCKING_DIR), str(_HOOKS_TREE)):
+    if each_path not in sys.path:
+        sys.path.insert(0, each_path)
+
+
+def _load_hook_module(module_name: str, module_path: pathlib.Path) -> ModuleType:
+    hook_spec = importlib.util.spec_from_file_location(module_name, module_path)
+    assert hook_spec is not None
+    assert hook_spec.loader is not None
+    loaded_module = importlib.util.module_from_spec(hook_spec)
+    hook_spec.loader.exec_module(loaded_module)
+    return loaded_module
+
+
+enforcer_module = _load_hook_module(
+    "pr_converge_bugteam_enforcer_state_tolerance_target",
+    _BLOCKING_DIR / "pr_converge_bugteam_enforcer.py",
+)
+tracker_module = _load_hook_module(
+    "pr_converge_bugteam_skill_tracker_state_tolerance_target",
+    _LIFECYCLE_DIR / "pr_converge_bugteam_skill_tracker.py",
+)
+
+from hooks_constants.pr_converge_bugteam_enforcer_constants import (
+    BUGTEAM_PHASE,
+    CLAUDE_JOB_DIR_ENV_VAR,
+    PR_CONVERGE_STATE_FILENAME,
+)
+
+_HEAD_SHA_CURRENT = "abc123def456abc123def456abc123def456abcd"
+_TICK_CURRENT = 7
+_AUDIT_PROMPT = "Run the bugteam audit and report findings against the A-J categories."
+_AGENTS_SESSION_ID = "session-0123456789abcdef"
+_FIX_EXECUTOR_AGENT_ID = "prc-fix-42"
+
+
+def _persistent_agent_state_keys() -> dict[str, Any]:
+    return {
+        "agents_session_id": _AGENTS_SESSION_ID,
+        "persistent_agents": {
+            "fix_executor": {
+                "agent_id": _FIX_EXECUTOR_AGENT_ID,
+                "created_tick": 2,
+                "last_used_tick": 6,
+            }
+        },
+    }
+
+
+def _bugteam_phase_state(**overrides: Any) -> dict[str, Any]:
+    baseline_state: dict[str, Any] = {
+        "phase": BUGTEAM_PHASE,
+        "current_head": _HEAD_SHA_CURRENT,
+        "tick_count": _TICK_CURRENT,
+        "bugteam_skill_invoked_at_head": None,
+        "bugteam_skill_invoked_at_tick": None,
+    }
+    baseline_state.update(_persistent_agent_state_keys())
+    baseline_state.update(overrides)
+    return baseline_state
+
+
+def _write_state(state_directory: pathlib.Path, state: dict[str, Any]) -> pathlib.Path:
+    state_path = state_directory / PR_CONVERGE_STATE_FILENAME
+    state_path.write_text(json.dumps(state), encoding="utf-8")
+    return state_path
+
+
+def _read_state(state_directory: pathlib.Path) -> dict[str, Any]:
+    state_path = state_directory / PR_CONVERGE_STATE_FILENAME
+    return json.loads(state_path.read_text(encoding="utf-8"))
+
+
+def _clean_coder_audit_payload() -> dict[str, Any]:
+    return {
+        "tool_name": "Agent",
+        "tool_input": {
+            "subagent_type": "clean-coder",
+            "prompt": _AUDIT_PROMPT,
+            "description": "Audit the PR",
+        },
+    }
+
+
+def _bugteam_skill_payload() -> dict[str, Any]:
+    return {
+        "tool_name": "Skill",
+        "tool_input": {"skill": "bugteam", "args": "https://github.com/o/r/pull/1"},
+    }
+
+
+def _run_enforcer_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 captured_stdout:
+            try:
+                enforcer_module.main()
+            except SystemExit:
+                pass
+            return captured_stdout.getvalue()
+
+
+def _run_tracker_main_with_io(input_text: str) -> None:
+    with mock.patch("sys.stdin", io.StringIO(input_text)):
+        with mock.patch("sys.stdout", new_callable=io.StringIO):
+            with mock.patch("sys.stderr", new_callable=io.StringIO):
+                try:
+                    tracker_module.main()
+                except SystemExit:
+                    pass
+
+
+@pytest.fixture()
+def claude_job_directory(tmp_path: pathlib.Path, monkeypatch: pytest.MonkeyPatch) -> pathlib.Path:
+    monkeypatch.setenv(CLAUDE_JOB_DIR_ENV_VAR, str(tmp_path))
+    return tmp_path
+
+
+def test_should_block_enforcer_when_persistent_agent_keys_present_without_skill(
+    claude_job_directory: pathlib.Path,
+) -> None:
+    _write_state(claude_job_directory, _bugteam_phase_state())
+    captured_output = _run_enforcer_main_with_io(json.dumps(_clean_coder_audit_payload()))
+    deny_payload = json.loads(captured_output)
+    assert deny_payload["hookSpecificOutput"]["permissionDecision"] == "deny"
+
+
+def test_should_allow_enforcer_when_persistent_agent_keys_present_with_skill_recorded(
+    claude_job_directory: pathlib.Path,
+) -> None:
+    _write_state(
+        claude_job_directory,
+        _bugteam_phase_state(
+            bugteam_skill_invoked_at_head=_HEAD_SHA_CURRENT,
+            bugteam_skill_invoked_at_tick=_TICK_CURRENT,
+        ),
+    )
+    captured_output = _run_enforcer_main_with_io(json.dumps(_clean_coder_audit_payload()))
+    assert captured_output == ""
+
+
+def test_should_stamp_tracker_fields_when_persistent_agent_keys_present(
+    claude_job_directory: pathlib.Path,
+) -> None:
+    _write_state(claude_job_directory, _bugteam_phase_state())
+    _run_tracker_main_with_io(json.dumps(_bugteam_skill_payload()))
+    updated_state = _read_state(claude_job_directory)
+    assert updated_state["bugteam_skill_invoked_at_head"] == _HEAD_SHA_CURRENT
+    assert updated_state["bugteam_skill_invoked_at_tick"] == _TICK_CURRENT
+
+
+def test_should_preserve_persistent_agent_keys_on_tracker_stamp_write(
+    claude_job_directory: pathlib.Path,
+) -> None:
+    _write_state(claude_job_directory, _bugteam_phase_state())
+    _run_tracker_main_with_io(json.dumps(_bugteam_skill_payload()))
+    updated_state = _read_state(claude_job_directory)
+    assert updated_state["agents_session_id"] == _AGENTS_SESSION_ID
+    assert updated_state["persistent_agents"] == _persistent_agent_state_keys()["persistent_agents"]

package/hooks/blocking/test_shared_stdin_adoption.py

@@ -10,11 +10,11 @@ each real hook script through its production ``__main__`` stdin path over a
 corpus that pins those fail-soft edges plus a representative allow payload, so a
 conversion that changes any decision is caught.
 
-The deterministic deny payloads for the two Write/Edit blockers whose triggers
-need no filesystem or state setup (``md_to_html_blocker``,
-``open_questions_in_plans_blocker``) are exercised here too; each remaining
-hook's full deny coverage stays in its own suite, which also drives the real
-``main()`` and so re-proves the decision after the parser swap.
+The deterministic deny payload for the Write/Edit blocker whose trigger
+needs no filesystem or state setup (``open_questions_in_plans_blocker``) is
+exercised here too; each remaining hook's full deny coverage stays in its own
+suite, which also drives the real ``main()`` and so re-proves the decision
+after the parser swap.
 """
 
 import json
@@ -28,7 +28,6 @@ import pytest
 _BLOCKING_DIRECTORY = Path(__file__).resolve().parent
 
 ALL_CONVERTED_HOOK_FILENAMES = (
-    "md_to_html_blocker.py",
     "open_questions_in_plans_blocker.py",
     "claude_md_orphan_file_blocker.py",
     "pr_converge_bugteam_enforcer.py",
@@ -83,30 +82,6 @@ def test_fail_soft_payload_exits_zero_with_no_decision(hook_filename: str, stdin
     )
 
 
-def test_md_to_html_blocker_still_denies_relative_markdown_write() -> None:
-    payload = json.dumps(
-        {
-            "tool_name": "Write",
-            "tool_input": {"file_path": "notes/topic.md", "content": "# Topic"},
-        }
-    )
-    completed = _run_hook_script("md_to_html_blocker.py", payload)
-    assert completed.returncode == 0
-    assert _decision_from_stdout(completed) == "deny"
-
-
-def test_md_to_html_blocker_still_allows_non_markdown_write() -> None:
-    payload = json.dumps(
-        {
-            "tool_name": "Write",
-            "tool_input": {"file_path": "notes/topic.txt", "content": "plain"},
-        }
-    )
-    completed = _run_hook_script("md_to_html_blocker.py", payload)
-    assert completed.returncode == 0
-    assert _decision_from_stdout(completed) is None
-
-
 def test_open_questions_blocker_still_denies_plan_with_open_questions(
     tmp_path: Path,
 ) -> None:

package/hooks/hooks_constants/CLAUDE.md

@@ -24,7 +24,6 @@ Shared constant modules imported by hooks throughout the `hooks/` tree. Each fil
 | `dead_dataclass_field_constants.py` | Patterns for detecting unused dataclass fields |
 | `dead_module_constant_constants.py` | Patterns for detecting unexported `UPPER_SNAKE` constants in `*_constants.py` modules |
 | `destructive_command_segment_constants.py` | The list of destructive shell command patterns the blocker matches |
-| `doc_gist_auto_publish_constants.py` | Sentinel marker and URL patterns for the doc-gist auto-publish hook |
 | `docstring_rule_gate_count_blocker_constants.py` | Target rule basename, spelled-out-number lookup, count-clause and `check_*` validator patterns, and block-message text for the docstring-rule gate-count staleness blocker |
 | `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 |
@@ -34,10 +33,8 @@ Shared constant modules imported by hooks throughout the `hooks/` tree. Each fil
 | `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 |
-| `html_companion_constants.py` | Blocked URL schemes and other config for the `.md`-to-`.html` companion hook |
 | `inline_tuple_string_magic_constants.py` | Patterns for detecting magic strings in inline tuple literals |
 | `js_conventions_constants.py` | Banned identifier set, boolean-prefix pattern, and declaration/JSDoc patterns for the JavaScript convention checks |
-| `md_to_html_blocker_constants.py` | Path exemptions and trigger patterns for the markdown-to-html blocker |
 | `messages.py` | Short user-facing notice strings shown when a Stop hook redirects agent behavior |
 | `multi_edit_reconstruction.py` | `apply_edits()` / `edits_for_tool()` — shared helpers that reconstruct the post-edit content of an Edit or MultiEdit, imported by the blockers that judge post-edit content |
 | `open_questions_in_plans_blocker_constants.py` | Patterns for detecting unresolved open questions in plan documents |