claude-dev-env 4.0.0 → 4.2.0

package/.agents/skills/syncing-submodules/scripts/test_submodule_sync.py

@@ -0,0 +1,303 @@
+from __future__ import annotations
+
+import os
+import subprocess
+import sys
+from pathlib import Path
+
+import pytest
+
+SCRIPT_DIRECTORY = Path(__file__).resolve().parent
+if str(SCRIPT_DIRECTORY) not in sys.path:
+    sys.path.insert(0, str(SCRIPT_DIRECTORY))
+
+import submodule_sync
+from submodule_sync_constants.config.constants import (
+    GH_COMMAND_TIMEOUT_SECONDS,
+    GIT_COMMAND_TIMEOUT_SECONDS,
+)
+
+
+def _build_git_environment() -> dict[str, str]:
+    return {
+        each_name: each_content
+        for each_name, each_content in os.environ.items()
+        if not each_name.upper().startswith("GIT_")
+    }
+
+
+def _run_fixture_git(
+    repository_path: Path,
+    *all_arguments: str,
+) -> subprocess.CompletedProcess[str]:
+    return subprocess.run(
+        ["git", *all_arguments],
+        cwd=repository_path,
+        check=False,
+        capture_output=True,
+        text=True,
+        env=_build_git_environment(),
+        timeout=GIT_COMMAND_TIMEOUT_SECONDS,
+    )
+
+
+def _require_fixture_git(repository_path: Path, *all_arguments: str) -> str:
+    completed_process = _run_fixture_git(repository_path, *all_arguments)
+    assert completed_process.returncode == 0, completed_process.stderr
+    return completed_process.stdout.strip()
+
+
+def _configure_fixture_identity(repository_path: Path) -> None:
+    _require_fixture_git(repository_path, "config", "user.name", "Fixture User")
+    _require_fixture_git(
+        repository_path,
+        "config",
+        "user.email",
+        "fixture@example.invalid",
+    )
+    _require_fixture_git(repository_path, "config", "commit.gpgsign", "false")
+
+
+def _initialize_fixture_repository(repository_path: Path) -> None:
+    repository_path.mkdir(parents=True)
+    _require_fixture_git(repository_path, "init", "-b", "main")
+    _configure_fixture_identity(repository_path)
+
+
+def _create_submodule_fixture(tmp_path: Path) -> tuple[Path, Path]:
+    source_repository = tmp_path / "source-repository"
+    parent_repository = tmp_path / "parent-repository"
+    _initialize_fixture_repository(source_repository)
+    (source_repository / "README.md").write_text("source\n", encoding="utf-8")
+    _require_fixture_git(source_repository, "add", "README.md")
+    _require_fixture_git(source_repository, "commit", "-m", "Create source")
+    _initialize_fixture_repository(parent_repository)
+    (parent_repository / "README.md").write_text("parent\n", encoding="utf-8")
+    _require_fixture_git(parent_repository, "add", "README.md")
+    _require_fixture_git(parent_repository, "commit", "-m", "Create parent")
+    _require_fixture_git(
+        parent_repository,
+        "-c",
+        "protocol.file.allow=always",
+        "submodule",
+        "add",
+        str(source_repository),
+        "nested/sub[module]",
+    )
+    _require_fixture_git(parent_repository, "commit", "-am", "Add submodule")
+    submodule_repository = parent_repository / "nested" / "sub[module]"
+    _configure_fixture_identity(submodule_repository)
+    return parent_repository, submodule_repository
+
+
+def _commit_child_change(submodule_repository: Path) -> str:
+    (submodule_repository / "change.txt").write_text("change\n", encoding="utf-8")
+    _require_fixture_git(submodule_repository, "add", "change.txt")
+    _require_fixture_git(submodule_repository, "commit", "-m", "Record child change")
+    return _require_fixture_git(submodule_repository, "rev-parse", "HEAD")
+
+
+def _assert_parent_pointer_commit(
+    parent_repository: Path,
+    child_commit_hash: str,
+) -> None:
+    recorded_pointer = _require_fixture_git(
+        parent_repository,
+        "rev-parse",
+        "HEAD:nested/sub[module]",
+    )
+    changed_path = _require_fixture_git(
+        parent_repository,
+        "diff",
+        "HEAD^",
+        "HEAD",
+        "--name-only",
+    )
+    parent_commit_body = _require_fixture_git(
+        parent_repository,
+        "log",
+        "-1",
+        "--pretty=%B",
+    )
+    assert recorded_pointer == child_commit_hash
+    assert changed_path == "nested/sub[module]"
+    assert "Submodule commit: Record child change" in parent_commit_body
+    assert "Co-Authored-By" not in parent_commit_body
+
+
+def test_sync_updates_bracketed_pointer_and_preserves_staged_path(
+    tmp_path: Path,
+) -> None:
+    parent_repository, submodule_repository = _create_submodule_fixture(tmp_path)
+    staged_note_path = parent_repository / "staged-note.txt"
+    staged_note_path.write_text("keep staged\n", encoding="utf-8")
+    _require_fixture_git(parent_repository, "add", "staged-note.txt")
+    child_commit_hash = _commit_child_change(submodule_repository)
+
+    sync_report = submodule_sync.sync_repository(submodule_repository)
+
+    assert sync_report.status is submodule_sync.SyncStatus.UPDATED
+    assert sync_report.commit == child_commit_hash
+    assert sync_report.submodule_path == "nested/sub[module]"
+    assert (
+        _require_fixture_git(parent_repository, "status", "--short")
+        == "A  staged-note.txt"
+    )
+    _assert_parent_pointer_commit(parent_repository, child_commit_hash)
+
+
+def test_second_sync_is_unchanged_without_new_commit(tmp_path: Path) -> None:
+    parent_repository, submodule_repository = _create_submodule_fixture(tmp_path)
+    _commit_child_change(submodule_repository)
+
+    first_report = submodule_sync.sync_repository(submodule_repository)
+    parent_commit = _require_fixture_git(parent_repository, "rev-parse", "HEAD")
+    second_report = submodule_sync.sync_repository(submodule_repository)
+
+    assert first_report.status is submodule_sync.SyncStatus.UPDATED
+    assert second_report.status is submodule_sync.SyncStatus.UNCHANGED
+    assert second_report.parent_commit == parent_commit
+    assert _require_fixture_git(parent_repository, "rev-parse", "HEAD") == parent_commit
+
+
+def test_standalone_repository_is_a_noop(tmp_path: Path) -> None:
+    standalone_repository = tmp_path / "standalone"
+    _initialize_fixture_repository(standalone_repository)
+    (standalone_repository / "note.txt").write_text("unchanged\n", encoding="utf-8")
+    _require_fixture_git(standalone_repository, "add", "note.txt")
+    before_status = _require_fixture_git(standalone_repository, "status", "--short")
+
+    sync_report = submodule_sync.sync_repository(standalone_repository)
+
+    assert sync_report.status is submodule_sync.SyncStatus.NOT_SUBMODULE
+    assert sync_report.repository == standalone_repository.resolve().as_posix()
+    assert (
+        _require_fixture_git(standalone_repository, "status", "--short")
+        == before_status
+    )
+
+
+@pytest.mark.parametrize(
+    ("failed_git_operation", "failure_exit_code"),
+    [("add", 1), ("diff", 2), ("commit", 1)],
+)
+def test_git_failures_return_error_status(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+    failed_git_operation: str,
+    failure_exit_code: int,
+) -> None:
+    _, submodule_repository = _create_submodule_fixture(tmp_path)
+    _commit_child_change(submodule_repository)
+    original_execute_git = submodule_sync._execute_git
+
+    def fail_selected_operation(
+        all_arguments: tuple[str, ...],
+        cwd: Path,
+    ) -> subprocess.CompletedProcess[str]:
+        if all_arguments[0] == failed_git_operation:
+            return subprocess.CompletedProcess(
+                ["git", *all_arguments],
+                failure_exit_code,
+                "",
+                f"fatal: fixture {failed_git_operation} failure",
+            )
+        return original_execute_git(all_arguments, cwd)
+
+    monkeypatch.setattr(submodule_sync, "_execute_git", fail_selected_operation)
+    sync_report = submodule_sync.sync_repository(submodule_repository)
+
+    assert sync_report.status is submodule_sync.SyncStatus.ERROR
+    assert sync_report.diagnostic == f"fatal: fixture {failed_git_operation} failure"
+
+
+def test_inherited_git_dir_does_not_redirect_commands(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    unrelated_repository = tmp_path / "unrelated"
+    _initialize_fixture_repository(unrelated_repository)
+    parent_repository, submodule_repository = _create_submodule_fixture(tmp_path)
+    child_commit_hash = _commit_child_change(submodule_repository)
+    monkeypatch.setenv("GIT_DIR", str(unrelated_repository / ".git"))
+
+    sync_report = submodule_sync.sync_repository(submodule_repository)
+
+    assert sync_report.status is submodule_sync.SyncStatus.UPDATED
+    recorded_pointer = _require_fixture_git(
+        parent_repository,
+        "rev-parse",
+        "HEAD:nested/sub[module]",
+    )
+    assert recorded_pointer == child_commit_hash
+
+
+def test_pull_request_lookup_returns_url_on_success(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    completed_process = subprocess.CompletedProcess(
+        ["gh"],
+        0,
+        "https://github.com/example/repo/pull/1\n",
+        "",
+    )
+
+    def return_completed_process(
+        *all_arguments: object,
+        **all_keyword_arguments: object,
+    ) -> subprocess.CompletedProcess[str]:
+        return completed_process
+
+    monkeypatch.setattr(submodule_sync.subprocess, "run", return_completed_process)
+
+    assert submodule_sync.lookup_pull_request_url(tmp_path) == (
+        "https://github.com/example/repo/pull/1"
+    )
+
+
+@pytest.mark.parametrize(
+    "completed_process",
+    [
+        subprocess.CompletedProcess(["gh"], 1, "", "no pull request"),
+        subprocess.CompletedProcess(["gh"], 1, "", "auth failed"),
+        subprocess.CompletedProcess(["gh"], 0, "", ""),
+    ],
+)
+def test_pull_request_lookup_soft_failures_return_none(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+    completed_process: subprocess.CompletedProcess[str],
+) -> None:
+    def return_completed_process(
+        *all_arguments: object,
+        **all_keyword_arguments: object,
+    ) -> subprocess.CompletedProcess[str]:
+        return completed_process
+
+    monkeypatch.setattr(submodule_sync.subprocess, "run", return_completed_process)
+
+    assert submodule_sync.lookup_pull_request_url(tmp_path) is None
+
+
+@pytest.mark.parametrize(
+    "lookup_exception",
+    [
+        FileNotFoundError(),
+        subprocess.TimeoutExpired("gh", GH_COMMAND_TIMEOUT_SECONDS),
+    ],
+)
+def test_pull_request_lookup_unavailable_returns_none(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+    lookup_exception: Exception,
+) -> None:
+    def raise_lookup_exception(
+        *all_arguments: object,
+        **all_keyword_arguments: object,
+    ) -> None:
+        raise lookup_exception
+
+    monkeypatch.setattr(submodule_sync.subprocess, "run", raise_lookup_exception)
+
+    assert submodule_sync.lookup_pull_request_url(tmp_path) is None

package/.agents/skills/syncing-submodules/scripts/test_sync_parent_pointer.py

@@ -0,0 +1,83 @@
+from __future__ import annotations
+
+import json
+import sys
+from pathlib import Path
+
+import pytest
+
+SCRIPT_DIRECTORY = Path(__file__).resolve().parent
+if str(SCRIPT_DIRECTORY) not in sys.path:
+    sys.path.insert(0, str(SCRIPT_DIRECTORY))
+
+import sync_parent_pointer
+from submodule_sync import SyncReport, SyncStatus
+
+
+def _read_single_json_line(
+    capsys: pytest.CaptureFixture[str],
+) -> tuple[dict[str, object], str]:
+    captured_streams = capsys.readouterr()
+    all_stdout_lines = captured_streams.out.splitlines()
+    assert len(all_stdout_lines) == 1
+    parsed_record = json.loads(all_stdout_lines[0])
+    assert isinstance(parsed_record, dict)
+    return parsed_record, captured_streams.err
+
+
+def test_invalid_repository_emits_one_json_record_and_diagnostic(
+    tmp_path: Path,
+    capsys: pytest.CaptureFixture[str],
+) -> None:
+    exit_code = sync_parent_pointer.main(["--repository", str(tmp_path / "missing")])
+
+    sync_record, captured_error = _read_single_json_line(capsys)
+    assert exit_code == 1
+    assert sync_record["status"] == "error"
+    assert sync_record["diagnostic"]
+    assert "syncing-submodules:" in captured_error
+
+
+def test_invalid_arguments_emit_one_json_record_and_exit_two(
+    capsys: pytest.CaptureFixture[str],
+) -> None:
+    exit_code = sync_parent_pointer.main(["--unknown"])
+
+    sync_record, captured_error = _read_single_json_line(capsys)
+    assert exit_code == 2
+    assert sync_record["status"] == "error"
+    assert "invalid command arguments" in str(sync_record["diagnostic"])
+    assert captured_error
+
+
+def test_success_emits_one_json_record(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+    capsys: pytest.CaptureFixture[str],
+) -> None:
+    expected_report = SyncReport(
+        status=SyncStatus.NOT_SUBMODULE,
+        repository=tmp_path.as_posix(),
+    )
+
+    def return_expected_report(repository: Path) -> SyncReport:
+        return expected_report
+
+    monkeypatch.setattr(
+        sync_parent_pointer,
+        "sync_repository",
+        return_expected_report,
+    )
+    exit_code = sync_parent_pointer.main(["--repository", str(tmp_path)])
+
+    sync_record, captured_error = _read_single_json_line(capsys)
+    assert exit_code == 0
+    assert sync_record["status"] == "not_submodule"
+    assert captured_error == ""
+
+
+def test_native_post_commit_source_and_test_are_removed() -> None:
+    hook_directory = Path(__file__).resolve().parents[4] / "hooks" / "git-hooks"
+
+    assert not (hook_directory / "post_commit.py").exists()
+    assert not (hook_directory / "test_post_commit.py").exists()

package/bin/ever-shipped-skills.mjs

@@ -119,6 +119,7 @@ export const EVER_SHIPPED_SKILL_NAMES = new Set([
     'source-command-sr-loop',
     'split-pr',
     'structure-prompt',
+    'syncing-submodules',
     'task-build',
     'team-advisor',
     'update',

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

@@ -0,0 +1,30 @@
+import { strict as assert } from 'node:assert';
+import { test } from 'node:test';
+import { existsSync, readdirSync } from 'node:fs';
+import { dirname, join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { EVER_SHIPPED_SKILL_NAMES } from './ever-shipped-skills.mjs';
+import {
+    MANAGED_SKILLS_DIRECTORY_NAME,
+    PACKAGE_AGENTS_HOME_DIRECTORY_NAME,
+} from './install-constants.mjs';
+
+const THIS_DIRECTORY = dirname(fileURLToPath(import.meta.url));
+const PACKAGE_DIRECTORY = dirname(THIS_DIRECTORY);
+
+test('EVER_SHIPPED_SKILL_NAMES includes every current shipped skill', () => {
+    const sourceSkillsDirectory = join(
+        PACKAGE_DIRECTORY,
+        PACKAGE_AGENTS_HOME_DIRECTORY_NAME,
+        MANAGED_SKILLS_DIRECTORY_NAME,
+    );
+    const allCurrentSkillNames = readdirSync(sourceSkillsDirectory, { withFileTypes: true })
+        .filter(eachEntry => eachEntry.isDirectory())
+        .filter(eachEntry => existsSync(join(sourceSkillsDirectory, eachEntry.name, 'SKILL.md')))
+        .map(eachEntry => eachEntry.name);
+    const allUncoveredSkillNames = allCurrentSkillNames.filter(
+        eachSkillName => !EVER_SHIPPED_SKILL_NAMES.has(eachSkillName),
+    );
+
+    assert.deepEqual(allUncoveredSkillNames, [], 'every current skill must enter the fallback set');
+});

package/bin/git_hooks_installer.mjs

@@ -6,7 +6,6 @@ import { join } from 'node:path';
 export const KNOWN_GIT_HOOK_NAMES = Object.freeze([
     'pre-commit',
     'pre-push',
-    'post-commit',
 ]);
 
 export const SHIM_DOCSTRING = (

package/bin/git_hooks_installer.test.mjs

@@ -58,6 +58,22 @@ test('writeAllGitHookShims creates one shim per known hook name', () => {
 });
 
 
+test('known git hooks exclude post-commit', () => {
+    assert.equal(KNOWN_GIT_HOOK_NAMES.includes('post-commit'), false);
+});
+
+
+test('writeAllGitHookShims does not create a post-commit shim', () => {
+    const { temporaryRoot, gitHooksDirectory } = makeTemporaryGitHooksDirectory();
+    try {
+        writeAllGitHookShims({ gitHooksDirectory });
+        assert.equal(existsSync(join(gitHooksDirectory, 'post-commit')), false);
+    } finally {
+        rmSync(temporaryRoot, { recursive: true, force: true });
+    }
+});
+
+
 test('configureGlobalGitHooksPath sets the path when nothing is currently configured', () => {
     const commandsRun = [];
     const gitConfigReaderReturningEmpty = () => '';
@@ -205,4 +221,3 @@ test('writeGitHookShim rejects hooks directory that is a symlink (loopP5c-5)', (
     }
 });
 
-

package/bin/install.mjs

@@ -6,7 +6,10 @@ import { homedir } from 'node:os';
 import { execSync, execFileSync, spawnSync } from 'node:child_process';
 import { fileURLToPath } from 'node:url';
 import { createRequire } from 'node:module';
-import { installAllGitHooks } from './git_hooks_installer.mjs';
+import {
+    installAllGitHooks,
+    KNOWN_GIT_HOOK_NAMES,
+} from './git_hooks_installer.mjs';
 import { installMypyIniForClaudeHooks } from './install_mypy_ini.mjs';
 import { expandHomeDirectoryTokensInSettings } from './expand_home_directory_tokens.mjs';
 import { EVER_SHIPPED_SKILL_NAMES } from './ever-shipped-skills.mjs';
@@ -2368,7 +2371,7 @@ function executeInstallPlanMutations(plan, transactionHelpers) {
         } else {
             console.warn(`  Git hooks: ${gitHookInstallationResult.hooksPathConfigurationResult.reason}`);
         }
-        console.log(`  Git hook shims: ${gitHookInstallationResult.createdShimPaths.length} files (pre-commit, pre-push, post-commit)`);
+        console.log(`  Git hook shims: ${gitHookInstallationResult.createdShimPaths.length} files (${KNOWN_GIT_HOOK_NAMES.join(', ')})`);
         syncWrittenPaths([...allInstalledFiles, ...publishedPointerPaths]);
         throwIfFault(FAULT_PHASES.AFTER_GIT_CONFIG);
         throwIfFault(FAULT_PHASES.AFTER_LINK_PUBLICATION);

package/bin/install.prune.test.mjs

@@ -13,15 +13,8 @@ import {
 import { tmpdir } from 'node:os';
 import { join, dirname, basename } from 'node:path';
 import { fileURLToPath } from 'node:url';
-import {
-    MANAGED_SKILLS_DIRECTORY_NAME,
-    PACKAGE_AGENTS_HOME_DIRECTORY_NAME,
-} from './install-constants.mjs';
-import { EVER_SHIPPED_SKILL_NAMES } from './ever-shipped-skills.mjs';
-
 const THIS_DIRECTORY = dirname(fileURLToPath(import.meta.url));
 const INSTALLER_PATH = join(THIS_DIRECTORY, 'install.mjs');
-const PACKAGE_DIRECTORY = dirname(THIS_DIRECTORY);
 const INSTALLER_PROCESS_TIMEOUT_MS = 60_000;
 const EXCLUDED_PACKAGE_COPY_DIRECTORY = 'node_modules';
 
@@ -50,6 +43,11 @@ const PRIOR_RUN_BACKUP_DIRECTORY_NAMES = [
 ];
 const SKILLS_DIRECTORY_NAME = 'skills';
 const HOOKS_DIRECTORY_NAME = 'hooks';
+const GIT_HOOKS_DIRECTORY_NAME = 'git-hooks';
+const PRE_COMMIT_HOOK_NAME = 'pre-commit';
+const PRE_PUSH_HOOK_NAME = 'pre-push';
+const POST_COMMIT_HOOK_NAME = 'post-commit';
+const FOREIGN_HOOK_NAME = 'foreign-hook';
 const SETTINGS_FILE_NAME = 'settings.json';
 const MANIFEST_FILE_NAME = '.claude-dev-env-manifest.json';
 const CLAUDE_HUB_FILE_NAME = 'CLAUDE.md';
@@ -117,23 +115,6 @@ function createSandbox(homeDirectoryPrefix = 'cdev-prune-home-') {
     return { homeDirectory, claudeDirectory, skillsDirectory, manifestPath };
 }
 
-test('the retired-skill fallback covers every current shipped skill', () => {
-    const sourceSkillsDirectory = join(
-        PACKAGE_DIRECTORY,
-        PACKAGE_AGENTS_HOME_DIRECTORY_NAME,
-        MANAGED_SKILLS_DIRECTORY_NAME,
-    );
-    const allCurrentSkillNames = readdirSync(sourceSkillsDirectory, { withFileTypes: true })
-        .filter(eachEntry => eachEntry.isDirectory())
-        .filter(eachEntry => existsSync(join(sourceSkillsDirectory, eachEntry.name, 'SKILL.md')))
-        .map(eachEntry => eachEntry.name);
-    const allUncoveredSkillNames = allCurrentSkillNames.filter(
-        eachSkillName => !EVER_SHIPPED_SKILL_NAMES.has(eachSkillName),
-    );
-
-    assert.deepEqual(allUncoveredSkillNames, [], 'every current skill must enter the fallback set');
-});
-
 test('a core install runs the spaced-path Write dispatcher and captures its red denial', () => {
     const sandbox = createSandbox('cdev prune & (home)-');
     try {
@@ -1003,6 +984,37 @@ test('a full reinstall leaves a manifest-recorded path under no managed root in
     }
 });
 
+test('a reinstall removes a retired post-commit shim and preserves a foreign git hook', () => {
+    const sandbox = createSandbox();
+    try {
+        runInstaller(sandbox.homeDirectory, []);
+        const gitHooksDirectory = join(
+            sandbox.claudeDirectory, HOOKS_DIRECTORY_NAME, GIT_HOOKS_DIRECTORY_NAME,
+        );
+        const postCommitShimPath = join(gitHooksDirectory, POST_COMMIT_HOOK_NAME);
+        const foreignHookPath = join(gitHooksDirectory, FOREIGN_HOOK_NAME);
+        const foreignHookContentBytes = Buffer.from('foreign hook content\n', 'utf8');
+        writeFileWithParents(postCommitShimPath, 'generated by an earlier install\n');
+        writeFileWithParents(foreignHookPath, foreignHookContentBytes);
+        appendManifestFiles(sandbox.manifestPath, [postCommitShimPath]);
+
+        runInstaller(sandbox.homeDirectory, []);
+
+        const freshManifest = readManifest(sandbox.manifestPath);
+        assert.equal(existsSync(postCommitShimPath), false);
+        assert.deepEqual(readFileSync(foreignHookPath), foreignHookContentBytes);
+        assert.equal(freshManifest.files.includes(postCommitShimPath), false);
+        assert.equal(freshManifest.files.includes(foreignHookPath), false);
+        for (const gitHookName of [PRE_COMMIT_HOOK_NAME, PRE_PUSH_HOOK_NAME]) {
+            const generatedShimPath = join(gitHooksDirectory, gitHookName);
+            assert.equal(existsSync(generatedShimPath), true);
+            assert.equal(freshManifest.files.includes(generatedShimPath), true);
+        }
+    } finally {
+        rmSync(sandbox.homeDirectory, { recursive: true, force: true });
+    }
+});
+
 test('a full reinstall drops a retired hook script and its settings entry in one run', () => {
     const sandbox = createSandbox();
     try {
@@ -1042,6 +1054,65 @@ test('a full reinstall drops a retired hook script and its settings entry in one
     }
 });
 
+test('a full reinstall removes the retired Everything path rewriter and keeps a foreign hook neighbor', () => {
+    const sandbox = createSandbox();
+    try {
+        runInstaller(sandbox.homeDirectory, []);
+        const retiredHookPath = join(
+            sandbox.claudeDirectory,
+            HOOKS_DIRECTORY_NAME,
+            'blocking',
+            'es_exe_path_rewriter.py',
+        );
+        writeFileWithParents(retiredHookPath, 'a hook an earlier install wrote\n');
+        appendManifestFiles(sandbox.manifestPath, [retiredHookPath]);
+
+        const foreignHookPath = join(
+            sandbox.claudeDirectory,
+            HOOKS_DIRECTORY_NAME,
+            'blocking',
+            'foreign_search_hook.py',
+        );
+        const foreignHookBytes = Buffer.from('a user hook the installer never wrote\n');
+        writeFileWithParents(foreignHookPath, foreignHookBytes);
+
+        runInstaller(sandbox.homeDirectory, []);
+
+        const freshManifest = readManifest(sandbox.manifestPath);
+        const installedDispatcherConstantsPath = join(
+            sandbox.claudeDirectory,
+            HOOKS_DIRECTORY_NAME,
+            'hooks_constants',
+            'bash_pre_tool_use_dispatcher_constants.py',
+        );
+        assert.equal(existsSync(retiredHookPath), false, 'the retired search hook leaves the installed hooks');
+        assert.equal(
+            freshManifest.files.includes(retiredHookPath),
+            false,
+            'the fresh manifest drops the retired search hook',
+        );
+        assert.equal(
+            freshManifest.files.includes(foreignHookPath),
+            false,
+            'the fresh manifest does not claim the foreign hook',
+        );
+        assert.deepEqual(
+            readFileSync(foreignHookPath),
+            foreignHookBytes,
+            'the foreign hook keeps its original bytes',
+        );
+        assert.equal(
+            readFileSync(installedDispatcherConstantsPath, 'utf8').includes(
+                'es_exe_path_rewriter.py',
+            ),
+            false,
+            'the installed dispatcher constants omit the retired search hook',
+        );
+    } 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

@@ -51,6 +51,13 @@ import {
 } from './expand_home_directory_tokens.mjs';
 
 
+test('installer reports the authoritative Git hook names', () => {
+    const installerSource = readFileSync(new URL('./install.mjs', import.meta.url), 'utf8');
+    assert.match(installerSource, /KNOWN_GIT_HOOK_NAMES\.join\(', '\)/);
+    assert.doesNotMatch(installerSource, /pre-commit, pre-push, post-commit/);
+});
+
+
 function createTemporaryGitRepository() {
     const repositoryRoot = mkdtempSync(join(tmpdir(), 'cdev-installer-validation-'));
     const gitOptions = { cwd: repositoryRoot, stdio: 'ignore' };