claude-dev-env 8.88.7 → 8.90.0

package/hooks/advisory/test_owned_pr_review_loop.py

@@ -0,0 +1,369 @@
+"""Behavior tests for the owned pull request review-loop context hook.
+
+The hook is a PostToolUse observer. It never blocks. These tests pin which
+tool calls wake it, which repositories get the review-loop block, and that
+every other path stays quiet. Each end-to-end test runs the script as a
+subprocess with a Claude Code or Codex payload on stdin.
+"""
+
+from __future__ import annotations
+
+import json
+import re
+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 owned_pr_review_loop
+except ImportError as import_error:
+    raise ImportError(
+        "test_owned_pr_review_loop: cannot import its sibling modules; "
+        "ensure the advisory directory is importable."
+    ) from import_error
+
+
+HOOK_SCRIPT_PATH = Path(__file__).resolve().parent / "owned_pr_review_loop.py"
+HOOKS_JSON_PATH = Path(__file__).resolve().parent.parent / "hooks.json"
+OWNED_PR_URL = "https://github.com/jl-cmd-projects/claude-dev-env/pull/42"
+FOREIGN_PR_URL = "https://github.com/acme/widgets/pull/3"
+
+
+def _run_hook(payload: dict[str, object]) -> str:
+    completed = subprocess.run(
+        [sys.executable, str(HOOK_SCRIPT_PATH)],
+        input=json.dumps(payload),
+        capture_output=True,
+        text=True,
+        check=False,
+    )
+    assert completed.returncode == 0, completed.stderr
+    return completed.stdout
+
+
+def _shell_payload(
+    command: str, stdout: str, tool_name: str = "Bash", input_key: str = "command"
+) -> dict[str, object]:
+    return {
+        "hook_event_name": "PostToolUse",
+        "tool_name": tool_name,
+        "tool_input": {input_key: command},
+        "tool_response": {"stdout": stdout, "stderr": ""},
+    }
+
+
+def _mcp_payload(tool_name: str, owner: str, repository: str, url: str) -> dict[str, object]:
+    return {
+        "hook_event_name": "PostToolUse",
+        "tool_name": tool_name,
+        "tool_input": {"owner": owner, "repo": repository, "title": "Add a hook"},
+        "tool_response": [{"type": "text", "text": json.dumps({"id": "1", "url": url})}],
+    }
+
+
+def _context_of(stdout: str) -> str:
+    return json.loads(stdout)["hookSpecificOutput"]["additionalContext"]
+
+
+@pytest.mark.parametrize(
+    "command",
+    [
+        "gh pr create --title t --body b",
+        "gh pr new --fill",
+        "git push -u origin feature && gh pr create --fill",
+        'pwsh -Command "gh pr create --fill"',
+        "gh api repos/acme/widgets/pulls --input pr.json",
+        "gh api /repos/acme/widgets/pulls -f title=t -f head=x -f base=main",
+        "gh api -X POST repos/acme/widgets/pulls",
+        "gh api repos/acme/widgets/pulls --input=pr.json",
+        "gh api repos/acme/widgets/pulls --raw-field=title=t",
+        "gh api --method=POST repos/acme/widgets/pulls",
+        "gh api -XPOST repos/acme/widgets/pulls",
+        "gh api repos/acme/widgets/pulls -Ftitle=t -fhead=x",
+    ],
+)
+def test_should_detect_gh_pr_create(command: str) -> None:
+    assert owned_pr_review_loop.command_creates_pull_request(command)
+
+
+@pytest.mark.parametrize(
+    "command",
+    [
+        "gh pr view 42",
+        "git push -u origin feature",
+        "gh pr",
+        "echo gh pr create",
+        "gh api repos/acme/widgets/pulls",
+        "gh api repos/acme/widgets/pulls/42 -X PATCH -f state=closed",
+        "gh api repos/acme/widgets/issues --input issue.json",
+        "gh api --method GET repos/acme/widgets/pulls -f state=open",
+        "gh api -X GET repos/acme/widgets/pulls -f state=open",
+    ],
+)
+def test_should_not_detect_other_commands(command: str) -> None:
+    assert not owned_pr_review_loop.command_creates_pull_request(command)
+
+
+@pytest.mark.parametrize(
+    "tool_name",
+    [
+        "mcp__github__create_pull_request",
+        "mcp__codex_apps__github_create_pull_request",
+    ],
+)
+def test_should_treat_mcp_create_tools_as_pull_request_creation(tool_name: str) -> None:
+    assert owned_pr_review_loop.tool_call_opens_pull_request(tool_name, {})
+
+
+def test_should_read_the_codex_cmd_key_for_shell_tools() -> None:
+    assert owned_pr_review_loop.tool_call_opens_pull_request(
+        "exec_command", {"cmd": ["gh", "pr", "create", "--fill"]}
+    )
+
+
+def test_should_ignore_other_mcp_tools() -> None:
+    assert not owned_pr_review_loop.tool_call_opens_pull_request(
+        "mcp__github__merge_pull_request", {}
+    )
+
+
+def test_should_take_the_last_url_from_gh_output() -> None:
+    pull_request = owned_pr_review_loop.opened_pull_request(
+        {"command": "gh pr create"},
+        {"stdout": f"Warning: see {FOREIGN_PR_URL}\n{OWNED_PR_URL}\n"},
+    )
+    assert pull_request == {
+        "owner": "jl-cmd-projects",
+        "repository": "claude-dev-env",
+        "number": "42",
+        "url": OWNED_PR_URL,
+    }
+
+
+def test_should_take_the_url_for_the_mcp_input_repository() -> None:
+    pull_request = owned_pr_review_loop.opened_pull_request(
+        {"owner": "JL-CMD-PROJECTS", "repo": "claude-dev-env"},
+        f"Opened {OWNED_PR_URL}; see also {FOREIGN_PR_URL}",
+    )
+    assert pull_request is not None
+    assert pull_request["number"] == "42"
+
+
+def test_should_take_the_declared_url_over_urls_cited_in_the_body() -> None:
+    rest_response = json.dumps(
+        {
+            "html_url": OWNED_PR_URL,
+            "body": "Follows https://github.com/jl-cmd-projects/claude-dev-env/pull/7",
+        }
+    )
+    pull_request = owned_pr_review_loop.opened_pull_request(
+        {"command": "gh api repos/jl-cmd-projects/claude-dev-env/pulls --input pr.json"},
+        {"stdout": rest_response},
+    )
+    assert pull_request is not None
+    assert pull_request["number"] == "42"
+
+
+def test_should_take_the_declared_url_from_an_mcp_text_item() -> None:
+    mcp_response = [
+        {
+            "type": "text",
+            "text": json.dumps(
+                {
+                    "url": OWNED_PR_URL,
+                    "body": "Replaces https://github.com/jl-cmd-projects/claude-dev-env/pull/7",
+                }
+            ),
+        }
+    ]
+    pull_request = owned_pr_review_loop.opened_pull_request(
+        {"owner": "jl-cmd-projects", "repo": "claude-dev-env"}, mcp_response
+    )
+    assert pull_request is not None
+    assert pull_request["number"] == "42"
+
+
+def test_should_keep_a_declared_pull_request_whose_body_says_already_exists() -> None:
+    rest_response = json.dumps({"html_url": OWNED_PR_URL, "body": "The helper already exists."})
+    pull_request = owned_pr_review_loop.opened_pull_request(
+        {"command": "gh api repos/jl-cmd-projects/claude-dev-env/pulls --input pr.json"},
+        {"stdout": rest_response},
+    )
+    assert pull_request is not None
+    assert pull_request["url"] == OWNED_PR_URL
+
+
+def test_should_find_no_pull_request_after_a_failed_command() -> None:
+    assert (
+        owned_pr_review_loop.opened_pull_request(
+            {"command": "gh pr create"}, f"Error: Exit code 1\n{OWNED_PR_URL}"
+        )
+        is None
+    )
+
+
+def test_should_find_no_pull_request_when_one_already_exists() -> None:
+    assert (
+        owned_pr_review_loop.opened_pull_request(
+            {"command": "gh pr create"},
+            {"stdout": f'a pull request for branch "x" already exists:\n{OWNED_PR_URL}'},
+        )
+        is None
+    )
+
+
+def test_should_digest_names_in_normalized_form() -> None:
+    assert owned_pr_review_loop.name_digest("Acme-Widgets/Tools") == (
+        owned_pr_review_loop.name_digest("acmewidgetstools")
+    )
+    assert owned_pr_review_loop.name_digest("acme") != (
+        owned_pr_review_loop.name_digest("acmewidgets")
+    )
+
+
+@pytest.mark.parametrize(
+    ("owner", "repository", "expected"),
+    [
+        ("Acme-Widgets", "tools", True),
+        ("acme-widgets", "site", True),
+        ("Acme-Widgets", "reviewed", False),
+        ("Other-Org", "tools", False),
+    ],
+)
+def test_should_require_an_owned_repository_outside_the_preset_list(
+    owner: str, repository: str, expected: bool
+) -> None:
+    all_owned_owner_digests = frozenset({owned_pr_review_loop.name_digest("acme-widgets")})
+    all_preset_repository_digests = frozenset(
+        {owned_pr_review_loop.name_digest("acme-widgets/reviewed")}
+    )
+    assert (
+        owned_pr_review_loop.needs_review_loop(
+            owner, repository, all_owned_owner_digests, all_preset_repository_digests
+        )
+        is expected
+    )
+
+
+@pytest.mark.parametrize(
+    ("owner", "repository", "expected"),
+    [
+        ("jl-cmd-projects", "claude-dev-env", True),
+        ("jl-cmd", "claude-dev-env", True),
+        ("acme", "widgets", False),
+    ],
+)
+def test_should_apply_the_shipped_owner_list(owner: str, repository: str, expected: bool) -> None:
+    assert (
+        owned_pr_review_loop.needs_review_loop(
+            owner,
+            repository,
+            owned_pr_review_loop.ALL_OWNED_OWNER_DIGESTS,
+            owned_pr_review_loop.ALL_PRESET_REPOSITORY_DIGESTS,
+        )
+        is expected
+    )
+
+
+def test_should_name_every_step_and_skill_in_the_context() -> None:
+    context = owned_pr_review_loop.build_review_loop_context(
+        {
+            "owner": "jl-cmd-projects",
+            "repository": "claude-dev-env",
+            "number": "42",
+            "url": OWNED_PR_URL,
+        }
+    )
+    assert "jl-cmd-projects/claude-dev-env#42" in context
+    assert "efficient-review" in context
+    assert "gh pr ready 42 --repo jl-cmd-projects/claude-dev-env" in context
+    assert "poteto-mode/playbooks/babysit.md" in context
+    assert "poteto-mode/playbooks/shipping.md" in context
+    assert "merged" in context
+
+
+def test_main_should_emit_the_loop_after_gh_pr_create_on_an_owned_repository() -> None:
+    stdout = _run_hook(_shell_payload("gh pr create --fill", f"{OWNED_PR_URL}\n"))
+    payload = json.loads(stdout)
+    assert payload["hookSpecificOutput"]["hookEventName"] == "PostToolUse"
+    assert "efficient-review" in _context_of(stdout)
+
+
+def test_main_should_emit_the_loop_after_a_gh_api_pulls_post() -> None:
+    rest_response = json.dumps(
+        {
+            "url": "https://api.github.com/repos/jl-cmd-projects/claude-dev-env/pulls/42",
+            "html_url": OWNED_PR_URL,
+            "_links": {"html": {"href": OWNED_PR_URL}},
+        }
+    )
+    stdout = _run_hook(
+        _shell_payload("gh api repos/jl-cmd-projects/claude-dev-env/pulls --input pr.json", rest_response)
+    )
+    assert "jl-cmd-projects/claude-dev-env#42" in _context_of(stdout)
+
+
+def test_main_should_emit_the_loop_for_a_codex_shell_call() -> None:
+    stdout = _run_hook(
+        _shell_payload(
+            "gh pr create --fill", f"{OWNED_PR_URL}\n", tool_name="exec_command", input_key="cmd"
+        )
+    )
+    assert OWNED_PR_URL in _context_of(stdout)
+
+
+@pytest.mark.parametrize(
+    "tool_name",
+    ["mcp__github__create_pull_request", "mcp__codex_apps__github_create_pull_request"],
+)
+def test_main_should_emit_the_loop_after_an_mcp_create(tool_name: str) -> None:
+    stdout = _run_hook(
+        _mcp_payload(
+            tool_name,
+            "jl-cmd-projects",
+            "DeepStack",
+            "https://github.com/jl-cmd-projects/DeepStack/pull/9",
+        )
+    )
+    assert "jl-cmd-projects/DeepStack#9" in _context_of(stdout)
+
+
+def test_main_should_stay_quiet_for_a_repository_we_do_not_own() -> None:
+    assert _run_hook(_shell_payload("gh pr create --fill", f"{FOREIGN_PR_URL}\n")) == ""
+
+
+def test_main_should_stay_quiet_for_a_command_that_opens_no_pull_request() -> None:
+    assert _run_hook(_shell_payload("gh pr view 42", f"{OWNED_PR_URL}\n")) == ""
+
+
+def test_main_should_stay_quiet_for_a_failed_create() -> None:
+    payload = _shell_payload("gh pr create --fill", "")
+    payload["tool_response"] = "Error: Exit code 1\npull request create failed"
+    assert _run_hook(payload) == ""
+
+
+def test_hooks_json_should_route_shell_and_mcp_create_calls_to_the_hook() -> None:
+    hooks_config = json.loads(HOOKS_JSON_PATH.read_text(encoding="utf-8"))
+    all_matchers = [
+        each_group["matcher"]
+        for each_group in hooks_config["hooks"]["PostToolUse"]
+        if any(
+            "advisory/owned_pr_review_loop.py" in each_hook.get("command", "")
+            for each_hook in each_group["hooks"]
+        )
+    ]
+    assert len(all_matchers) == 1
+    for each_tool_name in (
+        "Bash",
+        "PowerShell",
+        "exec_command",
+        "shell_command",
+        "mcp__github__create_pull_request",
+        "mcp__codex_apps__github_create_pull_request",
+    ):
+        assert re.fullmatch(all_matchers[0], each_tool_name), each_tool_name

package/hooks/blocking/session_title_turn_gate.py

@@ -0,0 +1,287 @@
+#!/usr/bin/env python3
+"""Stop hook that holds a turn until it sets the session title.
+
+A turn starts after the latest user prompt in the transcript. Tool results,
+meta entries, sidechain entries and compaction summaries are not prompts, and
+a Stop hook block lands as an attachment, so a held turn stays the same turn.
+A title call on a sidechain entry belongs to a subagent and does not count.
+The turn may end once a tool whose name ends in __set_session_title ran in it
+and its result came back without an error. A title the format gate denied
+does not count. A held turn (``stop_hook_active`` true) whose title call
+failed may end, so a title tool that keeps failing cannot hold it forever. A
+held turn with no title call stays held, whichever Stop gate held it.
+
+The session has the title tool when a transcript record names it::
+
+    attachment.tools[].name / attachment.entries[].name   (tool listing)
+    attachment.addedNames / attachment.readdedNames       (deferred tools)
+    assistant tool_use name                               (an earlier call)
+
+A later ``removedNames`` entry takes the name away again. With no such record,
+or with an unreadable transcript, the hook lets the turn end, so Codex,
+Cursor and sessions without the tool keep working.
+
+A block writes ``{"decision": "block", "reason": ...}`` to stdout. The reason
+names the four status emoji and tells the model to close with one short
+sentence, so the held turn neither ends empty nor repeats the reply.
+"""
+
+from __future__ import annotations
+
+import json
+import sys
+from pathlib import Path
+
+hooks_root_directory = str(Path(__file__).resolve().parent.parent)
+if hooks_root_directory not in sys.path:
+    sys.path.insert(0, hooks_root_directory)
+
+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.session_title_constants import (
+    ALL_SKIPPED_PROMPT_FLAGS,
+    ALL_TOOL_LISTING_NAME_KEYS,
+    ALL_TOOL_LISTING_RECORD_KEYS,
+    ALLOW_EXIT_CODE,
+    ASSISTANT_ENTRY_TYPE,
+    ATTACHMENT_KEY,
+    BLOCK_DECISION,
+    BLOCK_ID_KEY,
+    BLOCK_NAME_KEY,
+    CONTENT_KEY,
+    DECISION_KEY,
+    DECODE_ERRORS_POLICY,
+    ENTRY_TYPE_KEY,
+    IS_ERROR_KEY,
+    MESSAGE_KEY,
+    REASON_KEY,
+    REMOVED_NAMES_KEY,
+    SIDECHAIN_FLAG_KEY,
+    STOP_HOOK_ACTIVE_KEY,
+    TITLE_TOOL_DISPLAY_SEPARATOR,
+    TITLE_TOOL_NAME_PATTERN,
+    TOOL_RESULT_BLOCK_TYPE,
+    TOOL_USE_BLOCK_TYPE,
+    TOOL_USE_ID_KEY,
+    TRANSCRIPT_PATH_KEY,
+    TURN_BLOCK_REASON,
+    TURN_GATE_EVENT_NAME,
+    USER_ENTRY_TYPE,
+    UTF8_ENCODING,
+)
+
+
+def _content_blocks(all_entry_fields: dict[str, object]) -> list[dict[str, object]]:
+    message = all_entry_fields.get(MESSAGE_KEY)
+    content = message.get(CONTENT_KEY) if isinstance(message, dict) else None
+    if not isinstance(content, list):
+        return []
+    return [each_block for each_block in content if isinstance(each_block, dict)]
+
+
+def _is_user_prompt(all_entry_fields: dict[str, object]) -> bool:
+    if all_entry_fields.get(ENTRY_TYPE_KEY) != USER_ENTRY_TYPE:
+        return False
+    if any(all_entry_fields.get(each_flag) for each_flag in ALL_SKIPPED_PROMPT_FLAGS):
+        return False
+    message = all_entry_fields.get(MESSAGE_KEY)
+    content = message.get(CONTENT_KEY) if isinstance(message, dict) else None
+    if isinstance(content, str):
+        return bool(content.strip())
+    return any(
+        each_block.get(ENTRY_TYPE_KEY) != TOOL_RESULT_BLOCK_TYPE
+        for each_block in _content_blocks(all_entry_fields)
+    )
+
+
+def _tool_use_blocks(all_entry_fields: dict[str, object]) -> list[dict[str, object]]:
+    if all_entry_fields.get(ENTRY_TYPE_KEY) != ASSISTANT_ENTRY_TYPE:
+        return []
+    return [
+        each_block
+        for each_block in _content_blocks(all_entry_fields)
+        if each_block.get(ENTRY_TYPE_KEY) == TOOL_USE_BLOCK_TYPE
+    ]
+
+
+def _title_names(all_values: object) -> list[str]:
+    if not isinstance(all_values, list):
+        return []
+    all_names = [
+        each_value.get(BLOCK_NAME_KEY) if isinstance(each_value, dict) else each_value
+        for each_value in all_values
+    ]
+    return [
+        each_name
+        for each_name in all_names
+        if isinstance(each_name, str) and TITLE_TOOL_NAME_PATTERN.match(each_name)
+    ]
+
+
+def available_title_tools(all_entries: list[dict[str, object]]) -> list[str]:
+    """Return the title tool names the session holds at the end of the transcript.
+
+    ::
+
+        attachment {"tools": [{"name": "mcp__x__set_session_title"}]}   -> ["mcp__x__set_session_title"]
+        then attachment {"removedNames": ["mcp__x__set_session_title"]} -> []
+        no listing and no call                                          -> []
+
+    Args:
+        all_entries: The transcript entries, oldest first.
+
+    Returns:
+        The title tool names, in the order the transcript first named them.
+    """
+    available_names: dict[str, None] = {}
+    for each_entry in all_entries:
+        attachment = each_entry.get(ATTACHMENT_KEY)
+        if isinstance(attachment, dict):
+            _apply_tool_listing(available_names, attachment)
+        available_names.update(dict.fromkeys(_title_names(_tool_use_blocks(each_entry))))
+    return list(available_names)
+
+
+def _apply_tool_listing(
+    all_available_names: dict[str, None], all_attachment_fields: dict[str, object]
+) -> None:
+    for each_key in (*ALL_TOOL_LISTING_NAME_KEYS, *ALL_TOOL_LISTING_RECORD_KEYS):
+        all_available_names.update(
+            dict.fromkeys(_title_names(all_attachment_fields.get(each_key)))
+        )
+    for each_removed_name in _title_names(all_attachment_fields.get(REMOVED_NAMES_KEY)):
+        all_available_names.pop(each_removed_name, None)
+
+
+def _turn_entries(all_entries: list[dict[str, object]]) -> list[dict[str, object]]:
+    last_prompt_index = max(
+        (
+            each_index
+            for each_index, each_entry in enumerate(all_entries)
+            if _is_user_prompt(each_entry)
+        ),
+        default=-1,
+    )
+    return [
+        each_entry
+        for each_entry in all_entries[last_prompt_index + 1 :]
+        if not each_entry.get(SIDECHAIN_FLAG_KEY)
+    ]
+
+
+def _title_call_ids(all_turn_entries: list[dict[str, object]]) -> set[object]:
+    return {
+        each_block.get(BLOCK_ID_KEY)
+        for each_entry in all_turn_entries
+        for each_block in _tool_use_blocks(each_entry)
+        if TITLE_TOOL_NAME_PATTERN.match(str(each_block.get(BLOCK_NAME_KEY)))
+    }
+
+
+def title_attempted_this_turn(all_entries: list[dict[str, object]]) -> bool:
+    """Return True when a title call ran after the latest prompt, whatever its result.
+
+    Args:
+        all_entries: The transcript entries, oldest first.
+
+    Returns:
+        True when this turn called the title tool.
+    """
+    return bool(_title_call_ids(_turn_entries(all_entries)))
+
+
+def title_set_this_turn(all_entries: list[dict[str, object]]) -> bool:
+    """Return True when a title call after the latest prompt came back without an error.
+
+    ::
+
+        prompt -> set_session_title -> ok result      -> True
+        prompt -> set_session_title -> denied result  -> False
+        set_session_title -> ok result -> prompt      -> False
+
+    Args:
+        all_entries: The transcript entries, oldest first.
+
+    Returns:
+        True when this turn set the title.
+    """
+    all_turn_entries = _turn_entries(all_entries)
+    all_title_call_ids = _title_call_ids(all_turn_entries)
+    return any(
+        each_block.get(ENTRY_TYPE_KEY) == TOOL_RESULT_BLOCK_TYPE
+        and each_block.get(TOOL_USE_ID_KEY) in all_title_call_ids
+        and not each_block.get(IS_ERROR_KEY)
+        for each_entry in all_turn_entries
+        if each_entry.get(ENTRY_TYPE_KEY) == USER_ENTRY_TYPE
+        for each_block in _content_blocks(each_entry)
+    )
+
+
+def turn_block_reason(
+    all_entries: list[dict[str, object]], is_stop_hook_active: bool
+) -> str | None:
+    """Return the reason to hold the turn, or None when the turn may end.
+
+    ::
+
+        no title tool in the transcript                         -> None
+        title set this turn                                     -> None
+        held turn whose title call failed (stop_hook_active)    -> None
+        no title call this turn                                 -> reason
+
+    Args:
+        all_entries: The transcript entries, oldest first.
+        is_stop_hook_active: True when a Stop hook already held this turn.
+
+    Returns:
+        The block reason that names the title tool, or None.
+    """
+    all_title_tools = available_title_tools(all_entries)
+    if not all_title_tools or title_set_this_turn(all_entries):
+        return None
+    if is_stop_hook_active and title_attempted_this_turn(all_entries):
+        return None
+    return TURN_BLOCK_REASON.format(tool_name=TITLE_TOOL_DISPLAY_SEPARATOR.join(all_title_tools))
+
+
+def _parsed_entry(line: str) -> dict[str, object] | None:
+    try:
+        parsed_entry = json.loads(line)
+    except json.JSONDecodeError:
+        return None
+    return parsed_entry if isinstance(parsed_entry, dict) else None
+
+
+def read_transcript_entries(transcript_path: object) -> list[dict[str, object]]:
+    """Return the transcript's JSON object entries, or an empty list when it cannot be read."""
+    if not isinstance(transcript_path, str) or not transcript_path:
+        return []
+    try:
+        all_lines = (
+            Path(transcript_path)
+            .read_text(encoding=UTF8_ENCODING, errors=DECODE_ERRORS_POLICY)
+            .splitlines()
+        )
+    except OSError:
+        return []
+    all_parsed_entries = (_parsed_entry(each_line) for each_line in all_lines)
+    return [each_entry for each_entry in all_parsed_entries if each_entry is not None]
+
+
+def main() -> int:
+    hook_input = read_hook_input_dictionary_from_stdin()
+    if hook_input is None:
+        return ALLOW_EXIT_CODE
+    block_reason = turn_block_reason(
+        read_transcript_entries(hook_input.get(TRANSCRIPT_PATH_KEY)),
+        hook_input.get(STOP_HOOK_ACTIVE_KEY) is True,
+    )
+    if block_reason is None:
+        return ALLOW_EXIT_CODE
+    log_hook_block(Path(__file__).name, TURN_GATE_EVENT_NAME, block_reason)
+    sys.stdout.write(json.dumps({DECISION_KEY: BLOCK_DECISION, REASON_KEY: block_reason}))
+    return ALLOW_EXIT_CODE
+
+
+if __name__ == "__main__":
+    sys.exit(main())

package/hooks/blocking/test_session_title_format_gate.py

@@ -19,6 +19,7 @@ DESKTOP_TITLE_TOOL = "mcp__ccd_session_mgmt__set_session_title"
 RED_FLAG = "\U0001f6a9"
 CHECK_MARK = "✅"
 HOURGLASS = "⏳"
+ROADBLOCK = "\U0001f6a7"
 
 
 def run_gate(
@@ -49,6 +50,8 @@ def isolated_home(monkeypatch: pytest.MonkeyPatch, tmp_path: Path) -> None:
         f"{CHECK_MARK} Session title gate",
         f"{RED_FLAG}️ Runner sign-in",
         f"{RED_FLAG} CI gate + docs",
+        f"{ROADBLOCK} Push refused",
+        f"{ROADBLOCK}️ Host unreachable",
     ],
 )
 def test_should_allow_a_well_formed_title_on_each_title_tool(
@@ -62,6 +65,8 @@ def test_should_allow_a_well_formed_title_on_each_title_tool(
     [
         ("Broker gate + replay rule", STATUS_PREFIX_MESSAGE),
         ("\U0001f680 Broker gate", STATUS_PREFIX_MESSAGE),
+        ("\u26d4 Push refused", STATUS_PREFIX_MESSAGE),
+        (f"{ROADBLOCK}{HOURGLASS} Push refused", STATUS_PREFIX_MESSAGE),
         (f"{HOURGLASS}Broker gate", STATUS_PREFIX_MESSAGE),
         (f"{HOURGLASS} Broker gate\nand more", SINGLE_LINE_MESSAGE),
         (f"{HOURGLASS} Broker gate.", TRAILING_PUNCTUATION_MESSAGE),