claude-dev-env 4.2.0 → 7.0.0

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

@@ -32,6 +32,7 @@ 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_DIFF_UNIFIED_ZERO_COMMAND,
     ALL_GIT_GREP_BASE_TREE_COMMAND_PREFIX,
     ALL_PROSE_STOPWORD_TOKENS,
     ALL_STRING_ESCAPE_SEQUENCES,
@@ -622,21 +623,23 @@ def _identifier_names_on_added_code_lines(diff_text: str) -> frozenset[str]:
 
 
 def _base_tree_names(
-    repository_root: Path, all_names: frozenset[str]
+    repository_root: Path,
+    all_names: frozenset[str],
+    tree_revision: str,
 ) -> frozenset[str]:
-    """Return the names the repository's base tree already contains.
+    """Return the names the comparison tree already contains.
 
-    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.
-    That is the behaviour the sweep has with no base-tree check at all.
+    Each name is looked up as a whole word in ``tree_revision``. A repository
+    with no commits yet, or a lookup that git cannot run, reports the name as
+    absent, so the sweep treats it as newly introduced.
 
     Args:
         repository_root: The repository root the lookups run in.
         all_names: The identifier names to look up.
+        tree_revision: The revision whose tree is searched.
 
     Returns:
-        The subset of names present in the base tree.
+        The subset of names present in that tree.
     """
     all_present_names: set[str] = set()
     for each_name in sorted(all_names):
@@ -645,7 +648,7 @@ def _base_tree_names(
                 [
                     *ALL_GIT_GREP_BASE_TREE_COMMAND_PREFIX,
                     each_name,
-                    GIT_BASE_TREE_REVISION,
+                    tree_revision,
                 ],
                 cwd=str(repository_root),
                 capture_output=True,
@@ -695,14 +698,16 @@ def _raise_for_git_failure(
 
 
 def _strict_base_tree_names(
-    repository_root: Path, all_names: frozenset[str]
+    repository_root: Path,
+    all_names: frozenset[str],
+    tree_revision: 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,
+            tree_revision,
         )
         grep_process = _run_strict_git(repository_root, all_arguments)
         if grep_process.returncode == 0:
@@ -728,14 +733,53 @@ def strict_staged_terminology_findings(repository_root: Path) -> list[str]:
         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
+    return _strict_terminology_findings(
+        repository_root,
+        ALL_GIT_DIFF_CACHED_UNIFIED_ZERO_COMMAND,
+        GIT_BASE_TREE_REVISION,
     )
+
+
+def strict_base_terminology_findings(
+    repository_root: Path, base_revision: str
+) -> list[str]:
+    """Return near-miss findings for worktree changes against a base revision.
+
+    Args:
+        repository_root: The repository root the worktree diff is read from.
+        base_revision: The tree that worktree changes are compared against.
+
+    Returns:
+        One finding string per near-miss term on an added prose line.
+
+    Raises:
+        RuntimeError: Git could not read the committed diff or look up an
+            identifier in the comparison tree.
+    """
+    all_arguments = (
+        *ALL_GIT_DIFF_UNIFIED_ZERO_COMMAND,
+        base_revision,
+    )
+    return _strict_terminology_findings(
+        repository_root,
+        all_arguments,
+        base_revision,
+    )
+
+
+def _strict_terminology_findings(
+    repository_root: Path,
+    all_diff_arguments: Sequence[str],
+    tree_revision: str,
+) -> list[str]:
+    diff_process = _run_strict_git(repository_root, all_diff_arguments)
     _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)
+        for each_name in _strict_base_tree_names(
+            repository_root, all_added_names, tree_revision
+        )
     )
     return _find_terminology_near_misses(diff_process.stdout, preexisting_tuples)
 
@@ -743,16 +787,15 @@ def strict_staged_terminology_findings(repository_root: Path) -> list[str]:
 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
-    identifiers are swept.
+    An identifier already present in HEAD is not treated as introduced, so
+    prose is not flagged against it.
 
     Args:
         repository_root: The repository root the staged diff is read from.
 
     Returns:
-        One finding string per near-miss term on a staged added prose line, or
-        an empty list when the staged diff is empty or git cannot be run.
+        One finding string per near-miss term on a staged prose line, or an
+        empty list when the staged diff is empty or git cannot be run.
     """
     diff_process = subprocess.run(
         list(ALL_GIT_DIFF_CACHED_UNIFIED_ZERO_COMMAND),
@@ -770,7 +813,9 @@ def staged_terminology_findings(repository_root: Path) -> list[str]:
     all_added_names = _identifier_names_on_added_code_lines(diff_process.stdout)
     preexisting_tuples = frozenset(
         _identifier_token_tuple(each_name)
-        for each_name in _base_tree_names(repository_root, all_added_names)
+        for each_name in _base_tree_names(
+            repository_root, all_added_names, GIT_BASE_TREE_REVISION
+        )
     )
     return _find_terminology_near_misses(diff_process.stdout, preexisting_tuples)
 

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

@@ -31,6 +31,7 @@ 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
+strict_base_terminology_findings = sweep_module.strict_base_terminology_findings
 main = sweep_module.main
 parse_added_lines = sweep_module._parse_added_lines
 
@@ -53,6 +54,54 @@ def _init_git_repository(repository_path: Path) -> None:
         )
 
 
+def _run_repository_git(repository_path: Path, all_arguments: list[str]) -> str:
+    completed = subprocess.run(
+        all_arguments,
+        cwd=repository_path,
+        check=True,
+        capture_output=True,
+        text=True,
+        env=_hermetic_git_environment(),
+    )
+    return completed.stdout.strip()
+
+
+def _write_repository_text(
+    repository_path: Path, relative_path: str, text: str
+) -> None:
+    (repository_path / relative_path).write_text(text, encoding="utf-8")
+
+
+def _commit_all(repository_path: Path, message: str) -> None:
+    _run_repository_git(repository_path, ["git", "add", "-A"])
+    _run_repository_git(repository_path, ["git", "commit", "-m", message])
+
+
+def _head_revision(repository_path: Path) -> str:
+    return _run_repository_git(repository_path, ["git", "rev-parse", "HEAD"])
+
+
+def _committed_near_miss_repository(repository_path: Path) -> str:
+    _init_git_repository(repository_path)
+    _write_repository_text(repository_path, "quota.py", "baseline = 1\n")
+    _write_repository_text(repository_path, "README.md", "Baseline quota text.\n")
+    _commit_all(repository_path, "base")
+    comparison_revision = _head_revision(repository_path)
+    _write_repository_text(
+        repository_path,
+        "quota.py",
+        "baseline = 1\npremium_request_interactions = 5\n",
+    )
+    _commit_all(repository_path, "identifier")
+    _write_repository_text(
+        repository_path,
+        "README.md",
+        "The premium-request-budget field gates the run.\n",
+    )
+    _commit_all(repository_path, "documentation")
+    return comparison_revision
+
+
 CODE_AND_PROSE_DIFF = (
     "diff --git a/api/quota.py b/api/quota.py\n"
     "--- a/api/quota.py\n"
@@ -310,6 +359,16 @@ def test_staged_terminology_findings_empty_when_clean(tmp_path: Path) -> None:
     assert staged_terminology_findings(tmp_path) == []
 
 
+def test_strict_base_terminology_findings_reports_committed_near_miss(
+    tmp_path: Path,
+) -> None:
+    comparison_revision = _committed_near_miss_repository(tmp_path)
+    all_findings = strict_base_terminology_findings(tmp_path, comparison_revision)
+    assert len(all_findings) == 1
+    assert "README.md:1" in all_findings[0]
+    assert "premium-request-budget" in all_findings[0]
+
+
 def test_parse_added_lines_counts_pre_increment_content_as_added_line() -> None:
     diff_with_pre_increment = (
         "diff --git a/app.mjs b/app.mjs\n"

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.agents-home.test.mjs

@@ -32,6 +32,8 @@ const INSTALLER_PATH = join(THIS_DIRECTORY, 'install.mjs');
 const PACKAGE_DIRECTORY = dirname(THIS_DIRECTORY);
 const SHIPPED_SKILL_NAME = 'privacy-hygiene';
 const ELI5_SKILL_NAME = 'eli5';
+const E_CODE_REVIEW_SKILL_NAME = 'e-code-review';
+const REFERENCE_DIRECTORY_NAME = 'reference';
 const SHIPPED_AGENT_FILE_NAME = 'clean-coder.md';
 const SHIPPED_AGENT_FILE_NAMES = [
     SHIPPED_AGENT_FILE_NAME,
@@ -69,10 +71,7 @@ const CLEAN_CODER_POLICY_REFERENCES = [
     ],
 ];
 const PERSONAL_SKILL_NAME = 'my-notes';
-const SHARED_DIRECTORY_NAME = '_shared';
-const PR_LOOP_DIRECTORY_NAME = 'pr-loop';
 const PREFLIGHT_PROPOSAL_FILE_NAME = 'preflight-proposal.md';
-const PREFLIGHT_PROPOSAL_POINTER = '@~/.claude/_shared/pr-loop/preflight-proposal.md';
 
 /**
  * @param {string} homeDirectory
@@ -100,20 +99,23 @@ function runInstaller(homeDirectory, extraArguments, environmentOverrides = {})
 }
 
 /**
- * @param {{ homeDirectory: string, skillsInstallDirectory: string }} installationPaths
+ * @param {{ skillsInstallDirectory: string }} installationPaths
  */
 function assertProposalContractInstallation(installationPaths) {
-    const { homeDirectory, skillsInstallDirectory } = installationPaths;
+    const { skillsInstallDirectory } = installationPaths;
     const allContractPathSegments = [
-        SHARED_DIRECTORY_NAME, PR_LOOP_DIRECTORY_NAME, PREFLIGHT_PROPOSAL_FILE_NAME,
+        E_CODE_REVIEW_SKILL_NAME,
+        REFERENCE_DIRECTORY_NAME,
+        PREFLIGHT_PROPOSAL_FILE_NAME,
     ];
-    const installedPointerPath = join(skillsInstallDirectory, ...allContractPathSegments);
-    const pointerLine = readFileSync(installedPointerPath, 'utf8').trimEnd().split('\n').at(-1);
-    const allTargetSegments = pointerLine.slice('@~/'.length).split('/');
-    const installedContractPath = join(homeDirectory, ...allTargetSegments);
-    const sourceContractPath = join(PACKAGE_DIRECTORY, ...allContractPathSegments);
+    const installedContractPath = join(skillsInstallDirectory, ...allContractPathSegments);
+    const sourceSkillsDirectory = resolvePackageManagedDirectory(
+        PACKAGE_DIRECTORY,
+        MANAGED_SKILLS_DIRECTORY_NAME,
+    );
+    const sourceContractPath = join(sourceSkillsDirectory, ...allContractPathSegments);
 
-    assert.equal(pointerLine, PREFLIGHT_PROPOSAL_POINTER);
+    assert.equal(existsSync(installedContractPath), true);
     assert.equal(readFileSync(installedContractPath, 'utf8'), readFileSync(sourceContractPath, 'utf8'));
 }
 
@@ -197,7 +199,7 @@ test('a full install writes skills and agents under .agents and points .claude a
         );
         assert.equal(realpathSync(lookupSkillFile), realpathSync(canonicalSkillFile));
         assert.equal(realpathSync(lookupEli5SkillFile), realpathSync(canonicalEli5SkillFile));
-        assertProposalContractInstallation({ homeDirectory, skillsInstallDirectory });
+        assertProposalContractInstallation({ skillsInstallDirectory });
         assert.equal(
             readFileSync(lookupAgentFile, 'utf8'),
             readFileSync(canonicalAgentFile, 'utf8'),

package/bin/install.mjs

@@ -35,6 +35,11 @@ import {
     WINDOWS_PYTHON_LAUNCHER_COMMAND,
     PYTHON_PROBE_TIMEOUT_MILLISECONDS,
 } from './install-constants.mjs';
+import {
+    PSTACK_PLUGIN_DIRECTORY_NAME,
+    PSTACK_PLUGIN_MANIFEST_RELATIVE_PATH,
+    refreshPstackPluginManifest,
+} from '../scripts/refresh_pstack_plugin_skills.mjs';
 import {
     resolveInstallRoot,
     parseExplicitTargetFromArgv,
@@ -172,6 +177,7 @@ export const CORE_SKILLS = [
     'grok-spawn',
     'pr-small-cl',
     'everything-search',
+    'test-runner',
     'privacy-hygiene',
     'issue-tracker',
     'task-build',
@@ -428,6 +434,26 @@ export function runCursorRuleSync(pythonCommand, scriptPath, claudeRoot, cursorR
     );
 }
 
+/**
+ * Refresh the pstack plugin manifest Claude Code reads, when this home has one.
+ *
+ * Claude Code loads a skills-directory folder as a plugin when it holds
+ * `.claude-plugin/plugin.json`, and namespaces its skills as `pstack:how`.
+ * Without the manifest, a folder of skill folders loads nothing.
+ *
+ * @param {string} [skillsRoot] The skills root to read. Defaults to the root
+ *   this run installs into.
+ * @returns {string|null} The manifest path when this run wrote it, else null.
+ */
+export function refreshInstalledPstackPluginManifest(
+    skillsRoot = join(CLAUDE_HOME, MANAGED_SKILLS_DIRECTORY_NAME),
+) {
+    const pluginRoot = join(skillsRoot, PSTACK_PLUGIN_DIRECTORY_NAME);
+    const outcome = refreshPstackPluginManifest(pluginRoot);
+    if (!outcome.didWrite) return null;
+    return join(pluginRoot, PSTACK_PLUGIN_MANIFEST_RELATIVE_PATH);
+}
+
 function seedCodexPstackPreferences() {
     const preferenceDirectory = join(AGENTS_HOME, CURSOR_RULES_DIRECTORY_NAME);
     const preferencePath = join(
@@ -1181,6 +1207,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 +1229,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',
 ]);
 
 /**
@@ -2312,6 +2345,9 @@ function executeInstallPlanMutations(plan, transactionHelpers) {
     }
     summary.skills = { created: skillsCreated, updated: skillsUpdated, pruned: 0, paths: skillPaths };
     allInstalledFiles.push(...skillPaths);
+    const pstackManifestPath = refreshInstalledPstackPluginManifest();
+    if (pstackManifestPath) allInstalledFiles.push(pstackManifestPath);
+    summary.pstackPlugin = { manifestPath: pstackManifestPath };
     syncWrittenPaths([...allInstalledFiles, ...publishedPointerPaths]);
     throwIfFault(FAULT_PHASES.AFTER_FILE_STAGING);
     throwIfFault(FAULT_PHASES.BEFORE_DURABLE_PROMOTION);

package/bin/install.policy-lint.test.mjs

@@ -0,0 +1,78 @@
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+import { readFileSync } from 'node:fs';
+import {
+    FOLDED_HOOK_RELATIVE_PATHS,
+    mergeHooksIntoSettings,
+} from './install.mjs';
+
+const allRetiredWriteHooks = [
+    'blocking/code_rules_enforcer.py',
+    'blocking/tdd_enforcer.py',
+    'blocking/windows_rmtree_blocker.py',
+    'blocking/state_description_blocker.py',
+    'blocking/subprocess_budget_completeness.py',
+    'blocking/hook_prose_detector_consistency.py',
+    'blocking/workflow_substitution_slot_blocker.py',
+];
+const sourceHooks = JSON.parse(readFileSync(new URL('../hooks/hooks.json', import.meta.url), 'utf8'));
+const installedRoot = '/fixture-home/.claude';
+const foreignCommand = 'python /unmanaged/keep_this_hook.py';
+const foreignSessionCommand = 'node /unmanaged/session.js';
+
+function legacySettings() {
+    return {
+        permissions: { allow: ['Read'] },
+        hooks: {
+            PreToolUse: [{
+                matcher: 'Write|Edit|MultiEdit|apply_patch',
+                hooks: [
+                    { type: 'command', command: foreignCommand, timeout: 17 },
+                    ...allRetiredWriteHooks.map(relativePath => ({
+                        type: 'command',
+                        command: `python ${installedRoot}/hooks/${relativePath}`,
+                        timeout: 10,
+                    })),
+                ],
+            }],
+            SessionStart: [{
+                matcher: '',
+                hooks: [{ type: 'command', command: foreignSessionCommand, timeout: 9 }],
+            }],
+        },
+    };
+}
+
+function allCommands(settings) {
+    return Object.values(settings.hooks).flatMap(groups =>
+        groups.flatMap(group => group.hooks.map(hook => hook.command)));
+}
+
+test('every retired write registration already has an installer-owned prune path', () => {
+    for (const relativePath of allRetiredWriteHooks) {
+        assert.ok(FOLDED_HOOK_RELATIVE_PATHS.has(relativePath), relativePath);
+    }
+});
+
+test('upgrade prunes legacy direct file checks while retaining foreign hooks', () => {
+    const settings = legacySettings();
+    mergeHooksIntoSettings(settings, sourceHooks, installedRoot, 'python3');
+    const commands = allCommands(settings);
+    for (const relativePath of allRetiredWriteHooks) {
+        assert.ok(!commands.some(command => command.includes(relativePath)), relativePath);
+    }
+    assert.ok(commands.includes(foreignCommand));
+    assert.ok(commands.includes(foreignSessionCommand));
+    assert.deepEqual(settings.permissions, { allow: ['Read'] });
+    assert.ok(commands.some(command => command.includes('/blocking/pre_tool_use_dispatcher.py')));
+    assert.ok(commands.some(command => command.includes('/blocking/bash_pre_tool_use_dispatcher.py')));
+});
+
+test('reinstall does not restore retired direct checks or duplicate foreign hooks', () => {
+    const settings = legacySettings();
+    mergeHooksIntoSettings(settings, sourceHooks, installedRoot, 'python3');
+    const firstInstall = structuredClone(settings);
+    mergeHooksIntoSettings(settings, sourceHooks, installedRoot, 'python3');
+    assert.deepEqual(settings, firstInstall);
+    assert.equal(allCommands(settings).filter(command => command === foreignCommand).length, 1);
+});