claude-dev-env 4.3.0 → 7.1.0

package/hooks/advisory/test_pr_done_reminder.py

@@ -0,0 +1,249 @@
+"""Behavior tests for the PR done-checklist context reminder.
+
+The hook is a PostToolUse observer on Bash. It never blocks. These tests pin
+three things: which commands wake it, what the checklist says for each live
+PR state, and that a probe failure stays quiet. The ``gh`` probe is faked at
+the subprocess boundary so no test touches the network.
+"""
+
+from __future__ import annotations
+
+import io
+import json
+import subprocess
+import sys
+from pathlib import Path
+
+import pytest
+
+try:
+    advisory_directory = str(Path(__file__).resolve().parent)
+    if advisory_directory not in sys.path:
+        sys.path.insert(0, advisory_directory)
+    import pr_done_reminder
+except ImportError as import_error:
+    raise ImportError(
+        "test_pr_done_reminder: cannot import its sibling modules; "
+        "ensure the advisory directory is importable."
+    ) from import_error
+
+
+_CLEAN_PR_OBJECT: dict[str, object] = {
+    "number": 42,
+    "url": "https://github.com/acme/widgets/pull/42",
+    "isDraft": True,
+    "mergeable": "MERGEABLE",
+    "mergeStateStatus": "CLEAN",
+    "statusCheckRollup": [
+        {"name": "pytest", "status": "COMPLETED", "conclusion": "SUCCESS"},
+        {"context": "lint", "state": "SUCCESS"},
+    ],
+    "labels": [],
+}
+
+
+def _payload(command: str, tool_response: object = None) -> str:
+    response: object = {"stdout": "", "stderr": ""} if tool_response is None else tool_response
+    return json.dumps(
+        {
+            "session_id": "reminder-session",
+            "cwd": "C:/repo",
+            "tool_name": "Bash",
+            "tool_input": {"command": command},
+            "tool_response": response,
+        }
+    )
+
+
+def _fake_gh(pr_object: dict[str, object] | None, stderr: str = "") -> object:
+    def _run(*args: object, **kwargs: object) -> subprocess.CompletedProcess[str]:
+        del args, kwargs
+        if pr_object is None:
+            return subprocess.CompletedProcess([], 1, stdout="", stderr=stderr)
+        return subprocess.CompletedProcess([], 0, stdout=json.dumps(pr_object), stderr="")
+
+    return _run
+
+
+def _run_main(
+    monkeypatch: pytest.MonkeyPatch,
+    capsys: pytest.CaptureFixture[str],
+    payload_text: str,
+    fake_gh: object,
+) -> str:
+    monkeypatch.setattr(pr_done_reminder.subprocess, "run", fake_gh)
+    monkeypatch.setattr(sys, "stdin", io.StringIO(payload_text))
+    pr_done_reminder.main()
+    return capsys.readouterr().out
+
+
+def _additional_context(stdout_text: str) -> str:
+    return str(json.loads(stdout_text)["hookSpecificOutput"]["additionalContext"])
+
+
+@pytest.mark.parametrize(
+    "command",
+    [
+        "git push",
+        "git push -u origin feat/x",
+        "git -C C:/repo push origin HEAD",
+        "gh pr create --draft --title t --body-file b.md",
+        "git add -A && git commit -F m.txt && git push",
+        "git -c push.default=current push",
+        "git --git-dir=C:/repo/.git push",
+        'pwsh -NoProfile -Command "git push -u origin feat/x"',
+        "pwsh -NoProfile -Command 'gh pr create --draft --fill'",
+        'powershell -Command "git add -A; git push"',
+    ],
+)
+def test_should_wake_on_git_push_and_gh_pr_create(command: str) -> None:
+    assert pr_done_reminder.command_triggers_reminder(command) is True
+
+
+@pytest.mark.parametrize(
+    "command",
+    [
+        "git status",
+        "git pull",
+        "git stash push -u -q -- packages",
+        "git log --grep push",
+        "git commit -m push",
+        "gh pr view 42",
+        "gh pr ready --undo",
+        "echo git push",
+        'pwsh -NoProfile -Command "git status"',
+        "pytest tests/",
+    ],
+)
+def test_should_stay_quiet_for_other_commands(command: str) -> None:
+    assert pr_done_reminder.command_triggers_reminder(command) is False
+
+
+def test_should_say_done_when_mergeable_and_checks_pass() -> None:
+    context = pr_done_reminder.build_reminder_context(_CLEAN_PR_OBJECT)
+
+    assert context.startswith("=== PR DONE CHECKLIST")
+    assert "never a block" in context
+    assert "DONE. Add the label now:" in context
+    assert "gh pr edit 42 --add-label done" in context
+    assert "NOT DONE" not in context
+
+
+def test_should_keep_the_checklist_order_verdict_then_recheck_then_footer() -> None:
+    all_lines = pr_done_reminder.build_reminder_context(_CLEAN_PR_OBJECT).split("\n")
+
+    all_labels = [each_line.split(":")[0] for each_line in all_lines[1:-1]]
+    assert all_labels == [
+        "PR #42  https",
+        "Mergeable",
+        "CI checks",
+        "Draft",
+        "Label done",
+        "Verdict",
+        "Add label",
+        "Re-check",
+    ]
+    assert all_lines[-1] == "A PR is done only when every line above is clean."
+
+
+def test_should_say_not_done_and_name_the_conflict_fix() -> None:
+    conflicted = {**_CLEAN_PR_OBJECT, "mergeable": "CONFLICTING", "mergeStateStatus": "DIRTY"}
+
+    context = pr_done_reminder.build_reminder_context(conflicted)
+
+    assert "NOT DONE" in context
+    assert "CONFLICTS with the base branch" in context
+    assert "gh pr view 42 --json mergeable" in context
+    assert "gh pr edit 42 --add-label" not in context
+
+
+def test_should_count_failing_and_pending_checks() -> None:
+    mixed_checks = {
+        **_CLEAN_PR_OBJECT,
+        "statusCheckRollup": [
+            {"name": "pytest", "status": "COMPLETED", "conclusion": "FAILURE"},
+            {"name": "mypy", "status": "IN_PROGRESS", "conclusion": ""},
+            {"context": "lint", "state": "PENDING"},
+            {"context": "docs", "state": "SUCCESS"},
+        ],
+    }
+
+    context = pr_done_reminder.build_reminder_context(mixed_checks)
+
+    assert "1 failing" in context
+    assert "2 pending" in context
+    assert "4 total" in context
+    assert "NOT DONE" in context
+
+
+def test_should_tell_the_agent_to_wait_when_github_is_still_computing() -> None:
+    unknown = {**_CLEAN_PR_OBJECT, "mergeable": "UNKNOWN", "mergeStateStatus": "UNKNOWN"}
+
+    context = pr_done_reminder.build_reminder_context(unknown)
+
+    assert "still computing" in context
+    assert "NOT DONE" in context
+
+
+def test_should_report_the_done_label_when_already_set() -> None:
+    labeled = {**_CLEAN_PR_OBJECT, "labels": [{"name": "done"}]}
+
+    context = pr_done_reminder.build_reminder_context(labeled)
+
+    assert "Label done:  set" in context
+
+
+def test_main_should_emit_additional_context_after_a_successful_push(
+    monkeypatch: pytest.MonkeyPatch, capsys: pytest.CaptureFixture[str]
+) -> None:
+    stdout_text = _run_main(monkeypatch, capsys, _payload("git push"), _fake_gh(_CLEAN_PR_OBJECT))
+
+    payload = json.loads(stdout_text)
+    assert payload["hookSpecificOutput"]["hookEventName"] == "PostToolUse"
+    assert "permissionDecision" not in payload["hookSpecificOutput"]
+    assert "decision" not in payload
+    assert "PR #42" in _additional_context(stdout_text)
+
+
+def test_main_should_also_serve_the_powershell_tool(
+    monkeypatch: pytest.MonkeyPatch, capsys: pytest.CaptureFixture[str]
+) -> None:
+    payload = json.loads(_payload("git push"))
+    payload["tool_name"] = "PowerShell"
+
+    stdout_text = _run_main(monkeypatch, capsys, json.dumps(payload), _fake_gh(_CLEAN_PR_OBJECT))
+
+    assert "PR #42" in _additional_context(stdout_text)
+
+
+def test_main_should_stay_quiet_when_the_push_failed(
+    monkeypatch: pytest.MonkeyPatch, capsys: pytest.CaptureFixture[str]
+) -> None:
+    failed_push = _payload("git push", "Error: Exit code 1\nrejected")
+
+    assert _run_main(monkeypatch, capsys, failed_push, _fake_gh(_CLEAN_PR_OBJECT)) == ""
+
+
+def test_main_should_stay_quiet_for_a_non_trigger_command(
+    monkeypatch: pytest.MonkeyPatch, capsys: pytest.CaptureFixture[str]
+) -> None:
+    assert _run_main(monkeypatch, capsys, _payload("git status"), _fake_gh(_CLEAN_PR_OBJECT)) == ""
+
+
+def test_main_should_remind_to_open_a_pr_when_the_branch_has_none(
+    monkeypatch: pytest.MonkeyPatch, capsys: pytest.CaptureFixture[str]
+) -> None:
+    no_pr = _fake_gh(None, stderr='no pull requests found for branch "feat/x"')
+
+    context = _additional_context(_run_main(monkeypatch, capsys, _payload("git push"), no_pr))
+
+    assert "No open pull request found" in context
+    assert "gh pr create --draft" in context
+
+
+def test_main_should_stay_quiet_on_any_other_gh_failure(
+    monkeypatch: pytest.MonkeyPatch, capsys: pytest.CaptureFixture[str]
+) -> None:
+    gh_down = _fake_gh(None, stderr="error connecting to api.github.com")
+
+    assert _run_main(monkeypatch, capsys, _payload("git push"), gh_down) == ""

package/hooks/blocking/bash_post_call_dispatcher.py

@@ -14,9 +14,11 @@ collision, and needs no change to that shared, out-of-scope test file.
 Reads the tool payload from stdin once, selects the hosted hooks applicable to
 the payload's tool name, and runs each one in-process via the shared
 hosted-hook runner. A hosted PostToolUse hook here carries no permission
-decision -- it is a side-effecting observer, not a gate -- so this dispatcher
-runs the whole roster unconditionally and emits nothing itself, matching every
-hosted hook's own empty-stdout contract.
+decision -- it is an observer, not a gate -- so this dispatcher runs the whole
+roster unconditionally and never blocks. The one thing it forwards is context:
+a hosted hook may print a ``hookSpecificOutput.additionalContext`` string (the
+PR done reminder does), and the dispatcher joins every such string into one
+PostToolUse payload. A hook that prints nothing adds nothing.
 
 A single hosted hook crash fails open: ``run_hook_capturing_output`` isolates
 it, so it contributes nothing and does not stop the remaining hosted hooks.
@@ -27,11 +29,17 @@ imports load once into this process rather than once per hook.
 
 from __future__ import annotations
 
+import json
+import sys
 
 import _path_setup  # noqa: F401
 
 from hooks_constants.bash_post_call_dispatcher_constants import (
+    ADDITIONAL_CONTEXT_JOIN_SEPARATOR,
+    ADDITIONAL_CONTEXT_KEY,
     ALL_BASH_POST_TOOL_USE_HOSTED_HOOK_ENTRIES,
+    HOOK_SPECIFIC_OUTPUT_KEY,
+    POST_TOOL_USE_HOOK_EVENT_NAME,
 )
 from hooks_constants.bash_pre_tool_use_dispatcher_constants import BashHostedHookEntry
 from hooks_constants.hosted_hook_runner import (
@@ -50,15 +58,54 @@ def select_applicable_entries(tool_name: str) -> list[BashHostedHookEntry]:
     ]
 
 
+def additional_context_from_hook_output(captured_stdout: str) -> str | None:
+    """Return the additionalContext string a hosted hook printed, or None.
+
+    Empty output, non-JSON output, and JSON without a non-empty
+    ``hookSpecificOutput.additionalContext`` string all return None.
+    """
+    if not captured_stdout.strip():
+        return None
+    try:
+        hook_output = json.loads(captured_stdout)
+    except json.JSONDecodeError:
+        return None
+    if not isinstance(hook_output, dict):
+        return None
+    hook_specific_output = hook_output.get(HOOK_SPECIFIC_OUTPUT_KEY)
+    if not isinstance(hook_specific_output, dict):
+        return None
+    additional_context = hook_specific_output.get(ADDITIONAL_CONTEXT_KEY)
+    if not isinstance(additional_context, str) or not additional_context.strip():
+        return None
+    return additional_context
+
+
 def dispatch(payload_text: str, tool_name: str) -> None:
-    """Run every hosted hook applicable to tool_name, in registration order.
+    """Run every hosted hook applicable to tool_name, then forward their context.
 
     Each hosted hook's crash is isolated by ``run_hook_capturing_output``, so
-    one hook failing never stops a later one in the same roster.
+    one hook failing never stops a later one in the same roster. Every
+    additionalContext string the hooks printed is joined into one PostToolUse
+    payload on stdout; when no hook printed one, nothing is written.
     """
+    all_additional_context: list[str] = []
     for each_entry in select_applicable_entries(tool_name):
         script_path = resolved_hook_script_path(each_entry.script_relative_path)
-        run_hook_capturing_output(script_path, payload_text)
+        hook_run = run_hook_capturing_output(script_path, payload_text)
+        additional_context = additional_context_from_hook_output(hook_run.captured_stdout)
+        if additional_context is not None:
+            all_additional_context.append(additional_context)
+    if not all_additional_context:
+        return
+    payload = {
+        HOOK_SPECIFIC_OUTPUT_KEY: {
+            "hookEventName": POST_TOOL_USE_HOOK_EVENT_NAME,
+            ADDITIONAL_CONTEXT_KEY: ADDITIONAL_CONTEXT_JOIN_SEPARATOR.join(all_additional_context),
+        }
+    }
+    sys.stdout.write(json.dumps(payload))
+    sys.stdout.flush()
 
 
 def main() -> None:

package/hooks/blocking/code_rules_banned_identifiers.py

@@ -30,6 +30,7 @@ from code_rules_shared import (  # noqa: E402
 from hooks_constants.banned_identifiers_constants import (  # noqa: E402
     ALL_BANNED_IDENTIFIERS,
     ALL_BANNED_NOUN_WORDS,
+    ALL_BLAST_RADIUS_EXCEPTION_SUFFIXES,
     BANNED_IDENTIFIER_MESSAGE_SUFFIX,
     BANNED_IDENTIFIER_SKIP_ADVISORY,
     BANNED_NOUN_COMPATIBILITY_COMMENT,
@@ -228,6 +229,8 @@ def _find_banned_noun_word(identifier: str) -> str | None:
         identifier (e.g., ``'result'`` for ``'HolidayPeakResult'``). Returns
         ``None`` when no banned noun word is present.
     """
+    if identifier.endswith(ALL_BLAST_RADIUS_EXCEPTION_SUFFIXES):
+        return None
     for each_word in _identifier_word_parts(identifier):
         if each_word in ALL_BANNED_NOUN_WORDS:
             return each_word

package/hooks/blocking/code_rules_paired_test.py

@@ -215,12 +215,27 @@ def _collect_referenced_identifiers(source: str) -> set[str]:
     return all_referenced_identifiers
 
 
+def _sibling_test_paths(stem_test_path: Path) -> list[Path]:
+    """Return the capped, sorted test files beside the stem test, stem excluded."""
+    suite_directory = stem_test_path.parent
+    stem_path_key = os.path.normcase(str(stem_test_path.resolve()))
+    all_sibling_paths: list[Path] = []
+    for each_glob in ALL_TEST_FILENAME_GLOBS:
+        all_sibling_paths.extend(
+            each_path
+            for each_path in sorted(suite_directory.glob(each_glob))
+            if os.path.normcase(str(each_path.resolve())) != stem_path_key
+        )
+    return all_sibling_paths[:MAX_TEST_FILES_SCANNED]
+
+
 def _suite_referenced_identifiers(stem_test_path: Path) -> set[str]:
     """Return identifiers referenced across every test file beside the stem test.
 
-    Scans every ``test_*.py`` and ``*_test.py`` file in the directory holding the
-    stem-matched test file, bounded by the scan cap, and unions the identifiers
-    each one references.
+    Reads the stem-matched test file first, then scans every other ``test_*.py``
+    and ``*_test.py`` file in its directory, bounded by the scan cap, and unions
+    the identifiers each one references. The stem test always counts, so a
+    directory with more test files than the cap cannot hide it.
 
     Args:
         stem_test_path: The stem-matched test file whose directory is scanned.
@@ -228,12 +243,9 @@ def _suite_referenced_identifiers(stem_test_path: Path) -> set[str]:
     Returns:
         The union of referenced identifiers across the scanned test files.
     """
-    suite_directory = stem_test_path.parent
-    all_test_file_paths: list[Path] = []
-    for each_glob in ALL_TEST_FILENAME_GLOBS:
-        all_test_file_paths.extend(sorted(suite_directory.glob(each_glob)))
+    all_test_file_paths = [stem_test_path, *_sibling_test_paths(stem_test_path)]
     all_referenced_identifiers: set[str] = set()
-    for each_test_file_path in all_test_file_paths[:MAX_TEST_FILES_SCANNED]:
+    for each_test_file_path in all_test_file_paths:
         try:
             test_source = each_test_file_path.read_text(encoding="utf-8")
         except (OSError, UnicodeDecodeError):
@@ -364,16 +376,12 @@ def _production_stem_from_test_filename(test_filename: str) -> str | None:
     if test_filename.startswith(STEM_TEST_FILENAME_PREFIX) and test_filename.endswith(
         PYTHON_SOURCE_SUFFIX
     ):
-        production_stem = test_filename[
-            len(STEM_TEST_FILENAME_PREFIX) : -len(PYTHON_SOURCE_SUFFIX)
-        ]
+        production_stem = test_filename[len(STEM_TEST_FILENAME_PREFIX) : -len(PYTHON_SOURCE_SUFFIX)]
         return production_stem or None
     return None
 
 
-def _paired_production_module_path(
-    test_path: Path, production_stem: str
-) -> Path | None:
+def _paired_production_module_path(test_path: Path, production_stem: str) -> Path | None:
     """Return the production module a stem-matched test file pairs with, or None.
 
     Mirrors ``_stem_matched_test_path`` in reverse for the two common layouts: a
@@ -515,4 +523,3 @@ def check_test_file_omits_module_public_function(
         if len(all_omission_violations) >= MAX_PAIRED_TEST_COVERAGE_ISSUES:
             break
     return all_omission_violations
-

package/hooks/blocking/precommit_code_rules_gate.py

@@ -1,11 +1,8 @@
-"""Library helper: resolve a directory's Git repository root.
-
-``pii_prevention_blocker.py`` and ``pii_payload_scan.py`` import
-``resolve_repository_root`` to find the repository a staged-commit scan
-targets, and ``session_edit_stage_gate.py`` imports it to find the
-repository a commit's unstaged-edit check targets. This module carries no
-hook entry point of its own; the native ``git-hooks/pre_commit.py`` runs
-the real commit-time CODE_RULES enforcement.
+"""Library helper that resolves a directory to its Git repository root.
+
+``pii_payload_scan.py`` imports ``resolve_repository_root`` for staged scans.
+This module has no hook entry point. Native ``git-hooks/pre_commit.py`` shows
+the local verification advisory and does not enforce CODE_RULES.
 """
 
 import subprocess

package/hooks/blocking/test_bash_dispatcher_interpreter_starts.py

@@ -1,61 +1,16 @@
-"""Benchmark: consolidated Bash dispatcher starts one interpreter, not N.
+"""Tests for the retired Bash and PowerShell blocking roster."""
 
-Standalone registration starts one Python process per hosted hook. The
-dispatcher replaces that chain with a single process that hosts every hook
-in-process. This test pins the before/after interpreter-start counts so a
-regression that re-splits the chain fails CI.
-"""
-
-from __future__ import annotations
-
-import json
-import subprocess
 import sys
 from pathlib import Path
 
-_HOOKS_DIR = str(Path(__file__).resolve().parent.parent)
-if _HOOKS_DIR not in sys.path:
-    sys.path.insert(0, _HOOKS_DIR)
+_HOOKS_ROOT = Path(__file__).resolve().parent.parent
+if str(_HOOKS_ROOT) not in sys.path:
+    sys.path.insert(0, str(_HOOKS_ROOT))
 
-from hooks_constants.bash_pre_tool_use_dispatcher_constants import (  # noqa: E402
+from hooks_constants.bash_pre_tool_use_dispatcher_constants import (
     ALL_BASH_HOSTED_HOOK_ENTRIES,
-    BASH_TOOL_NAME,
 )
 
-_BLOCKING_DIR = Path(__file__).resolve().parent
-_HOOKS_ROOT = _BLOCKING_DIR.parent
-_DISPATCHER_SCRIPT = str(_BLOCKING_DIR / "bash_pre_tool_use_dispatcher.py")
-
-STANDALONE_INTERPRETER_STARTS_PER_BASH_CALL = len(ALL_BASH_HOSTED_HOOK_ENTRIES)
-DISPATCHER_INTERPRETER_STARTS_PER_BASH_CALL = 1
-
-
-def test_roster_is_large_enough_that_consolidation_saves_starts() -> None:
-    """Consolidation only pays off when the chain hosts more than one hook."""
-    assert STANDALONE_INTERPRETER_STARTS_PER_BASH_CALL >= 10
-    assert DISPATCHER_INTERPRETER_STARTS_PER_BASH_CALL == 1
-    assert STANDALONE_INTERPRETER_STARTS_PER_BASH_CALL > DISPATCHER_INTERPRETER_STARTS_PER_BASH_CALL
-
-
-def test_dispatcher_handles_a_bash_call_in_one_process() -> None:
-    """One subprocess run of the dispatcher covers the full Bash hosted chain."""
-    payload_text = json.dumps(
-        {"tool_name": BASH_TOOL_NAME, "tool_input": {"command": "echo interpreter-start-probe"}}
-    )
-    completed = subprocess.run(
-        [sys.executable, _DISPATCHER_SCRIPT],
-        check=False,
-        input=payload_text,
-        capture_output=True,
-        text=True,
-        encoding="utf-8",
-    )
-    assert completed.returncode == 0
-    assert DISPATCHER_INTERPRETER_STARTS_PER_BASH_CALL == 1
-
 
-def test_standalone_chain_would_start_one_process_per_roster_entry() -> None:
-    """Each roster path is a real script that would own its own interpreter start."""
-    for each_entry in ALL_BASH_HOSTED_HOOK_ENTRIES:
-        assert (_HOOKS_ROOT / each_entry.script_relative_path).is_file()
-    assert len(ALL_BASH_HOSTED_HOOK_ENTRIES) == STANDALONE_INTERPRETER_STARTS_PER_BASH_CALL
+def test_retired_bash_roster_has_no_effective_blocking_hooks() -> None:
+    assert ALL_BASH_HOSTED_HOOK_ENTRIES == ()

package/hooks/blocking/test_bash_post_call_dispatcher.py

@@ -15,16 +15,26 @@ from pathlib import Path
 
 import pytest
 
-from bash_post_call_dispatcher import dispatch, main, select_applicable_entries
+from bash_post_call_dispatcher import (
+    additional_context_from_hook_output,
+    dispatch,
+    main,
+    select_applicable_entries,
+)
 from hooks_constants.bash_pre_tool_use_dispatcher_constants import BASH_TOOL_NAME
 from hooks_constants.hosted_hook_runner import HostedHookRun
 from tdd_enforcer_parts import content_hash_store
 
+_ALL_EXPECTED_ROSTER_PATHS = [
+    "observability/test_failure_recorder.py",
+    "advisory/pr_done_reminder.py",
+]
 
-def test_select_applicable_entries_returns_the_hosted_hook_for_bash() -> None:
+
+def test_select_applicable_entries_returns_the_hosted_hooks_for_bash() -> None:
     all_entries = select_applicable_entries(BASH_TOOL_NAME)
     all_script_paths = [each_entry.script_relative_path for each_entry in all_entries]
-    assert all_script_paths == ["observability/test_failure_recorder.py"]
+    assert all_script_paths == _ALL_EXPECTED_ROSTER_PATHS
 
 
 def test_select_applicable_entries_returns_none_for_a_write_tool() -> None:
@@ -45,7 +55,58 @@ def test_dispatch_runs_every_hosted_hook_in_roster_order(
 
     dispatch('{"tool_name": "Bash"}', BASH_TOOL_NAME)
 
-    assert all_call_paths == ["test_failure_recorder.py"]
+    assert all_call_paths == [Path(each_path).name for each_path in _ALL_EXPECTED_ROSTER_PATHS]
+
+
+def test_dispatch_forwards_hosted_hook_additional_context_as_one_payload(
+    monkeypatch: pytest.MonkeyPatch, capsys: pytest.CaptureFixture[str]
+) -> None:
+    context_by_hook = {
+        "test_failure_recorder.py": "",
+        "pr_done_reminder.py": json.dumps(
+            {"hookSpecificOutput": {"hookEventName": "PostToolUse", "additionalContext": "PR #42"}}
+        ),
+    }
+
+    def _fake_run_hook(script_path: str, payload_text: str) -> HostedHookRun:
+        del payload_text
+        return HostedHookRun(
+            captured_stdout=context_by_hook[Path(script_path).name], did_crash=False
+        )
+
+    monkeypatch.setattr("bash_post_call_dispatcher.run_hook_capturing_output", _fake_run_hook)
+
+    dispatch('{"tool_name": "Bash"}', BASH_TOOL_NAME)
+
+    emitted = json.loads(capsys.readouterr().out)
+    assert emitted == {
+        "hookSpecificOutput": {"hookEventName": "PostToolUse", "additionalContext": "PR #42"}
+    }
+    assert "decision" not in emitted
+
+
+def test_dispatch_writes_nothing_when_no_hosted_hook_printed_context(
+    monkeypatch: pytest.MonkeyPatch, capsys: pytest.CaptureFixture[str]
+) -> None:
+    def _fake_run_hook(script_path: str, payload_text: str) -> HostedHookRun:
+        del script_path, payload_text
+        return HostedHookRun(captured_stdout="", did_crash=False)
+
+    monkeypatch.setattr("bash_post_call_dispatcher.run_hook_capturing_output", _fake_run_hook)
+
+    dispatch('{"tool_name": "Bash"}', BASH_TOOL_NAME)
+
+    assert capsys.readouterr().out == ""
+
+
+@pytest.mark.parametrize(
+    "captured_stdout",
+    ["", "   ", "not json", "[]", '{"decision": "block"}', '{"hookSpecificOutput": {}}'],
+)
+def test_additional_context_from_hook_output_ignores_non_context_output(
+    captured_stdout: str,
+) -> None:
+    assert additional_context_from_hook_output(captured_stdout) is None
 
 
 def test_main_exits_zero_and_writes_nothing_to_stdout(