claude-dev-env 8.88.7 → 8.90.0

package/bin/install.codex-rules.test.mjs

@@ -62,7 +62,6 @@ function runInstaller(homeDirectory, extraArguments) {
             CDE_INSTALL_DEEPSTACK: '0',
             CDE_INSTALL_USAGE_WRAPUP: '0',
             CDE_INSTALL_SUBAGENT_MODELS: '0',
-            CDE_INSTALL_DEEPEN_FIRST_PROMPT: '0',
             HOME: homeDirectory,
             USERPROFILE: homeDirectory,
             GIT_CONFIG_GLOBAL: join(homeDirectory, '.gitconfig'),
@@ -96,7 +95,6 @@ function scanTextWithProductionPiiScanner(scannedText) {
                     CDE_INSTALL_DEEPSTACK: '0',
                     CDE_INSTALL_USAGE_WRAPUP: '0',
                     CDE_INSTALL_SUBAGENT_MODELS: '0',
-                    CDE_INSTALL_DEEPEN_FIRST_PROMPT: '0',
                     PYTHONPATH: BLOCKING_HOOKS_DIRECTORY,
                     CLAUDE_LOCAL_IDENTITY_PATH: join(
                         temporaryDirectory,

package/bin/install.cursor-rules.test.mjs

@@ -36,7 +36,6 @@ function runInstaller(homeDirectory, extraArguments, environmentOverrides = {})
             CDE_INSTALL_DEEPSTACK: '0',
             CDE_INSTALL_USAGE_WRAPUP: '0',
             CDE_INSTALL_SUBAGENT_MODELS: '0',
-            CDE_INSTALL_DEEPEN_FIRST_PROMPT: '0',
             HOME: homeDirectory,
             USERPROFILE: homeDirectory,
             CODEX_HOME: join(homeDirectory, '.codex'),
@@ -135,14 +134,20 @@ test('seeds one editable policy and one native Codex routing hook', () => {
         );
         assert.equal(firstSpawnPromptGroups.length, 1);
         assert.match(firstSpawnPromptGroups[0].hooks[0].command, /skill_loaded_reminder\.py/);
-        assert.deepEqual(Object.keys(firstCodexHooks.hooks), ['PreToolUse', 'UserPromptSubmit', 'Stop']);
+        assert.deepEqual(Object.keys(firstCodexHooks.hooks), ['PreToolUse', 'UserPromptSubmit', 'PostToolUse', 'Stop']);
+        const allCodexPostToolUseCommands = firstCodexHooks.hooks.PostToolUse.flatMap(
+            group => group.hooks.map(hook => hook.command),
+        );
+        assert.equal(allCodexPostToolUseCommands.length, 1, 'Codex gets the owned PR review loop and no other PostToolUse hook');
+        assert.match(allCodexPostToolUseCommands[0], /advisory\/owned_pr_review_loop\.py/);
         const allCodexStopCommands = firstCodexHooks.hooks.Stop.flatMap(group => group.hooks.map(hook => hook.command));
         assert.equal(allCodexStopCommands.length, 1, 'Codex gets the open tasks Stop gate and no other Stop hook');
         assert.match(allCodexStopCommands[0], /open_tasks_stop_gate\.py/);
-        assert.ok(
-            firstCodexHooks.hooks.UserPromptSubmit.some(group =>
+        assert.equal(
+            (firstCodexHooks.hooks.UserPromptSubmit ?? []).some(group =>
                 group.hooks.some(hook => String(hook.command).includes('deepen_first_prompt.py')),
             ),
+            false,
         );
         assert.equal(
             firstCodexHooks.hooks.PreToolUse.some(group => group.matcher === 'Write|Edit|MultiEdit|apply_patch'),
@@ -285,6 +290,7 @@ test('Codex reinstall removes omitted package hooks and preserves user configura
         const suffixCommand = `python "${join(codexHome, 'hooks', 'blocking', 'pre_tool_use_dispatcher.py.backup')}"`;
         hooksByEvent.PreToolUse.push({ matcher: 'suffix', hooks: [{ type: 'command', command: suffixCommand }] });
         hooksByEvent.CustomEvent = { metadata: 'keep-event' };
+        hooksByEvent.PostToolUse = [{ matcher: 'Write', hooks: [{ type: 'command', command: 'python user-post-tool-use.py' }] }];
         const expectedUserHooks = JSON.parse(JSON.stringify(hooksByEvent));
         for (const eachGroup of Object.values(expectedUserHooks).flat()) {
             if (eachGroup.hooks && eachGroup.metadata) eachGroup.hooks.shift();
@@ -301,15 +307,20 @@ test('Codex reinstall removes omitted package hooks and preserves user configura
             ['Agent|Task', 'multi_agent_v1__spawn_agent'].includes(eachGroup.matcher));
         assert.equal(allSpawnGroups.length, 2);
         migratedHooks.hooks.PreToolUse = migratedHooks.hooks.PreToolUse.filter(eachGroup => !allSpawnGroups.includes(eachGroup));
-        const allPackagePromptCommands = migratedHooks.hooks.UserPromptSubmit
+        const allPackagePromptCommands = (migratedHooks.hooks.UserPromptSubmit ?? [])
             .flatMap(eachGroup => eachGroup.hooks)
             .map(eachHook => eachHook.command);
-        assert.ok(allPackagePromptCommands.some(eachCommand => eachCommand.includes('deepen_first_prompt.py')));
+        assert.equal(allPackagePromptCommands.some(eachCommand => eachCommand.includes('deepen_first_prompt.py')), false);
         delete migratedHooks.hooks.UserPromptSubmit;
         const allPackageStopGroups = migratedHooks.hooks.Stop.filter(eachGroup =>
             eachGroup.hooks.some(eachHook => eachHook.command.includes('open_tasks_stop_gate.py')));
         assert.equal(allPackageStopGroups.length, 1);
         migratedHooks.hooks.Stop = migratedHooks.hooks.Stop.filter(eachGroup => !allPackageStopGroups.includes(eachGroup));
+        const allPackagePostToolUseGroups = migratedHooks.hooks.PostToolUse.filter(eachGroup =>
+            eachGroup.hooks.some(eachHook => eachHook.command.includes('owned_pr_review_loop.py')));
+        assert.equal(allPackagePostToolUseGroups.length, 1);
+        assert.equal(allPackagePostToolUseGroups[0].hooks.length, 1);
+        migratedHooks.hooks.PostToolUse = migratedHooks.hooks.PostToolUse.filter(eachGroup => !allPackagePostToolUseGroups.includes(eachGroup));
         assert.deepEqual(migratedHooks, { enabled: false, metadata: 'keep-file', hooks: expectedUserHooks });
         assert.equal(readFileSync(configPath, 'utf8'), disabledConfig);
         const firstInstall = readFileSync(codexHooksPath, 'utf8');
@@ -356,27 +367,91 @@ test('uninstall removes the routing hook and keeps a Codex user hook', () => {
     }
 });
 
-test('should ship the deepen skill to Cursor and the deepen block to Codex, and remove both on uninstall', () => {
-    const homeDirectory = mkdtempSync(join(tmpdir(), 'cdev-deepen-surfaces-'));
+const RETIRED_DEEPEN_CODEX_BLOCK = '<!-- claude-dev-env deepen: start -->\nDeepen the first interactive user task.\n<!-- claude-dev-env deepen: end -->\n';
+
+function allSettingsHookCommands(settingsPath) {
+    const settings = JSON.parse(readFileSync(settingsPath, 'utf8'));
+    return Object.values(settings.hooks ?? {})
+        .flatMap(allGroups => allGroups)
+        .flatMap(group => group.hooks ?? [])
+        .map(hook => String(hook.command));
+}
+
+function assertNoDeepenPieceInstalled(homeDirectory, cursorSkillPath, codexGuidancePath, settingsPath) {
+    assert.equal(existsSync(cursorSkillPath), false, 'the Cursor deepen skill is gone');
+    assert.equal(existsSync(join(homeDirectory, '.claude', 'skills', 'deepen')), false, 'the Claude deepen skill is gone');
+    assert.equal(existsSync(join(homeDirectory, '.claude', 'commands', 'deepen.md')), false, 'the /deepen command is gone');
+    const codexGuidance = existsSync(codexGuidancePath) ? readFileSync(codexGuidancePath, 'utf8') : '';
+    assert.doesNotMatch(codexGuidance, /claude-dev-env deepen/);
+    assert.equal(
+        allSettingsHookCommands(settingsPath).some(command => command.includes('deepen_first_prompt.py')),
+        false,
+        'settings.json runs no deepen hook',
+    );
+    const cursorHooksPath = join(homeDirectory, DEFAULT_CURSOR_DIRECTORY_NAME, 'hooks.json');
+    const cursorHooksText = existsSync(cursorHooksPath) ? readFileSync(cursorHooksPath, 'utf8') : '';
+    assert.equal(cursorHooksText.includes('deepen_first_prompt.py'), false, 'Cursor runs no deepen hook');
+    const installedHookPath = join(homeDirectory, '.claude', 'hooks', 'session', 'deepen_first_prompt.py');
+    if (existsSync(installedHookPath)) {
+        assert.match(readFileSync(installedHookPath, 'utf8'), /claude-dev-env retired hook stand-in/);
+    }
+}
+
+test('a full install over an old deepen install removes every deepen piece, and a repeat install keeps them out', () => {
+    const homeDirectory = mkdtempSync(join(tmpdir(), 'cdev-deepen-retired-'));
     try {
-        const sourceSkillPath = join(PACKAGE_DIRECTORY, '.agents', 'skills', 'deepen', 'SKILL.md');
+        const claudeDirectory = join(homeDirectory, '.claude');
         const cursorSkillPath = join(homeDirectory, DEFAULT_CURSOR_DIRECTORY_NAME, 'skills', 'deepen', 'SKILL.md');
         const codexGuidancePath = join(homeDirectory, '.codex', 'AGENTS.md');
-        const manifestPath = join(homeDirectory, '.claude', '.claude-dev-env-manifest.json');
+        const manifestPath = join(claudeDirectory, '.claude-dev-env-manifest.json');
+        const settingsPath = join(claudeDirectory, 'settings.json');
+        const retiredPluginVersion = join(claudeDirectory, 'plugins', 'cache', 'claude-dev-env', 'deepen-first-prompt', '0.1.0');
+        const fakeClaudeLogPath = join(homeDirectory, 'fake-claude.log');
+        const orphanedMarkerPath = join(retiredPluginVersion, '.orphaned_at');
+        const isWindows = process.platform === 'win32';
+        const fakeClaudePath = join(homeDirectory, isWindows ? 'fake-claude.cmd' : 'fake-claude.sh');
+        writeFileSync(
+            fakeClaudePath,
+            isWindows
+                ? `@echo off\r\n>>"${fakeClaudeLogPath}" echo %*\r\ntype nul > "${orphanedMarkerPath}"\r\n`
+                : `#!/bin/sh\necho "$@" >> '${fakeClaudeLogPath}'\ntouch '${orphanedMarkerPath}'\n`,
+            { mode: 0o755 },
+        );
+        const environment = { CDE_CLAUDE_EXECUTABLE: fakeClaudePath };
 
-        runInstaller(homeDirectory, []);
+        runInstaller(homeDirectory, [], environment);
 
-        assert.equal(readFileSync(cursorSkillPath, 'utf8'), readFileSync(sourceSkillPath, 'utf8'));
-        assert.equal(JSON.parse(readFileSync(manifestPath, 'utf8')).files.includes(cursorSkillPath), true);
-        const codexGuidance = readFileSync(codexGuidancePath, 'utf8');
-        assert.match(codexGuidance, /<!-- claude-dev-env deepen: start -->/);
-        assert.match(codexGuidance, /CDE_DEEPEN:v1/);
+        mkdirSync(dirname(cursorSkillPath), { recursive: true });
+        writeFileSync(cursorSkillPath, '# deepen\n');
+        const manifest = JSON.parse(readFileSync(manifestPath, 'utf8'));
+        manifest.files.push(cursorSkillPath);
+        writeFileSync(manifestPath, JSON.stringify(manifest, null, 2));
+        writeFileSync(codexGuidancePath, `${readFileSync(codexGuidancePath, 'utf8')}${RETIRED_DEEPEN_CODEX_BLOCK}`);
+        const settings = JSON.parse(readFileSync(settingsPath, 'utf8'));
+        const reminderCommand = settings.hooks.UserPromptSubmit
+            .flatMap(group => group.hooks)
+            .map(hook => hook.command)
+            .find(command => command.includes('skill_loaded_reminder.py'));
+        settings.hooks.UserPromptSubmit.push({
+            matcher: '',
+            hooks: [{ type: 'command', command: reminderCommand.replace('skill_loaded_reminder.py', 'deepen_first_prompt.py'), timeout: 10 }],
+        });
+        writeFileSync(settingsPath, JSON.stringify(settings, null, 2));
+        const cursorHooksPath = join(homeDirectory, DEFAULT_CURSOR_DIRECTORY_NAME, 'hooks.json');
+        const cursorHooks = JSON.parse(readFileSync(cursorHooksPath, 'utf8'));
+        cursorHooks.hooks.beforeSubmitPrompt = [{ command: "python3 '/old/hooks/session/deepen_first_prompt.py'", timeout: 10 }];
+        writeFileSync(cursorHooksPath, JSON.stringify(cursorHooks, null, 2));
+        mkdirSync(retiredPluginVersion, { recursive: true });
 
-        runInstaller(homeDirectory, ['--uninstall']);
+        runInstaller(homeDirectory, [], environment);
+
+        assertNoDeepenPieceInstalled(homeDirectory, cursorSkillPath, codexGuidancePath, settingsPath);
+        assert.match(readFileSync(fakeClaudeLogPath, 'utf8'), /^plugin uninstall deepen-first-prompt@claude-dev-env\r?$/m);
+        assert.equal(existsSync(retiredPluginVersion), false, 'the retired plugin cache is gone');
+
+        runInstaller(homeDirectory, [], environment);
 
-        assert.equal(existsSync(cursorSkillPath), false);
-        const remainingGuidance = existsSync(codexGuidancePath) ? readFileSync(codexGuidancePath, 'utf8') : '';
-        assert.doesNotMatch(remainingGuidance, /claude-dev-env deepen/);
+        assertNoDeepenPieceInstalled(homeDirectory, cursorSkillPath, codexGuidancePath, settingsPath);
     } finally {
         rmSync(homeDirectory, { recursive: true, force: true });
     }
@@ -568,7 +643,7 @@ test('a full install writes only native Cursor hooks: AGENTS.md on sessionStart
         assert.equal(gateCommands.length, 1);
         assert.deepEqual(cursorHooks.hooks.stop.filter(entry => entry.command === userStopEntry.command), [userStopEntry]);
         assert.equal(execSync(gateCommands[0], { input: '{"conversation_id": "c-1", "status": "completed"}', encoding: 'utf8' }), '');
-        assert.deepEqual(cursorHooks.hooks.beforeSubmitPrompt, [{ command: "python3 '/old/hooks/session/deepen_first_prompt.py'", timeout: 10 }]);
+        assert.equal(cursorHooks.hooks.beforeSubmitPrompt, undefined);
 
         runInstaller(homeDirectory, ['--uninstall']);
         const remainingHooks = JSON.parse(readFileSync(cursorHooksPath, 'utf8'));

package/bin/install.mjs

@@ -52,19 +52,22 @@ import {
     PYTHON_PROBE_TIMEOUT_MILLISECONDS,
     ALL_CODEX_NATIVE_PRE_TOOL_USE_MATCHERS,
     ALL_CODEX_NATIVE_STOP_HOOK_SCRIPT_NAMES,
+    ALL_CODEX_NATIVE_POST_TOOL_USE_HOOK_SCRIPT_NAMES,
 } from './install-constants.mjs';
 import {
+    ALL_RETIRED_PLUGIN_SPECS,
     PSTACK_PLUGIN_SPEC,
-    DEEPEN_FIRST_PROMPT_PLUGIN_SPEC,
     SUBAGENT_MODELS_PLUGIN_SPEC,
     USAGE_WRAPUP_PLUGIN_SPEC,
     installMarketplacePlugins,
+    removeRetiredMarketplacePlugins,
     shouldInstallMarketplacePlugin,
 } from './install-pstack-plugin.mjs';
 import {
     DEEPSTACK_PLUGIN_SPEC,
     installDeepStackForHosts,
     removeDeepStackCursorHooks,
+    removeRetiredCursorFirstTaskHook,
 } from './install-deepstack-plugin.mjs';
 import { seedCodexPstackModels } from './seed-codex-pstack-models.mjs';
 import {
@@ -85,7 +88,6 @@ import {
     removeCodexPackageGuidance,
     removeCodexQuestionGuidance,
     writeCodexAgentsGuidance,
-    writeCodexDeepenGuidance,
     writeCodexPackageGuidance,
     writeCodexQuestionGuidance,
 } from './codex-skill-load-block.mjs';
@@ -247,8 +249,8 @@ export const CORE_SKILLS = [
     'issue-tracker',
     'task-build',
     'eli5',
-    'deepen',
     'efficient-review',
+    'pr-visual',
 ];
 
 export function collectPackageSourceConflicts(packageDirectory) {
@@ -1298,6 +1300,7 @@ export const RETIRED_HOOK_REGISTRATION_RELATIVE_PATHS = new Set([
     'blocking/artifact_look_gate.py',
     'blocking/session_title_stop_gate.py',
     'session/issue_tracker_session_starter.py',
+    'session/deepen_first_prompt.py',
 ]);
 
 export const MOVED_HOOK_RELATIVE_PATHS = new Set([
@@ -1997,7 +2000,7 @@ export function pruneRetiredHookEntriesFromSettings(
     return removedCount;
 }
 
-const RETIRED_HOOK_STAND_IN_MARKER = 'claude-dev-env retired hook stand-in';
+export const RETIRED_HOOK_STAND_IN_MARKER = 'claude-dev-env retired hook stand-in';
 
 const RETIRED_HOOK_STAND_IN_SOURCE = `"""${RETIRED_HOOK_STAND_IN_MARKER}.
 
@@ -2245,15 +2248,17 @@ function mergeHooksAtPath(
     return groupCount;
 }
 
-function isCodexNativeStopHook(hook) {
-    const scriptName = String(hook?.command ?? '').replace(/\\/g, '/').split('/').pop();
-    return ALL_CODEX_NATIVE_STOP_HOOK_SCRIPT_NAMES.has(scriptName);
+function hookScriptName(hook) {
+    return String(hook?.command ?? '').replace(/\\/g, '/').split('/').pop();
 }
 
-function selectCodexNativeStopGroups(stopGroups) {
-    if (!Array.isArray(stopGroups)) return [];
-    return stopGroups
-        .map(group => ({ ...group, hooks: (group?.hooks ?? []).filter(isCodexNativeStopHook) }))
+function selectCodexNativeGroupsByScriptName(groups, allScriptNames) {
+    if (!Array.isArray(groups)) return [];
+    return groups
+        .map(group => ({
+            ...group,
+            hooks: (group?.hooks ?? []).filter(hook => allScriptNames.has(hookScriptName(hook))),
+        }))
         .filter(group => group.hooks.length > 0);
 }
 
@@ -2267,7 +2272,14 @@ function selectCodexNativeHooksConfig(hooksConfig) {
                 ? preToolUseGroups.filter(group => ALL_CODEX_NATIVE_PRE_TOOL_USE_MATCHERS.has(group?.matcher))
                 : [],
             UserPromptSubmit: Array.isArray(userPromptSubmitGroups) ? userPromptSubmitGroups : [],
-            Stop: selectCodexNativeStopGroups(hooksConfig.hooks?.Stop),
+            PostToolUse: selectCodexNativeGroupsByScriptName(
+                hooksConfig.hooks?.PostToolUse,
+                ALL_CODEX_NATIVE_POST_TOOL_USE_HOOK_SCRIPT_NAMES,
+            ),
+            Stop: selectCodexNativeGroupsByScriptName(
+                hooksConfig.hooks?.Stop,
+                ALL_CODEX_NATIVE_STOP_HOOK_SCRIPT_NAMES,
+            ),
         },
     };
 }
@@ -2561,10 +2573,12 @@ function pruneStaleFilesAcrossManagedRoots(priorInstalledFiles, currentInstalled
     }
     const cursorInstallDirectory = INSTALL_ROOT_RESOLUTION.cursorInstallDirectory;
     const retiredCursorSyncManifestPath = join(cursorInstallDirectory, '.sync-manifest.json');
-    const isRetiredCursorRuleFile = priorFile => resolve(priorFile) === retiredCursorSyncManifestPath
-        || isInsideDirectory(resolve(priorFile), INSTALL_ROOT_RESOLUTION.cursorRulesInstallDirectory);
+    const retiredCursorSkillsDirectory = join(cursorInstallDirectory, MANAGED_SKILLS_DIRECTORY_NAME);
+    const isRetiredCursorFile = priorFile => resolve(priorFile) === retiredCursorSyncManifestPath
+        || isInsideDirectory(resolve(priorFile), INSTALL_ROOT_RESOLUTION.cursorRulesInstallDirectory)
+        || isInsideDirectory(resolve(priorFile), retiredCursorSkillsDirectory);
     const retiredCursorRulesOutcome = pruneStaleInstalledFiles(
-        priorInstalledFiles?.filter(isRetiredCursorRuleFile) ?? null,
+        priorInstalledFiles?.filter(isRetiredCursorFile) ?? null,
         currentInstalledFiles,
         cursorInstallDirectory,
         join(backupRoot, 'cursor'),
@@ -3005,23 +3019,6 @@ function executeInstallPlanMutations(plan, transactionHelpers) {
     }
     summary.skills = { created: skillsCreated, updated: skillsUpdated, pruned: 0, paths: skillPaths };
     allInstalledFiles.push(...skillPaths);
-    if (copiedSkillNames.has('deepen')) {
-        for (const sourceRoot of allSourceRoots) {
-            const deepenSourceDirectory = join(
-                resolvePackageManagedDirectory(sourceRoot, MANAGED_SKILLS_DIRECTORY_NAME),
-                'deepen',
-            );
-            if (!existsSync(deepenSourceDirectory)) continue;
-            const cursorDeepenDirectory = join(
-                INSTALL_ROOT_RESOLUTION.cursorInstallDirectory,
-                'skills',
-                'deepen',
-            );
-            const cursorSkillStats = copyTree(deepenSourceDirectory, cursorDeepenDirectory);
-            allInstalledFiles.push(...cursorSkillStats.paths);
-            break;
-        }
-    }
     if (!selectedGroups) {
         summary.retiredSessionContinuity = {
             changedPaths: removeRetiredSessionContinuityHooks(),
@@ -3078,12 +3075,6 @@ function executeInstallPlanMutations(plan, transactionHelpers) {
             claudeRoot: CLAUDE_HOME,
             codexHome: INSTALL_ROOT_RESOLUTION.codexHomeDirectory,
             cursorDirectory: INSTALL_ROOT_RESOLUTION.cursorInstallDirectory,
-            firstTaskHookPath: join(
-                INSTALL_ROOT_RESOLUTION.hooksInstallDirectory,
-                'session',
-                'deepen_first_prompt.py',
-            ),
-            pythonCommand,
             formatPathArgument: commandArgumentFromPath,
         });
         summary.deepStackPlugin = deepStackPlugin;
@@ -3096,10 +3087,27 @@ function executeInstallPlanMutations(plan, transactionHelpers) {
             allActionNeededLines.push(`DeepStack (cursor): failed — ${cursorOutcome.warning}`);
         }
     }
+    if (!selectedGroups) {
+        const retiredCursorHooksPath = removeRetiredCursorFirstTaskHook(
+            INSTALL_ROOT_RESOLUTION.cursorInstallDirectory,
+        );
+        if (retiredCursorHooksPath) {
+            console.log(`  Retired first-task hook removed from ${retiredCursorHooksPath}`);
+        }
+        const retiredPlugins = removeRetiredMarketplacePlugins(ALL_RETIRED_PLUGIN_SPECS, {
+            claudeRoot: CLAUDE_HOME,
+        });
+        summary.retiredPlugins = retiredPlugins;
+        for (const eachIdentifier of retiredPlugins.removedIdentifiers) {
+            console.log(`  Retired plugin uninstalled: ${eachIdentifier}`);
+        }
+        for (const eachFailure of retiredPlugins.failedRemovals) {
+            console.warn(`  Warning: retired plugin ${eachFailure.pluginIdentifier} was not uninstalled: ${eachFailure.detail}`);
+        }
+    }
     const allRepositoryPluginSpecs = [
         USAGE_WRAPUP_PLUGIN_SPEC,
         SUBAGENT_MODELS_PLUGIN_SPEC,
-        DEEPEN_FIRST_PROMPT_PLUGIN_SPEC,
     ].filter(eachSpec => shouldInstallMarketplacePlugin(eachSpec));
     if (!selectedGroups && allRepositoryPluginSpecs.length > 0) {
         const repositoryPlugins = installMarketplacePlugins(allRepositoryPluginSpecs, {
@@ -3123,10 +3131,7 @@ function executeInstallPlanMutations(plan, transactionHelpers) {
             readFileSync(join(PACKAGE_ROOT, 'rules', 'question-presentation.md'), 'utf8'),
         );
         if (questionGuidancePath) allCodexGuidancePaths.push(questionGuidancePath);
-        const deepenGuidancePath = writeCodexDeepenGuidance(
-            INSTALL_ROOT_RESOLUTION.codexHomeDirectory,
-        );
-        if (deepenGuidancePath) allCodexGuidancePaths.push(deepenGuidancePath);
+        removeCodexDeepenGuidance(INSTALL_ROOT_RESOLUTION.codexHomeDirectory);
         const solPromptPath = installCodexSolPrompt(
             INSTALL_ROOT_RESOLUTION.codexHomeDirectory,
             join(PACKAGE_ROOT, SOL_PROMPT_DIRECTORY_NAME, SOL_PROMPT_FILE_NAME),
@@ -3676,7 +3681,6 @@ Usage:
   npx ${PACKAGE_NAME} --no-deepstack  Full install without the DeepStack plugin (also CDE_INSTALL_DEEPSTACK=0)
   npx ${PACKAGE_NAME} --no-usage-wrapup  Full install without the usage-wrapup plugin (also CDE_INSTALL_USAGE_WRAPUP=0)
   npx ${PACKAGE_NAME} --no-subagent-models  Full install without the subagent-models plugin (also CDE_INSTALL_SUBAGENT_MODELS=0)
-  npx ${PACKAGE_NAME} --no-deepen-first-prompt  Full install without the deepen-first-prompt plugin (also CDE_INSTALL_DEEPEN_FIRST_PROMPT=0)
   npx ${PACKAGE_NAME} --uninstall  Remove installed files from the selected root
   npx ${PACKAGE_NAME} --help       Show this help
 

package/bin/install.pr-visual.test.mjs

@@ -0,0 +1,40 @@
+import { strict as assert } from 'node:assert';
+import { execFileSync } from 'node:child_process';
+import { existsSync, mkdtempSync, readFileSync, realpathSync, rmSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { dirname, join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { test } from 'node:test';
+
+const PACKAGE_DIRECTORY = dirname(dirname(fileURLToPath(import.meta.url)));
+const SKILL_PATH_SEGMENTS = ['.agents', 'skills', 'pr-visual'];
+const REQUIRED_FILES = ['SKILL.md', 'scripts/collect.py', 'scripts/render.py', 'scripts/metrics.py', 'scripts/verify.py', 'scripts/visual_config/config/constants.py', 'assets/viewer.html', 'assets/icons.symbols', 'fixtures/bar.scene.json', 'fixtures/integrated.scene.json', 'references/formats.md'];
+const INSTALL_MODES = [[], ['--only', 'core']];
+const NPM_EXECUTABLE = process.platform === 'win32' ? 'npm.cmd' : 'npm';
+
+test('packed full and core installs ship the runnable PR visual skill to the shared agents home', () => {
+    const sandbox = mkdtempSync(join(tmpdir(), 'cde-pr-visual-'));
+    try {
+        const packed = JSON.parse(execFileSync(NPM_EXECUTABLE, ['pack', '--json', '--ignore-scripts', '--offline', '--cache', join(sandbox, 'npm-cache'), '--pack-destination', sandbox], { cwd: PACKAGE_DIRECTORY, encoding: 'utf8', shell: process.platform === 'win32' }));
+        execFileSync('tar', ['-xzf', join(sandbox, packed[0].filename), '-C', sandbox]);
+        const packaged = join(sandbox, 'package');
+        for (const [eachIndex, eachArguments] of INSTALL_MODES.entries()) {
+            const homeDirectory = join(sandbox, `home-${eachIndex}`);
+            execFileSync(process.execPath, [join(packaged, 'bin/install.mjs'), ...eachArguments], {
+                encoding: 'utf8',
+                env: { ...process.env, CLAUDE_CONFIG_DIR: undefined, LLM_SETTINGS_PROFILES_ROOT: undefined, HOME: homeDirectory, USERPROFILE: homeDirectory, CODEX_HOME: join(homeDirectory, '.codex'), GIT_CONFIG_GLOBAL: join(homeDirectory, '.gitconfig'), CDE_INSTALL_PSTACK: '0', CDE_INSTALL_DEEPSTACK: '0', CDE_INSTALL_USAGE_WRAPUP: '0', CDE_INSTALL_SUBAGENT_MODELS: '0', CDE_INSTALL_DEEPEN_FIRST_PROMPT: '0' },
+            });
+            const installed = join(homeDirectory, ...SKILL_PATH_SEGMENTS);
+            for (const eachFile of REQUIRED_FILES) assert.deepEqual(readFileSync(join(installed, eachFile)), readFileSync(join(packaged, ...SKILL_PATH_SEGMENTS, eachFile)));
+            assert.equal(realpathSync(join(homeDirectory, '.claude/skills/pr-visual')), realpathSync(installed));
+            const manifest = JSON.parse(readFileSync(join(homeDirectory, '.claude/.claude-dev-env-manifest.json'), 'utf8'));
+            assert.ok(manifest.skills.includes('pr-visual'));
+            const visual = join(sandbox, `visual-${eachIndex}.html`);
+            execFileSync(process.platform === 'win32' ? 'python' : 'python3', [join(installed, 'scripts/render.py'), join(installed, 'fixtures/integrated.scene.json'), '--out', visual]);
+            assert.ok(existsSync(visual));
+            assert.match(readFileSync(visual, 'utf8'), /Duration \(ms\)/);
+        }
+    } finally {
+        rmSync(sandbox, { recursive: true, force: true });
+    }
+});

package/bin/install.prompt-context.test.mjs

@@ -35,12 +35,11 @@ test('reinstall drops the retired style reminder and keeps one skill reminder ho
     mergeHooksIntoSettings(settings, hooksConfig, 'C:/Users/example/.claude', 'python');
 
     const userPromptHooks = settings.hooks.UserPromptSubmit.flatMap(eachGroup => eachGroup.hooks);
-    assert.equal(userPromptHooks.length, 5);
+    assert.equal(userPromptHooks.length, 4);
     assert.equal(userPromptHooks[0].command, userCommand);
     assert.match(userPromptHooks[1].command, /session\/skill_loaded_reminder\.py$/);
-    assert.match(userPromptHooks[2].command, /session\/deepen_first_prompt\.py$/);
-    assert.match(userPromptHooks[3].command, /lifecycle\/nested_project_hooks\.py$/);
-    assert.match(userPromptHooks[4].command, /blocking\/chat_reply_gate\.py$/);
+    assert.match(userPromptHooks[2].command, /lifecycle\/nested_project_hooks\.py$/);
+    assert.match(userPromptHooks[3].command, /blocking\/chat_reply_gate\.py$/);
     assert.ok(userPromptHooks.every(eachHook => !eachHook.command.includes('style_reminder_prompt')));
 
     const firstMerge = JSON.stringify(settings);

package/bin/install.prune.test.mjs

@@ -266,7 +266,6 @@ function resolveInstallerInvocation(homeDirectory) {
         CDE_INSTALL_DEEPSTACK: '0',
         CDE_INSTALL_USAGE_WRAPUP: '0',
         CDE_INSTALL_SUBAGENT_MODELS: '0',
-        CDE_INSTALL_DEEPEN_FIRST_PROMPT: '0',
         HOME: homeDirectory,
         USERPROFILE: homeDirectory,
         GIT_CONFIG_GLOBAL: join(homeDirectory, '.gitconfig'),

package/bin/install.question-presentation.test.mjs

@@ -28,7 +28,6 @@ function installInScratchHome(homeDirectory, argumentsList = [], extraEnvironmen
             CDE_INSTALL_DEEPSTACK: '0',
             CDE_INSTALL_USAGE_WRAPUP: '0',
             CDE_INSTALL_SUBAGENT_MODELS: '0',
-            CDE_INSTALL_DEEPEN_FIRST_PROMPT: '0',
             HOME: homeDirectory,
             USERPROFILE: homeDirectory,
             CODEX_HOME: join(homeDirectory, '.codex'),
@@ -186,7 +185,6 @@ test('a successful pstack install omits the retired skill block and gains the qu
         CDE_INSTALL_DEEPSTACK: '0',
         CDE_INSTALL_USAGE_WRAPUP: '0',
         CDE_INSTALL_SUBAGENT_MODELS: '0',
-        CDE_INSTALL_DEEPEN_FIRST_PROMPT: '0',
         CDE_CODEX_EXECUTABLE: commandPath,
         CDE_CLAUDE_EXECUTABLE: commandPath,
     });
@@ -216,7 +214,6 @@ test('enabling pstack after a pstack-off install preserves question guidance', (
         CDE_INSTALL_DEEPSTACK: '0',
         CDE_INSTALL_USAGE_WRAPUP: '0',
         CDE_INSTALL_SUBAGENT_MODELS: '0',
-        CDE_INSTALL_DEEPEN_FIRST_PROMPT: '0',
         CDE_CODEX_EXECUTABLE: commandPath,
         CDE_CLAUDE_EXECUTABLE: commandPath,
     });
@@ -247,7 +244,6 @@ test('a failed pstack transition restores question-only guidance and removes its
         CDE_INSTALL_DEEPSTACK: '0',
         CDE_INSTALL_USAGE_WRAPUP: '0',
         CDE_INSTALL_SUBAGENT_MODELS: '0',
-        CDE_INSTALL_DEEPEN_FIRST_PROMPT: '0',
         CDE_CODEX_EXECUTABLE: commandPath,
         CDE_CLAUDE_EXECUTABLE: commandPath,
         CLAUDE_DEV_ENV_INSTALL_FAULT: 'after_file_staging',

package/bin/install.settings-defaults.test.mjs

@@ -70,7 +70,6 @@ function runInstallerInSandbox(sandboxHome, installerArguments = []) {
             CDE_INSTALL_DEEPSTACK: '0',
             CDE_INSTALL_USAGE_WRAPUP: '0',
             CDE_INSTALL_SUBAGENT_MODELS: '0',
-            CDE_INSTALL_DEEPEN_FIRST_PROMPT: '0',
             HOME: sandboxHome,
             USERPROFILE: sandboxHome,
             GIT_CONFIG_GLOBAL: gitConfigGlobal,

package/bin/install.shared-settings.test.mjs

@@ -34,7 +34,6 @@ function installEnvironment(homeDirectory) {
         CDE_INSTALL_DEEPSTACK: '0',
         CDE_INSTALL_USAGE_WRAPUP: '0',
         CDE_INSTALL_SUBAGENT_MODELS: '0',
-        CDE_INSTALL_DEEPEN_FIRST_PROMPT: '0',
     };
 }