claude-dev-env 2.36.0 → 4.1.0

package/_shared/pr-loop/scripts/terminology_sweep.py

@@ -1,7 +1,7 @@
 """Flag a prose term that names a code identifier a hair differently.
 
 A change adds the field ``premium_request_interactions`` while the same
-branch's docs call it the ``premium-request-budget`` field: one thing, two
+branch's docs call it the ``premium-request-budget`` field. One thing, two
 names, and a reader who searches one never finds the other.
 
 ::
@@ -14,38 +14,29 @@ names, and a reader who searches one never finds the other.
 
 The sweep reads a unified diff, collects the multi-word identifiers added on
 code lines, and scans each added prose line for a hyphen or space variant that
-renames only the final word of an identifier: it agrees on every earlier word
-and differs on the last. A term that diverges in any earlier word, or shares
-only one leading word, is ordinary prose. It also spares English compound
-tails, singular/plural forms, stopword windows, and words that are themselves
-tokens of another introduced identifier.
+renames only the final word of an identifier. The variant agrees on every
+earlier word and differs on the last. A term that diverges in any earlier
+word, or shares only one leading word, is ordinary prose. It also spares
+English compound tails, singular/plural forms, stopword windows, and words
+that are themselves tokens of another introduced identifier.
 """
 
 import argparse
 import os
 import subprocess
 import sys
+from collections.abc import Sequence
 from pathlib import Path
 
-parent_directory = str(Path(__file__).resolve().parent)
-if parent_directory not in sys.path:
-    sys.path.insert(0, parent_directory)
-
-from pr_loop_shared_constants.terminology_sweep_constants import (  # noqa: E402
+from pr_loop_shared_constants.terminology_sweep_constants import (
     ALL_COMMON_ENGLISH_COMPOUND_TAIL_WORDS,
+    ALL_DIFF_FILE_PATH_STRIP_PREFIXES,
+    ALL_GIT_DIFF_CACHED_UNIFIED_ZERO_COMMAND,
     ALL_GIT_GREP_BASE_TREE_COMMAND_PREFIX,
     ALL_PROSE_STOPWORD_TOKENS,
     ALL_STRING_ESCAPE_SEQUENCES,
-    ALL_TEST_FILE_NAME_INFIX_MARKERS,
-    GIT_BASE_TREE_REVISION,
-    IDENTIFIER_TOKEN_SEPARATOR,
-    PROSE_WINDOW_WORD_SEPARATOR,
-    TEST_DIRECTORY_PATH_SEGMENT,
-    TEST_FILE_PREFIX,
-    TEST_FILE_SUFFIX,
-    ALL_DIFF_FILE_PATH_STRIP_PREFIXES,
-    ALL_GIT_DIFF_CACHED_UNIFIED_ZERO_COMMAND,
     ALL_SWEEP_CODE_FILE_EXTENSIONS,
+    ALL_TEST_FILE_NAME_INFIX_MARKERS,
     CAMEL_CASE_IDENTIFIER_PATTERN,
     CAMEL_CASE_WORD_PATTERN,
     DIFF_ADDED_LINE_PREFIX,
@@ -55,19 +46,32 @@ from pr_loop_shared_constants.terminology_sweep_constants import (  # noqa: E402
     DIFF_NEW_FILE_HEADER_PREFIX,
     DIFF_OLD_FILE_HEADER_PREFIX,
     DIFF_REMOVED_LINE_PREFIX,
+    GIT_BASE_TREE_REVISION,
+    GIT_DECODE_ERRORS,
+    GIT_DIFF_OPERATION,
     GIT_DIFF_SUBPROCESS_TIMEOUT_SECONDS,
+    GIT_FAILURE_WITHOUT_DETAILS,
+    GIT_GREP_OPERATION_TEMPLATE,
+    GIT_NO_MATCH_EXIT_CODE,
+    GIT_OPERATION_FAILURE_TEMPLATE,
+    GIT_TEXT_ENCODING,
     HYPHENATED_PROSE_TOKEN_PATTERN,
+    IDENTIFIER_TOKEN_SEPARATOR,
     INLINE_CODE_SPAN_PATTERN,
     JAVASCRIPT_LINE_COMMENT_MARKER,
     JSDOC_CONTINUATION_MARKER,
     MARKDOWN_FILE_EXTENSION,
     MINIMUM_IDENTIFIER_TOKEN_COUNT,
+    PROSE_WINDOW_WORD_SEPARATOR,
     PROSE_WORD_PATTERN,
     PYTHON_COMMENT_MARKER,
     SNAKE_CASE_IDENTIFIER_PATTERN,
     STRING_LITERAL_CONTENT_PATTERN,
     TERMINOLOGY_FINDING_TEMPLATE,
     TERMINOLOGY_SWEEP_DESCRIPTION,
+    TEST_DIRECTORY_PATH_SEGMENT,
+    TEST_FILE_PREFIX,
+    TEST_FILE_SUFFIX,
 )
 
 IdentifierTuple = tuple[str, ...]
@@ -173,8 +177,8 @@ def _prose_fragments(file_path: str, line_text: str) -> list[str]:
     A Markdown line is prose with its inline-code spans removed, since a
     backticked span names code verbatim. A code line contributes its comment
     tail, its JSDoc continuation text, and the contents of its string
-    literals. A test module contributes its comment tail and JSDoc text only
-    — its string literals hold fixture data, not prose.
+    literals. A test module contributes its comment tail and JSDoc text only.
+    Its string literals hold fixture data, not prose.
 
     Args:
         file_path: The path the added line belongs to.
@@ -201,9 +205,9 @@ def _prose_fragments(file_path: str, line_text: str) -> list[str]:
 def _is_test_file(file_path: str) -> bool:
     """Return whether a diff path names a test code module.
 
-    A test module's string literals hold fixture data — embedded diffs,
-    generated source, file trees — not documentation prose, so the sweep
-    reads only its comments and JSDoc lines. A ``quota.test.mjs``, a
+    A test module's string literals hold fixture data: embedded diffs,
+    generated source, and file trees. That is not documentation prose, so the
+    sweep reads only its comments and JSDoc lines. A ``quota.test.mjs``, a
     ``layout.spec.ts``, and a ``fixtures.py`` under a tests directory are all
     test modules, so every one of these paths counts::
 
@@ -260,8 +264,8 @@ def _string_literal_fragments(line_text: str) -> list[str]:
     Escape sequences inside a literal (``\\n``, ``\\t``) are replaced with
     spaces before the words are read, so an escape letter never glues onto a
     neighbouring word as a phantom prose term. A literal left with no
-    whitespace after that replacement is an identifier-shaped value — a UID,
-    a key, a path — not prose, and contributes nothing.
+    whitespace after that replacement is an identifier-shaped value: a UID,
+    a key, or a path. It is not prose, and contributes nothing.
     """
     all_fragments: list[str] = []
     for each_match in STRING_LITERAL_CONTENT_PATTERN.finditer(line_text):
@@ -413,9 +417,7 @@ def _word_is_identifier_vocabulary(
         return True
     if prose_word.endswith("es") and prose_word[:-2] in all_identifier_tokens:
         return True
-    if prose_word.endswith("ies") and prose_word[:-3] + "y" in all_identifier_tokens:
-        return True
-    return False
+    return prose_word.endswith("ies") and prose_word[:-3] + "y" in all_identifier_tokens
 
 
 def _near_miss_identifier(
@@ -525,22 +527,8 @@ def _findings_for_line(
     return all_findings
 
 
-def sweep_diff(
-    diff_text: str,
-    all_preexisting_identifier_tuples: frozenset[IdentifierTuple] = frozenset(),
-) -> list[str]:
-    """Return every terminology near-miss finding for a unified diff.
-
-    Args:
-        diff_text: The unified-diff text to sweep.
-        all_preexisting_identifier_tuples: Token tuples of added-line identifiers
-            the base tree already names. A pre-existing identifier is not one
-            the diff introduces, so no prose is flagged against it. Its
-            tokens still count as code vocabulary.
-
-    Returns:
-        One finding string per near-miss term on an added prose line.
-    """
+def _find_terminology_near_misses(
+    diff_text: str, all_preexisting_identifier_tuples: frozenset[IdentifierTuple]) -> list[str]:
     all_added_lines = _parse_added_lines(diff_text)
     all_identifier_tuples = _collect_introduced_identifiers(all_added_lines)
     all_identifier_tokens = frozenset(
@@ -571,6 +559,27 @@ def sweep_diff(
     return all_findings
 
 
+def sweep_diff(
+    diff_text: str,
+    all_preexisting_identifier_tuples: frozenset[IdentifierTuple] = frozenset(),
+) -> list[str]:
+    """Return every terminology near-miss finding for a unified diff.
+
+    Args:
+        diff_text: The unified-diff text to sweep.
+        all_preexisting_identifier_tuples: Token tuples of added-line identifiers
+            the base tree already names. A pre-existing identifier is not one
+            the diff introduces, so no prose is flagged against it. Its
+            tokens still count as code vocabulary.
+
+    Returns:
+        One finding string per near-miss term on an added prose line.
+    """
+    return _find_terminology_near_misses(
+        diff_text, all_preexisting_identifier_tuples
+    )
+
+
 def repository_environment() -> dict[str, str]:
     """Return the process environment with every GIT_ variable removed.
 
@@ -619,8 +628,8 @@ def _base_tree_names(
 
     Each name is looked up as a whole word in the base revision's tree. A
     repository with no commits yet, or a lookup that git cannot run, reports
-    the name as absent, so the sweep then treats it as newly introduced —
-    the behaviour the sweep has with no base-tree check at all.
+    the name as absent, so the sweep then treats it as newly introduced.
+    That is the behaviour the sweep has with no base-tree check at all.
 
     Args:
         repository_root: The repository root the lookups run in.
@@ -652,11 +661,90 @@ def _base_tree_names(
     return frozenset(all_present_names)
 
 
+def _run_strict_git(
+    repository_root: Path, all_arguments: Sequence[str]
+) -> subprocess.CompletedProcess[str]:
+    try:
+        return subprocess.run(
+            list(all_arguments),
+            cwd=str(repository_root),
+            capture_output=True,
+            text=True,
+            encoding=GIT_TEXT_ENCODING,
+            errors=GIT_DECODE_ERRORS,
+            timeout=GIT_DIFF_SUBPROCESS_TIMEOUT_SECONDS,
+            check=False,
+            env=repository_environment(),
+        )
+    except (subprocess.TimeoutExpired, OSError) as e:
+        raise RuntimeError(str(e)) from e
+
+
+def _raise_for_git_failure(
+    git_process: subprocess.CompletedProcess[str], operation: str
+) -> None:
+    if git_process.returncode == 0:
+        return
+    details = git_process.stderr.strip() or git_process.stdout.strip()
+    raise RuntimeError(
+        GIT_OPERATION_FAILURE_TEMPLATE.format(
+            operation=operation,
+            details=details or GIT_FAILURE_WITHOUT_DETAILS,
+        )
+    )
+
+
+def _strict_base_tree_names(
+    repository_root: Path, all_names: frozenset[str]
+) -> frozenset[str]:
+    all_present_names: set[str] = set()
+    for each_name in sorted(all_names):
+        all_arguments = (
+            *ALL_GIT_GREP_BASE_TREE_COMMAND_PREFIX,
+            each_name,
+            GIT_BASE_TREE_REVISION,
+        )
+        grep_process = _run_strict_git(repository_root, all_arguments)
+        if grep_process.returncode == 0:
+            all_present_names.add(each_name)
+            continue
+        if grep_process.returncode == GIT_NO_MATCH_EXIT_CODE:
+            continue
+        operation = GIT_GREP_OPERATION_TEMPLATE.format(identifier=each_name)
+        _raise_for_git_failure(grep_process, operation)
+    return frozenset(all_present_names)
+
+
+def strict_staged_terminology_findings(repository_root: Path) -> list[str]:
+    """Return near-miss findings for the staged diff.
+
+    Args:
+        repository_root: The repository root the staged diff is read from.
+
+    Returns:
+        One finding string per near-miss term on a staged prose line.
+
+    Raises:
+        RuntimeError: Git could not read the staged diff or look up an
+            identifier in HEAD.
+    """
+    diff_process = _run_strict_git(
+        repository_root, ALL_GIT_DIFF_CACHED_UNIFIED_ZERO_COMMAND
+    )
+    _raise_for_git_failure(diff_process, GIT_DIFF_OPERATION)
+    all_added_names = _identifier_names_on_added_code_lines(diff_process.stdout)
+    preexisting_tuples = frozenset(
+        _identifier_token_tuple(each_name)
+        for each_name in _strict_base_tree_names(repository_root, all_added_names)
+    )
+    return _find_terminology_near_misses(diff_process.stdout, preexisting_tuples)
+
+
 def staged_terminology_findings(repository_root: Path) -> list[str]:
     """Return terminology near-miss findings for a repository's staged diff.
 
     An identifier the base tree already names is not one the staged diff
-    introduces, so no prose is flagged against it — only genuinely new
+    introduces, so no prose is flagged against it. Only genuinely new
     identifiers are swept.
 
     Args:
@@ -684,7 +772,7 @@ def staged_terminology_findings(repository_root: Path) -> list[str]:
         _identifier_token_tuple(each_name)
         for each_name in _base_tree_names(repository_root, all_added_names)
     )
-    return sweep_diff(diff_process.stdout, preexisting_tuples)
+    return _find_terminology_near_misses(diff_process.stdout, preexisting_tuples)
 
 
 def _read_diff_text(diff_file_path: str | None) -> str:

package/_shared/pr-loop/scripts/tests/test_terminology_sweep.py

@@ -2,6 +2,7 @@
 
 import importlib.util
 import subprocess
+import sys
 from pathlib import Path
 from types import ModuleType
 
@@ -10,17 +11,26 @@ import pytest
 
 def _load_sweep_module() -> ModuleType:
     module_path = Path(__file__).parent.parent / "terminology_sweep.py"
+    module_directory = str(module_path.parent)
+    should_remove_module_directory = module_directory not in sys.path
+    if should_remove_module_directory:
+        sys.path.insert(0, module_directory)
     spec = importlib.util.spec_from_file_location("terminology_sweep", module_path)
     assert spec is not None
     assert spec.loader is not None
     module = importlib.util.module_from_spec(spec)
-    spec.loader.exec_module(module)
+    try:
+        spec.loader.exec_module(module)
+    finally:
+        if should_remove_module_directory:
+            sys.path.remove(module_directory)
     return module
 
 
 sweep_module = _load_sweep_module()
 sweep_diff = sweep_module.sweep_diff
 staged_terminology_findings = sweep_module.staged_terminology_findings
+strict_staged_terminology_findings = sweep_module.strict_staged_terminology_findings
 main = sweep_module.main
 parse_added_lines = sweep_module._parse_added_lines
 
@@ -282,6 +292,8 @@ def test_staged_terminology_findings_flags_staged_prose(tmp_path: Path) -> None:
         env=_hermetic_git_environment(),
     )
     findings = staged_terminology_findings(tmp_path)
+    with pytest.raises(RuntimeError, match="git grep"):
+        strict_staged_terminology_findings(tmp_path)
     assert any("premium-request" in each_finding for each_finding in findings)
 
 

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 {

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' };

package/docs/references/team-advisor-skill.md

@@ -1,6 +1,6 @@
-# Team-Advisor Skill
+# Team-advisor skill
 
-`/team-advisor` binds one standing warm advisor for this session at the strongest reachable tier. This skill is the selected custom reproduction path for advisor behavior: it forwards explicit packets to a warm Agent/SendMessage advisor or the read-only `codex_sol_advisor.py` path across many decision points.
+`/team-advisor` binds one standing warm advisor for this session at the strongest reachable tier. It sends explicit packets to a warm Agent/SendMessage advisor or the read-only `codex_astra_advisor.py` helper.
 
 ## Refs
 
@@ -17,4 +17,4 @@ Follow the call rules in `advisor-tool.md` (orientation first, then consult befo
 
 ## Selected path
 
-`/team-advisor` is the repository's advisor implementation. It provides explicit first-consult packets, delta consults, a standing warm reviewer, an in-session Sol spawn on Codex, and a read-only Sol CLI option.
+`/team-advisor` is the repository's advisor implementation. It provides explicit first-consult packets, delta consults, a standing warm reviewer, an in-session Astra spawn on Codex, and a read-only Astra CLI option.

package/hooks/validators/README.md

@@ -2,7 +2,41 @@
 
 AST-based Python style checks for code quality enforcement.
 
-The checks live in `python_style_checks.py`; the shared source-line splitting, function-discovery, and statement-classification helpers they build on live in `python_style_helpers.py`. `python_style_import_bootstrap.py` recognizes the repo's sys.path bootstrap-guard idiom so the imports-at-top check does not penalize a file for following it. `hook_timing_harness.py` measures real wall-clock time for the Write/Edit hooks `hooks.json` registers, reporting p50 and p95 over a configurable run count. `fast_save_validators.py` runs the twelve non-Mypy, non-Ruff checks in-process for the Write/Edit save-path gate, with no per-check subprocess.
+The checks live in `python_style_checks.py`. Shared source-line splitting, function discovery, and statement classification live in `python_style_helpers.py`. `python_style_import_bootstrap.py` recognizes the repo's sys.path bootstrap-guard idiom so the imports-at-top check does not penalize a file for following it. `fast_save_validators.py` runs the twelve non-Mypy, non-Ruff checks in-process for the Write/Edit save-path gate, with no per-check subprocess.
+
+## Production modules
+
+| File | Role |
+|---|---|
+| `abbreviation_checks.py` | Abbreviation and single-letter name checks |
+| `code_quality_checks.py` | Function, nesting, and file length checks |
+| `comment_checks.py` | Comment detection for the opt-in diff-aware linter |
+| `exempt_paths.py` | Shared config, test, and hook-infrastructure path exemptions |
+| `fast_save_validators.py` | In-process Write/Edit save-path validator roster |
+| `file_structure_checks.py` | File structure checks for pre-PR validation |
+| `git_checks.py` | Git and GitHub checks for pre-push review |
+| `health_check.py` | Validator availability, dependency, and version checks |
+| `hook_timing_harness.py` | Hook runtime measurement and threshold report |
+| `magic_value_checks.py` | Hardcoded magic-number checks |
+| `mypy_integration.py` | Mypy static type checking integration |
+| `output_formatter.py` | Colored, diff, progress, and JSON validator output |
+| `pr_reference_checks.py` | PR and commit reference checks in comments |
+| `project_roots.py` | Project-root resolution from a path |
+| `pyproject_config_discovery.py` | Walk-up discovery of tool pyproject tables |
+| `python_antipattern_checks.py` | Mutable defaults, bare except, and print checks |
+| `python_style_checks.py` | Import placement, decorator spacing, blank lines, and view naming |
+| `python_style_helpers.py` | Source-line splitting and function-discovery helpers |
+| `python_style_import_bootstrap.py` | sys.path bootstrap-guard recognizer |
+| `react_checks.py` | React class-component and error-boundary checks |
+| `ruff_integration.py` | Ruff lint integration |
+| `run_all_validators.py` | Pre-push validator orchestration and report |
+| `security_checks.py` | Hardcoded-secret, SQL injection, and XSS checks |
+| `system_temporary_roots.py` | System temp-root membership for staged copies |
+| `todo_checks.py` | TODO/FIXME tracking with issue-reference requirement |
+| `type_safety_checks.py` | Missing type hints and Any usage checks |
+| `useless_test_checks.py` | Useless-test detection |
+| `validator_base.py` | Shared validator dataclasses, source read, and parse |
+| `validator_defaults.py` | Shared constants for the validators package |
 
 ## Checks Implemented
 

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "claude-dev-env",
-    "version": "2.36.0",
+    "version": "4.1.0",
     "description": "Claude Code development standards — rules, hooks, agents, commands, and skills",
     "type": "module",
     "bin": {