claude-dev-env 8.74.1 → 8.75.0

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())

package/hooks/blocking/test_session_title_stop_gate.py

@@ -1,295 +0,0 @@
-import io
-import json
-from pathlib import Path
-
-import pytest
-
-import session_title_stop_gate
-
-REMOTE_TITLE_TOOL = "mcp__claude-code-remote__set_session_title"
-DESKTOP_TITLE_TOOL = "mcp__ccd_session_mgmt__set_session_title"
-REMOTE_SESSION_VARIABLE = "CLAUDE_CODE_REMOTE_SESSION_ID"
-
-
-def prompt(text: str) -> dict[str, object]:
-    return {"type": "user", "message": {"role": "user", "content": text}}
-
-
-def meta_prompt(text: str) -> dict[str, object]:
-    return {
-        "type": "user",
-        "isMeta": True,
-        "message": {"role": "user", "content": [{"type": "text", "text": text}]},
-    }
-
-
-def tool_call(tool_use_id: str, name: str) -> dict[str, object]:
-    return {
-        "type": "assistant",
-        "message": {
-            "role": "assistant",
-            "content": [{"type": "tool_use", "id": tool_use_id, "name": name, "input": {}}],
-        },
-    }
-
-
-def tool_result(tool_use_id: str, is_error: bool = False) -> dict[str, object]:
-    return {
-        "type": "user",
-        "message": {
-            "role": "user",
-            "content": [
-                {
-                    "type": "tool_result",
-                    "tool_use_id": tool_use_id,
-                    "content": "ok",
-                    "is_error": is_error,
-                }
-            ],
-        },
-    }
-
-
-def deferred_tools(*all_names: str) -> dict[str, object]:
-    return {
-        "type": "attachment",
-        "attachment": {"type": "deferred_tools_delta", "addedNames": list(all_names)},
-    }
-
-
-def run_gate(
-    monkeypatch: pytest.MonkeyPatch,
-    capsys: pytest.CaptureFixture[str],
-    tmp_path: Path,
-    all_entries: list[dict[str, object]],
-    stop_hook_active: bool = False,
-) -> tuple[int, str]:
-    transcript_path = tmp_path / "session.jsonl"
-    transcript_path.write_text(
-        "".join(json.dumps(each) + "\n" for each in all_entries), encoding="utf-8"
-    )
-    hook_input = {
-        "hook_event_name": "Stop",
-        "transcript_path": str(transcript_path),
-        "stop_hook_active": stop_hook_active,
-    }
-    monkeypatch.setattr(
-        "sys.stdin", io.TextIOWrapper(io.BytesIO(json.dumps(hook_input).encode("utf-8")))
-    )
-    exit_code = session_title_stop_gate.main()
-    return exit_code, capsys.readouterr().out
-
-
-@pytest.fixture(autouse=True)
-def isolated_home(monkeypatch: pytest.MonkeyPatch, tmp_path: Path) -> None:
-    monkeypatch.setenv("HOME", str(tmp_path))
-    monkeypatch.setenv("USERPROFILE", str(tmp_path))
-    monkeypatch.delenv(REMOTE_SESSION_VARIABLE, raising=False)
-
-
-def test_should_block_a_remote_turn_that_set_no_title(
-    monkeypatch: pytest.MonkeyPatch, capsys: pytest.CaptureFixture[str], tmp_path: Path
-) -> None:
-    monkeypatch.setenv(REMOTE_SESSION_VARIABLE, "cse_1")
-    exit_code, stdout_text = run_gate(
-        monkeypatch,
-        capsys,
-        tmp_path,
-        [prompt("Fix the runner"), tool_call("t1", "Bash"), tool_result("t1")],
-    )
-    decision = json.loads(stdout_text)
-    assert exit_code == 0
-    assert decision["decision"] == "block"
-    assert REMOTE_TITLE_TOOL in decision["reason"]
-
-
-def test_should_pass_a_turn_whose_title_call_succeeded(
-    monkeypatch: pytest.MonkeyPatch, capsys: pytest.CaptureFixture[str], tmp_path: Path
-) -> None:
-    monkeypatch.setenv(REMOTE_SESSION_VARIABLE, "cse_1")
-    all_entries = [prompt("Fix the runner"), tool_call("t1", REMOTE_TITLE_TOOL), tool_result("t1")]
-    assert run_gate(monkeypatch, capsys, tmp_path, all_entries) == (0, "")
-
-
-def test_should_block_when_the_only_title_call_was_denied(
-    monkeypatch: pytest.MonkeyPatch, capsys: pytest.CaptureFixture[str], tmp_path: Path
-) -> None:
-    monkeypatch.setenv(REMOTE_SESSION_VARIABLE, "cse_1")
-    all_entries = [
-        prompt("Fix the runner"),
-        tool_call("t1", REMOTE_TITLE_TOOL),
-        tool_result("t1", is_error=True),
-    ]
-    _, stdout_text = run_gate(monkeypatch, capsys, tmp_path, all_entries)
-    assert json.loads(stdout_text)["decision"] == "block"
-
-
-def test_should_block_when_the_title_was_set_only_in_an_earlier_turn(
-    monkeypatch: pytest.MonkeyPatch, capsys: pytest.CaptureFixture[str], tmp_path: Path
-) -> None:
-    all_entries = [
-        prompt("Fix the runner"),
-        tool_call("t1", DESKTOP_TITLE_TOOL),
-        tool_result("t1"),
-        prompt("Now open the pull request"),
-        tool_call("t2", "Bash"),
-        tool_result("t2"),
-    ]
-    _, stdout_text = run_gate(monkeypatch, capsys, tmp_path, all_entries)
-    assert DESKTOP_TITLE_TOOL in json.loads(stdout_text)["reason"]
-
-
-def test_should_keep_a_title_set_before_a_meta_entry_in_the_same_turn(
-    monkeypatch: pytest.MonkeyPatch, capsys: pytest.CaptureFixture[str], tmp_path: Path
-) -> None:
-    monkeypatch.setenv(REMOTE_SESSION_VARIABLE, "cse_1")
-    all_entries = [
-        prompt("Fix the runner"),
-        tool_call("t1", REMOTE_TITLE_TOOL),
-        tool_result("t1"),
-        meta_prompt("Base directory for this skill: /skills/pr-lifecycle"),
-    ]
-    assert run_gate(monkeypatch, capsys, tmp_path, all_entries) == (0, "")
-
-
-def test_should_block_a_desktop_session_once_its_title_tool_is_listed(
-    monkeypatch: pytest.MonkeyPatch, capsys: pytest.CaptureFixture[str], tmp_path: Path
-) -> None:
-    all_entries = [deferred_tools("TaskCreate", DESKTOP_TITLE_TOOL), prompt("Fix the runner")]
-    _, stdout_text = run_gate(monkeypatch, capsys, tmp_path, all_entries)
-    assert DESKTOP_TITLE_TOOL in json.loads(stdout_text)["reason"]
-
-
-def test_should_stay_silent_in_a_session_with_no_title_tool(
-    monkeypatch: pytest.MonkeyPatch, capsys: pytest.CaptureFixture[str], tmp_path: Path
-) -> None:
-    all_entries = [
-        deferred_tools("TaskCreate"),
-        prompt("Fix the runner"),
-        tool_call("t1", "Bash"),
-        tool_result("t1"),
-    ]
-    assert run_gate(monkeypatch, capsys, tmp_path, all_entries) == (0, "")
-
-
-def test_should_stay_silent_in_a_remote_session_whose_tool_list_lacks_the_title_tool(
-    monkeypatch: pytest.MonkeyPatch, capsys: pytest.CaptureFixture[str], tmp_path: Path
-) -> None:
-    monkeypatch.setenv(REMOTE_SESSION_VARIABLE, "cse_1")
-    all_entries = [
-        deferred_tools("TaskCreate", "mcp__claude-code-remote__get_session"),
-        prompt("Fix the runner"),
-        tool_call("t1", "Bash"),
-        tool_result("t1"),
-    ]
-    assert run_gate(monkeypatch, capsys, tmp_path, all_entries) == (0, "")
-
-
-def test_should_block_a_remote_session_whose_deferred_list_holds_no_remote_server_tool(
-    monkeypatch: pytest.MonkeyPatch, capsys: pytest.CaptureFixture[str], tmp_path: Path
-) -> None:
-    monkeypatch.setenv(REMOTE_SESSION_VARIABLE, "cse_1")
-    all_entries = [
-        deferred_tools("TaskCreate", "WebFetch"),
-        prompt("Fix the runner"),
-        tool_call("t1", "Bash"),
-        tool_result("t1"),
-    ]
-    _, stdout_text = run_gate(monkeypatch, capsys, tmp_path, all_entries)
-    assert json.loads(stdout_text)["decision"] == "block"
-
-
-def test_should_block_a_remote_session_whose_tool_list_names_the_title_tool(
-    monkeypatch: pytest.MonkeyPatch, capsys: pytest.CaptureFixture[str], tmp_path: Path
-) -> None:
-    monkeypatch.setenv(REMOTE_SESSION_VARIABLE, "cse_1")
-    all_entries = [
-        deferred_tools("TaskCreate", REMOTE_TITLE_TOOL),
-        prompt("Fix the runner"),
-        tool_call("t1", "Bash"),
-        tool_result("t1"),
-    ]
-    _, stdout_text = run_gate(monkeypatch, capsys, tmp_path, all_entries)
-    assert json.loads(stdout_text)["decision"] == "block"
-
-
-def earlier_stop_block() -> dict[str, object]:
-    return {
-        "type": "attachment",
-        "attachment": {"type": "hook_blocking_error", "hookEvent": "Stop"},
-    }
-
-
-def test_should_stay_silent_in_a_remote_session_after_an_unmet_earlier_block(
-    monkeypatch: pytest.MonkeyPatch, capsys: pytest.CaptureFixture[str], tmp_path: Path
-) -> None:
-    monkeypatch.setenv(REMOTE_SESSION_VARIABLE, "cse_1")
-    all_entries = [
-        prompt("Fix the runner"),
-        earlier_stop_block(),
-        prompt("Next task"),
-        tool_call("t1", "Bash"),
-        tool_result("t1"),
-    ]
-    assert run_gate(monkeypatch, capsys, tmp_path, all_entries) == (0, "")
-
-
-def test_should_block_after_an_earlier_block_once_the_title_tool_is_listed(
-    monkeypatch: pytest.MonkeyPatch, capsys: pytest.CaptureFixture[str], tmp_path: Path
-) -> None:
-    monkeypatch.setenv(REMOTE_SESSION_VARIABLE, "cse_1")
-    all_entries = [
-        deferred_tools(REMOTE_TITLE_TOOL),
-        prompt("Fix the runner"),
-        earlier_stop_block(),
-        prompt("Next task"),
-        tool_call("t1", "Bash"),
-        tool_result("t1"),
-    ]
-    _, stdout_text = run_gate(monkeypatch, capsys, tmp_path, all_entries)
-    assert json.loads(stdout_text)["decision"] == "block"
-
-
-def test_should_stay_silent_on_the_retry_after_a_block(
-    monkeypatch: pytest.MonkeyPatch, capsys: pytest.CaptureFixture[str], tmp_path: Path
-) -> None:
-    monkeypatch.setenv(REMOTE_SESSION_VARIABLE, "cse_1")
-    assert run_gate(
-        monkeypatch, capsys, tmp_path, [prompt("Fix the runner")], stop_hook_active=True
-    ) == (0, "")
-
-
-def test_should_stay_silent_when_the_transcript_is_missing(
-    monkeypatch: pytest.MonkeyPatch, capsys: pytest.CaptureFixture[str], tmp_path: Path
-) -> None:
-    monkeypatch.setenv(REMOTE_SESSION_VARIABLE, "cse_1")
-    hook_input = {"hook_event_name": "Stop", "transcript_path": str(tmp_path / "absent.jsonl")}
-    monkeypatch.setattr(
-        "sys.stdin", io.TextIOWrapper(io.BytesIO(json.dumps(hook_input).encode("utf-8")))
-    )
-    assert session_title_stop_gate.main() == 0
-    assert capsys.readouterr().out == ""
-
-
-def test_stop_block_reason_returns_none_after_a_successful_title_call() -> None:
-    all_entries = [prompt("Fix the runner"), tool_call("t1", REMOTE_TITLE_TOOL), tool_result("t1")]
-    assert session_title_stop_gate.stop_block_reason(all_entries, is_remote_session=True) is None
-
-
-def test_stop_block_reason_names_the_seen_tool_when_the_turn_has_no_title() -> None:
-    all_entries = [
-        prompt("Fix the runner"),
-        tool_call("t1", DESKTOP_TITLE_TOOL),
-        tool_result("t1"),
-        prompt("Next"),
-    ]
-    block_reason = session_title_stop_gate.stop_block_reason(all_entries, is_remote_session=False)
-    assert block_reason is not None and DESKTOP_TITLE_TOOL in block_reason
-
-
-def test_stop_block_reason_tells_the_model_to_set_the_title_in_silence() -> None:
-    all_entries = [prompt("Fix the runner"), tool_call("t1", REMOTE_TITLE_TOOL), prompt("Next")]
-    block_reason = session_title_stop_gate.stop_block_reason(all_entries, is_remote_session=True)
-    assert block_reason is not None
-    assert "Say nothing to the user about the title" in block_reason
-    assert "end with no text" in block_reason

package/scripts/repository_checks/followup_ledger_duplicates.py

@@ -1,55 +0,0 @@
-"""Committed follow-up ledger check for exact repeated lines.
-
-GitHub's server-side merge ignores ``merge=union``, so repeated lines arrive
-only through a local union merge. This check stops them at the merge queue.
-"""
-
-from __future__ import annotations
-
-from collections.abc import Sequence
-from pathlib import Path
-from types import ModuleType
-
-from policy_lint.config import constants as policy_constants
-
-from repository_checks.config import constants as repository_constants
-from repository_checks.hook_modules import load_hooks_module
-from repository_checks.models import RepositoryFinding
-
-
-def collect_followup_ledger_duplicate_findings(
-    repository_root: Path, all_tracked_paths: Sequence[str]
-) -> list[RepositoryFinding]:
-    """Return a finding when the tracked ledger repeats a line.
-
-    Args:
-        repository_root: Git repository root.
-        all_tracked_paths: Repository-relative tracked paths.
-
-    Returns:
-        One finding naming the repeated-line count, or no findings.
-    """
-    ledger = load_hooks_module(repository_constants.FOLLOWUP_LEDGER_MODULE_NAME)
-    ledger_path = ledger.followup_ledger_path(repository_root)
-    relative_path = ledger_path.relative_to(repository_root).as_posix()
-    if relative_path not in all_tracked_paths:
-        return []
-    repeated_line_count = _repeated_line_count(ledger, ledger_path)
-    if not repeated_line_count:
-        return []
-    return [
-        RepositoryFinding(
-            repository_constants.CHECK_ID_FOLLOWUP_LEDGER_DUPLICATES,
-            relative_path,
-            repository_constants.FOLLOWUP_LEDGER_DUPLICATE_MESSAGE_TEMPLATE.format(
-                repeated_line_count=repeated_line_count
-            ),
-        )
-    ]
-
-
-def _repeated_line_count(ledger: ModuleType, ledger_path: Path) -> int:
-    all_ledger_lines = ledger_path.read_text(
-        encoding=policy_constants.UTF8_ENCODING
-    ).splitlines()
-    return len(all_ledger_lines) - len(ledger.deduplicated_lines(all_ledger_lines))

package/scripts/tests/test_followup_ledger_duplicates.py

@@ -1,58 +0,0 @@
-"""Behavior tests for the committed follow-up ledger duplicate check."""
-
-from __future__ import annotations
-
-import sys
-from pathlib import Path
-
-_TESTS_DIRECTORY = Path(__file__).resolve().parent
-if str(_TESTS_DIRECTORY) not in sys.path:
-    sys.path.insert(0, str(_TESTS_DIRECTORY))
-
-from repository_checks.config.constants import (
-    CHECK_ID_FOLLOWUP_LEDGER_DUPLICATES,
-    FINDINGS_EXIT_CODE,
-    SUCCESS_EXIT_CODE,
-)
-from repository_policy_test_support import (
-    commit_tracked_files,
-    initialize_repository,
-    run_policy,
-    write_text,
-)
-
-_LEDGER_RELATIVE_PATH = ".claude/followups/smells.jsonl"
-
-
-def test_should_flag_a_committed_ledger_with_a_repeated_line(tmp_path: Path) -> None:
-    repository_root = tmp_path / "repo"
-    initialize_repository(repository_root)
-    write_text(
-        repository_root / _LEDGER_RELATIVE_PATH,
-        '{"rule_id": "a"}\n{"rule_id": "b"}\n{"rule_id": "a"}\n',
-    )
-    commit_tracked_files(repository_root)
-
-    exit_code, stdout_text, _stderr_text = run_policy(repository_root)
-
-    assert exit_code == FINDINGS_EXIT_CODE
-    assert (
-        f"{CHECK_ID_FOLLOWUP_LEDGER_DUPLICATES}: {_LEDGER_RELATIVE_PATH}:"
-        in stdout_text
-    )
-    assert "cde followup dedupe" in stdout_text
-
-
-def test_should_pass_a_committed_ledger_without_repeats(tmp_path: Path) -> None:
-    repository_root = tmp_path / "repo"
-    initialize_repository(repository_root)
-    write_text(
-        repository_root / _LEDGER_RELATIVE_PATH,
-        '{"rule_id": "a"}\n{"rule_id": "b"}\n',
-    )
-    commit_tracked_files(repository_root)
-
-    exit_code, stdout_text, _stderr_text = run_policy(repository_root)
-
-    assert exit_code == SUCCESS_EXIT_CODE
-    assert stdout_text == ""