claude-dev-env 4.2.0 → 4.3.0

package/.agents/skills/test-runner/scripts/test_run_tests.py

@@ -0,0 +1,281 @@
+"""Focused behavior tests for the explicit test runner."""
+
+from __future__ import annotations
+
+import importlib
+import subprocess
+import sys
+from collections.abc import Callable
+from pathlib import Path
+
+import pytest
+
+SCRIPTS_DIRECTORY = Path(__file__).resolve().parent
+if str(SCRIPTS_DIRECTORY) not in sys.path:
+    sys.path.insert(0, str(SCRIPTS_DIRECTORY))
+
+run_tests = importlib.import_module("run_tests")
+
+FRONTEND_COMMANDS = [
+    ["ps", "aux"],
+    ["npm", "run", "build"],
+    ["python", "manage.py", "collectstatic", "--noinput"],
+    [
+        "curl",
+        "-s",
+        "-o",
+        "/dev/null",
+        "-w",
+        "%{http_code}",
+        "--max-time",
+        "2",
+        "http://localhost:3000",
+    ],
+    ["playwright", "test"],
+]
+
+
+def _create_django_project(project_root: Path, *, has_database: bool) -> None:
+    project_root.mkdir()
+    (project_root / "manage.py").write_text(
+        "import sys\n\nif __name__ == '__main__':\n    sys.exit(0)\n",
+        encoding="utf-8",
+    )
+    if has_database:
+        (project_root / "db.sqlite3").write_bytes(b"database")
+
+
+def _completed_process(
+    all_arguments: list[str],
+    return_code: int = 0,
+    stdout_text: str = "",
+) -> subprocess.CompletedProcess[str]:
+    return subprocess.CompletedProcess(
+        args=all_arguments,
+        returncode=return_code,
+        stdout=stdout_text,
+        stderr="",
+    )
+
+
+def _build_recording_process(
+    all_calls: list[tuple[list[str], dict[str, object]]],
+) -> Callable[..., subprocess.CompletedProcess[str]]:
+    def run_process(
+        all_arguments: list[str],
+        **keyword_arguments: object,
+    ) -> subprocess.CompletedProcess[str]:
+        all_calls.append((all_arguments, keyword_arguments))
+        stdout_text = "200" if all_arguments[0] == "curl" else ""
+        return _completed_process(all_arguments, stdout_text=stdout_text)
+
+    return run_process
+
+
+def test_select_runner_recognizes_supported_forms() -> None:
+    assert run_tests.select_runner(["pytest", "tests"]).name == "pytest"
+    assert run_tests.select_runner(["python", "-m", "pytest"]).name == "pytest"
+    assert run_tests.select_runner(["npx", "playwright", "test"]).is_playwright
+
+
+def test_extract_target_url_reads_explicit_base_url() -> None:
+    assert (
+        run_tests.extract_target_url(
+            ["playwright", "test", "--base-url", "http://127.0.0.1:9000"], True
+        )
+        == "http://127.0.0.1:9000"
+    )
+
+
+def test_run_preflight_skips_plain_pytest_without_django(
+    tmp_path: Path,
+) -> None:
+    selected_runner = run_tests.select_runner(["python", "-m", "pytest"])
+    assert (
+        run_tests.run_preflight(selected_runner, tmp_path, ["python", "-m", "pytest"])
+        is None
+    )
+
+
+def test_run_child_process_returns_child_status(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    child_process = _completed_process(["pytest"], return_code=6)
+    monkeypatch.setattr(
+        run_tests.subprocess, "run", lambda *_args, **_kwargs: child_process
+    )
+    assert run_tests.run_child_process(["pytest"], tmp_path) == 6
+
+
+def test_main_runs_plain_pytest_without_django_preflight(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    child_process = _completed_process(["python", "-m", "pytest", "tests"], 7)
+    all_calls: list[dict[str, object]] = []
+
+    def run_child(
+        all_arguments: list[str],
+        **keyword_arguments: object,
+    ) -> subprocess.CompletedProcess[str]:
+        all_calls.append({"arguments": all_arguments, **keyword_arguments})
+        return child_process
+
+    monkeypatch.setattr(run_tests.subprocess, "run", run_child)
+    exit_code = run_tests.main(
+        ["--project", str(tmp_path), "--", "python", "-m", "pytest", "tests"]
+    )
+
+    assert exit_code == 7
+    assert all_calls == [
+        {
+            "arguments": ["python", "-m", "pytest", "tests"],
+            "cwd": tmp_path.resolve(),
+            "check": False,
+        }
+    ]
+
+
+def test_missing_django_database_stops_before_child_launch(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    project_root = tmp_path / "django-project"
+    _create_django_project(project_root, has_database=False)
+    all_calls: list[list[str]] = []
+
+    def record_launch(all_arguments: list[str], **_keyword_arguments: object) -> None:
+        all_calls.append(all_arguments)
+
+    monkeypatch.setattr(run_tests.subprocess, "run", record_launch)
+    exit_code = run_tests.main(
+        ["--project", str(project_root), "--", "python", "-m", "pytest"]
+    )
+
+    assert exit_code != 0
+    assert all_calls == []
+
+
+def test_django_pytest_passes_server_check_and_returns_child_status(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    project_root = tmp_path / "django-project"
+    _create_django_project(project_root, has_database=True)
+    all_calls: list[tuple[list[str], dict[str, object]]] = []
+
+    monkeypatch.setattr(
+        run_tests.subprocess, "run", _build_recording_process(all_calls)
+    )
+    exit_code = run_tests.main(
+        ["--project", str(project_root), "--", "python", "-m", "pytest", "tests"]
+    )
+
+    assert exit_code == 0
+    assert all_calls[-1][0] == ["python", "-m", "pytest", "tests"]
+
+
+def test_playwright_server_failure_stops_before_child_launch(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    (tmp_path / "manage.py").write_text("", encoding="utf-8")
+    all_calls: list[list[str]] = []
+
+    def run_process(
+        all_arguments: list[str],
+        **_keyword_arguments: object,
+    ) -> subprocess.CompletedProcess[str]:
+        all_calls.append(all_arguments)
+        return _completed_process(all_arguments, stdout_text="000")
+
+    monkeypatch.setattr(run_tests.subprocess, "run", run_process)
+    exit_code = run_tests.main(
+        [
+            "--project",
+            str(tmp_path),
+            "--",
+            "npx",
+            "playwright",
+            "test",
+            "--base-url",
+            "http://127.0.0.1:1",
+        ]
+    )
+
+    assert exit_code != 0
+    assert [each_call[0] for each_call in all_calls] == ["ps", "curl"]
+
+
+def test_playwright_missing_test_database_flag_stops_before_health_check(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    (tmp_path / "manage.py").write_text("", encoding="utf-8")
+    process_listing = "python manage.py runserver 8000\n"
+    all_calls: list[list[str]] = []
+
+    def run_process(
+        all_arguments: list[str],
+        **_keyword_arguments: object,
+    ) -> subprocess.CompletedProcess[str]:
+        all_calls.append(all_arguments)
+        return _completed_process(all_arguments, stdout_text=process_listing)
+
+    monkeypatch.setattr(run_tests.subprocess, "run", run_process)
+    exit_code = run_tests.main(
+        [
+            "--project",
+            str(tmp_path),
+            "--",
+            "playwright",
+            "test",
+            "--base-url",
+            "http://localhost:8000",
+        ]
+    )
+
+    assert exit_code != 0
+    assert [each_call[0] for each_call in all_calls] == ["ps"]
+
+
+def test_playwright_builds_frontend_and_collects_static_files(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    project_root = tmp_path / "django-project"
+    _create_django_project(project_root, has_database=True)
+    (project_root / "frontend").mkdir()
+    all_calls: list[tuple[list[str], dict[str, object]]] = []
+    monkeypatch.setattr(run_tests, "check_runserver_port_conflicts", lambda *_: None)
+    monkeypatch.setattr(
+        run_tests.subprocess, "run", _build_recording_process(all_calls)
+    )
+
+    exit_code = run_tests.main(
+        ["--project", str(project_root), "--", "playwright", "test"]
+    )
+
+    assert exit_code == 0
+    assert [each_call[0] for each_call in all_calls] == FRONTEND_COMMANDS
+    assert all_calls[1][1]["cwd"] == project_root / "frontend"
+    assert all_calls[2][1]["cwd"] == project_root.resolve()
+
+
+def test_invalid_runner_does_not_launch_a_child(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    all_calls: list[list[str]] = []
+
+    def record_launch(all_arguments: list[str], **_keyword_arguments: object) -> None:
+        all_calls.append(all_arguments)
+
+    monkeypatch.setattr(run_tests.subprocess, "run", record_launch)
+    exit_code = run_tests.main(
+        ["--project", str(tmp_path), "--", "python", "-m", "unittest"]
+    )
+
+    assert exit_code == 2
+    assert all_calls == []

package/.agents/skills/test-runner/scripts/test_runner_constants/__init__.py

@@ -0,0 +1 @@
+"""Constants package for the test-runner command."""

package/.agents/skills/test-runner/scripts/test_runner_constants/config/__init__.py

@@ -0,0 +1 @@
+"""Configuration package for the test-runner command."""

package/.agents/skills/test-runner/scripts/test_runner_constants/config/constants.py

@@ -0,0 +1,96 @@
+"""Names, messages, and limits used by the test-runner command."""
+
+from __future__ import annotations
+
+import re
+
+DEFAULT_DJANGO_URL: str = "http://localhost:8000"
+DEFAULT_PLAYWRIGHT_URL: str = "http://localhost:3000"
+DJANGO_DATABASE_FILENAME: str = "db.sqlite3"
+MANAGE_PY_FILENAME: str = "manage.py"
+FRONTEND_DIRECTORY_NAME: str = "frontend"
+PYTEST_RUNNER_NAME: str = "pytest"
+PLAYWRIGHT_RUNNER_NAME: str = "playwright"
+PYTHON_MODULE_FLAG: str = "-m"
+PLAYWRIGHT_TEST_SUBCOMMAND: str = "test"
+COMMAND_SEPARATOR: str = "--"
+PROJECT_FLAG: str = "--project"
+BASE_URL_FLAG: str = "--base-url"
+ALL_EXECUTABLE_SUFFIXES: tuple[str, ...] = (".exe", ".cmd", ".bat")
+ARGUMENT_ASSIGNMENT_SEPARATOR: str = "="
+COMMAND_ARGUMENT_SEPARATOR: str = " "
+DIRECTORY_LIST_SEPARATOR: str = ", "
+PWD_ENVIRONMENT_NAME: str = "PWD"
+PYTHON_EXECUTABLE_PREFIX: str = "python"
+PYTEST_EXECUTABLE_PREFIX: str = "pytest"
+PLAYWRIGHT_EXECUTABLE_NAME: str = "playwright"
+NPX_EXECUTABLE_NAME: str = "npx"
+RUNSERVER_COMMAND_NAME: str = "runserver"
+TEST_DATABASE_FLAG: str = "--test-db"
+ALL_RUNSERVER_OPTIONS_WITH_VALUES: frozenset[str] = frozenset(
+    {"--pythonpath", "--settings", "--verbosity"}
+)
+PROCESS_LIST_ARGUMENTS: tuple[str, ...] = ("ps", "aux")
+ALL_PROCESS_INFORMATION_FIELDS: tuple[str, ...] = ("pid", "cmdline", "cwd")
+ALL_FRONTEND_BUILD_ARGUMENTS: tuple[str, ...] = ("npm", "run", "build")
+ALL_COLLECTSTATIC_ARGUMENTS: tuple[str, ...] = (
+    "python",
+    "manage.py",
+    "collectstatic",
+    "--noinput",
+)
+CURL_EXECUTABLE_NAME: str = "curl"
+CURL_SILENT_FLAG: str = "-s"
+CURL_OUTPUT_FLAG: str = "-o"
+CURL_WRITE_OUT_FLAG: str = "-w"
+CURL_STATUS_FORMAT: str = "%{http_code}"
+CURL_MAX_TIME_FLAG: str = "--max-time"
+NULL_DEVICE_PATH: str = "/dev/null"
+ALL_LOCAL_SERVER_HOSTS: frozenset[str] = frozenset(
+    {"localhost", "127.0.0.1", "0.0.0.0"}
+)
+ALL_BLOCKED_STATUS_CODES: frozenset[int] = frozenset({500, 502, 503, 504})
+SERVER_URL_PATTERN: re.Pattern[str] = re.compile(r"https?://[^\s\"']+")
+ALL_URL_TRAILING_PUNCTUATION: str = ".,;:)]}"
+DEFAULT_DJANGO_PORT: str = "8000"
+PROCESS_CURL_TIMEOUT_SECONDS: int = 2
+HEALTH_CHECK_TIMEOUT_SECONDS: int = 3
+BUILD_TIMEOUT_SECONDS: int = 120
+EXIT_CODE_SUCCESS: int = 0
+EXIT_CODE_FAILURE: int = 1
+EXIT_CODE_INVALID_ARGUMENTS: int = 2
+MINIMUM_PLAYWRIGHT_ARGUMENT_COUNT: int = 2
+MINIMUM_NPX_ARGUMENT_COUNT: int = 3
+MINIMUM_PROCESS_ARGUMENT_COUNT: int = 3
+MINIMUM_RUNSERVER_PROCESS_COUNT: int = 2
+RUNSERVER_COMMAND_INDEX: int = 2
+PLAYWRIGHT_TEST_COMMAND_INDEX: int = 2
+ERROR_COMMAND_SEPARATOR_REQUIRED: str = "the child command must follow --"
+ERROR_CHILD_COMMAND_REQUIRED: str = "a supported child test command is required"
+ERROR_UNSUPPORTED_RUNNER: str = "only pytest and playwright test commands are supported"
+ERROR_PREFLIGHT_FAILURE_TEMPLATE: str = "test preflight failed: {}"
+ERROR_PROJECT_NOT_DIRECTORY_TEMPLATE: str = "project is not a directory: {}"
+ERROR_CHILD_LAUNCH_TEMPLATE: str = "test child could not start: {}"
+HEALTH_CHECK_ERROR_TEMPLATE: str = (
+    "BLOCKED: Server at {} is not healthy ({}). Fix the server before running tests."
+)
+UNREACHABLE_ERROR_TEMPLATE: str = (
+    "BLOCKED: Server at {} is unreachable. Start the server before running tests."
+)
+MISSING_DATABASE_ERROR_TEMPLATE: str = (
+    "BLOCKED: No database file ({}) found in {}. Run migrations before running tests."
+)
+FRONTEND_BUILD_FAILED_MESSAGE: str = (
+    "BLOCKED: Frontend build failed. Fix build errors before running e2e tests."
+)
+MISSING_TEST_DATABASE_FLAG_TEMPLATE: str = (
+    "BLOCKED: Django server on port {} is not running with --test-db. Restart "
+    "with: python manage.py runserver --test-db 0.0.0.0:{}"
+)
+PORT_CONFLICT_ERROR_TEMPLATE: str = (
+    "BLOCKED: Multiple Django runserver processes are bound to port {} across "
+    "worktrees: {}. Stop stale servers first."
+)
+PROCESS_LIST_RUNSERVER_TOKEN: str = "runserver"
+PROCESS_LIST_SELF_FILTER_TOKEN: str = "grep"
+UTF8_ENCODING: str = "utf-8"

package/.agents/skills-archived/pr-loop-cloud-transport/reference/identity-and-hooks.md

@@ -26,7 +26,7 @@ Author-keyed logic accounts for the split: a self-PR check keys on the login tha
 
 ## Hooks that still gate a cloud run
 
-The commit and push gates read git commands, which a cloud run still issues through Bash, so they fire normally and the run follows them: `session_edit_stage_gate`, `block_main_commit`, `test_preflight_check`, and the pre-push base-ref check that needs `origin/HEAD` set (SKILL.md Step 2).
+The commit and push gates read git commands, which a cloud run still issues through Bash, so they fire normally and the run follows them: `session_edit_stage_gate`, `block_main_commit`, and the pre-push base-ref check that needs `origin/HEAD` set (SKILL.md Step 2). Run tests through the `test-runner` skill when Django or Playwright readiness checks apply.
 
 ## Hooks that go quiet on the MCP path
 

package/bin/ever-shipped-skills.mjs

@@ -88,6 +88,7 @@ export const EVER_SHIPPED_SKILL_NAMES = new Set([
     'pr-loop-lifecycle',
     'pr-review-responder',
     'pr-scope-resolve',
+    'pull-request',
     'pre-compact',
     'privacy-hygiene',
     'prototype',
@@ -122,6 +123,7 @@ export const EVER_SHIPPED_SKILL_NAMES = new Set([
     'syncing-submodules',
     'task-build',
     'team-advisor',
+    'test-runner',
     'update',
     'usage-pause',
     'verified-build',

package/bin/ever-shipped-skills.test.mjs

@@ -28,3 +28,11 @@ test('EVER_SHIPPED_SKILL_NAMES includes every current shipped skill', () => {
 
     assert.deepEqual(allUncoveredSkillNames, [], 'every current skill must enter the fallback set');
 });
+
+test('EVER_SHIPPED_SKILL_NAMES retains the explicit test runner', () => {
+    assert.ok(EVER_SHIPPED_SKILL_NAMES.has('test-runner'));
+});
+
+test('EVER_SHIPPED_SKILL_NAMES includes the pull request skill', () => {
+    assert.equal(EVER_SHIPPED_SKILL_NAMES.has('pull-request'), true);
+});

package/bin/install.mjs

@@ -172,6 +172,7 @@ export const CORE_SKILLS = [
     'grok-spawn',
     'pr-small-cl',
     'everything-search',
+    'test-runner',
     'privacy-hygiene',
     'issue-tracker',
     'task-build',
@@ -1181,6 +1182,11 @@ export const FOLDED_HOOK_RELATIVE_PATHS = new Set([
     'blocking/pytest_testpaths_orphan_blocker.py',
     'blocking/open_questions_in_plans_blocker.py',
     'blocking/md_to_html_blocker.py',
+    'blocking/gh_body_arg_blocker.py',
+    'blocking/volatile_path_in_post_blocker.py',
+    'blocking/conventional_pr_title_gate.py',
+    'blocking/gh_pr_author_enforcer.py',
+    'blocking/pr_description_writer_gate.py',
     'session/untracked_repo_detector.py',
 ]);
 
@@ -1198,11 +1204,13 @@ export const POST_FOLDED_HOOK_RELATIVE_PATHS = new Set([
     'workflow/auto_formatter.py',
     'workflow/doc_gist_auto_publish.py',
     'workflow/md_to_html_companion.py',
+    'blocking/gh_pr_author_restore.py',
 ]);
 
-/** Hook scripts that still ship but no longer run as registered hooks. */
 export const RETIRED_HOOK_REGISTRATION_RELATIVE_PATHS = new Set([
     'session/untracked_repo_detector.py',
+    'session/gh_pr_author_session_cleanup.py',
+    'observability/pr_description_writer_spawn_tracker.py',
 ]);
 
 /**

package/bin/install.prune.test.mjs

@@ -66,6 +66,41 @@ const NESTED_SKILL_DIRECTORY = 'foo';
 const NESTED_SKILL_FILE_SEGMENTS = [NESTED_SKILL_DIRECTORY, 'scripts', 'a.py'];
 const MYPY_INI_FILE_NAME = '.mypy.ini';
 const SKIPPED_RECORD_SUMMARY_MARKER = 'manifest record(s) skipped';
+const RETIRED_PULL_REQUEST_HOOK_RELATIVE_PATHS = [
+    '_gh_pr_author_swap_utils.py',
+    'test__gh_pr_author_swap_utils.py',
+    'blocking/conventional_pr_title_gate.py',
+    'blocking/gh_body_arg_blocker.py',
+    'blocking/gh_pr_author_enforcer.py',
+    'blocking/gh_pr_author_restore.py',
+    'blocking/pr_description_writer_gate.py',
+    'blocking/test_conventional_pr_title_gate.py',
+    'blocking/test_gh_body_arg_blocker.py',
+    'blocking/test_gh_pr_author_enforcer.py',
+    'blocking/test_gh_pr_author_restore.py',
+    'blocking/test_gh_pr_author_swap_utils.py',
+    'blocking/test_pr_description_writer_gate.py',
+    'blocking/test_volatile_path_in_post_blocker.py',
+    'blocking/volatile_path_in_post_blocker.py',
+    'hooks_constants/conventional_pr_title_gate_constants.py',
+    'hooks_constants/gh_pr_author_swap_constants.py',
+    'hooks_constants/pr_description_writer_gate_constants.py',
+    'hooks_constants/volatile_path_in_post_blocker_constants.py',
+    'observability/pr_description_writer_spawn_tracker.py',
+    'observability/test_pr_description_writer_spawn_tracker.py',
+    'session/gh_pr_author_session_cleanup.py',
+    'session/test_gh_pr_author_session_cleanup.py',
+];
+const RETIRED_PULL_REQUEST_REGISTRATION_PATHS = [
+    'blocking/conventional_pr_title_gate.py',
+    'blocking/gh_body_arg_blocker.py',
+    'blocking/gh_pr_author_enforcer.py',
+    'blocking/gh_pr_author_restore.py',
+    'blocking/pr_description_writer_gate.py',
+    'blocking/volatile_path_in_post_blocker.py',
+    'observability/pr_description_writer_spawn_tracker.py',
+    'session/gh_pr_author_session_cleanup.py',
+];
 
 /**
  * Report whether a path under one managed root landed in a run backup.
@@ -1113,6 +1148,61 @@ test('a full reinstall removes the retired Everything path rewriter and keeps a
     }
 });
 
+test('a full reinstall removes retired pull request hooks and preserves foreign and recovery state', () => {
+    const sandbox = createSandbox();
+    try {
+        runInstaller(sandbox.homeDirectory, []);
+        const retiredPaths = RETIRED_PULL_REQUEST_HOOK_RELATIVE_PATHS.map(relativePath => (
+            join(sandbox.claudeDirectory, HOOKS_DIRECTORY_NAME, ...relativePath.split('/'))
+        ));
+        for (const retiredPath of retiredPaths) {
+            writeFileWithParents(retiredPath, 'an earlier install managed this file\n');
+        }
+        appendManifestFiles(sandbox.manifestPath, retiredPaths);
+        const foreignHookPath = join(
+            sandbox.claudeDirectory, HOOKS_DIRECTORY_NAME, 'blocking', 'foreign_pr_hook.py',
+        );
+        const foreignHookBytes = Buffer.from('a user hook the installer never wrote\n', 'utf8');
+        writeFileWithParents(foreignHookPath, foreignHookBytes);
+        const recoveryStatePath = join(
+            sandbox.homeDirectory, 'pending', 'gh_pr_author_swap_session-a.json',
+        );
+        const recoveryStateBytes = Buffer.from('{"original_account":"prior"}\n', 'utf8');
+        writeFileWithParents(recoveryStatePath, recoveryStateBytes);
+        const settings = readSettings(sandbox.claudeDirectory);
+        settings.hooks.PreToolUse.push({
+            matcher: 'Bash',
+            hooks: [
+                ...RETIRED_PULL_REQUEST_REGISTRATION_PATHS.map(relativePath => ({
+                    type: 'command',
+                    command: `python3 "${join(sandbox.claudeDirectory, HOOKS_DIRECTORY_NAME, ...relativePath.split('/')).replace(/\\/g, '/')}"`,
+                })),
+                { type: 'command', command: `python3 "${foreignHookPath.replace(/\\/g, '/')}"` },
+            ],
+        });
+        writeFileSync(
+            join(sandbox.claudeDirectory, SETTINGS_FILE_NAME),
+            JSON.stringify(settings, null, 4) + '\n',
+        );
+
+        runInstaller(sandbox.homeDirectory, []);
+
+        const freshManifest = readManifest(sandbox.manifestPath);
+        const allCommands = allHookCommands(readSettings(sandbox.claudeDirectory));
+        for (const retiredPath of retiredPaths) {
+            assert.equal(existsSync(retiredPath), false, `${retiredPath} leaves installed hooks`);
+            assert.equal(freshManifest.files.includes(retiredPath), false);
+        }
+        for (const relativePath of RETIRED_PULL_REQUEST_REGISTRATION_PATHS) {
+            assert.ok(allCommands.every(command => !command.includes(relativePath)));
+        }
+        assert.deepEqual(readFileSync(foreignHookPath), foreignHookBytes);
+        assert.deepEqual(readFileSync(recoveryStatePath), recoveryStateBytes);
+    } finally {
+        rmSync(sandbox.homeDirectory, { recursive: true, force: true });
+    }
+});
+
 test('a full reinstall removes a retired hook entry under an event type the current config leaves out', () => {
     const sandbox = createSandbox();
     try {

package/bin/install.test.mjs

@@ -228,6 +228,11 @@ test('CORE_SKILLS ships ELI5 as the leaf presentation skill', () => {
     assert.equal(INSTALL_GROUPS.core.skills.includes('eli5'), true);
 });
 
+test('CORE_SKILLS ships test-runner for explicit Django and Playwright readiness checks', () => {
+    assert.ok(CORE_SKILLS.includes('test-runner'));
+    assert.equal(INSTALL_GROUPS.core.skills.includes('test-runner'), true);
+});
+
 
 test('EVER_SHIPPED_SKILL_NAMES retains imagegen so reinstall prunes the retired skill', () => {
     assert.ok(
@@ -1246,7 +1251,7 @@ const OLD_FOLDED_HOOKS_SETTINGS = {
 
 
 test('FOLDED_HOOK_RELATIVE_PATHS contains folded hooks plus retired entries', () => {
-    assert.equal(FOLDED_HOOK_RELATIVE_PATHS.size, 16);
+    assert.equal(FOLDED_HOOK_RELATIVE_PATHS.size, 21);
     assert.ok(FOLDED_HOOK_RELATIVE_PATHS.has('blocking/write_existing_file_blocker.py'));
     assert.ok(FOLDED_HOOK_RELATIVE_PATHS.has('blocking/code_rules_enforcer.py'));
     assert.ok(FOLDED_HOOK_RELATIVE_PATHS.has('blocking/pytest_testpaths_orphan_blocker.py'));
@@ -1256,16 +1261,22 @@ test('FOLDED_HOOK_RELATIVE_PATHS contains folded hooks plus retired entries', ()
 
 
 test('retired hook registrations stay managed so reinstall removes them', () => {
-    const retiredPath = 'session/untracked_repo_detector.py';
+    const retiredPaths = new Set([
+        'session/untracked_repo_detector.py',
+        'session/gh_pr_author_session_cleanup.py',
+        'observability/pr_description_writer_spawn_tracker.py',
+    ]);
     const shippedHooks = JSON.parse(
         readFileSync(new URL('../hooks/hooks.json', import.meta.url), 'utf8')
     );
     const shippedCommands = Object.values(shippedHooks.hooks).flatMap(matcherGroups => (
         matcherGroups.flatMap(matcherGroup => matcherGroup.hooks.map(hook => hook.command))
     ));
-    assert.deepEqual(RETIRED_HOOK_REGISTRATION_RELATIVE_PATHS, new Set([retiredPath]));
-    assert.ok(managedHookScriptRelativePaths({ hooks: {} }).has(retiredPath));
-    assert.ok(shippedCommands.every(command => !command.includes(retiredPath)));
+    assert.deepEqual(RETIRED_HOOK_REGISTRATION_RELATIVE_PATHS, retiredPaths);
+    for (const retiredPath of retiredPaths) {
+        assert.ok(managedHookScriptRelativePaths({ hooks: {} }).has(retiredPath));
+        assert.ok(shippedCommands.every(command => !command.includes(retiredPath)));
+    }
 });
 
 
@@ -1288,6 +1299,11 @@ test('FOLDED_HOOK_RELATIVE_PATHS lists every hook the PreToolUse dispatcher host
     ];
     const retiredHooks = [
         'blocking/md_to_html_blocker.py',
+        'blocking/gh_body_arg_blocker.py',
+        'blocking/volatile_path_in_post_blocker.py',
+        'blocking/conventional_pr_title_gate.py',
+        'blocking/gh_pr_author_enforcer.py',
+        'blocking/pr_description_writer_gate.py',
         'session/untracked_repo_detector.py',
     ];
     for (const hostedPath of dispatcherHostedHooks) {
@@ -1480,12 +1496,13 @@ const OLD_POST_FOLDED_HOOKS_SETTINGS = {
 };
 
 
-test('POST_FOLDED_HOOK_RELATIVE_PATHS contains the after-write hooks and the retired md_to_html_companion', () => {
-    assert.equal(POST_FOLDED_HOOK_RELATIVE_PATHS.size, 4);
+test('POST_FOLDED_HOOK_RELATIVE_PATHS contains hosted and retired post-tool hooks', () => {
+    assert.equal(POST_FOLDED_HOOK_RELATIVE_PATHS.size, 5);
     assert.ok(POST_FOLDED_HOOK_RELATIVE_PATHS.has('validation/mypy_validator.py'));
     assert.ok(POST_FOLDED_HOOK_RELATIVE_PATHS.has('workflow/auto_formatter.py'));
     assert.ok(POST_FOLDED_HOOK_RELATIVE_PATHS.has('workflow/doc_gist_auto_publish.py'));
     assert.ok(POST_FOLDED_HOOK_RELATIVE_PATHS.has('workflow/md_to_html_companion.py'));
+    assert.ok(POST_FOLDED_HOOK_RELATIVE_PATHS.has('blocking/gh_pr_author_restore.py'));
 });