claude-dev-env 4.3.0 → 7.0.0

package/hooks/advisory/test_pr_done_reminder.py

@@ -0,0 +1,249 @@
+"""Behavior tests for the PR done-checklist context reminder.
+
+The hook is a PostToolUse observer on Bash. It never blocks. These tests pin
+three things: which commands wake it, what the checklist says for each live
+PR state, and that a probe failure stays quiet. The ``gh`` probe is faked at
+the subprocess boundary so no test touches the network.
+"""
+
+from __future__ import annotations
+
+import io
+import json
+import subprocess
+import sys
+from pathlib import Path
+
+import pytest
+
+try:
+    advisory_directory = str(Path(__file__).resolve().parent)
+    if advisory_directory not in sys.path:
+        sys.path.insert(0, advisory_directory)
+    import pr_done_reminder
+except ImportError as import_error:
+    raise ImportError(
+        "test_pr_done_reminder: cannot import its sibling modules; "
+        "ensure the advisory directory is importable."
+    ) from import_error
+
+
+_CLEAN_PR_OBJECT: dict[str, object] = {
+    "number": 42,
+    "url": "https://github.com/acme/widgets/pull/42",
+    "isDraft": True,
+    "mergeable": "MERGEABLE",
+    "mergeStateStatus": "CLEAN",
+    "statusCheckRollup": [
+        {"name": "pytest", "status": "COMPLETED", "conclusion": "SUCCESS"},
+        {"context": "lint", "state": "SUCCESS"},
+    ],
+    "labels": [],
+}
+
+
+def _payload(command: str, tool_response: object = None) -> str:
+    response: object = {"stdout": "", "stderr": ""} if tool_response is None else tool_response
+    return json.dumps(
+        {
+            "session_id": "reminder-session",
+            "cwd": "C:/repo",
+            "tool_name": "Bash",
+            "tool_input": {"command": command},
+            "tool_response": response,
+        }
+    )
+
+
+def _fake_gh(pr_object: dict[str, object] | None, stderr: str = "") -> object:
+    def _run(*args: object, **kwargs: object) -> subprocess.CompletedProcess[str]:
+        del args, kwargs
+        if pr_object is None:
+            return subprocess.CompletedProcess([], 1, stdout="", stderr=stderr)
+        return subprocess.CompletedProcess([], 0, stdout=json.dumps(pr_object), stderr="")
+
+    return _run
+
+
+def _run_main(
+    monkeypatch: pytest.MonkeyPatch,
+    capsys: pytest.CaptureFixture[str],
+    payload_text: str,
+    fake_gh: object,
+) -> str:
+    monkeypatch.setattr(pr_done_reminder.subprocess, "run", fake_gh)
+    monkeypatch.setattr(sys, "stdin", io.StringIO(payload_text))
+    pr_done_reminder.main()
+    return capsys.readouterr().out
+
+
+def _additional_context(stdout_text: str) -> str:
+    return str(json.loads(stdout_text)["hookSpecificOutput"]["additionalContext"])
+
+
+@pytest.mark.parametrize(
+    "command",
+    [
+        "git push",
+        "git push -u origin feat/x",
+        "git -C C:/repo push origin HEAD",
+        "gh pr create --draft --title t --body-file b.md",
+        "git add -A && git commit -F m.txt && git push",
+        "git -c push.default=current push",
+        "git --git-dir=C:/repo/.git push",
+        'pwsh -NoProfile -Command "git push -u origin feat/x"',
+        "pwsh -NoProfile -Command 'gh pr create --draft --fill'",
+        'powershell -Command "git add -A; git push"',
+    ],
+)
+def test_should_wake_on_git_push_and_gh_pr_create(command: str) -> None:
+    assert pr_done_reminder.command_triggers_reminder(command) is True
+
+
+@pytest.mark.parametrize(
+    "command",
+    [
+        "git status",
+        "git pull",
+        "git stash push -u -q -- packages",
+        "git log --grep push",
+        "git commit -m push",
+        "gh pr view 42",
+        "gh pr ready --undo",
+        "echo git push",
+        'pwsh -NoProfile -Command "git status"',
+        "pytest tests/",
+    ],
+)
+def test_should_stay_quiet_for_other_commands(command: str) -> None:
+    assert pr_done_reminder.command_triggers_reminder(command) is False
+
+
+def test_should_say_done_when_mergeable_and_checks_pass() -> None:
+    context = pr_done_reminder.build_reminder_context(_CLEAN_PR_OBJECT)
+
+    assert context.startswith("=== PR DONE CHECKLIST")
+    assert "never a block" in context
+    assert "DONE. Add the label now:" in context
+    assert "gh pr edit 42 --add-label done" in context
+    assert "NOT DONE" not in context
+
+
+def test_should_keep_the_checklist_order_verdict_then_recheck_then_footer() -> None:
+    all_lines = pr_done_reminder.build_reminder_context(_CLEAN_PR_OBJECT).split("\n")
+
+    all_labels = [each_line.split(":")[0] for each_line in all_lines[1:-1]]
+    assert all_labels == [
+        "PR #42  https",
+        "Mergeable",
+        "CI checks",
+        "Draft",
+        "Label done",
+        "Verdict",
+        "Add label",
+        "Re-check",
+    ]
+    assert all_lines[-1] == "A PR is done only when every line above is clean."
+
+
+def test_should_say_not_done_and_name_the_conflict_fix() -> None:
+    conflicted = {**_CLEAN_PR_OBJECT, "mergeable": "CONFLICTING", "mergeStateStatus": "DIRTY"}
+
+    context = pr_done_reminder.build_reminder_context(conflicted)
+
+    assert "NOT DONE" in context
+    assert "CONFLICTS with the base branch" in context
+    assert "gh pr view 42 --json mergeable" in context
+    assert "gh pr edit 42 --add-label" not in context
+
+
+def test_should_count_failing_and_pending_checks() -> None:
+    mixed_checks = {
+        **_CLEAN_PR_OBJECT,
+        "statusCheckRollup": [
+            {"name": "pytest", "status": "COMPLETED", "conclusion": "FAILURE"},
+            {"name": "mypy", "status": "IN_PROGRESS", "conclusion": ""},
+            {"context": "lint", "state": "PENDING"},
+            {"context": "docs", "state": "SUCCESS"},
+        ],
+    }
+
+    context = pr_done_reminder.build_reminder_context(mixed_checks)
+
+    assert "1 failing" in context
+    assert "2 pending" in context
+    assert "4 total" in context
+    assert "NOT DONE" in context
+
+
+def test_should_tell_the_agent_to_wait_when_github_is_still_computing() -> None:
+    unknown = {**_CLEAN_PR_OBJECT, "mergeable": "UNKNOWN", "mergeStateStatus": "UNKNOWN"}
+
+    context = pr_done_reminder.build_reminder_context(unknown)
+
+    assert "still computing" in context
+    assert "NOT DONE" in context
+
+
+def test_should_report_the_done_label_when_already_set() -> None:
+    labeled = {**_CLEAN_PR_OBJECT, "labels": [{"name": "done"}]}
+
+    context = pr_done_reminder.build_reminder_context(labeled)
+
+    assert "Label done:  set" in context
+
+
+def test_main_should_emit_additional_context_after_a_successful_push(
+    monkeypatch: pytest.MonkeyPatch, capsys: pytest.CaptureFixture[str]
+) -> None:
+    stdout_text = _run_main(monkeypatch, capsys, _payload("git push"), _fake_gh(_CLEAN_PR_OBJECT))
+
+    payload = json.loads(stdout_text)
+    assert payload["hookSpecificOutput"]["hookEventName"] == "PostToolUse"
+    assert "permissionDecision" not in payload["hookSpecificOutput"]
+    assert "decision" not in payload
+    assert "PR #42" in _additional_context(stdout_text)
+
+
+def test_main_should_also_serve_the_powershell_tool(
+    monkeypatch: pytest.MonkeyPatch, capsys: pytest.CaptureFixture[str]
+) -> None:
+    payload = json.loads(_payload("git push"))
+    payload["tool_name"] = "PowerShell"
+
+    stdout_text = _run_main(monkeypatch, capsys, json.dumps(payload), _fake_gh(_CLEAN_PR_OBJECT))
+
+    assert "PR #42" in _additional_context(stdout_text)
+
+
+def test_main_should_stay_quiet_when_the_push_failed(
+    monkeypatch: pytest.MonkeyPatch, capsys: pytest.CaptureFixture[str]
+) -> None:
+    failed_push = _payload("git push", "Error: Exit code 1\nrejected")
+
+    assert _run_main(monkeypatch, capsys, failed_push, _fake_gh(_CLEAN_PR_OBJECT)) == ""
+
+
+def test_main_should_stay_quiet_for_a_non_trigger_command(
+    monkeypatch: pytest.MonkeyPatch, capsys: pytest.CaptureFixture[str]
+) -> None:
+    assert _run_main(monkeypatch, capsys, _payload("git status"), _fake_gh(_CLEAN_PR_OBJECT)) == ""
+
+
+def test_main_should_remind_to_open_a_pr_when_the_branch_has_none(
+    monkeypatch: pytest.MonkeyPatch, capsys: pytest.CaptureFixture[str]
+) -> None:
+    no_pr = _fake_gh(None, stderr='no pull requests found for branch "feat/x"')
+
+    context = _additional_context(_run_main(monkeypatch, capsys, _payload("git push"), no_pr))
+
+    assert "No open pull request found" in context
+    assert "gh pr create --draft" in context
+
+
+def test_main_should_stay_quiet_on_any_other_gh_failure(
+    monkeypatch: pytest.MonkeyPatch, capsys: pytest.CaptureFixture[str]
+) -> None:
+    gh_down = _fake_gh(None, stderr="error connecting to api.github.com")
+
+    assert _run_main(monkeypatch, capsys, _payload("git push"), gh_down) == ""

package/hooks/blocking/bash_post_call_dispatcher.py

@@ -14,9 +14,11 @@ collision, and needs no change to that shared, out-of-scope test file.
 Reads the tool payload from stdin once, selects the hosted hooks applicable to
 the payload's tool name, and runs each one in-process via the shared
 hosted-hook runner. A hosted PostToolUse hook here carries no permission
-decision -- it is a side-effecting observer, not a gate -- so this dispatcher
-runs the whole roster unconditionally and emits nothing itself, matching every
-hosted hook's own empty-stdout contract.
+decision -- it is an observer, not a gate -- so this dispatcher runs the whole
+roster unconditionally and never blocks. The one thing it forwards is context:
+a hosted hook may print a ``hookSpecificOutput.additionalContext`` string (the
+PR done reminder does), and the dispatcher joins every such string into one
+PostToolUse payload. A hook that prints nothing adds nothing.
 
 A single hosted hook crash fails open: ``run_hook_capturing_output`` isolates
 it, so it contributes nothing and does not stop the remaining hosted hooks.
@@ -27,11 +29,17 @@ imports load once into this process rather than once per hook.
 
 from __future__ import annotations
 
+import json
+import sys
 
 import _path_setup  # noqa: F401
 
 from hooks_constants.bash_post_call_dispatcher_constants import (
+    ADDITIONAL_CONTEXT_JOIN_SEPARATOR,
+    ADDITIONAL_CONTEXT_KEY,
     ALL_BASH_POST_TOOL_USE_HOSTED_HOOK_ENTRIES,
+    HOOK_SPECIFIC_OUTPUT_KEY,
+    POST_TOOL_USE_HOOK_EVENT_NAME,
 )
 from hooks_constants.bash_pre_tool_use_dispatcher_constants import BashHostedHookEntry
 from hooks_constants.hosted_hook_runner import (
@@ -50,15 +58,54 @@ def select_applicable_entries(tool_name: str) -> list[BashHostedHookEntry]:
     ]
 
 
+def additional_context_from_hook_output(captured_stdout: str) -> str | None:
+    """Return the additionalContext string a hosted hook printed, or None.
+
+    Empty output, non-JSON output, and JSON without a non-empty
+    ``hookSpecificOutput.additionalContext`` string all return None.
+    """
+    if not captured_stdout.strip():
+        return None
+    try:
+        hook_output = json.loads(captured_stdout)
+    except json.JSONDecodeError:
+        return None
+    if not isinstance(hook_output, dict):
+        return None
+    hook_specific_output = hook_output.get(HOOK_SPECIFIC_OUTPUT_KEY)
+    if not isinstance(hook_specific_output, dict):
+        return None
+    additional_context = hook_specific_output.get(ADDITIONAL_CONTEXT_KEY)
+    if not isinstance(additional_context, str) or not additional_context.strip():
+        return None
+    return additional_context
+
+
 def dispatch(payload_text: str, tool_name: str) -> None:
-    """Run every hosted hook applicable to tool_name, in registration order.
+    """Run every hosted hook applicable to tool_name, then forward their context.
 
     Each hosted hook's crash is isolated by ``run_hook_capturing_output``, so
-    one hook failing never stops a later one in the same roster.
+    one hook failing never stops a later one in the same roster. Every
+    additionalContext string the hooks printed is joined into one PostToolUse
+    payload on stdout; when no hook printed one, nothing is written.
     """
+    all_additional_context: list[str] = []
     for each_entry in select_applicable_entries(tool_name):
         script_path = resolved_hook_script_path(each_entry.script_relative_path)
-        run_hook_capturing_output(script_path, payload_text)
+        hook_run = run_hook_capturing_output(script_path, payload_text)
+        additional_context = additional_context_from_hook_output(hook_run.captured_stdout)
+        if additional_context is not None:
+            all_additional_context.append(additional_context)
+    if not all_additional_context:
+        return
+    payload = {
+        HOOK_SPECIFIC_OUTPUT_KEY: {
+            "hookEventName": POST_TOOL_USE_HOOK_EVENT_NAME,
+            ADDITIONAL_CONTEXT_KEY: ADDITIONAL_CONTEXT_JOIN_SEPARATOR.join(all_additional_context),
+        }
+    }
+    sys.stdout.write(json.dumps(payload))
+    sys.stdout.flush()
 
 
 def main() -> None:

package/hooks/blocking/code_rules_paired_test.py

@@ -215,12 +215,27 @@ def _collect_referenced_identifiers(source: str) -> set[str]:
     return all_referenced_identifiers
 
 
+def _sibling_test_paths(stem_test_path: Path) -> list[Path]:
+    """Return the capped, sorted test files beside the stem test, stem excluded."""
+    suite_directory = stem_test_path.parent
+    stem_path_key = os.path.normcase(str(stem_test_path.resolve()))
+    all_sibling_paths: list[Path] = []
+    for each_glob in ALL_TEST_FILENAME_GLOBS:
+        all_sibling_paths.extend(
+            each_path
+            for each_path in sorted(suite_directory.glob(each_glob))
+            if os.path.normcase(str(each_path.resolve())) != stem_path_key
+        )
+    return all_sibling_paths[:MAX_TEST_FILES_SCANNED]
+
+
 def _suite_referenced_identifiers(stem_test_path: Path) -> set[str]:
     """Return identifiers referenced across every test file beside the stem test.
 
-    Scans every ``test_*.py`` and ``*_test.py`` file in the directory holding the
-    stem-matched test file, bounded by the scan cap, and unions the identifiers
-    each one references.
+    Reads the stem-matched test file first, then scans every other ``test_*.py``
+    and ``*_test.py`` file in its directory, bounded by the scan cap, and unions
+    the identifiers each one references. The stem test always counts, so a
+    directory with more test files than the cap cannot hide it.
 
     Args:
         stem_test_path: The stem-matched test file whose directory is scanned.
@@ -228,12 +243,9 @@ def _suite_referenced_identifiers(stem_test_path: Path) -> set[str]:
     Returns:
         The union of referenced identifiers across the scanned test files.
     """
-    suite_directory = stem_test_path.parent
-    all_test_file_paths: list[Path] = []
-    for each_glob in ALL_TEST_FILENAME_GLOBS:
-        all_test_file_paths.extend(sorted(suite_directory.glob(each_glob)))
+    all_test_file_paths = [stem_test_path, *_sibling_test_paths(stem_test_path)]
     all_referenced_identifiers: set[str] = set()
-    for each_test_file_path in all_test_file_paths[:MAX_TEST_FILES_SCANNED]:
+    for each_test_file_path in all_test_file_paths:
         try:
             test_source = each_test_file_path.read_text(encoding="utf-8")
         except (OSError, UnicodeDecodeError):
@@ -364,16 +376,12 @@ def _production_stem_from_test_filename(test_filename: str) -> str | None:
     if test_filename.startswith(STEM_TEST_FILENAME_PREFIX) and test_filename.endswith(
         PYTHON_SOURCE_SUFFIX
     ):
-        production_stem = test_filename[
-            len(STEM_TEST_FILENAME_PREFIX) : -len(PYTHON_SOURCE_SUFFIX)
-        ]
+        production_stem = test_filename[len(STEM_TEST_FILENAME_PREFIX) : -len(PYTHON_SOURCE_SUFFIX)]
         return production_stem or None
     return None
 
 
-def _paired_production_module_path(
-    test_path: Path, production_stem: str
-) -> Path | None:
+def _paired_production_module_path(test_path: Path, production_stem: str) -> Path | None:
     """Return the production module a stem-matched test file pairs with, or None.
 
     Mirrors ``_stem_matched_test_path`` in reverse for the two common layouts: a
@@ -515,4 +523,3 @@ def check_test_file_omits_module_public_function(
         if len(all_omission_violations) >= MAX_PAIRED_TEST_COVERAGE_ISSUES:
             break
     return all_omission_violations
-

package/hooks/blocking/test_bash_post_call_dispatcher.py

@@ -15,16 +15,26 @@ from pathlib import Path
 
 import pytest
 
-from bash_post_call_dispatcher import dispatch, main, select_applicable_entries
+from bash_post_call_dispatcher import (
+    additional_context_from_hook_output,
+    dispatch,
+    main,
+    select_applicable_entries,
+)
 from hooks_constants.bash_pre_tool_use_dispatcher_constants import BASH_TOOL_NAME
 from hooks_constants.hosted_hook_runner import HostedHookRun
 from tdd_enforcer_parts import content_hash_store
 
+_ALL_EXPECTED_ROSTER_PATHS = [
+    "observability/test_failure_recorder.py",
+    "advisory/pr_done_reminder.py",
+]
 
-def test_select_applicable_entries_returns_the_hosted_hook_for_bash() -> None:
+
+def test_select_applicable_entries_returns_the_hosted_hooks_for_bash() -> None:
     all_entries = select_applicable_entries(BASH_TOOL_NAME)
     all_script_paths = [each_entry.script_relative_path for each_entry in all_entries]
-    assert all_script_paths == ["observability/test_failure_recorder.py"]
+    assert all_script_paths == _ALL_EXPECTED_ROSTER_PATHS
 
 
 def test_select_applicable_entries_returns_none_for_a_write_tool() -> None:
@@ -45,7 +55,58 @@ def test_dispatch_runs_every_hosted_hook_in_roster_order(
 
     dispatch('{"tool_name": "Bash"}', BASH_TOOL_NAME)
 
-    assert all_call_paths == ["test_failure_recorder.py"]
+    assert all_call_paths == [Path(each_path).name for each_path in _ALL_EXPECTED_ROSTER_PATHS]
+
+
+def test_dispatch_forwards_hosted_hook_additional_context_as_one_payload(
+    monkeypatch: pytest.MonkeyPatch, capsys: pytest.CaptureFixture[str]
+) -> None:
+    context_by_hook = {
+        "test_failure_recorder.py": "",
+        "pr_done_reminder.py": json.dumps(
+            {"hookSpecificOutput": {"hookEventName": "PostToolUse", "additionalContext": "PR #42"}}
+        ),
+    }
+
+    def _fake_run_hook(script_path: str, payload_text: str) -> HostedHookRun:
+        del payload_text
+        return HostedHookRun(
+            captured_stdout=context_by_hook[Path(script_path).name], did_crash=False
+        )
+
+    monkeypatch.setattr("bash_post_call_dispatcher.run_hook_capturing_output", _fake_run_hook)
+
+    dispatch('{"tool_name": "Bash"}', BASH_TOOL_NAME)
+
+    emitted = json.loads(capsys.readouterr().out)
+    assert emitted == {
+        "hookSpecificOutput": {"hookEventName": "PostToolUse", "additionalContext": "PR #42"}
+    }
+    assert "decision" not in emitted
+
+
+def test_dispatch_writes_nothing_when_no_hosted_hook_printed_context(
+    monkeypatch: pytest.MonkeyPatch, capsys: pytest.CaptureFixture[str]
+) -> None:
+    def _fake_run_hook(script_path: str, payload_text: str) -> HostedHookRun:
+        del script_path, payload_text
+        return HostedHookRun(captured_stdout="", did_crash=False)
+
+    monkeypatch.setattr("bash_post_call_dispatcher.run_hook_capturing_output", _fake_run_hook)
+
+    dispatch('{"tool_name": "Bash"}', BASH_TOOL_NAME)
+
+    assert capsys.readouterr().out == ""
+
+
+@pytest.mark.parametrize(
+    "captured_stdout",
+    ["", "   ", "not json", "[]", '{"decision": "block"}', '{"hookSpecificOutput": {}}'],
+)
+def test_additional_context_from_hook_output_ignores_non_context_output(
+    captured_stdout: str,
+) -> None:
+    assert additional_context_from_hook_output(captured_stdout) is None
 
 
 def test_main_exits_zero_and_writes_nothing_to_stdout(

package/hooks/blocking/test_code_rules_enforcer_paired_test.py

@@ -19,6 +19,10 @@ _BLOCKING_DIRECTORY = Path(__file__).resolve().parent
 if str(_BLOCKING_DIRECTORY) not in sys.path:
     sys.path.insert(0, str(_BLOCKING_DIRECTORY))
 
+from hooks_constants.paired_test_coverage_constants import (  # noqa: E402
+    MAX_TEST_FILES_SCANNED,
+)
+
 from code_rules_paired_test import (  # noqa: E402
     check_public_function_missing_paired_test,
     check_test_file_omits_module_public_function,
@@ -26,9 +30,7 @@ from code_rules_paired_test import (  # noqa: E402
 
 _TWO_PUBLIC_FUNCTIONS = "def alpha():\n    return 1\n\n\ndef beta():\n    return 2\n"
 _THREE_PUBLIC_FUNCTIONS = (
-    "def alpha():\n    return 1\n\n\n"
-    "def beta():\n    return 2\n\n\n"
-    "def gamma():\n    return 3\n"
+    "def alpha():\n    return 1\n\n\ndef beta():\n    return 2\n\n\ndef gamma():\n    return 3\n"
 )
 
 
@@ -145,6 +147,28 @@ def test_counts_coverage_across_sibling_test_files(
     assert all_issues == []
 
 
+def test_reads_the_stem_test_when_the_suite_exceeds_the_scan_cap(
+    neutral_package_directory: Path,
+) -> None:
+    filler_body = "def test_nothing():\n    assert True\n"
+    _write_test_file(
+        neutral_package_directory,
+        "test_a0000.py",
+        "from pkg.mod import alpha\n\ndef test_alpha():\n    assert alpha() == 1\n",
+    )
+    for each_index in range(1, MAX_TEST_FILES_SCANNED + 1):
+        _write_test_file(neutral_package_directory, f"test_a{each_index:04d}.py", filler_body)
+    _write_test_file(
+        neutral_package_directory,
+        "test_mod.py",
+        "from pkg.mod import beta\n\ndef test_beta():\n    assert beta() == 2\n",
+    )
+    all_issues = check_public_function_missing_paired_test(
+        _TWO_PUBLIC_FUNCTIONS, str(neutral_package_directory / "mod.py")
+    )
+    assert all_issues == []
+
+
 def test_main_and_private_functions_are_never_required(
     neutral_package_directory: Path,
 ) -> None:
@@ -183,8 +207,7 @@ def _write_module(package_directory: Path, body: str) -> None:
 
 
 _SUITE_COVERS_ALPHA_BETA = (
-    "from pkg.mod import alpha, beta\n\n"
-    "def test_pair():\n    assert alpha() == 1 and beta() == 2\n"
+    "from pkg.mod import alpha, beta\n\ndef test_pair():\n    assert alpha() == 1 and beta() == 2\n"
 )
 
 
@@ -193,9 +216,7 @@ def test_flags_module_public_function_when_test_suite_omits_it(
 ) -> None:
     _write_module(neutral_package_directory, _THREE_PUBLIC_FUNCTIONS)
     test_path = str(neutral_package_directory / "tests" / "test_mod.py")
-    all_issues = check_test_file_omits_module_public_function(
-        _SUITE_COVERS_ALPHA_BETA, test_path
-    )
+    all_issues = check_test_file_omits_module_public_function(_SUITE_COVERS_ALPHA_BETA, test_path)
     assert len(all_issues) == 1
     assert "gamma" in all_issues[0]
     assert "mod.py" in all_issues[0]
@@ -231,9 +252,7 @@ def test_skips_test_file_with_no_paired_production_module(
     neutral_package_directory: Path,
 ) -> None:
     test_path = str(neutral_package_directory / "tests" / "test_mod.py")
-    all_issues = check_test_file_omits_module_public_function(
-        _SUITE_COVERS_ALPHA_BETA, test_path
-    )
+    all_issues = check_test_file_omits_module_public_function(_SUITE_COVERS_ALPHA_BETA, test_path)
     assert all_issues == []
 
 
@@ -242,9 +261,7 @@ def test_ignores_a_non_stem_matched_written_file(
 ) -> None:
     _write_module(neutral_package_directory, _THREE_PUBLIC_FUNCTIONS)
     helper_path = str(neutral_package_directory / "helper.py")
-    all_issues = check_test_file_omits_module_public_function(
-        _SUITE_COVERS_ALPHA_BETA, helper_path
-    )
+    all_issues = check_test_file_omits_module_public_function(_SUITE_COVERS_ALPHA_BETA, helper_path)
     assert all_issues == []
 
 
@@ -274,9 +291,7 @@ def test_judges_post_edit_content_over_stale_on_disk_test(
         "from pkg.mod import alpha, beta, gamma\n\n"
         "def test_all():\n    assert alpha() and beta() and gamma()\n"
     )
-    all_issues = check_test_file_omits_module_public_function(
-        post_edit_covers_all, test_path
-    )
+    all_issues = check_test_file_omits_module_public_function(post_edit_covers_all, test_path)
     assert all_issues == []
 
 
@@ -290,9 +305,7 @@ def test_counts_coverage_across_sibling_test_files_on_test_write(
         "from pkg.mod import gamma\n\ndef test_gamma():\n    assert gamma() == 3\n",
     )
     test_path = str(neutral_package_directory / "tests" / "test_mod.py")
-    all_issues = check_test_file_omits_module_public_function(
-        _SUITE_COVERS_ALPHA_BETA, test_path
-    )
+    all_issues = check_test_file_omits_module_public_function(_SUITE_COVERS_ALPHA_BETA, test_path)
     assert all_issues == []
 
 
@@ -301,9 +314,7 @@ def test_test_side_message_names_module_and_function_without_line_prefix(
 ) -> None:
     _write_module(neutral_package_directory, _THREE_PUBLIC_FUNCTIONS)
     test_path = str(neutral_package_directory / "tests" / "test_mod.py")
-    all_issues = check_test_file_omits_module_public_function(
-        _SUITE_COVERS_ALPHA_BETA, test_path
-    )
+    all_issues = check_test_file_omits_module_public_function(_SUITE_COVERS_ALPHA_BETA, test_path)
     assert len(all_issues) == 1
     assert not all_issues[0].startswith("Line ")
     assert "mod.py" in all_issues[0]
@@ -315,9 +326,7 @@ def test_test_side_omission_blocks_on_any_test_file_edit(
 ) -> None:
     _write_module(neutral_package_directory, _THREE_PUBLIC_FUNCTIONS)
     test_path = str(neutral_package_directory / "tests" / "test_mod.py")
-    all_issues = check_test_file_omits_module_public_function(
-        _SUITE_COVERS_ALPHA_BETA, test_path
-    )
+    all_issues = check_test_file_omits_module_public_function(_SUITE_COVERS_ALPHA_BETA, test_path)
     assert len(all_issues) == 1
     assert "gamma" in all_issues[0]
 
@@ -333,7 +342,5 @@ def test_skips_when_paired_production_module_is_exempt(
         "from pkg import alpha, beta, gamma\n\n"
         "def test_all():\n    assert alpha() and beta() and gamma()\n"
     )
-    all_issues = check_test_file_omits_module_public_function(
-        suite_covers_all, beside_test_path
-    )
+    all_issues = check_test_file_omits_module_public_function(suite_covers_all, beside_test_path)
     assert all_issues == []

package/hooks/blocking/test_code_rules_js_resume_task_enumeration.py

@@ -17,8 +17,8 @@ import pathlib
 import sys
 
 _PACKAGE_ROOT = pathlib.Path(__file__).resolve().parents[2]
-_SHIPPED_CONVERGE_MJS = (
-    _PACKAGE_ROOT / ".agents" / "skills" / "autoconverge" / "workflow" / "converge.mjs"
+_ARCHIVED_CONVERGE_MJS = (
+    _PACKAGE_ROOT.parents[1] / "skill-archive" / "autoconverge" / "workflow" / "converge.mjs"
 )
 
 _HOOK_DIRECTORY = pathlib.Path(__file__).parent
@@ -750,8 +750,8 @@ def should_still_flag_real_dispatch_alongside_task_substring_identifier() -> Non
     assert "spawnVerifierAgent" in issues[0]
 
 
-def should_not_flag_shipped_converge_workflow() -> None:
-    converge_source = _SHIPPED_CONVERGE_MJS.read_text(encoding="utf-8")
+def should_not_flag_archived_converge_regression_fixture() -> None:
+    converge_source = _ARCHIVED_CONVERGE_MJS.read_text(encoding="utf-8")
     issues = check_js_resume_task_enumeration_coverage(
         converge_source, "skills/autoconverge/workflow/converge.mjs"
     )