claude-dev-env 4.1.0 → 4.3.0

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

@@ -0,0 +1,185 @@
+"""Focused tests for explicit test-runner preflight helpers."""
+
+from __future__ import annotations
+
+import importlib
+import subprocess
+import sys
+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))
+
+preflight_checks = importlib.import_module("preflight_checks")
+
+
+def test_check_server_health_reports_unhealthy_response(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    completed_process = subprocess.CompletedProcess(
+        args=["curl"], returncode=0, stdout="503", stderr=""
+    )
+    monkeypatch.setattr(
+        preflight_checks.subprocess,
+        "run",
+        lambda *_arguments, **_keywords: completed_process,
+    )
+
+    assert preflight_checks.check_server_health("http://localhost:3000") == (
+        "BLOCKED: Server at http://localhost:3000 is not healthy (HTTP 503). "
+        "Fix the server before running tests."
+    )
+
+
+def test_check_django_database_requires_db_sqlite3(tmp_path: Path) -> None:
+    (tmp_path / "manage.py").write_text("", encoding="utf-8")
+
+    assert preflight_checks.check_django_database(tmp_path) == (
+        f"BLOCKED: No database file (db.sqlite3) found in {tmp_path}. "
+        "Run migrations before running tests."
+    )
+
+
+def test_extract_port_from_url_uses_explicit_or_default_port() -> None:
+    assert preflight_checks.extract_port_from_url("http://localhost:9000") == "9000"
+    assert preflight_checks.extract_port_from_url("http://localhost") == "8000"
+
+
+def test_check_test_db_flag_requires_detected_server_flag(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    (tmp_path / "manage.py").write_text("", encoding="utf-8")
+    monkeypatch.setattr(
+        preflight_checks,
+        "_read_process_listing",
+        lambda: "python manage.py runserver",
+    )
+
+    assert preflight_checks.check_test_db_flag("http://localhost:8000", tmp_path) == (
+        "BLOCKED: Django server on port 8000 is not running with --test-db. "
+        "Restart with: python manage.py runserver --test-db 0.0.0.0:8000"
+    )
+
+
+def test_check_test_db_flag_ignores_test_database_flag_on_another_port(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    (tmp_path / "manage.py").write_text("", encoding="utf-8")
+    monkeypatch.setattr(
+        preflight_checks,
+        "_read_process_listing",
+        lambda: (
+            "python manage.py runserver --test-db 9000\n8000 python manage.py runserver"
+        ),
+    )
+
+    assert preflight_checks.check_test_db_flag("http://localhost:8000", tmp_path) == (
+        "BLOCKED: Django server on port 8000 is not running with --test-db. "
+        "Restart with: python manage.py runserver --test-db 0.0.0.0:8000"
+    )
+
+
+def test_check_test_db_flag_skips_value_taking_runserver_options(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    (tmp_path / "manage.py").write_text("", encoding="utf-8")
+    monkeypatch.setattr(
+        preflight_checks,
+        "_read_process_listing",
+        lambda: "python manage.py runserver --settings project.settings 8000",
+    )
+
+    assert preflight_checks.check_test_db_flag("http://localhost:8000", tmp_path) == (
+        "BLOCKED: Django server on port 8000 is not running with --test-db. "
+        "Restart with: python manage.py runserver --test-db 0.0.0.0:8000"
+    )
+
+
+def test_check_test_db_flag_accepts_value_taking_options_with_test_db(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    (tmp_path / "manage.py").write_text("", encoding="utf-8")
+    monkeypatch.setattr(
+        preflight_checks,
+        "_read_process_listing",
+        lambda: "python manage.py runserver --settings project.settings --test-db 8000",
+    )
+
+    assert (
+        preflight_checks.check_test_db_flag("http://localhost:8000", tmp_path) is None
+    )
+
+
+def test_check_runserver_port_conflicts_reports_other_worktree(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    project_root = tmp_path / "project"
+    other_project_root = tmp_path / "other-project"
+    project_root.mkdir()
+    other_project_root.mkdir()
+    monkeypatch.setattr(
+        preflight_checks,
+        "_get_runserver_processes_on_port",
+        lambda _port: [(1, str(project_root)), (2, str(other_project_root))],
+    )
+
+    assert (
+        preflight_checks.check_runserver_port_conflicts(
+            "http://localhost:8000", project_root
+        )
+        == f"BLOCKED: Multiple Django runserver processes are bound to port 8000 across worktrees: {other_project_root.resolve()}. Stop stale servers first."
+    )
+
+
+def test_build_frontend_runs_build_then_collectstatic(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    (tmp_path / "manage.py").write_text("", encoding="utf-8")
+    (tmp_path / "frontend").mkdir()
+    all_calls: list[tuple[list[str], Path]] = []
+
+    def run_process(
+        all_arguments: list[str], **keyword_arguments: object
+    ) -> subprocess.CompletedProcess[str]:
+        all_calls.append((all_arguments, keyword_arguments["cwd"]))
+        return subprocess.CompletedProcess(
+            args=all_arguments, returncode=0, stdout="", stderr=""
+        )
+
+    monkeypatch.setattr(preflight_checks.subprocess, "run", run_process)
+
+    assert preflight_checks.build_frontend(tmp_path) is None
+    assert all_calls == [
+        (["npm", "run", "build"], tmp_path / "frontend"),
+        (["python", "manage.py", "collectstatic", "--noinput"], tmp_path),
+    ]
+
+
+def test_build_frontend_skips_collectstatic_without_manage_py(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    (tmp_path / "frontend").mkdir()
+    all_calls: list[list[str]] = []
+
+    def run_process(
+        all_arguments: list[str], **_keyword_arguments: object
+    ) -> subprocess.CompletedProcess[str]:
+        all_calls.append(all_arguments)
+        return subprocess.CompletedProcess(
+            args=all_arguments, returncode=0, stdout="", stderr=""
+        )
+
+    monkeypatch.setattr(preflight_checks.subprocess, "run", run_process)
+
+    assert preflight_checks.build_frontend(tmp_path) is None
+    assert all_calls == [["npm", "run", "build"]]

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',
 ]);
 
 /**