claude-dev-env 8.74.1 → 8.75.0

package/hooks/test_followup_ledger.py

@@ -12,9 +12,8 @@ if _hooks_directory not in sys.path:
 from followup_ledger import (
     FollowupFinding,
     all_recorded_findings,
-    deduplicate_ledger,
-    deduplicated_lines,
-    followup_ledger_path,
+    finding_path,
+    followup_directory,
     head_commit,
     record_followup_finding,
 )
@@ -62,27 +61,29 @@ def test_all_recorded_findings_is_empty_without_a_ledger(tmp_path: Path) -> None
     assert all_recorded_findings(tmp_path) == ()
 
 
-def test_all_recorded_findings_skips_an_unreadable_line(tmp_path: Path) -> None:
+def test_all_recorded_findings_skips_an_unreadable_file(tmp_path: Path) -> None:
     finding = FollowupFinding(
         "instruction-mode", "docs/AGENTS.md", "wrong mode", "instruction-mode"
     )
     record_followup_finding(tmp_path, finding)
-    ledger_path = followup_ledger_path(tmp_path)
-    with ledger_path.open("a", encoding="utf-8") as ledger_file:
-        ledger_file.write("{ not json\n")
+    (followup_directory(tmp_path) / "damaged.json").write_text(
+        "{ not json\n", encoding="utf-8"
+    )
 
     assert all_recorded_findings(tmp_path) == (finding,)
 
 
-def test_record_followup_finding_writes_one_json_object_per_line(tmp_path: Path) -> None:
-    record_followup_finding(
-        tmp_path, FollowupFinding("instruction-mode", "docs/AGENTS.md", "wrong mode")
-    )
+def test_record_followup_finding_writes_one_json_file_per_finding(
+    tmp_path: Path,
+) -> None:
+    finding = FollowupFinding("instruction-mode", "docs/AGENTS.md", "wrong mode")
 
-    all_lines = followup_ledger_path(tmp_path).read_text(encoding="utf-8").splitlines()
+    record_followup_finding(tmp_path, finding)
 
-    assert len(all_lines) == 1
-    assert json.loads(all_lines[0])["rule_id"] == "instruction-mode"
+    all_record_paths = list(followup_directory(tmp_path).glob("*.json"))
+    assert all_record_paths == [finding_path(tmp_path, finding)]
+    recorded = json.loads(all_record_paths[0].read_text(encoding="utf-8"))
+    assert recorded["rule_id"] == "instruction-mode"
 
 
 def test_a_recorded_ledger_stays_out_of_git_status(tmp_path: Path) -> None:
@@ -98,7 +99,7 @@ def test_a_recorded_ledger_stays_out_of_git_status(tmp_path: Path) -> None:
         capture_output=True,
         text=True,
     )
-    assert followup_ledger_path(tmp_path).is_file()
+    assert any(followup_directory(tmp_path).glob("*.json"))
     assert status_result.stdout == ""
 
 
@@ -133,9 +134,9 @@ def test_a_recorded_finding_carries_its_check_severity_and_origin(
 def test_a_record_written_without_the_tracking_fields_still_reads(
     tmp_path: Path,
 ) -> None:
-    ledger_path = followup_ledger_path(tmp_path)
-    ledger_path.parent.mkdir(parents=True, exist_ok=True)
-    ledger_path.write_text(
+    record_path = followup_directory(tmp_path) / "older.json"
+    record_path.parent.mkdir(parents=True, exist_ok=True)
+    record_path.write_text(
         json.dumps(
             {
                 "rule_id": "instruction-mode",
@@ -268,57 +269,75 @@ def test_head_commit_reads_a_packed_branch_from_a_linked_worktree(
     assert head_commit(worktree_root) == expected_commit
 
 
-def test_deduplicated_lines_keeps_the_first_of_each_exact_line_in_order() -> None:
-    assert deduplicated_lines(["a", "b", "a", "c", "b"]) == ["a", "b", "c"]
+def test_the_file_name_depends_on_the_tracking_key_alone(tmp_path: Path) -> None:
+    first = FollowupFinding("r1", "a.py", "m1", "r1", "smell", "aaa1111")
+    later = first._replace(origin_commit="bbb2222")
+    other = first._replace(message="m2")
 
+    assert finding_path(tmp_path, first) == finding_path(tmp_path, later)
+    assert finding_path(tmp_path, first) != finding_path(tmp_path, other)
 
-def test_record_followup_finding_removes_lines_a_union_merge_repeated(
-    tmp_path: Path,
-) -> None:
-    ledger_path = followup_ledger_path(tmp_path)
-    ledger_path.parent.mkdir(parents=True)
-    first_line = '{"rule_id": "r1", "file_path": "a.py", "message": "m1"}'
-    second_line = '{"rule_id": "r2", "file_path": "b.py", "message": "m2"}'
-    ledger_path.write_text(
-        f"{first_line}\n{second_line}\n{first_line}\n", encoding="utf-8"
-    )
 
-    record_followup_finding(tmp_path, FollowupFinding("r3", "c.py", "m3", "r3"))
-
-    all_ledger_lines = ledger_path.read_text(encoding="utf-8").splitlines()
-    assert all_ledger_lines[:2] == [first_line, second_line]
-    assert [json.loads(each_line)["rule_id"] for each_line in all_ledger_lines] == [
-        "r1",
-        "r2",
-        "r3",
-    ]
+def _git(repository_root: Path, *all_arguments: str) -> subprocess.CompletedProcess:
+    return subprocess.run(
+        [
+            "git",
+            "-C",
+            str(repository_root),
+            "-c",
+            "user.name=t",
+            "-c",
+            "user.email=t@t",
+            *all_arguments,
+        ],
+        check=False,
+        capture_output=True,
+        text=True,
+    )
 
 
-def test_record_followup_finding_removes_a_repeat_of_an_already_recorded_finding(
-    tmp_path: Path,
-) -> None:
-    finding = FollowupFinding("r1", "a.py", "m1", "r1")
-    record_followup_finding(tmp_path, finding)
-    ledger_path = followup_ledger_path(tmp_path)
-    recorded_text = ledger_path.read_text(encoding="utf-8")
-    ledger_path.write_text(recorded_text * 2, encoding="utf-8")
+def _commit_finding_on_branch(
+    repository_root: Path, branch_name: str, finding: FollowupFinding
+) -> set[str]:
+    _git(repository_root, "checkout", "--quiet", "-b", branch_name, "main")
+    record_followup_finding(repository_root, finding)
+    _git(repository_root, "add", "--all")
+    _git(repository_root, "commit", "--quiet", "-m", branch_name)
+    changed_text = _git(
+        repository_root, "diff", "--name-only", "main", branch_name
+    ).stdout
+    return set(changed_text.split())
 
-    record_followup_finding(tmp_path, finding)
 
-    assert ledger_path.read_text(encoding="utf-8") == recorded_text
+def test_two_parallel_writers_share_no_file_and_merge_cleanly(tmp_path: Path) -> None:
+    repository_root = tmp_path / "repo"
+    subprocess.run(
+        ["git", "init", "--quiet", "-b", "main", str(repository_root)], check=True
+    )
+    ignore_path = followup_directory(repository_root) / ".gitignore"
+    ignore_path.parent.mkdir(parents=True)
+    ignore_path.write_text("!*.json\n", encoding="utf-8")
+    _git(repository_root, "add", "--all")
+    _git(repository_root, "commit", "--quiet", "-m", "start")
+    first = FollowupFinding("r1", "a.py", "m1", "r1")
+    second = FollowupFinding("r2", "b.py", "m2", "r2")
 
+    first_files = _commit_finding_on_branch(repository_root, "first", first)
+    second_files = _commit_finding_on_branch(repository_root, "second", second)
+    _git(repository_root, "checkout", "--quiet", "first")
+    merge_result = _git(repository_root, "merge", "--no-edit", "second")
 
-def test_deduplicate_ledger_reports_how_many_lines_it_removed(tmp_path: Path) -> None:
-    ledger_path = followup_ledger_path(tmp_path)
-    ledger_path.parent.mkdir(parents=True)
-    ledger_path.write_text("x\ny\nx\nx\n", encoding="utf-8")
+    assert first_files and second_files
+    assert not first_files & second_files
+    assert merge_result.returncode == 0, merge_result.stdout + merge_result.stderr
+    assert all_recorded_findings(repository_root) == (first, second)
 
-    removed_count = deduplicate_ledger(tmp_path)
 
-    assert removed_count == 2
-    assert ledger_path.read_text(encoding="utf-8") == "x\ny\n"
+def test_a_committed_ignore_file_is_left_as_it_stands(tmp_path: Path) -> None:
+    ignore_path = followup_directory(tmp_path) / ".gitignore"
+    ignore_path.parent.mkdir(parents=True)
+    ignore_path.write_text("!*.json\n", encoding="utf-8")
 
+    record_followup_finding(tmp_path, FollowupFinding("r1", "a.py", "m1", "r1"))
 
-def test_deduplicate_ledger_leaves_an_absent_ledger_absent(tmp_path: Path) -> None:
-    assert deduplicate_ledger(tmp_path) == 0
-    assert not followup_ledger_path(tmp_path).exists()
+    assert ignore_path.read_text(encoding="utf-8") == "!*.json\n"

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.1",
+    "version": "8.75.0",
     "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,