claude-dev-env 8.74.0 → 8.74.2

package/hooks/test_followup_ledger_maintenance.py

@@ -0,0 +1,107 @@
+"""Behavior tests for clearing and normalizing the follow-up ledger."""
+
+import json
+import sys
+from pathlib import Path
+
+_hooks_directory = str(Path(__file__).resolve().parent)
+if _hooks_directory not in sys.path:
+    sys.path.insert(0, _hooks_directory)
+
+from followup_ledger import (
+    FollowupFinding,
+    all_recorded_findings,
+    finding_path,
+    followup_directory,
+    record_followup_finding,
+)
+from followup_ledger_maintenance import clear_recorded_findings, normalize_ledger
+
+
+def test_clear_removes_every_finding_and_the_legacy_ledger_but_keeps_the_ignore(
+    tmp_path: Path,
+) -> None:
+    record_followup_finding(tmp_path, FollowupFinding("r1", "a.py", "m1", "r1"))
+    record_followup_finding(tmp_path, FollowupFinding("r2", "b.py", "m2", "r2"))
+    legacy_path = followup_directory(tmp_path) / "smells.jsonl"
+    legacy_path.write_text("{}\n", encoding="utf-8")
+
+    clear_recorded_findings(tmp_path)
+
+    assert all_recorded_findings(tmp_path) == ()
+    assert not legacy_path.exists()
+    assert (followup_directory(tmp_path) / ".gitignore").is_file()
+
+
+def test_normalize_splits_a_legacy_ledger_and_keeps_the_first_origin(
+    tmp_path: Path,
+) -> None:
+    first_record = {
+        "rule_id": "r1",
+        "file_path": "a.py",
+        "message": "m1",
+        "origin_commit": "aaa1111",
+    }
+    later_record = {**first_record, "origin_commit": "bbb2222"}
+    legacy_path = followup_directory(tmp_path) / "smells.jsonl"
+    legacy_path.parent.mkdir(parents=True)
+    legacy_path.write_text(
+        f"{json.dumps(first_record)}\n{json.dumps(later_record)}\nnot json\n",
+        encoding="utf-8",
+    )
+
+    normalization = normalize_ledger(tmp_path)
+
+    assert normalization.migrated_count == 2
+    assert normalization.removed_count == 0
+    assert not legacy_path.exists()
+    assert [each.origin_commit for each in all_recorded_findings(tmp_path)] == [
+        "aaa1111"
+    ]
+
+
+def test_normalize_renames_a_misnamed_finding_file(tmp_path: Path) -> None:
+    finding = FollowupFinding("r1", "a.py", "m1", "r1")
+    record_followup_finding(tmp_path, finding)
+    expected_path = finding_path(tmp_path, finding)
+    misnamed_path = expected_path.with_name("misnamed.json")
+    expected_path.rename(misnamed_path)
+
+    normalization = normalize_ledger(tmp_path)
+
+    assert normalization.removed_count == 0
+    assert expected_path.is_file()
+    assert not misnamed_path.exists()
+
+
+def test_normalize_keeps_the_legacy_ledger_when_a_finding_cannot_be_written(
+    tmp_path: Path,
+) -> None:
+    legacy_path = followup_directory(tmp_path) / "smells.jsonl"
+    legacy_path.parent.mkdir(parents=True)
+    legacy_text = json.dumps({"rule_id": "r1", "file_path": "a.py", "message": "m1"})
+    legacy_path.write_text(legacy_text + "\n", encoding="utf-8")
+    blocked_path = finding_path(tmp_path, FollowupFinding("r1", "a.py", "m1", "r1"))
+    blocked_path.mkdir()
+
+    normalization = normalize_ledger(tmp_path)
+
+    assert normalization.migrated_count == 0
+    assert legacy_path.read_text(encoding="utf-8") == legacy_text + "\n"
+
+
+def test_normalize_keeps_a_misnamed_finding_when_its_name_holds_a_damaged_file(
+    tmp_path: Path,
+) -> None:
+    finding = FollowupFinding("r1", "a.py", "m1", "r1")
+    record_followup_finding(tmp_path, finding)
+    expected_path = finding_path(tmp_path, finding)
+    misnamed_path = expected_path.with_name("misnamed.json")
+    expected_path.rename(misnamed_path)
+    expected_path.write_text("{ damaged\n", encoding="utf-8")
+
+    normalization = normalize_ledger(tmp_path)
+
+    assert normalization.removed_count == 0
+    assert misnamed_path.is_file()
+    assert all_recorded_findings(tmp_path) == (finding,)

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "claude-dev-env",
-    "version": "8.74.0",
+    "version": "8.74.2",
     "description": "Claude Code development standards — rules, hooks, agents, commands, and skills",
     "type": "module",
     "bin": {

package/rules/flag-non-breaking-findings.md

@@ -13,7 +13,7 @@ paths:
 
 **When:** Writing a local gate or changing a check's severity.
 
-Give every check ID a breaking or smell severity row; style and structure findings are smells. Fail the gate and stop for a bug, secret, broken test, syntax error, or instruction file that cannot load. Record a smell in `.claude/followups/smells.jsonl`, proceed, and fix it later in one combined follow-up pull request per parent pull request, whose body names the parent as `Follow-up to #N`; ledger failure leaves the gate decision unchanged. Treat an unclassified check as breaking.
+Give every check ID a breaking or smell severity row; style and structure findings are smells. Fail the gate and stop for a bug, secret, broken test, syntax error, or instruction file that cannot load. Record a smell as one file in `.claude/followups/`, proceed, and fix it later in one combined follow-up pull request per parent pull request, whose body names the parent as `Follow-up to #N`; ledger failure leaves the gate decision unchanged. Treat an unclassified check as breaking.
 
 **Enforcement:** none.
 

package/scripts/dev_env_scripts_constants/followup_constants.py

@@ -63,7 +63,10 @@ ABSENT_LOCATION_PATH: str = ""
 LINE_SEPARATOR: str = "\n"
 EMPTY_LEDGER_MESSAGE: str = "no follow-ups recorded"
 UNREADABLE_REPORT_TEMPLATE: str = "cannot read the lint report: {report_path}"
-DEDUPE_RESULT_TEMPLATE: str = "removed {removed_count} duplicate ledger lines"
+DEDUPE_RESULT_TEMPLATE: str = (
+    "moved {migrated_count} legacy ledger lines into finding files, "
+    "removed {removed_count} duplicate finding files"
+)
 USAGE_TEXT: str = (
     "Usage: followup_cli.py <list|ingest|brief|clear|count|dedupe> "
     "[--repository-root PATH]\n"

package/scripts/followup_cli.py

@@ -12,8 +12,8 @@ work. This command reads those records back.
 ``list`` names what is outstanding, ``ingest`` adds the diagnostics from a
 policy-lint JSON report, ``brief`` writes the task an agent works from, and
 ``clear`` empties the ledger once the follow-up pull request carries the
-fixes, and ``dedupe`` removes exact repeated lines a ``merge=union`` merge
-left behind.
+fixes, and ``dedupe`` moves a legacy ``smells.jsonl`` into one file per
+finding and removes duplicate finding files.
 """
 
 from __future__ import annotations
@@ -62,11 +62,10 @@ if _hooks_directory not in sys.path:
 from followup_ledger import (
     FollowupFinding,
     all_recorded_findings,
-    deduplicate_ledger,
-    followup_ledger_path,
     head_commit,
     record_followup_finding,
 )
+from followup_ledger_maintenance import clear_recorded_findings, normalize_ledger
 from hooks_constants.followup_ledger_constants import SEVERITY_SMELL
 
 
@@ -307,26 +306,26 @@ def _run_clear(repository_root: Path) -> int:
     Returns:
         SUCCESS_EXIT_CODE.
     """
-    try:
-        followup_ledger_path(repository_root).unlink(missing_ok=True)
-    except OSError:
-        return SUCCESS_EXIT_CODE
+    clear_recorded_findings(repository_root)
     return SUCCESS_EXIT_CODE
 
 
 def _run_dedupe(repository_root: Path, stdout: TextIO) -> int:
-    """Remove exact repeated lines from the repository's ledger.
+    """Move every record to the file its tracking key names.
 
     Args:
         repository_root: The repository whose ledger to clean.
-        stdout: The stream the removed-line count goes to.
+        stdout: The stream the migrated and removed counts go to.
 
     Returns:
         SUCCESS_EXIT_CODE.
     """
-    removed_line_count = deduplicate_ledger(repository_root)
+    normalization = normalize_ledger(repository_root)
     stdout.write(
-        DEDUPE_RESULT_TEMPLATE.format(removed_count=removed_line_count)
+        DEDUPE_RESULT_TEMPLATE.format(
+            migrated_count=normalization.migrated_count,
+            removed_count=normalization.removed_count,
+        )
         + LINE_SEPARATOR
     )
     return SUCCESS_EXIT_CODE

package/scripts/policy_lint/adapter_configuration.py

@@ -134,7 +134,6 @@ def _names_exempt_registration_path(registered_string: str) -> bool:
         hooks/blocking/issue_close_handoff_gate.py       -> exempt
         hooks/blocking/verify_before_acting.py           -> exempt
         hooks/blocking/session_title_format_gate.py      -> exempt
-        hooks/blocking/session_title_stop_gate.py        -> exempt
         hooks/blocking/artifact_dark_mode_gate.py        -> exempt
         hooks/blocking/some_new_blocker.py               -> flagged
 

package/scripts/policy_lint/config/constants.py

@@ -70,7 +70,6 @@ ALL_ACTION_BOUNDARY_EXEMPT_REGISTRATION_PATHS = (
     "blocking/issue_close_handoff_gate.py",
     "blocking/verify_before_acting.py",
     "blocking/session_title_format_gate.py",
-    "blocking/session_title_stop_gate.py",
     "blocking/image_read_size_gate.py",
     "blocking/artifact_dark_mode_gate.py",
     "blocking/haiku_spawn_slim_gate.py",

package/scripts/repository_checks/config/constants.py

@@ -9,7 +9,6 @@ from policy_lint.config.constants import (
 
 CHECK_ID_CLAUDE_MD_ORPHANS = "claude-md-orphans"
 CHECK_ID_ENV_VAR_DOCUMENTATION = "env-var-documentation"
-CHECK_ID_FOLLOWUP_LEDGER_DUPLICATES = "followup-ledger-duplicates"
 CHECK_ID_PACKAGE_INVENTORY = "package-inventory"
 CHECK_ID_PYTEST_TESTPATHS = "pytest-testpaths"
 CHECK_ID_TRACKED_PERSONAL_DATA = "tracked-secrets"
@@ -19,7 +18,6 @@ PRIVATE_TERMS_SKIPPED_FILE_NAME = "CHANGELOG.md"
 ALL_CHECK_IDS = (
     CHECK_ID_CLAUDE_MD_ORPHANS,
     CHECK_ID_ENV_VAR_DOCUMENTATION,
-    CHECK_ID_FOLLOWUP_LEDGER_DUPLICATES,
     CHECK_ID_PACKAGE_INVENTORY,
     CHECK_ID_PYTEST_TESTPATHS,
     CHECK_ID_TRACKED_PERSONAL_DATA,
@@ -31,7 +29,6 @@ SEVERITY_SMELL = "smell"
 SEVERITY_BY_CHECK_ID: dict[str, str] = {
     CHECK_ID_CLAUDE_MD_ORPHANS: SEVERITY_BREAKING,
     CHECK_ID_ENV_VAR_DOCUMENTATION: SEVERITY_BREAKING,
-    CHECK_ID_FOLLOWUP_LEDGER_DUPLICATES: SEVERITY_BREAKING,
     CHECK_ID_PACKAGE_INVENTORY: SEVERITY_SMELL,
     CHECK_ID_PYTEST_TESTPATHS: SEVERITY_BREAKING,
     CHECK_ID_TRACKED_PERSONAL_DATA: SEVERITY_BREAKING,
@@ -52,9 +49,6 @@ EMPTY_REPORT_TEXT = ""
 TRACKED_MATCH_MESSAGE_TEMPLATE = "[{category}] {preview}"
 CLAUDE_MD_MISSING_FILE_MESSAGE_TEMPLATE = "references missing file {filename}"
 PACKAGE_INVENTORY_MESSAGE_TEMPLATE = "production file is absent from package inventory"
-FOLLOWUP_LEDGER_DUPLICATE_MESSAGE_TEMPLATE = (
-    "{repeated_line_count} lines repeat an earlier line; run `cde followup dedupe`"
-)
 PYTEST_TESTPATH_MESSAGE_TEMPLATE = (
     "test file is outside the package testpaths allowlist"
 )

package/scripts/repository_checks/runner.py

@@ -11,9 +11,6 @@ from repository_checks.config import constants as repository_constants
 from repository_checks.env_var_documentation import (
     collect_env_var_documentation_findings,
 )
-from repository_checks.followup_ledger_duplicates import (
-    collect_followup_ledger_duplicate_findings,
-)
 from repository_checks.models import RepositoryCheckReport, RepositoryFinding
 from repository_checks.package_inventory import collect_package_inventory_findings
 from repository_checks.pytest_testpaths import collect_pytest_testpath_findings
@@ -84,10 +81,6 @@ def _all_collectors() -> tuple[tuple[str, RepositoryCollector], ...]:
             repository_constants.CHECK_ID_ENV_VAR_DOCUMENTATION,
             collect_env_var_documentation_findings,
         ),
-        (
-            repository_constants.CHECK_ID_FOLLOWUP_LEDGER_DUPLICATES,
-            collect_followup_ledger_duplicate_findings,
-        ),
         (
             repository_constants.CHECK_ID_PACKAGE_INVENTORY,
             collect_package_inventory_findings,

package/scripts/test_followup_cli.py

@@ -17,7 +17,8 @@ from followup_cli import main
 from followup_ledger import (
     FollowupFinding,
     all_recorded_findings,
-    followup_ledger_path,
+    finding_path,
+    followup_directory,
     record_followup_finding,
 )
 
@@ -307,17 +308,80 @@ def test_list_names_the_check_behind_each_finding(tmp_path: Path) -> None:
     assert "f00dcafe" in output_text
 
 
-def test_dedupe_removes_repeated_ledger_lines_and_keeps_the_order(
+def test_dedupe_moves_a_legacy_ledger_into_one_file_per_finding(
     tmp_path: Path,
 ) -> None:
-    ledger_path = followup_ledger_path(tmp_path)
-    ledger_path.parent.mkdir(parents=True)
-    ledger_path.write_text("first\nsecond\nfirst\n", encoding="utf-8")
+    first_line = json.dumps({"rule_id": "r1", "file_path": "a.py", "message": "m1"})
+    second_line = json.dumps({"rule_id": "r2", "file_path": "b.py", "message": "m2"})
+    legacy_path = followup_directory(tmp_path) / "smells.jsonl"
+    legacy_path.parent.mkdir(parents=True)
+    legacy_path.write_text(
+        f"{first_line}\n{second_line}\n{first_line}\n", encoding="utf-8"
+    )
 
     exit_code, output_text = run_command(
         ["dedupe", "--repository-root", str(tmp_path)]
     )
 
     assert exit_code == 0
-    assert output_text == DEDUPE_RESULT_TEMPLATE.format(removed_count=1) + "\n"
-    assert ledger_path.read_text(encoding="utf-8") == "first\nsecond\n"
+    assert output_text == (
+        DEDUPE_RESULT_TEMPLATE.format(migrated_count=3, removed_count=0) + "\n"
+    )
+    assert not legacy_path.exists()
+    assert [each.rule_id for each in all_recorded_findings(tmp_path)] == ["r1", "r2"]
+
+
+def test_dedupe_removes_a_misnamed_copy_of_a_recorded_finding(tmp_path: Path) -> None:
+    finding = FollowupFinding("r1", "a.py", "m1", "r1")
+    record_followup_finding(tmp_path, finding)
+    recorded_path = finding_path(tmp_path, finding)
+    copy_path = recorded_path.with_name("copy.json")
+    copy_path.write_text(recorded_path.read_text(encoding="utf-8"), encoding="utf-8")
+
+    exit_code, output_text = run_command(
+        ["dedupe", "--repository-root", str(tmp_path)]
+    )
+
+    assert exit_code == 0
+    assert output_text == (
+        DEDUPE_RESULT_TEMPLATE.format(migrated_count=0, removed_count=1) + "\n"
+    )
+    assert not copy_path.exists()
+    assert all_recorded_findings(tmp_path) == (finding,)
+
+
+def test_fix_followups_reads_the_brief_then_clears_every_finding(
+    tmp_path: Path,
+) -> None:
+    report_path = tmp_path / "lint.json"
+    write_lint_report(
+        report_path,
+        [
+            {
+                "rule_id": "code-rules",
+                "check_id": "code-rules/constant-outside-config",
+                "message": "Constant TIMEOUT",
+                "location": {"path": "src/run.py"},
+            },
+            {
+                "rule_id": "test-pairing",
+                "message": "no paired test",
+                "location": {"path": "src/app.py"},
+            },
+        ],
+    )
+    root_arguments = ["--repository-root", str(tmp_path)]
+
+    ingest_exit_code, _ = run_command(["ingest", str(report_path), *root_arguments])
+    _, brief_text = run_command(["brief", *root_arguments])
+    clear_exit_code, _ = run_command(["clear", *root_arguments])
+    _, brief_after_clear = run_command(["brief", *root_arguments])
+
+    assert ingest_exit_code == 0
+    assert "- [code-rules/constant-outside-config] src/run.py: Constant TIMEOUT" in (
+        brief_text
+    )
+    assert "- [test-pairing] src/app.py: no paired test" in brief_text
+    assert clear_exit_code == 0
+    assert brief_after_clear == "no follow-ups recorded\n"
+    assert not list(followup_directory(tmp_path).glob("*.json"))

package/scripts/tests/test_adapter_configuration.py

@@ -98,12 +98,9 @@ def test_new_verify_before_acting_registration_is_clean(tmp_path: Path) -> None:
     assert adapters.hook_configuration_diagnostics(current_document, tmp_path) == ()
 
 
-def test_new_session_title_gate_registrations_are_clean(tmp_path: Path) -> None:
+def test_new_session_title_gate_registration_is_clean(tmp_path: Path) -> None:
     current_document = _hook_document(
-        [
-            "hooks/blocking/session_title_format_gate.py",
-            "hooks/blocking/session_title_stop_gate.py",
-        ],
+        ["hooks/blocking/session_title_format_gate.py"],
         '{"hooks": {}}',
     )
     assert adapters.hook_configuration_diagnostics(current_document, tmp_path) == ()

package/scripts/tests/test_cde_lint.py

@@ -422,10 +422,9 @@ def test_should_exit_zero_and_record_a_followup_when_only_warnings_exist(
         lint_runner=lambda _request: warning_report,
         repository_root=tmp_path,
     )
-    ledger_path = tmp_path / ".claude" / "followups" / "smells.jsonl"
     all_ledger_records = [
-        json.loads(each_line)
-        for each_line in ledger_path.read_text(encoding="utf-8").splitlines()
+        json.loads(each_path.read_text(encoding="utf-8"))
+        for each_path in (tmp_path / ".claude" / "followups").glob("*.json")
     ]
     assert exit_code == 0
     assert "paired test gap" in stdout_text
@@ -445,4 +444,4 @@ def test_should_leave_the_ledger_absent_when_every_finding_is_an_error(
         ),
         repository_root=tmp_path,
     )
-    assert not (tmp_path / ".claude" / "followups" / "smells.jsonl").exists()
+    assert not list((tmp_path / ".claude" / "followups").glob("*.json"))

package/scripts/tests/test_repository_policy.py

@@ -17,7 +17,6 @@ import repository_policy
 from repository_checks.config.constants import (
     CHECK_ID_CLAUDE_MD_ORPHANS,
     CHECK_ID_ENV_VAR_DOCUMENTATION,
-    CHECK_ID_FOLLOWUP_LEDGER_DUPLICATES,
     CHECK_ID_PACKAGE_INVENTORY,
     CHECK_ID_PYTEST_TESTPATHS,
     CHECK_ID_TRACKED_PERSONAL_DATA,
@@ -51,8 +50,7 @@ def test_should_keep_stable_check_identifiers() -> None:
     assert repository_policy.ALL_CHECK_IDS == (
         CHECK_ID_CLAUDE_MD_ORPHANS,
         CHECK_ID_ENV_VAR_DOCUMENTATION,
-        CHECK_ID_FOLLOWUP_LEDGER_DUPLICATES,
-        CHECK_ID_PACKAGE_INVENTORY,
+            CHECK_ID_PACKAGE_INVENTORY,
         CHECK_ID_PYTEST_TESTPATHS,
         CHECK_ID_TRACKED_PERSONAL_DATA,
         CHECK_ID_TRACKED_PRIVATE_TERMS,

package/hooks/blocking/session_title_stop_gate.py

@@ -1,217 +0,0 @@
-#!/usr/bin/env python3
-"""Stop hook that ends each turn only after the session title shows its status.
-
-A turn starts at the latest user prompt in the transcript, skipping tool
-results and meta entries. The turn may end once a tool whose name ends in
-__set_session_title ran in it without error. Otherwise the hook blocks the
-stop once and tells the model to set '<emoji> <name>'.
-
-The hook stays silent when:
-
-- the stop is already a retry after a block (stop_hook_active is true);
-- the session shows no title tool: no title tool named anywhere in the
-  transcript, and either no remote session id in the environment or a
-  deferred tool listing that names other remote-server tools and leaves
-  the title tool out, or an earlier Stop block the session never met;
-- the transcript cannot be read.
-"""
-
-from __future__ import annotations
-
-import json
-import os
-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 (
-    ALLOW_EXIT_CODE,
-    BLOCK_DECISION,
-    DEFERRED_TOOL_ATTACHMENT_TYPES,
-    HOOK_BLOCKING_ERROR_ATTACHMENT_TYPE,
-    REMOTE_SERVER_TOOL_PREFIX,
-    REMOTE_SESSION_ENVIRONMENT_VARIABLE,
-    REMOTE_TITLE_TOOL_NAME,
-    STOP_BLOCK_REASON,
-    STOP_GATE_EVENT_NAME,
-    STOP_HOOK_ACTIVE_KEY,
-    TITLE_TOOL_NAME_PATTERN,
-    TRANSCRIPT_PATH_KEY,
-    UNKNOWN_TITLE_TOOL_NAME,
-)
-from hooks_constants.setup_project_paths_constants import DECODE_ERRORS_POLICY, UTF8_ENCODING
-
-
-def _content_blocks(all_entry_fields: dict[str, object]) -> list[dict[str, object]]:
-    message = all_entry_fields.get("message")
-    content = message.get("content") 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("type") != "user" or all_entry_fields.get("isMeta") is True:
-        return False
-    message = all_entry_fields.get("message")
-    if isinstance(message, dict) and isinstance(message.get("content"), str):
-        return True
-    return any(each_block.get("type") == "text" for each_block in _content_blocks(all_entry_fields))
-
-
-def _title_tool_names_in(all_entry_fields: dict[str, object]) -> list[str]:
-    all_names: list[str] = []
-    if all_entry_fields.get("type") == "assistant":
-        all_names = [
-            str(each_block.get("name"))
-            for each_block in _content_blocks(all_entry_fields)
-            if each_block.get("type") == "tool_use"
-        ]
-    attachment = all_entry_fields.get("attachment")
-    if isinstance(attachment, dict) and attachment.get("type") in DEFERRED_TOOL_ATTACHMENT_TYPES:
-        all_names += [str(each_name) for each_name in attachment.get("addedNames") or []]
-        all_names += [
-            str(each_record.get("name"))
-            for each_record in attachment.get("entries") or []
-            if isinstance(each_record, dict)
-        ]
-    return [each_name for each_name in all_names if TITLE_TOOL_NAME_PATTERN.match(each_name)]
-
-
-def _defers_remote_server_tools(all_entry_fields: dict[str, object]) -> bool:
-    attachment = all_entry_fields.get("attachment")
-    if not isinstance(attachment, dict) or attachment.get("type") not in DEFERRED_TOOL_ATTACHMENT_TYPES:
-        return False
-    all_names = [str(each_name) for each_name in attachment.get("addedNames") or []]
-    all_names += [
-        str(each_record.get("name"))
-        for each_record in attachment.get("entries") or []
-        if isinstance(each_record, dict)
-    ]
-    return any(each_name.startswith(REMOTE_SERVER_TOOL_PREFIX) for each_name in all_names)
-
-
-def _is_stop_block(all_entry_fields: dict[str, object]) -> bool:
-    attachment = all_entry_fields.get("attachment")
-    return (
-        isinstance(attachment, dict)
-        and attachment.get("type") == HOOK_BLOCKING_ERROR_ATTACHMENT_TYPE
-        and attachment.get("hookEvent") == STOP_GATE_EVENT_NAME
-    )
-
-
-def _is_title_call(entry_type: object, all_block_fields: dict[str, object]) -> bool:
-    return (
-        entry_type == "assistant"
-        and all_block_fields.get("type") == "tool_use"
-        and bool(TITLE_TOOL_NAME_PATTERN.match(str(all_block_fields.get("name"))))
-    )
-
-
-def _title_set_since(all_turn_entries: list[dict[str, object]]) -> bool:
-    all_entry_blocks = [
-        (each_entry.get("type"), each_block)
-        for each_entry in all_turn_entries
-        for each_block in _content_blocks(each_entry)
-    ]
-    all_title_call_ids = {
-        str(each_block.get("id"))
-        for each_entry_type, each_block in all_entry_blocks
-        if _is_title_call(each_entry_type, each_block)
-    }
-    return any(
-        each_block.get("type") == "tool_result"
-        and str(each_block.get("tool_use_id")) in all_title_call_ids
-        and not each_block.get("is_error")
-        for _, each_block in all_entry_blocks
-    )
-
-
-def _turn_start_index(all_entries: list[dict[str, object]]) -> int:
-    return max(
-        (
-            each_index
-            for each_index, each_entry in enumerate(all_entries)
-            if _is_user_prompt(each_entry)
-        ),
-        default=0,
-    )
-
-
-def stop_block_reason(all_entries: list[dict[str, object]], is_remote_session: bool) -> str | None:
-    """Return the block reason when this turn has not set the title, else None.
-
-    ::
-
-        prompt -> set_session_title -> ok result   => None
-        prompt -> work, no title call              => block reason
-        no title tool anywhere, not remote         => None
-        remote, deferred remote tools lack title   => None
-        remote, earlier Stop block never met       => None
-        remote, remote tools load directly         => block reason
-
-    Args:
-        all_entries: The transcript entries, oldest first.
-        is_remote_session: True when the session runs in a cloud session.
-
-    Returns:
-        The reason to send back to the model, or None to let the turn end.
-    """
-    all_seen_tool_names = [
-        each_name for each_entry in all_entries for each_name in _title_tool_names_in(each_entry)
-    ]
-    if not all_seen_tool_names and (
-        not is_remote_session
-        or any(_defers_remote_server_tools(each) or _is_stop_block(each) for each in all_entries)
-    ):
-        return None
-    if _title_set_since(all_entries[_turn_start_index(all_entries) :]):
-        return None
-    if all_seen_tool_names:
-        return STOP_BLOCK_REASON.format(tool_name=all_seen_tool_names[-1])
-    tool_name = REMOTE_TITLE_TOOL_NAME if is_remote_session else UNKNOWN_TITLE_TOOL_NAME
-    return STOP_BLOCK_REASON.format(tool_name=tool_name)
-
-
-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_entries(transcript_path: str) -> list[dict[str, object]]:
-    with open(transcript_path, encoding=UTF8_ENCODING, errors=DECODE_ERRORS_POLICY) as transcript:
-        all_lines = transcript.readlines()
-    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 or hook_input.get(STOP_HOOK_ACTIVE_KEY):
-        return ALLOW_EXIT_CODE
-    transcript_path = hook_input.get(TRANSCRIPT_PATH_KEY)
-    if not isinstance(transcript_path, str) or not transcript_path:
-        return ALLOW_EXIT_CODE
-    try:
-        all_entries = _read_entries(transcript_path)
-    except OSError:
-        return ALLOW_EXIT_CODE
-    is_remote_session = bool(os.environ.get(REMOTE_SESSION_ENVIRONMENT_VARIABLE))
-    block_reason = stop_block_reason(all_entries, is_remote_session)
-    if block_reason is None:
-        return ALLOW_EXIT_CODE
-    log_hook_block(Path(__file__).name, STOP_GATE_EVENT_NAME, block_reason)
-    sys.stdout.write(json.dumps({"decision": BLOCK_DECISION, "reason": block_reason}))
-    return ALLOW_EXIT_CODE
-
-
-if __name__ == "__main__":
-    sys.exit(main())