claude-dev-env 4.3.0 → 7.0.0

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,
@@ -429,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(
@@ -2320,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);
+});

package/bin/install.prune.test.mjs

@@ -25,16 +25,43 @@ const RETIRED_SKILL_DIRECTORIES = [
     'post-audit-findings',
     'pr-consistency-audit',
     'bdd-protocol',
+    'hitl',
+    'autoconverge',
+    'pr-cleanup',
+    'pr-name-by-capability',
+    'pr-plain-language-cleanup',
+    'pr-refinement',
+    'pr-shared-extraction',
+    'pr-small-cl',
+    'pr-title-description',
+    'prototype',
+    'rebase',
+    'review-router',
+    'review-tier',
+    'run-claude-dev-env',
+    'session-log',
+    'session-tidy',
+    'source-command-sr-loop',
+    'update',
 ];
 const PERSONAL_SKILL_DIRECTORIES = ['credit-card-picker', 'midjourney-sref'];
-const SHIPPED_SKILL_DIRECTORY = 'autoconverge';
+const SHIPPED_SKILL_DIRECTORY = 'e-code-review';
 const PRUNED_BACKUP_DIRECTORY_NAME = '.claude-dev-env-pruned';
 const SKIP_PRUNE_NOTICE_MARKER = 'Skipping retired-skill and stale-file prune';
 const STALE_SKILL_FILE_RELATIVE_SEGMENTS = ['scripts', 'retired_module.py'];
 const RUNTIME_ARTIFACT_RELATIVE_SEGMENTS = ['scripts', '__pycache__', 'helper.cpython-312.pyc'];
 const SCOPED_GROUP_SKILL_DIRECTORY = 'orchestrator';
-const CORE_REVIEW_GUIDE_SKILL_DIRECTORIES = [
-    'pr-small-cl',
+const CORE_SKILL_DIRECTORIES = [
+    'orchestrator',
+    'orchestrator-refresh',
+    'team-advisor',
+    'grok-spawn',
+    'everything-search',
+    'test-runner',
+    'privacy-hygiene',
+    'issue-tracker',
+    'task-build',
+    'eli5',
 ];
 const PRIOR_RUN_BACKUP_DIRECTORY_NAMES = [
     '2020-01-01T00-00-00-000Z',
@@ -693,25 +720,33 @@ test('a scoped --only install leaves retired skills in place because prune runs
     }
 });
 
-test('a full reinstall keeps autoconverge because the package ships it again', () => {
+test('a full reinstall keeps the skill-builder stub and archives its obsolete support files', () => {
     const sandbox = createSandbox();
     try {
-        plantSkillDirectory(sandbox.skillsDirectory, 'autoconverge', true);
-        writeFileSync(join(sandbox.skillsDirectory, 'autoconverge', 'SKILL.md'), 'stale seeded copy\n');
+        const skillName = 'skill-builder';
+        plantSkillDirectory(sandbox.skillsDirectory, skillName, true);
+        const stubPath = join(sandbox.skillsDirectory, skillName, 'SKILL.md');
+        const obsoleteReferencePath = join(sandbox.skillsDirectory, skillName, 'references', 'retired.md');
+        writeFileWithParents(obsoleteReferencePath, 'obsolete skill-builder guidance\n');
+        writeFileSync(sandbox.manifestPath, JSON.stringify({
+            package: 'claude-dev-env',
+            version: '0.0.0',
+            installedAt: new Date().toISOString(),
+            files: [stubPath, obsoleteReferencePath],
+            skills: [skillName],
+        }, null, 2) + '\n');
 
         const installerOutput = runInstaller(sandbox.homeDirectory, []);
 
+        assert.equal(installerOutput.includes(SKIP_PRUNE_NOTICE_MARKER), false);
+        assert.equal(existsSync(stubPath), true, 'the requested stub stays installed');
+        assert.match(readFileSync(stubPath, 'utf8'), /TODO: Rework to follow pstack philosophy\./);
+        assert.ok(readManifest(sandbox.manifestPath).skills.includes(skillName));
+        assert.equal(existsSync(obsoleteReferencePath), false);
         assert.equal(
-            installerOutput.includes(SKIP_PRUNE_NOTICE_MARKER),
-            false,
-            'the full install runs the prune rather than skipping it',
-        );
-        const restoredSkillPath = join(sandbox.skillsDirectory, 'autoconverge', 'SKILL.md');
-        assert.equal(existsSync(restoredSkillPath), true, 'autoconverge survives and is reinstalled');
-        assert.notEqual(
-            readFileSync(restoredSkillPath, 'utf8'),
-            'stale seeded copy\n',
-            'the shipped autoconverge overwrites the stale seeded copy',
+            prunedSkillBackupContains(sandbox.claudeDirectory, join(skillName, 'references', 'retired.md')),
+            true,
+            'old implementation files move to the recovery backup while the stub stays',
         );
     } finally {
         rmSync(sandbox.homeDirectory, { recursive: true, force: true });
@@ -739,20 +774,24 @@ test('a scoped --only install records the skill names it installed', () => {
     }
 });
 
-test('a scoped core install ships the canonical review guide skills', () => {
+test('a fresh scoped core install ships active skills and omits retired skills', () => {
     const sandbox = createSandbox();
     try {
         runInstaller(sandbox.homeDirectory, ['--only', 'core']);
 
-        const missingGuideSkillNames = CORE_REVIEW_GUIDE_SKILL_DIRECTORIES.filter(
+        const missingSkillNames = CORE_SKILL_DIRECTORIES.filter(
             eachSkillName => !existsSync(join(sandbox.skillsDirectory, eachSkillName, 'SKILL.md')),
         );
-        assert.deepEqual(missingGuideSkillNames, []);
+        assert.deepEqual(missingSkillNames, []);
 
         const recordedSkillNames = new Set(readManifest(sandbox.manifestPath).skills);
-        for (const eachSkillName of CORE_REVIEW_GUIDE_SKILL_DIRECTORIES) {
+        for (const eachSkillName of CORE_SKILL_DIRECTORIES) {
             assert.equal(recordedSkillNames.has(eachSkillName), true);
         }
+        for (const eachSkillName of RETIRED_SKILL_DIRECTORIES) {
+            assert.equal(existsSync(join(sandbox.skillsDirectory, eachSkillName)), false);
+            assert.equal(recordedSkillNames.has(eachSkillName), false);
+        }
     } finally {
         rmSync(sandbox.homeDirectory, { recursive: true, force: true });
     }

package/bin/install.pstack-plugin.test.mjs

@@ -0,0 +1,114 @@
+import { test } from 'node:test';
+import { strict as assert } from 'node:assert';
+import {
+    mkdtempSync,
+    mkdirSync,
+    writeFileSync,
+    readFileSync,
+    existsSync,
+    rmSync,
+} from 'node:fs';
+import { tmpdir } from 'node:os';
+import { dirname, join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { execFileSync } from 'node:child_process';
+import { resolveInstallRoot } from './resolve-install-root.mjs';
+import { PSTACK_PLUGIN_MANIFEST_RELATIVE_PATH } from '../scripts/refresh_pstack_plugin_skills.mjs';
+
+const THIS_DIRECTORY = dirname(fileURLToPath(import.meta.url));
+const INSTALLER_PATH = join(THIS_DIRECTORY, 'install.mjs');
+const PACKAGE_DIRECTORY = dirname(THIS_DIRECTORY);
+
+function runInstaller(homeDirectory, extraArguments) {
+    return execFileSync('node', [INSTALLER_PATH, ...extraArguments], {
+        cwd: PACKAGE_DIRECTORY,
+        encoding: 'utf8',
+        env: {
+            ...process.env,
+            HOME: homeDirectory,
+            USERPROFILE: homeDirectory,
+            CODEX_HOME: join(homeDirectory, '.codex'),
+            CLAUDE_CONFIG_DIR: join(homeDirectory, '.claude'),
+            GIT_CONFIG_GLOBAL: join(homeDirectory, '.gitconfig'),
+        },
+    });
+}
+
+function seedPstackSkills(agentsHome, skillNames) {
+    const pluginRoot = join(agentsHome, 'skills', 'pstack');
+    for (const eachSkillName of skillNames) {
+        const skillDirectory = join(pluginRoot, eachSkillName);
+        mkdirSync(skillDirectory, { recursive: true });
+        writeFileSync(join(skillDirectory, 'SKILL.md'), '---\nname: ' + eachSkillName + '\n---\n');
+    }
+    return pluginRoot;
+}
+
+function withTemporaryHome(runAssertions) {
+    const homeDirectory = mkdtempSync(join(tmpdir(), 'cdev-pstack-plugin-'));
+    try {
+        const resolution = resolveInstallRoot({
+            homeDirectory,
+            environment: {},
+            explicitTarget: null,
+        });
+        runAssertions(homeDirectory, resolution);
+    } finally {
+        rmSync(homeDirectory, { recursive: true, force: true });
+    }
+}
+
+test('a pstack folder the user installed gains a plugin manifest', () => {
+    withTemporaryHome((homeDirectory, resolution) => {
+        const pluginRoot = seedPstackSkills(resolution.agentsHome, ['how', 'why']);
+
+        runInstaller(homeDirectory, ['--only', 'core']);
+
+        const manifestPath = join(pluginRoot, PSTACK_PLUGIN_MANIFEST_RELATIVE_PATH);
+        assert.equal(existsSync(manifestPath), true);
+        const manifest = JSON.parse(readFileSync(manifestPath, 'utf8'));
+        assert.equal(manifest.name, 'pstack');
+        assert.deepEqual(manifest.skills, ['./how', './why']);
+    });
+});
+
+test('a second install leaves an unchanged manifest byte for byte', () => {
+    withTemporaryHome((homeDirectory, resolution) => {
+        const pluginRoot = seedPstackSkills(resolution.agentsHome, ['how']);
+
+        runInstaller(homeDirectory, ['--only', 'core']);
+        const manifestPath = join(pluginRoot, PSTACK_PLUGIN_MANIFEST_RELATIVE_PATH);
+        const afterFirstInstall = readFileSync(manifestPath, 'utf8');
+        runInstaller(homeDirectory, ['--only', 'core']);
+
+        assert.equal(readFileSync(manifestPath, 'utf8'), afterFirstInstall);
+    });
+});
+
+test('a later install lists a skill a pstack update added', () => {
+    withTemporaryHome((homeDirectory, resolution) => {
+        const pluginRoot = seedPstackSkills(resolution.agentsHome, ['how']);
+        runInstaller(homeDirectory, ['--only', 'core']);
+
+        seedPstackSkills(resolution.agentsHome, ['why']);
+        runInstaller(homeDirectory, ['--only', 'core']);
+
+        const manifestPath = join(pluginRoot, PSTACK_PLUGIN_MANIFEST_RELATIVE_PATH);
+        const manifest = JSON.parse(readFileSync(manifestPath, 'utf8'));
+        assert.deepEqual(manifest.skills, ['./how', './why']);
+    });
+});
+
+test('an install with no pstack folder writes no manifest and does not fail', () => {
+    withTemporaryHome((homeDirectory, resolution) => {
+        runInstaller(homeDirectory, ['--only', 'core']);
+
+        const manifestPath = join(
+            resolution.agentsHome,
+            'skills',
+            'pstack',
+            PSTACK_PLUGIN_MANIFEST_RELATIVE_PATH,
+        );
+        assert.equal(existsSync(manifestPath), false);
+    });
+});

package/bin/install.test.mjs

@@ -43,6 +43,7 @@ import {
     retiredManagedHookRelativePaths,
     pruneRetiredHookEntriesFromSettings,
     retainNewestRunBackupOnly,
+    refreshInstalledPstackPluginManifest,
 } from './install.mjs';
 import { EVER_SHIPPED_SKILL_NAMES } from './ever-shipped-skills.mjs';
 import {
@@ -2541,3 +2542,39 @@ test('pruneStaleInstalledFiles leaves the run backup root standing when the rena
         rmSync(sandbox.root, { recursive: true, force: true });
     }
 });
+
+test('the pstack step writes a manifest for a skills root that carries pstack', () => {
+    const skillsRoot = mkdtempSync(join(tmpdir(), 'cdev-pstack-step-'));
+    try {
+        const skillDirectory = join(skillsRoot, 'pstack', 'how');
+        mkdirSync(skillDirectory, { recursive: true });
+        writeFileSync(join(skillDirectory, 'SKILL.md'), '---\nname: how\n---\n');
+
+        const manifestPath = refreshInstalledPstackPluginManifest(skillsRoot);
+
+        assert.equal(
+            manifestPath,
+            join(skillsRoot, 'pstack', '.claude-plugin', 'plugin.json'),
+            'the step reports the manifest it wrote so the run records the path',
+        );
+        const manifest = JSON.parse(readFileSync(manifestPath, 'utf8'));
+        assert.deepEqual(manifest.skills, ['./how']);
+        assert.equal(
+            refreshInstalledPstackPluginManifest(skillsRoot),
+            null,
+            'a second run writes nothing and reports no path',
+        );
+    } finally {
+        rmSync(skillsRoot, { recursive: true, force: true });
+    }
+});
+
+test('the pstack step reports no path for a skills root without pstack', () => {
+    const skillsRoot = mkdtempSync(join(tmpdir(), 'cdev-pstack-absent-'));
+    try {
+        assert.equal(refreshInstalledPstackPluginManifest(skillsRoot), null);
+        assert.equal(existsSync(join(skillsRoot, 'pstack')), false);
+    } finally {
+        rmSync(skillsRoot, { recursive: true, force: true });
+    }
+});