claude-dev-env 7.0.0 → 7.1.0

package/scripts/tests/test_verification_notice.py

@@ -0,0 +1,347 @@
+from __future__ import annotations
+
+import hashlib
+import json
+import os
+import subprocess
+import sys
+from pathlib import Path
+
+HOOKS_DIRECTORY = Path(__file__).resolve().parents[2] / "hooks" / "git-hooks"
+NOTICE_SCRIPT = HOOKS_DIRECTORY / "verification_notice.py"
+ALL_REMOTE_URLS = (
+    "https://github.com/JonEcho/python-automation.git",
+    "git@github.com:JonEcho/python-automation.git",
+    "ssh://git@github.com/JonEcho/python-automation.git",
+)
+
+
+def run_notice(
+    repository_path: Path,
+    event_name: str = "commit",
+) -> subprocess.CompletedProcess[str]:
+    return subprocess.run(
+        [
+            sys.executable,
+            str(NOTICE_SCRIPT),
+            "--event",
+            event_name,
+            "--repo",
+            str(repository_path),
+        ],
+        check=False,
+        capture_output=True,
+        text=True,
+        encoding="utf-8",
+        env={**os.environ, "PYTHONIOENCODING": "utf-8"},
+    )
+
+
+def create_target_repository(
+    temporary_directory: Path,
+    remote_url: str,
+) -> tuple[Path, str]:
+    repository_path = temporary_directory / "Jon Echo project with spaces Ω"
+    repository_path.mkdir(parents=True)
+    run_git(repository_path, "init", "--quiet")
+    run_git(repository_path, "config", "user.email", "test@example.invalid")
+    run_git(repository_path, "config", "user.name", "Verification Test")
+    (repository_path / "README.md").write_text("check\n", encoding="utf-8")
+    run_git(repository_path, "add", "README.md")
+    run_git(repository_path, "commit", "--quiet", "-m", "initial")
+    run_git(repository_path, "remote", "add", "origin", remote_url)
+    current_head = run_git(repository_path, "rev-parse", "HEAD").stdout.strip()
+    return repository_path, current_head
+
+
+def run_git(
+    repository_path: Path,
+    *arguments: str,
+) -> subprocess.CompletedProcess[str]:
+    return subprocess.run(
+        ["git", *arguments],
+        cwd=repository_path,
+        check=True,
+        capture_output=True,
+        text=True,
+        encoding="utf-8",
+    )
+
+
+def write_report(
+    repository_path: Path,
+    report_fields: dict[str, object],
+) -> None:
+    manifest_path = repository_path / "config" / "local-verification.json"
+    manifest_path.parent.mkdir(exist_ok=True)
+    manifest_mapping = {
+        "version": 1,
+        "checks": [
+            {
+                "id": "smoke",
+                "argv": ["python", "-c", "pass"],
+                "cwd": ".",
+                "timeout_seconds": 1.0,
+                "minimum_tests": None,
+            }
+        ],
+        "exclusions": [],
+    }
+    manifest_path.write_text(json.dumps(manifest_mapping), encoding="utf-8")
+    report_path = repository_path / ".git" / "local-verification" / "report.json"
+    report_path.parent.mkdir(exist_ok=True)
+    all_report_fields = {
+        "selection": {"selected_manifest_path": "config/local-verification.json"},
+        "manifest_digest": hashlib.sha256(
+            json.dumps(manifest_mapping, sort_keys=True, separators=(",", ":")).encode()
+        ).hexdigest(),
+        **report_fields,
+    }
+    report_path.write_text(json.dumps(all_report_fields), encoding="utf-8")
+
+
+def write_passing_report(repository_path: Path) -> str:
+    write_report(repository_path, {})
+    run_git(repository_path, "add", "config/local-verification.json")
+    run_git(repository_path, "commit", "--quiet", "-m", "manifest")
+    current_head = run_git(repository_path, "rev-parse", "HEAD").stdout.strip()
+    run_git(repository_path, "update-ref", "refs/remotes/origin/main", current_head)
+    write_report(
+        repository_path,
+        {
+            "head": current_head,
+            "base": current_head,
+            "worktree_clean": True,
+            "inputs_unchanged": True,
+            "publishable": True,
+            "status": "passed",
+            "aggregate": {
+                "status": "passed",
+                "total": 1,
+                "passed": 1,
+                "failed": 0,
+                "incomplete": 0,
+                "exit_code": 0,
+            },
+        },
+    )
+    return current_head
+
+
+def write_worktree_passing_report(
+    repository_path: Path,
+    linked_git_directory: Path,
+) -> str:
+    current_head = run_git(repository_path, "rev-parse", "HEAD").stdout.strip()
+    source_manifest_path = repository_path / "config" / "local-verification.json"
+    source_report_path = repository_path / ".git" / "local-verification" / "report.json"
+    metadata_directory = linked_git_directory / "local-verification"
+    metadata_directory.mkdir(parents=True, exist_ok=True)
+    metadata_manifest_path = metadata_directory / "local-verification.json"
+    metadata_manifest_path.write_bytes(source_manifest_path.read_bytes())
+    all_report_fields = json.loads(source_report_path.read_text(encoding="utf-8"))
+    all_report_fields["selection"]["selected_manifest_path"] = str(
+        metadata_manifest_path
+    )
+    metadata_report_path = metadata_directory / "report.json"
+    metadata_report_path.write_text(json.dumps(all_report_fields), encoding="utf-8")
+    return current_head
+
+
+def test_notice_matches_remote_formats_and_quotes_paths(tmp_path: Path) -> None:
+    for each_index, each_remote_url in enumerate(ALL_REMOTE_URLS):
+        repository_path, current_head = create_target_repository(
+            tmp_path / str(each_index), each_remote_url
+        )
+        completed_notice = run_notice(repository_path, "push")
+        assert completed_notice.returncode == 0
+        assert "LOCAL VERIFICATION ADVISORY" in completed_notice.stdout
+        assert f"Current SHA: {current_head}" in completed_notice.stdout
+        assert "State: pending" in completed_notice.stdout
+        assert "python '" in completed_notice.stdout
+        wrapper_suffix = str(Path(".github") / "ci" / "local_verify.py")
+        assert f"{wrapper_suffix}' --base origin/main" in completed_notice.stdout
+        assert "--executor '" in completed_notice.stdout
+        assert "--output '" in completed_notice.stdout
+        assert repository_path.name in completed_notice.stdout
+        assert "--base origin/main" in completed_notice.stdout
+        assert "does not block commit or push" in completed_notice.stdout
+
+
+def test_notice_reports_pending_when_manifest_exists_without_report(
+    tmp_path: Path,
+) -> None:
+    repository_path, _ = create_target_repository(
+        tmp_path,
+        "https://github.com/JonEcho/python-automation.git",
+    )
+    write_report(repository_path, {})
+    (repository_path / ".git" / "local-verification" / "report.json").unlink()
+
+    completed_notice = run_notice(repository_path)
+
+    assert completed_notice.returncode == 0
+    assert "State: pending" in completed_notice.stdout
+    assert "manifest is missing or unreadable" not in completed_notice.stdout
+    assert "No complete current pass is recorded" in completed_notice.stdout
+
+
+def test_notice_ignores_unrelated_remote(tmp_path: Path) -> None:
+    repository_path, _ = create_target_repository(
+        tmp_path,
+        "https://github.com/other-owner/other-repository.git",
+    )
+    completed_notice = run_notice(repository_path)
+    assert completed_notice.returncode == 0
+    assert completed_notice.stdout == ""
+
+
+def test_notice_reports_failed_checks_without_pass_label(tmp_path: Path) -> None:
+    repository_path, current_head = create_target_repository(
+        tmp_path,
+        "https://github.com/JonEcho/python-automation.git",
+    )
+    write_report(repository_path, {"head": current_head, "status": "failed"})
+    completed_notice = run_notice(repository_path)
+    assert completed_notice.returncode == 0
+    assert f"Current SHA: {current_head}" in completed_notice.stdout
+    assert "State: failed" in completed_notice.stdout
+    assert "recorded local checks failed" in completed_notice.stdout
+    assert "local-checks:passed" not in completed_notice.stdout
+
+
+def test_notice_reports_pass_only_for_complete_current_revision(tmp_path: Path) -> None:
+    repository_path, _ = create_target_repository(
+        tmp_path,
+        "https://github.com/JonEcho/python-automation.git",
+    )
+    current_head = write_passing_report(repository_path)
+    completed_notice = run_notice(repository_path)
+    assert completed_notice.returncode == 0
+    assert f"Verified SHA: {current_head}" in completed_notice.stdout
+    assert "State: passed" in completed_notice.stdout
+    assert (
+        "local-checks:passed is valid only for this exact current SHA"
+        in completed_notice.stdout
+    )
+
+
+def test_notice_handles_malformed_report_and_missing_repository(tmp_path: Path) -> None:
+    repository_path, _ = create_target_repository(
+        tmp_path,
+        "https://github.com/JonEcho/python-automation.git",
+    )
+    manifest_path = repository_path / "config" / "local-verification.json"
+    manifest_path.parent.mkdir(exist_ok=True)
+    manifest_mapping = {
+        "version": 1,
+        "checks": [
+            {
+                "id": "smoke",
+                "argv": ["python", "-c", "pass"],
+                "cwd": ".",
+                "timeout_seconds": 1.0,
+                "minimum_tests": None,
+            }
+        ],
+        "exclusions": [],
+    }
+    manifest_path.write_text(json.dumps(manifest_mapping), encoding="utf-8")
+    report_path = repository_path / ".git" / "local-verification" / "report.json"
+    report_path.parent.mkdir(exist_ok=True)
+    report_path.write_bytes(b"not-json\xff")
+    malformed_notice = run_notice(repository_path)
+    missing_notice = run_notice(tmp_path / "missing repository")
+    assert malformed_notice.returncode == 0
+    assert "State: unverified" in malformed_notice.stdout
+    assert missing_notice.returncode == 0
+    assert missing_notice.stdout == ""
+
+
+def test_notice_uses_worktree_specific_report_path(tmp_path: Path) -> None:
+    repository_path, _ = create_target_repository(
+        tmp_path / "main",
+        "https://github.com/JonEcho/python-automation.git",
+    )
+    linked_worktree_path = tmp_path / "linked worktree Ω"
+    run_git(repository_path, "worktree", "add", "--detach", str(linked_worktree_path))
+    linked_git_directory = Path(
+        run_git(linked_worktree_path, "rev-parse", "--absolute-git-dir").stdout.strip()
+    )
+
+    completed_notice = run_notice(linked_worktree_path)
+
+    expected_report_path = linked_git_directory / "local-verification" / "report.json"
+    shared_report_path = repository_path / ".git" / "local-verification" / "report.json"
+    assert completed_notice.returncode == 0
+    assert str(expected_report_path) in completed_notice.stdout
+    assert str(shared_report_path) not in completed_notice.stdout
+
+
+def test_notice_accepts_complete_report_in_worktree_metadata(tmp_path: Path) -> None:
+    repository_path, _ = create_target_repository(
+        tmp_path / "main",
+        "https://github.com/JonEcho/python-automation.git",
+    )
+    current_head = write_passing_report(repository_path)
+    linked_worktree_path = tmp_path / "linked worktree Ω"
+    run_git(repository_path, "worktree", "add", "--detach", str(linked_worktree_path))
+    linked_git_directory = Path(
+        run_git(linked_worktree_path, "rev-parse", "--absolute-git-dir").stdout.strip()
+    )
+    write_worktree_passing_report(repository_path, linked_git_directory)
+
+    completed_notice = run_notice(linked_worktree_path)
+
+    future_path = linked_worktree_path / "future.txt"
+    future_path.write_text("future\n", encoding="utf-8")
+    run_git(linked_worktree_path, "add", "future.txt")
+    run_git(linked_worktree_path, "commit", "--quiet", "-m", "future")
+    future_head = run_git(linked_worktree_path, "rev-parse", "HEAD").stdout.strip()
+    stale_notice = run_notice(linked_worktree_path)
+    run_git(linked_worktree_path, "reset", "--quiet", "--hard", current_head)
+    run_git(linked_worktree_path, "update-ref", "refs/remotes/origin/main", future_head)
+    moved_base_notice = run_notice(linked_worktree_path)
+
+    assert "State: passed" in completed_notice.stdout
+    assert f"Verified SHA: {current_head}" in completed_notice.stdout
+    assert "State: stale" in stale_notice.stdout
+    assert "State: unverified" in moved_base_notice.stdout
+
+
+def test_notice_invalidates_pass_after_worktree_edit(tmp_path: Path) -> None:
+    repository_path, _ = create_target_repository(
+        tmp_path,
+        "https://github.com/JonEcho/python-automation.git",
+    )
+    current_head = write_passing_report(repository_path)
+    passed_notice = run_notice(repository_path)
+    (repository_path / "untracked.txt").write_text("changed\n", encoding="utf-8")
+
+    changed_notice = run_notice(repository_path)
+
+    assert f"Verified SHA: {current_head}" in passed_notice.stdout
+    assert "State: passed" in passed_notice.stdout
+    assert "Verified SHA: none" in changed_notice.stdout
+    assert "State: unverified" in changed_notice.stdout
+
+
+def test_notice_invalidates_pass_after_origin_base_moves(tmp_path: Path) -> None:
+    repository_path, _ = create_target_repository(
+        tmp_path,
+        "https://github.com/JonEcho/python-automation.git",
+    )
+    current_head = write_passing_report(repository_path)
+    passed_notice = run_notice(repository_path)
+    (repository_path / "future.txt").write_text("future\n", encoding="utf-8")
+    run_git(repository_path, "add", "future.txt")
+    run_git(repository_path, "commit", "--quiet", "-m", "future")
+    future_head = run_git(repository_path, "rev-parse", "HEAD").stdout.strip()
+    run_git(repository_path, "reset", "--quiet", "--hard", current_head)
+    run_git(repository_path, "update-ref", "refs/remotes/origin/main", future_head)
+
+    moved_base_notice = run_notice(repository_path)
+
+    assert "State: passed" in passed_notice.stdout
+    assert "Verified SHA: none" in moved_base_notice.stdout
+    assert "State: unverified" in moved_base_notice.stdout

package/hooks/blocking/ask_user_question_shape_blocker.py

@@ -1,83 +0,0 @@
-#!/usr/bin/env python3
-"""PreToolUse hook that enforces AskUserQuestion field shape."""
-
-from __future__ import annotations
-
-import json
-import sys
-from collections.abc import Mapping, Sequence
-from pathlib import Path
-
-_hooks_dir = str(Path(__file__).resolve().parent.parent)
-if _hooks_dir not in sys.path:
-    sys.path.insert(0, _hooks_dir)
-
-from hooks_constants.ask_user_question_shape import (  # noqa: E402
-    analyze_ask_user_question_shape,
-)
-from hooks_constants.ask_user_question_shape_constants import (  # noqa: E402
-    ASK_USER_QUESTION_TOOL_NAME,
-    LEAN_QUESTION_BLOCK_GUIDANCE,
-    LEAN_QUESTION_BLOCK_PREFIX,
-    LEAN_QUESTION_VIOLATION_SEPARATOR,
-    USER_FACING_LEAN_QUESTION_NOTICE,
-)
-from hooks_constants.hook_block_logger import log_hook_block  # noqa: E402
-
-
-def build_lean_block_reason(all_violations: Sequence[str]) -> str:
-    """Build a deny reason that names each field-shape violation."""
-    violation_list = LEAN_QUESTION_VIOLATION_SEPARATOR.join(all_violations)
-    return f"{LEAN_QUESTION_BLOCK_PREFIX}{violation_list}. {LEAN_QUESTION_BLOCK_GUIDANCE}"
-
-
-def evaluate(payload_by_key: Mapping[str, object]) -> str | None:
-    """Return a deny reason when an AskUserQuestion payload breaks field shape."""
-    tool_name = payload_by_key.get("tool_name", "")
-    tool_input = payload_by_key.get("tool_input", {})
-    if tool_name != ASK_USER_QUESTION_TOOL_NAME:
-        return None
-    if not isinstance(tool_input, Mapping):
-        return None
-    shape_result = analyze_ask_user_question_shape(tool_input)
-    if shape_result.is_lean:
-        return None
-    return build_lean_block_reason(shape_result.all_violations)
-
-
-def build_deny_payload(deny_reason: str) -> dict[str, object]:
-    """Build the standard PreToolUse deny payload for a shape violation."""
-    log_hook_block(
-        calling_hook_name="ask_user_question_shape_blocker.py",
-        hook_event="PreToolUse",
-        block_reason=deny_reason,
-    )
-    return {
-        "hookSpecificOutput": {
-            "hookEventName": "PreToolUse",
-            "permissionDecision": "deny",
-            "permissionDecisionReason": deny_reason,
-        },
-        "systemMessage": USER_FACING_LEAN_QUESTION_NOTICE,
-        "suppressOutput": True,
-    }
-
-
-def main() -> None:
-    """Read one PreToolUse payload and deny malformed question shape."""
-    try:
-        payload_by_key = json.load(sys.stdin)
-    except json.JSONDecodeError:
-        sys.exit(0)
-
-    if not isinstance(payload_by_key, dict):
-        sys.exit(0)
-    deny_reason = evaluate(payload_by_key)
-    if deny_reason is None:
-        sys.exit(0)
-    sys.stdout.write(json.dumps(build_deny_payload(deny_reason)))
-    sys.stdout.flush()
-
-
-if __name__ == "__main__":
-    main()

package/hooks/blocking/bot_mention_comment_blocker.py

@@ -1,76 +0,0 @@
-#!/usr/bin/env python3
-"""PreToolUse hook: block @cursor or @copilot mentions in add_issue_comment body.
-
-Bugbot trigger requires exactly ``bugbot run`` with no other text. Copilot review
-requires the GitHub REST API endpoint, not an issue comment mention. This hook
-catches both mistakes and returns the correct procedure for each.
-"""
-
-import json
-import sys
-from pathlib import Path
-
-_hooks_dir = str(Path(__file__).resolve().parent.parent)
-if _hooks_dir not in sys.path:
-    sys.path.insert(0, _hooks_dir)
-
-from hooks_constants.bot_mention_comment_blocker_constants import (  # noqa: E402
-    COPILOT_MENTION_TOKEN,
-    CORRECTIVE_MESSAGE_COPILOT,
-    CORRECTIVE_MESSAGE_CURSOR,
-    CURSOR_MENTION_TOKEN,
-    TOOL_NAME,
-)
-from hooks_constants.hook_block_logger import log_hook_block  # noqa: E402
-
-
-def _body_contains_token(body: str, token: str) -> bool:
-    return token.lower() in body.lower()
-
-
-def _detect_bot_mention(body: str) -> str | None:
-    """Return corrective message if body contains a blocked mention, else None."""
-    if _body_contains_token(body, COPILOT_MENTION_TOKEN):
-        return CORRECTIVE_MESSAGE_COPILOT
-    if _body_contains_token(body, CURSOR_MENTION_TOKEN):
-        return CORRECTIVE_MESSAGE_CURSOR
-    return None
-
-
-def main() -> None:
-    try:
-        hook_input = json.load(sys.stdin)
-    except json.JSONDecodeError:
-        sys.exit(0)
-
-    if hook_input.get("tool_name", "") != TOOL_NAME:
-        sys.exit(0)
-
-    body = hook_input.get("tool_input", {}).get("body", "")
-    if not body:
-        sys.exit(0)
-
-    corrective_message = _detect_bot_mention(body)
-    if corrective_message is None:
-        sys.exit(0)
-
-    deny_payload = {
-        "hookSpecificOutput": {
-            "hookEventName": "PreToolUse",
-            "permissionDecision": "deny",
-            "permissionDecisionReason": corrective_message,
-        }
-    }
-    log_hook_block(
-        calling_hook_name="bot_mention_comment_blocker.py",
-        hook_event="PreToolUse",
-        block_reason=corrective_message,
-        tool_name=TOOL_NAME,
-    )
-    print(json.dumps(deny_payload))
-    sys.stdout.flush()
-    sys.exit(0)
-
-
-if __name__ == "__main__":
-    main()

package/hooks/blocking/claude_md_orphan_file_blocker.py

@@ -1,129 +0,0 @@
-#!/usr/bin/env python3
-"""PreToolUse hook: blocks a per-directory CLAUDE.md that names a file absent from its subtree.
-
-A per-directory ``CLAUDE.md`` documents the files reachable from its own
-directory in a markdown table whose first column names each file in backticks,
-and shows run commands inside fenced code blocks that invoke those files. When a
-first-column cell, or an interpreter invocation inside a fenced run command
-(``python script.py``), names a bare filename that exists nowhere under the scan
-root (the CLAUDE.md directory's parent, which covers the directory, its
-subdirectories, and its siblings), the doc points a reader at a file that is not
-there. This hook fires on Write, Edit, and MultiEdit targeting a file named
-``CLAUDE.md`` and blocks the write when any such cell or run command names a file
-absent from the scan root. A table block or a run-command fence whose own region
-declares an explicit relative-path source (a ``../`` token, in the rows/fence or
-the prose that introduces it) documents files outside the subtree, so that block's
-rows or that fence's commands are left alone — the exemption is scoped to the
-region, not the whole file.
-"""
-
-import sys
-from pathlib import Path
-
-try:
-    _hooks_root_directory = str(Path(__file__).resolve().parent.parent)
-    _blocking_directory = str(Path(__file__).resolve().parent)
-    for each_bootstrap_directory in (_hooks_root_directory, _blocking_directory):
-        if each_bootstrap_directory not in sys.path:
-            sys.path.insert(0, each_bootstrap_directory)
-    from claude_md_orphan_file_blocker_parts import (
-        decision,
-        references,
-        scan_plan,
-        subtree_scan,
-    )
-    from claude_md_orphan_file_blocker_parts.subtree_scan import (
-        MAX_SUBTREE_FILES_SCANNED,  # noqa: F401
-    )
-    from inventory_intent_records import records
-
-    from hooks_constants.pre_tool_use_stdin import (
-        read_hook_input_dictionary_from_stdin,
-    )
-except ImportError as import_error:
-    raise ImportError(
-        "claude_md_orphan_file_blocker: cannot import its parts submodules; "
-        "ensure the hooks directory is importable."
-    ) from import_error
-
-
-is_claude_md_file = references.is_claude_md_file
-find_referenced_filenames = references.find_referenced_filenames
-find_run_command_filenames = references.find_run_command_filenames
-find_missing_filenames = subtree_scan.find_missing_filenames
-build_orphan_scan_plan = scan_plan.build_orphan_scan_plan
-collect_missing_filenames = scan_plan.collect_missing_filenames
-deny_orphan_files = decision.deny_orphan_files
-
-
-def _partition_by_file_intent(
-    session_id: str, directory: str, all_missing_filenames: list[str]
-) -> tuple[list[str], list[str]]:
-    """Split missing filenames into those with a pending file intent and those without."""
-    matched_filenames = [
-        each_filename
-        for each_filename in all_missing_filenames
-        if records.has_fresh_file_intent(session_id, directory, each_filename)
-    ]
-    unmatched_filenames = [
-        each_filename
-        for each_filename in all_missing_filenames
-        if each_filename not in matched_filenames
-    ]
-    return matched_filenames, unmatched_filenames
-
-
-def _emit_orphan_decision(
-    input_data: dict,
-    tool_name: str,
-    file_path: str,
-    directory: str,
-    all_missing_filenames: list[str],
-) -> None:
-    """Consume covered rows and deny any genuine orphan the change introduces."""
-    session_id = str(input_data.get("session_id") or "")
-    matched_filenames, unmatched_filenames = _partition_by_file_intent(
-        session_id, directory, all_missing_filenames
-    )
-    if unmatched_filenames:
-        for each_filename in unmatched_filenames:
-            records.record_row_intent(session_id, directory, each_filename)
-        deny_orphan_files(tool_name, file_path, directory, unmatched_filenames)
-        return
-    for each_filename in matched_filenames:
-        records.consume_file_intent(session_id, directory, each_filename)
-
-
-def main() -> None:
-    """Read the PreToolUse payload from stdin and block an orphan-file CLAUDE.md."""
-    input_data = read_hook_input_dictionary_from_stdin()
-    if input_data is None:
-        sys.exit(0)
-    tool_name = input_data.get("tool_name", "")
-    if not isinstance(tool_name, str):
-        sys.exit(0)
-    tool_input = input_data.get("tool_input", {})
-    if not isinstance(tool_input, dict):
-        sys.exit(0)
-    if tool_name not in ("Write", "Edit", "MultiEdit"):
-        sys.exit(0)
-    file_path = tool_input.get("file_path", "")
-    if not isinstance(file_path, str) or not is_claude_md_file(file_path):
-        sys.exit(0)
-    claude_md_directory = Path(file_path).resolve().parent
-    if not claude_md_directory.is_dir():
-        sys.exit(0)
-    scan_plan_result = build_orphan_scan_plan(tool_name, tool_input, file_path, claude_md_directory)
-    if not scan_plan_result.candidate_contents:
-        sys.exit(0)
-    missing_filenames = collect_missing_filenames(scan_plan_result, claude_md_directory)
-    if not missing_filenames:
-        sys.exit(0)
-    _emit_orphan_decision(
-        input_data, tool_name, file_path, str(claude_md_directory), missing_filenames
-    )
-    sys.exit(0)
-
-
-if __name__ == "__main__":
-    main()