claude-dev-env 1.83.0 → 1.84.0

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 |

package/hooks/hooks_constants/blocking_check_limits.py

@@ -218,6 +218,9 @@ DOCSTRING_RUNON_SENTENCE_WORD_LIMIT: int = 30
 MAX_DOCSTRING_RUNON_SENTENCE_ISSUES: int = 5
 ALL_DOCSTRING_RUNON_JOINER_MARKERS: tuple[str, ...] = ("—", " -- ", ";")
 DOCSTRING_RUNON_SENTENCE_BOUNDARY_PATTERN: re.Pattern[str] = re.compile(r"(?<=[.!?])\s+")
+DOCSTRING_NARRATIVE_PROSE_LINE_LIMIT: int = 6
+DOCSTRING_NARRATIVE_LINE_JOIN_SEPARATOR: str = " "
+MAX_DOCSTRING_PROSE_WALL_ISSUES: int = 5
 
 ALL_DOCSTRING_NO_CONSUMER_CLAIM_PHRASES: tuple[str, ...] = (
     "no consumer reads",

package/hooks/hooks_constants/code_rules_path_utils_constants.py

@@ -22,8 +22,8 @@ ALL_CONFIG_DIRECTORY_NAMES = frozenset(
         "pr_converge_skill_constants",
         "pr_converge_scripts_constants",
         "bugteam_scripts_constants",
-        "doc_gist_scripts_constants",
         "implement_scripts_constants",
+        "log_audit_constants",
         "dev_env_scripts_constants",
     }
 )

package/hooks/hooks_constants/duplicate_rmtree_helper_blocker_constants.py

@@ -19,7 +19,6 @@ ALL_EXEMPT_PATH_FRAGMENTS: tuple[str, ...] = (
     "windows_safe_rmtree.py",
     "windows_filesystem.py",
     "session_env_cleanup.py",
-    "_md_to_html_blocker_test_support.py",
     "teardown_worktrees.py",
 )
 

package/hooks/hooks_constants/post_tool_use_dispatcher_constants.py

@@ -62,9 +62,4 @@ ALL_POST_HOSTED_HOOK_ENTRIES: tuple[PostHostedHookEntry, ...] = (
         script_relative_path="workflow/auto_formatter.py",
         is_blocking=False,
     ),
-    PostHostedHookEntry(
-        script_relative_path="workflow/doc_gist_auto_publish.py",
-        extra_argument_relative_paths=(PLUGIN_ROOT_PLACEHOLDER,),
-        is_blocking=False,
-    ),
 )

package/hooks/validation/post_tool_use_dispatcher.py

@@ -168,7 +168,7 @@ class PostDispatcherDecision:
         all_block_reasons: All block reasons from blocking hooks, in run order.
         all_non_block_stdout: Stdout from hooks that did not emit a block
             decision, concatenated in run order. Preserved so informational
-            output (such as the doc-gist htmlpreview URL) reaches the harness
+            output (such as an auto-formatter notice) reaches the harness
             on both the allow and block paths.
     """
 

package/hooks/validation/test_post_tool_use_dispatcher.py

@@ -5,11 +5,11 @@ hook as its own subprocess (the production path), records each hook's block
 decision, computes the expected aggregate, then runs the dispatcher on the same
 payload and asserts an equal block-or-allow decision and the union of reasons.
 
-Three focused tests pin the side-effecting behavior the dispatcher must not
+Two focused tests pin the side-effecting behavior the dispatcher must not
 change: the formatter formats only on a Write of a file git does not yet track
-and never blocks; the type-checker still blocks on a real type error when run
-through the dispatcher; and non-block stdout from side-effect hooks (such as
-the doc-gist htmlpreview URL) survives on both the allow and block paths.
+and never blocks; and the type-checker still blocks on a real type error when
+run through the dispatcher. Two more tests pin that non-block stdout from a
+side-effect hook survives on both the allow and block paths.
 
 Crash and early-exit tests exercise the aggregator directly: an early hook
 crash before mypy does not drop mypy's block, a non-blocking hook crash leaves
@@ -20,6 +20,7 @@ from __future__ import annotations
 
 import importlib.util
 import json
+import os
 import subprocess
 import sys
 from pathlib import Path
@@ -33,9 +34,6 @@ _VALIDATION_DIR_STR = str(Path(__file__).resolve().parent)
 if _VALIDATION_DIR_STR not in sys.path:
     sys.path.insert(0, _VALIDATION_DIR_STR)
 
-from hooks_constants.doc_gist_auto_publish_constants import (  # noqa: E402, I001
-    HOOK_SUBPROCESS_TIMEOUT_SECONDS as DOC_GIST_TIMEOUT_SECONDS,
-)
 from hooks_constants.post_tool_use_dispatcher_constants import (  # noqa: E402, I001
     ALL_POST_HOSTED_HOOK_ENTRIES,
     BLOCK_DECISION,
@@ -95,6 +93,26 @@ def _resolve_extra_arguments(each_entry: PostHostedHookEntry) -> list[str]:
     return resolved_arguments
 
 
+def _environment_without_git_hook_variables() -> dict[str, str]:
+    """Return the process environment with git's hook-scoped variables removed.
+
+    Git exports variables such as GIT_DIR and GIT_INDEX_FILE to hook
+    processes. When this suite runs under a git hook (the pre-commit gate
+    replays staged test files), those variables leak into the hook
+    subprocesses and point their project discovery at the wrong checkout.
+    Stripping them restores the cwd-based discovery the hooks use in
+    production.
+
+    Returns:
+        A copy of the environment without any GIT_-prefixed variable.
+    """
+    return {
+        each_name: each_value
+        for each_name, each_value in os.environ.items()
+        if not each_name.startswith("GIT_")
+    }
+
+
 def _run_hook_subprocess(
     each_entry: PostHostedHookEntry, payload_text: str
 ) -> subprocess.CompletedProcess[str]:
@@ -116,6 +134,7 @@ def _run_hook_subprocess(
         capture_output=True,
         text=True,
         encoding="utf-8",
+        env=_environment_without_git_hook_variables(),
     )
 
 
@@ -135,6 +154,7 @@ def _run_dispatcher(payload_text: str) -> subprocess.CompletedProcess[str]:
         capture_output=True,
         text=True,
         encoding="utf-8",
+        env=_environment_without_git_hook_variables(),
     )
 
 
@@ -267,10 +287,10 @@ def _post_tool_use_dispatcher_harness_timeout_seconds() -> int:
 def _hosted_hooks_worst_case_internal_seconds() -> int:
     """Return the summed worst-case internal subprocess budget of the hosted hooks.
 
-    The three hosted hooks run sequentially in one dispatcher process. The
-    type-checker, the formatter (its slower JS path), and the doc-gist publisher
-    each carry their own internal subprocess timeout; their sum is the dispatcher
-    process's worst-case runtime when each hook runs to its own ceiling.
+    The hosted hooks run sequentially in one dispatcher process. The
+    type-checker and the formatter (its slower JS path) each carry their own
+    internal subprocess timeout; their sum is the dispatcher process's
+    worst-case runtime when each hook runs to its own ceiling.
 
     Returns:
         The summed worst-case internal subprocess seconds across the hosted hooks.
@@ -281,21 +301,17 @@ def _hosted_hooks_worst_case_internal_seconds() -> int:
         auto_formatter.PYTHON_FORMAT_TIMEOUT_SECONDS,
         auto_formatter.JS_FORMAT_TIMEOUT_SECONDS,
     )
-    return (
-        mypy_validator.MYPY_TIMEOUT_SECONDS
-        + slowest_formatter_seconds
-        + DOC_GIST_TIMEOUT_SECONDS
-    )
+    return mypy_validator.MYPY_TIMEOUT_SECONDS + slowest_formatter_seconds
 
 
 def test_dispatcher_harness_timeout_clears_summed_hosted_hook_budgets() -> None:
     """The dispatcher harness timeout exceeds the summed worst-case hosted-hook budget.
 
-    The three hosted hooks run sequentially under one harness timeout. When the
+    The hosted hooks run sequentially under one harness timeout. When the
     harness timeout does not clear their summed worst-case internal budgets, a
     near-full slow type-check run consumes the budget and the harness kills the
-    dispatcher before the formatter and doc-gist publisher get their turn. The
-    harness timeout must exceed the sum so every hosted hook runs to completion.
+    dispatcher before the formatter gets its turn. The harness timeout must
+    exceed the sum so every hosted hook runs to completion.
     """
     harness_timeout_seconds = _post_tool_use_dispatcher_harness_timeout_seconds()
     summed_internal_seconds = _hosted_hooks_worst_case_internal_seconds()
@@ -303,7 +319,7 @@ def test_dispatcher_harness_timeout_clears_summed_hosted_hook_budgets() -> None:
         "PostToolUse dispatcher harness timeout "
         f"({harness_timeout_seconds}s) must exceed the summed worst-case internal "
         f"budgets of the hosted hooks ({summed_internal_seconds}s), or a slow "
-        "type-check run starves the formatter and doc-gist publisher."
+        "type-check run starves the formatter."
     )
 
 
@@ -315,14 +331,14 @@ def test_clean_edit_of_plain_text_allows() -> None:
 
 
 def test_clean_write_of_nonexistent_path_allows() -> None:
-    """Dispatcher allows a Write whose path does not exist (mypy and doc-gist skip)."""
+    """Dispatcher allows a Write whose path does not exist (mypy skips)."""
     missing_path = str(_VALIDATION_DIR / "does_not_exist_dispatcher_probe.txt")
     payload_text = _write_payload(missing_path, "hello world\n")
     _assert_dispatcher_matches_individual_hooks(payload_text)
 
 
-def test_edit_of_non_html_skips_doc_gist_allows() -> None:
-    """Dispatcher allows an Edit of an existing non-HTML file with no sentinel."""
+def test_edit_of_non_html_allows() -> None:
+    """Dispatcher allows an Edit of an existing non-HTML file."""
     existing_path = str(Path(__file__).resolve())
     payload_text = _edit_payload(existing_path, "old", "new")
     _assert_dispatcher_matches_individual_hooks(payload_text)
@@ -433,10 +449,10 @@ def test_formatter_formats_only_untracked_write_and_never_blocks(tmp_path: Path)
 def test_non_block_stdout_preserved_in_aggregator_allow_path() -> None:
     """Aggregator preserves non-block hook stdout on the allow path.
 
-    A side-effect hook (such as doc_gist_auto_publish) writes informational
-    text to stdout without emitting a block decision. The aggregator must carry
-    that text into all_non_block_stdout so the dispatcher can write it to the
-    real stdout on the allow path.
+    A side-effect hook writes informational text to stdout without emitting a
+    block decision. The aggregator must carry that text into
+    all_non_block_stdout so the dispatcher can write it to the real stdout on
+    the allow path.
     """
     informational_text = "https://htmlpreview.github.io/?https://gist.github.com/abc/123"
     all_results = [
@@ -459,7 +475,7 @@ def test_non_block_stdout_preserved_in_aggregator_allow_path() -> None:
 def test_non_block_stdout_preserved_in_aggregator_block_path() -> None:
     """Aggregator preserves non-block hook stdout even when another hook blocks.
 
-    When mypy_validator blocks and doc_gist_auto_publish wrote informational
+    When mypy_validator blocks and a side-effect hook wrote informational
     text, both the block reason and the informational text survive in the
     aggregated decision so _emit_block_decision can forward both to stdout.
     """
@@ -512,9 +528,9 @@ def test_early_hook_crash_does_not_drop_later_blocking_hook_block() -> None:
 def test_non_blocking_hook_crash_leaves_decision_allow() -> None:
     """A crash in a non-blocking hook does not change an allow to a block.
 
-    A side-effect hook such as auto_formatter or doc_gist_auto_publish carries
-    is_blocking=False. Its crash must not surface a blocking signal — the
-    aggregated decision stays allow.
+    A side-effect hook such as auto_formatter carries is_blocking=False. Its
+    crash must not surface a blocking signal — the aggregated decision stays
+    allow.
     """
     all_results = [
         PostHostedHookResult(captured_stdout="", did_crash=True, is_blocking=False),
@@ -566,12 +582,12 @@ def test_block_path_emits_single_parseable_json_object_on_stdout() -> None:
     )
     try:
         payload_text = _write_payload(str(type_error_file), type_error_file.read_text())
-        direct_block, _direct_reason = _parse_block_decision(
-            _run_hook_subprocess(ALL_POST_HOSTED_HOOK_ENTRIES[0], payload_text)
-        )
+        completed_direct = _run_hook_subprocess(ALL_POST_HOSTED_HOOK_ENTRIES[0], payload_text)
+        direct_block, _direct_reason = _parse_block_decision(completed_direct)
         assert direct_block, (
             "Precondition failed: mypy_validator did not block a real type error directly. "
-            "Is mypy installed and the file inside the git project?"
+            "Is mypy installed and the file inside the git project?\n"
+            f"stdout: {completed_direct.stdout!r}\nstderr: {completed_direct.stderr!r}"
         )
 
         dispatcher_result = _run_dispatcher(payload_text)