claude-dev-env 8.85.0 → 8.85.2

package/bin/install-deepstack-plugin.mjs

@@ -0,0 +1,300 @@
+import { spawnSync } from 'node:child_process';
+import { cpSync, existsSync, mkdirSync, mkdtempSync, readdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import {
+    installMarketplacePlugins,
+    marketplacePluginsPlan,
+    shouldInstallMarketplacePlugin,
+} from './install-pstack-plugin.mjs';
+
+export const DEEPSTACK_MARKETPLACE_REPOSITORY = 'jl-cmd-projects/DeepStack';
+export const DEEPSTACK_MARKETPLACE_NAME = 'DeepStack';
+export const DEEPSTACK_PLUGIN_NAME = 'deepstack';
+export const DEEPSTACK_PLUGIN_IDENTIFIER = `${DEEPSTACK_PLUGIN_NAME}@${DEEPSTACK_MARKETPLACE_NAME}`;
+export const DEEPSTACK_PLUGIN_HOSTS = Object.freeze(['claude', 'codex']);
+export const DEEPSTACK_PLUGIN_OPT_OUT_FLAG = '--no-deepstack';
+export const DEEPSTACK_PLUGIN_OPT_OUT_VARIABLE = 'CDE_INSTALL_DEEPSTACK';
+export const DEEPSTACK_SOURCE_VARIABLE = 'CDE_DEEPSTACK_SOURCE';
+export const DEEPSTACK_CURSOR_DIRECTORY_NAME = 'plugins/deepstack';
+export const DEEPSTACK_SKILL_RELATIVE_PATH = 'skills/deepstack-mode/SKILL.md';
+export const DEEPSTACK_SESSION_SCRIPT_RELATIVE_PATH = 'hooks/session-start.sh';
+export const DEEPSTACK_SESSION_RUNTIME = 'cursor';
+export const DEEPSTACK_FIRST_TASK_HOOK_NAME = 'deepen_first_prompt.py';
+export const DEEPSTACK_CODEX_MODEL_SHEET_NAME = 'deepstack-models.md';
+
+export const DEEPSTACK_PLUGIN_SPEC = Object.freeze({
+    name: DEEPSTACK_PLUGIN_NAME,
+    label: 'DeepStack',
+    marketplaceRepository: DEEPSTACK_MARKETPLACE_REPOSITORY,
+    marketplaceName: DEEPSTACK_MARKETPLACE_NAME,
+    sparsePaths: Object.freeze([]),
+    pluginIdentifier: DEEPSTACK_PLUGIN_IDENTIFIER,
+    hosts: DEEPSTACK_PLUGIN_HOSTS,
+    optOutFlag: DEEPSTACK_PLUGIN_OPT_OUT_FLAG,
+    optOutVariable: DEEPSTACK_PLUGIN_OPT_OUT_VARIABLE,
+});
+
+/**
+ * Quote one path for a hook command line.
+ *
+ * @param {string} pathValue The absolute path.
+ * @returns {string} A single-quoted shell word.
+ */
+function quoteCommandPath(pathValue) {
+    return `'${pathValue.replaceAll("'", `'\\''`)}'`;
+}
+
+/**
+ * Read the Claude, Codex, and Cursor actions one DeepStack install performs.
+ *
+ * Claude and Codex use the marketplace verbs. Cursor has no plugin command, so
+ * its action is a copy into the Cursor home plus two hook registrations.
+ *
+ * @returns {{claude: object, codex: object, cursor: {
+ *   pluginDirectoryName: string,
+ *   skillRelativePath: string,
+ *   sessionScriptRelativePath: string,
+ *   sessionRuntimeArgument: string,
+ *   firstTaskHookName: string,
+ * }}} The three host actions.
+ */
+export function deepStackInstallPlan() {
+    return {
+        claude: marketplacePluginsPlan([DEEPSTACK_PLUGIN_SPEC], 'claude'),
+        codex: marketplacePluginsPlan([DEEPSTACK_PLUGIN_SPEC], 'codex'),
+        cursor: {
+            pluginDirectoryName: DEEPSTACK_CURSOR_DIRECTORY_NAME,
+            skillRelativePath: DEEPSTACK_SKILL_RELATIVE_PATH,
+            sessionScriptRelativePath: DEEPSTACK_SESSION_SCRIPT_RELATIVE_PATH,
+            sessionRuntimeArgument: DEEPSTACK_SESSION_RUNTIME,
+            firstTaskHookName: DEEPSTACK_FIRST_TASK_HOOK_NAME,
+        },
+    };
+}
+
+/**
+ * @param {string|undefined} homeDirectory A Claude or Codex home.
+ * @returns {string|null} The newest cached plugin directory, or null.
+ */
+function newestCachedPlugin(homeDirectory) {
+    if (!homeDirectory) return null;
+    const cacheDirectory = join(
+        homeDirectory,
+        'plugins',
+        'cache',
+        DEEPSTACK_MARKETPLACE_NAME,
+        DEEPSTACK_PLUGIN_NAME,
+    );
+    if (!existsSync(cacheDirectory)) return null;
+    const versions = readdirSync(cacheDirectory, { withFileTypes: true })
+        .filter(entry => entry.isDirectory())
+        .map(entry => entry.name)
+        .filter(name => existsSync(join(cacheDirectory, name, DEEPSTACK_SKILL_RELATIVE_PATH)))
+        .sort();
+    if (versions.length === 0) return null;
+    return join(cacheDirectory, versions[versions.length - 1]);
+}
+
+/**
+ * Find the plugin tree to copy into Cursor.
+ *
+ * An explicit directory wins, then the source variable, then a marketplace
+ * cache written by the Claude or Codex install, then a shallow clone of
+ * jl-cmd-projects/DeepStack.
+ *
+ * @param {object} options Search inputs.
+ * @param {string} [options.claudeRoot] The Claude home.
+ * @param {string} [options.codexHome] The Codex home.
+ * @param {Record<string, string|undefined>} [options.environment] The process environment.
+ * @param {string} [options.sourceDirectory] A directory that already holds the plugin.
+ * @param {(destination: string) => string|null} [options.cloneRepository] Replaces the git clone.
+ * @returns {string|null} The plugin directory, or null when every source is empty.
+ */
+export function resolveDeepStackPluginSource(options = {}) {
+    if (options.sourceDirectory && existsSync(join(options.sourceDirectory, DEEPSTACK_SKILL_RELATIVE_PATH))) {
+        return options.sourceDirectory;
+    }
+    const environment = options.environment ?? process.env;
+    const fromEnvironment = environment[DEEPSTACK_SOURCE_VARIABLE];
+    if (fromEnvironment && existsSync(join(fromEnvironment, DEEPSTACK_SKILL_RELATIVE_PATH))) {
+        return fromEnvironment;
+    }
+    const cached = newestCachedPlugin(options.claudeRoot) ?? newestCachedPlugin(options.codexHome);
+    if (cached) return cached;
+    if (options.cloneRepository) return options.cloneRepository();
+    return null;
+}
+
+/**
+ * Add the SessionStart and first-task hook groups when they are absent.
+ *
+ * @param {object} configuration The parsed Cursor hooks file.
+ * @param {{sessionCommand: string, firstTaskCommand: string}} commands The two commands.
+ * @returns {object} The configuration with both groups present.
+ */
+export function mergeDeepStackCursorHooks(configuration, commands) {
+    const hooks = configuration.hooks && typeof configuration.hooks === 'object'
+        ? configuration.hooks
+        : {};
+    const sessionGroups = Array.isArray(hooks.SessionStart) ? [...hooks.SessionStart] : [];
+    const promptGroups = Array.isArray(hooks.UserPromptSubmit) ? [...hooks.UserPromptSubmit] : [];
+    const listed = (groups, needle) => JSON.stringify(groups).includes(needle);
+    if (!listed(sessionGroups, DEEPSTACK_SESSION_SCRIPT_RELATIVE_PATH)) {
+        sessionGroups.push({
+            matcher: 'startup|resume|clear|compact',
+            hooks: [{ type: 'command', command: commands.sessionCommand }],
+        });
+    }
+    if (!listed(promptGroups, DEEPSTACK_FIRST_TASK_HOOK_NAME)) {
+        promptGroups.push({
+            matcher: '',
+            hooks: [{ type: 'command', command: commands.firstTaskCommand, timeout: 10 }],
+        });
+    }
+    return {
+        ...configuration,
+        hooks: {
+            ...hooks,
+            SessionStart: sessionGroups,
+            UserPromptSubmit: promptGroups,
+        },
+    };
+}
+
+/**
+ * Copy the plugin into the Cursor home and register both hooks.
+ *
+ * @param {object} options Copy inputs.
+ * @param {string} options.cursorDirectory The Cursor home, usually ~/.cursor.
+ * @param {string|null} options.pluginSourceDirectory The plugin tree to copy.
+ * @param {string} options.firstTaskHookPath Absolute path of deepen_first_prompt.py.
+ * @returns {{status: string, pluginDirectory: string|null, hooksPath: string|null, warning: string|null}} The outcome.
+ */
+export function installDeepStackCursor(options) {
+    const plan = deepStackInstallPlan().cursor;
+    if (!options.cursorDirectory) {
+        return { status: 'failed', pluginDirectory: null, hooksPath: null, warning: 'Cursor home is unset.' };
+    }
+    if (!options.pluginSourceDirectory) {
+        return {
+            status: 'failed',
+            pluginDirectory: null,
+            hooksPath: null,
+            warning: `No ${DEEPSTACK_MARKETPLACE_REPOSITORY} plugin tree to copy.`,
+        };
+    }
+    const pluginDirectory = join(options.cursorDirectory, plan.pluginDirectoryName);
+    mkdirSync(options.cursorDirectory, { recursive: true });
+    cpSync(options.pluginSourceDirectory, pluginDirectory, { recursive: true, force: true });
+    const sessionCommand = `${quoteCommandPath(join(pluginDirectory, plan.sessionScriptRelativePath))} ${plan.sessionRuntimeArgument}`;
+    const firstTaskCommand = `python3 ${quoteCommandPath(options.firstTaskHookPath)}`;
+    const hooksPath = join(options.cursorDirectory, 'hooks.json');
+    const current = existsSync(hooksPath)
+        ? JSON.parse(readFileSync(hooksPath, 'utf8'))
+        : { hooks: {} };
+    const merged = mergeDeepStackCursorHooks(current, { sessionCommand, firstTaskCommand });
+    writeFileSync(hooksPath, `${JSON.stringify(merged, null, 2)}\n`);
+    return { status: 'installed', pluginDirectory, hooksPath, warning: null };
+}
+
+/**
+ * Write the Codex model sheet when this run installed the Codex plugin.
+ *
+ * @param {string} codexHome The Codex home.
+ * @returns {string|null} The sheet path when this run created it.
+ */
+export function seedCodexDeepStackModels(codexHome) {
+    const sheetPath = join(codexHome, DEEPSTACK_CODEX_MODEL_SHEET_NAME);
+    if (existsSync(sheetPath)) return null;
+    mkdirSync(codexHome, { recursive: true });
+    writeFileSync(sheetPath, 'session hook: on\n');
+    return sheetPath;
+}
+
+/**
+ * Install DeepStack for Claude, Codex, and Cursor.
+ *
+ * @param {object} [options] Install targets.
+ * @param {string} [options.claudeRoot] The managed Claude root.
+ * @param {string} [options.codexHome] The Codex home.
+ * @param {string} [options.cursorDirectory] The Cursor home.
+ * @param {string} [options.firstTaskHookPath] Absolute path of the hook the first-task command runs.
+ * @param {string} [options.sourceDirectory] A local plugin tree for the Cursor copy.
+ * @param {string[]} [options.argumentList] Command-line arguments, for the opt-out flag.
+ * @param {Record<string, string|undefined>} [options.environment] The process environment.
+ * @param {object} [dependencies] Seams for the marketplace command runner.
+ * @returns {{status: string, hosts: object[], cursor: object, warning: string|null}} The outcome.
+ */
+export function installDeepStackForHosts(options = {}, dependencies = {}) {
+    const environment = options.environment ?? process.env;
+    if (!shouldInstallMarketplacePlugin(DEEPSTACK_PLUGIN_SPEC, options.argumentList, environment)) {
+        return {
+            status: 'skipped',
+            hosts: [],
+            cursor: { status: 'skipped', pluginDirectory: null, hooksPath: null, warning: null },
+            warning: null,
+        };
+    }
+    const marketplace = installMarketplacePlugins([DEEPSTACK_PLUGIN_SPEC], {
+        claudeRoot: options.claudeRoot,
+        codexHome: options.codexHome,
+        environment,
+    }, dependencies);
+    let sourceDirectory = resolveDeepStackPluginSource({
+        claudeRoot: options.claudeRoot,
+        codexHome: options.codexHome,
+        environment,
+        sourceDirectory: options.sourceDirectory,
+    });
+    if (!sourceDirectory && options.allowClone !== false) {
+        sourceDirectory = cloneDeepStackRepository(mkdtempSync(join(tmpdir(), 'deepstack-')));
+    }
+    const cursor = installDeepStackCursor({
+        cursorDirectory: options.cursorDirectory,
+        pluginSourceDirectory: sourceDirectory,
+        firstTaskHookPath: options.firstTaskHookPath,
+    });
+    if (marketplace.hosts.some(host => host.host === 'codex' && host.status === 'installed') && options.codexHome) {
+        seedCodexDeepStackModels(options.codexHome);
+    }
+    const failed = marketplace.status === 'failed' || cursor.status === 'failed';
+    const installed = marketplace.hosts.some(host => host.status === 'installed') || cursor.status === 'installed';
+    return {
+        status: failed ? 'failed' : (installed ? 'installed' : marketplace.status),
+        hosts: marketplace.hosts,
+        cursor,
+        warning: [marketplace.warning, cursor.warning].filter(Boolean).join(' ') || null,
+    };
+}
+
+/**
+ * Clone jl-cmd-projects/DeepStack when no local tree is available.
+ *
+ * The installer calls this only from a full install that has no source
+ * directory and no marketplace cache. Tests pass a source directory instead.
+ *
+ * @param {string} destination An empty directory for the clone.
+ * @returns {string|null} The plugin directory inside the clone.
+ */
+/**
+ * Return the git clone URL for the DeepStack marketplace repository.
+ *
+ * @returns {string} The clone URL.
+ */
+export function deepStackCloneUrl() {
+    return ['https:', '', 'github.com', `${DEEPSTACK_MARKETPLACE_REPOSITORY}.git`].join('/');
+}
+
+export function cloneDeepStackRepository(destination) {
+    const outcome = spawnSync('git', [
+        'clone',
+        '--depth',
+        '1',
+        deepStackCloneUrl(),
+        destination,
+    ], { encoding: 'utf8' });
+    if (outcome.status !== 0) return null;
+    const pluginDirectory = join(destination, 'plugins', DEEPSTACK_PLUGIN_NAME);
+    return existsSync(join(pluginDirectory, DEEPSTACK_SKILL_RELATIVE_PATH)) ? pluginDirectory : null;
+}

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

@@ -0,0 +1,98 @@
+import { test } from 'node:test';
+import { strict as assert } from 'node:assert';
+import { mkdtempSync, mkdirSync, readFileSync, rmSync, writeFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import {
+    DEEPSTACK_MARKETPLACE_REPOSITORY,
+    DEEPSTACK_PLUGIN_IDENTIFIER,
+    DEEPSTACK_PLUGIN_SPEC,
+    deepStackCloneUrl,
+    deepStackInstallPlan,
+    installDeepStackCursor,
+    installDeepStackForHosts,
+    mergeDeepStackCursorHooks,
+} from './install-deepstack-plugin.mjs';
+import { marketplacePluginsPlan, shouldInstallMarketplacePlugin } from './install-pstack-plugin.mjs';
+
+test('Claude and Codex plans name jl-cmd-projects/DeepStack', () => {
+    const plan = deepStackInstallPlan();
+    assert.deepEqual(plan.claude.commands, [
+        ['plugin', 'marketplace', 'add', DEEPSTACK_MARKETPLACE_REPOSITORY],
+        ['plugin', 'install', DEEPSTACK_PLUGIN_IDENTIFIER],
+    ]);
+    assert.deepEqual(plan.codex.commands, [
+        ['plugin', 'marketplace', 'add', DEEPSTACK_MARKETPLACE_REPOSITORY],
+        ['plugin', 'add', DEEPSTACK_PLUGIN_IDENTIFIER],
+    ]);
+    assert.equal(DEEPSTACK_MARKETPLACE_REPOSITORY, 'jl-cmd-projects/DeepStack');
+    assert.equal(deepStackCloneUrl(), 'https://github.com/jl-cmd-projects/DeepStack.git');
+    assert.equal(plan.cursor.skillRelativePath, 'skills/deepstack-mode/SKILL.md');
+    assert.equal(plan.cursor.firstTaskHookName, 'deepen_first_prompt.py');
+    assert.throws(() => marketplacePluginsPlan([DEEPSTACK_PLUGIN_SPEC], 'cursor'), /cursor/);
+});
+
+test('cursor hooks keep the session hook and the first-task gate', () => {
+    const merged = mergeDeepStackCursorHooks({ hooks: { PreToolUse: [] } }, {
+        sessionCommand: "'/cursor/plugins/deepstack/hooks/session-start.sh' cursor",
+        firstTaskCommand: "python3 '/claude/hooks/session/deepen_first_prompt.py'",
+    });
+    assert.deepEqual(Object.keys(merged.hooks).sort(), ['PreToolUse', 'SessionStart', 'UserPromptSubmit']);
+    const text = JSON.stringify(merged);
+    assert.match(text, /session-start\.sh/);
+    assert.match(text, /deepen_first_prompt\.py/);
+});
+
+test('the cursor copy writes the skill and both hook commands', () => {
+    const root = mkdtempSync(join(tmpdir(), 'deepstack-cursor-'));
+    try {
+        const source = join(root, 'source');
+        mkdirSync(join(source, 'skills', 'deepstack-mode'), { recursive: true });
+        mkdirSync(join(source, 'hooks'), { recursive: true });
+        writeFileSync(join(source, 'skills', 'deepstack-mode', 'SKILL.md'), 'DeepStack intake\n');
+        writeFileSync(join(source, 'hooks', 'session-start.sh'), '#!/bin/sh\n');
+        const cursorDirectory = join(root, '.cursor');
+        const outcome = installDeepStackCursor({
+            cursorDirectory,
+            pluginSourceDirectory: source,
+            firstTaskHookPath: join(root, '.agents', 'hooks', 'session', 'deepen_first_prompt.py'),
+        });
+        assert.equal(outcome.status, 'installed');
+        assert.equal(
+            readFileSync(join(cursorDirectory, 'plugins', 'deepstack', 'skills', 'deepstack-mode', 'SKILL.md'), 'utf8'),
+            'DeepStack intake\n',
+        );
+        const hooks = JSON.parse(readFileSync(join(cursorDirectory, 'hooks.json'), 'utf8'));
+        const text = JSON.stringify(hooks);
+        assert.match(text, /session-start\.sh/);
+        assert.match(text, /deepen_first_prompt\.py/);
+        assert.equal(hooks.hooks.SessionStart[0].hooks[0].command.endsWith(' cursor'), true);
+    } finally {
+        rmSync(root, { recursive: true, force: true });
+    }
+});
+
+test('a missing plugin tree fails the cursor copy', () => {
+    const outcome = installDeepStackCursor({
+        cursorDirectory: '/tmp/unused-cursor',
+        pluginSourceDirectory: null,
+        firstTaskHookPath: '/tmp/deepen_first_prompt.py',
+    });
+    assert.equal(outcome.status, 'failed');
+    assert.match(outcome.warning, /jl-cmd-projects\/DeepStack/);
+});
+
+test('--no-deepstack and CDE_INSTALL_DEEPSTACK=0 skip the install', () => {
+    assert.equal(shouldInstallMarketplacePlugin(DEEPSTACK_PLUGIN_SPEC, ['--no-deepstack'], {}), false);
+    assert.equal(
+        shouldInstallMarketplacePlugin(DEEPSTACK_PLUGIN_SPEC, [], { CDE_INSTALL_DEEPSTACK: '0' }),
+        false,
+    );
+    const skipped = installDeepStackForHosts({
+        argumentList: ['--no-deepstack'],
+        environment: {},
+        allowClone: false,
+    });
+    assert.equal(skipped.status, 'skipped');
+    assert.equal(skipped.cursor.status, 'skipped');
+});

package/bin/install-pstack-plugin.mjs

@@ -210,10 +210,8 @@ function namesAnAbsentCommand(outcome) {
         && COMMAND_NOT_FOUND_PATTERN.test(outcome.stderr ?? '');
 }
 
-function firstLine(text) {
-    const trimmed = (text ?? '').trim();
-    if (!trimmed) return '';
-    return trimmed.split(/\r?\n/).filter(Boolean).at(-1);
+function singleLineDetail(text) {
+    return (text ?? '').split(/\r?\n/).map(eachLine => eachLine.trim()).filter(Boolean).join(' ');
 }
 
 const ORPHANED_VERSION_MARKER = '.orphaned_at';
@@ -266,7 +264,7 @@ function installForHost(allSpecs, host, homeDirectory, environment, runCommand)
         });
         if (namesAnAbsentCommand(outcome)) return absentHostOutcome(allSpecs, host, executable);
         if (outcome.status !== 0 || outcome.error) {
-            const detail = firstLine(outcome.stderr) || outcome.error?.message || `exit ${outcome.status}`;
+            const detail = singleLineDetail(outcome.stderr) || outcome.error?.message || `exit ${outcome.status}`;
             return {
                 host,
                 executable,

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

@@ -126,6 +126,34 @@ test('a failing command reports that host and still installs the next one', () =
         ['plugin', 'marketplace', 'add', PSTACK_MARKETPLACE_REPOSITORY]);
 });
 
+test('should report every line of a multi-line marketplace add error', () => {
+    const cloneFailure = [
+        'Failed to add marketplace: Fetching the marketplace from GitHub failed on both attempts.'
+            + ' HTTPS (https://github.com/jl-cmd/pstack-claude.git): HTTPS clone timed out',
+        '',
+        'SSH (git@github.com:jl-cmd/pstack-claude.git): git@github.com: Permission denied (publickey).',
+        'fatal: Could not read from remote repository.',
+        '',
+        'Please make sure you have the correct access rights',
+        'and the repository exists.',
+    ].join('\r\n');
+    const runner = recordingRunner((executable, commandArguments) => (
+        executable === 'claude' && commandArguments[2] === 'add'
+            ? { status: 1, stderr: cloneFailure }
+            : { status: 0, stderr: '' }));
+    const claude = installMarketplacePlugins([PSTACK_PLUGIN_SPEC], ROOTS, runner)
+        .hosts.find(host => host.host === 'claude');
+    assert.equal(
+        claude.warning,
+        `claude plugin marketplace add ${PSTACK_MARKETPLACE_REPOSITORY} failed: `
+        + 'Failed to add marketplace: Fetching the marketplace from GitHub failed on both attempts.'
+        + ' HTTPS (https://github.com/jl-cmd/pstack-claude.git): HTTPS clone timed out'
+        + ' SSH (git@github.com:jl-cmd/pstack-claude.git): git@github.com: Permission denied (publickey).'
+        + ' fatal: Could not read from remote repository.'
+        + ' Please make sure you have the correct access rights and the repository exists.',
+    );
+});
+
 test('an executable override replaces the host command for that host only', () => {
     const runner = recordingRunner();
     installMarketplacePlugins(

package/bin/install.agents-home.test.mjs

@@ -53,6 +53,7 @@ function runInstaller(homeDirectory, extraArguments, environmentOverrides = {})
         CLAUDE_CONFIG_DIR: undefined,
         LLM_SETTINGS_PROFILES_ROOT: undefined,
         CDE_INSTALL_PSTACK: '0',
+        CDE_INSTALL_DEEPSTACK: '0',
         CDE_INSTALL_USAGE_WRAPUP: '0',
         CDE_INSTALL_SUBAGENT_MODELS: '0',
         CDE_INSTALL_DEEPEN_FIRST_PROMPT: '0',

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

@@ -59,6 +59,7 @@ function runInstaller(homeDirectory, extraArguments) {
             CLAUDE_CONFIG_DIR: undefined,
             LLM_SETTINGS_PROFILES_ROOT: undefined,
             CDE_INSTALL_PSTACK: '0',
+            CDE_INSTALL_DEEPSTACK: '0',
             CDE_INSTALL_USAGE_WRAPUP: '0',
             CDE_INSTALL_SUBAGENT_MODELS: '0',
             CDE_INSTALL_DEEPEN_FIRST_PROMPT: '0',
@@ -92,6 +93,7 @@ function scanTextWithProductionPiiScanner(scannedText) {
                     CLAUDE_CONFIG_DIR: undefined,
                     LLM_SETTINGS_PROFILES_ROOT: undefined,
                     CDE_INSTALL_PSTACK: '0',
+                    CDE_INSTALL_DEEPSTACK: '0',
                     CDE_INSTALL_USAGE_WRAPUP: '0',
                     CDE_INSTALL_SUBAGENT_MODELS: '0',
                     CDE_INSTALL_DEEPEN_FIRST_PROMPT: '0',

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

@@ -33,6 +33,7 @@ function runInstaller(homeDirectory, extraArguments, environmentOverrides = {})
             ...process.env,
             LLM_SETTINGS_PROFILES_ROOT: undefined,
             CDE_INSTALL_PSTACK: '0',
+            CDE_INSTALL_DEEPSTACK: '0',
             CDE_INSTALL_USAGE_WRAPUP: '0',
             CDE_INSTALL_SUBAGENT_MODELS: '0',
             CDE_INSTALL_DEEPEN_FIRST_PROMPT: '0',

package/bin/install.mjs

@@ -60,6 +60,10 @@ import {
     installMarketplacePlugins,
     shouldInstallMarketplacePlugin,
 } from './install-pstack-plugin.mjs';
+import {
+    DEEPSTACK_PLUGIN_SPEC,
+    installDeepStackForHosts,
+} from './install-deepstack-plugin.mjs';
 import { seedCodexPstackModels } from './seed-codex-pstack-models.mjs';
 import {
     codexSolSettingSnapshotPaths,
@@ -227,6 +231,7 @@ export const CORE_SKILLS = [
     'task-build',
     'eli5',
     'deepen',
+    'efficient-review',
 ];
 
 export function collectPackageSourceConflicts(packageDirectory) {
@@ -2927,17 +2932,35 @@ function executeInstallPlanMutations(plan, transactionHelpers) {
                     allUserOwnedPreferencePaths.add(eachPath);
                 }
             }
-            const skillLoadGuidancePath = writeCodexAgentsGuidance(
+            const codexGuidancePath = writeCodexAgentsGuidance(
                 INSTALL_ROOT_RESOLUTION.codexHomeDirectory,
                 packageGuidanceText,
                 allPackageGuidancePaths,
             );
-            if (skillLoadGuidancePath) {
-                console.log(`  \u2713 ${skillLoadGuidancePath} (Codex skill-load line)`);
+            if (codexGuidancePath) {
+                console.log(`  \u2713 ${codexGuidancePath} (Codex package guidance)`);
             }
         }
         printPluginHostOutcomes([PSTACK_PLUGIN_SPEC], pstackPlugin);
     }
+    if (!selectedGroups && shouldInstallMarketplacePlugin(DEEPSTACK_PLUGIN_SPEC)) {
+        const deepStackPlugin = installDeepStackForHosts({
+            claudeRoot: CLAUDE_HOME,
+            codexHome: INSTALL_ROOT_RESOLUTION.codexHomeDirectory,
+            cursorDirectory: INSTALL_ROOT_RESOLUTION.cursorInstallDirectory,
+            firstTaskHookPath: join(
+                INSTALL_ROOT_RESOLUTION.hooksInstallDirectory,
+                'session',
+                'deepen_first_prompt.py',
+            ),
+        });
+        summary.deepStackPlugin = deepStackPlugin;
+        printPluginHostOutcomes([DEEPSTACK_PLUGIN_SPEC], deepStackPlugin);
+        const cursorOutcome = deepStackPlugin.cursor;
+        console.log(cursorOutcome.warning
+            ? `  DeepStack (cursor): ${cursorOutcome.status} — ${cursorOutcome.warning}`
+            : `  DeepStack (cursor): ${cursorOutcome.status}`);
+    }
     const allRepositoryPluginSpecs = [
         USAGE_WRAPUP_PLUGIN_SPEC,
         SUBAGENT_MODELS_PLUGIN_SPEC,
@@ -3484,6 +3507,7 @@ Usage:
   npx ${PACKAGE_NAME} --profile ID Install into one named profile root (under the profiles root)
   npx ${PACKAGE_NAME} --profiles A,B  Install into each selected profile (one ownership manifest per target)
   npx ${PACKAGE_NAME} --no-pstack  Full install without the pstack plugin (also CDE_INSTALL_PSTACK=0)
+  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)

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

@@ -31,6 +31,7 @@ function installEnvironment(homeDirectory) {
         GIT_CONFIG_GLOBAL: join(homeDirectory, '.gitconfig'),
         CODEX_HOME: join(homeDirectory, '.codex'),
         CDE_INSTALL_PSTACK: '0',
+        CDE_INSTALL_DEEPSTACK: '0',
         CDE_INSTALL_USAGE_WRAPUP: '0',
     };
 }

package/bin/install.prune.test.mjs

@@ -64,6 +64,7 @@ const CORE_SKILL_DIRECTORIES = [
     'issue-tracker',
     'task-build',
     'eli5',
+    'efficient-review',
 ];
 const PRIOR_RUN_BACKUP_DIRECTORY_NAMES = [
     '2020-01-01T00-00-00-000Z',
@@ -262,6 +263,7 @@ function resolveInstallerInvocation(homeDirectory) {
         CLAUDE_CONFIG_DIR: undefined,
         LLM_SETTINGS_PROFILES_ROOT: undefined,
         CDE_INSTALL_PSTACK: '0',
+        CDE_INSTALL_DEEPSTACK: '0',
         CDE_INSTALL_USAGE_WRAPUP: '0',
         CDE_INSTALL_SUBAGENT_MODELS: '0',
         CDE_INSTALL_DEEPEN_FIRST_PROMPT: '0',
@@ -802,6 +804,24 @@ test('a scoped --only install records the skill names it installed', () => {
     }
 });
 
+test('a fresh scoped core install includes efficient-review', () => {
+    const sandbox = createSandbox();
+    try {
+        runInstaller(sandbox.homeDirectory, ['--only', 'core']);
+        const skillPath = join(sandbox.skillsDirectory, 'efficient-review', 'SKILL.md');
+        const skillText = readFileSync(skillPath, 'utf8');
+        assert.match(skillText, /^name: efficient-review$/m);
+        assert.match(skillText, /\/efficient-review/);
+        assert.equal(readManifest(sandbox.manifestPath).skills.includes('efficient-review'), true);
+        assert.equal(
+            existsSync(join(sandbox.skillsDirectory, 'efficient-review', 'defaults.json')),
+            true,
+        );
+    } finally {
+        rmSync(sandbox.homeDirectory, { recursive: true, force: true });
+    }
+});
+
 test('a fresh scoped core install ships active skills and omits retired skills', () => {
     const sandbox = createSandbox();
     try {

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

@@ -25,6 +25,7 @@ function installInScratchHome(homeDirectory, argumentsList = [], extraEnvironmen
             CLAUDE_CONFIG_DIR: undefined,
             LLM_SETTINGS_PROFILES_ROOT: undefined,
             CDE_INSTALL_PSTACK: '0',
+            CDE_INSTALL_DEEPSTACK: '0',
             CDE_INSTALL_USAGE_WRAPUP: '0',
             CDE_INSTALL_SUBAGENT_MODELS: '0',
             CDE_INSTALL_DEEPEN_FIRST_PROMPT: '0',
@@ -171,7 +172,7 @@ test('a selected Claude profile receives the source rule and its Codex guidance'
     assert.ok(readFileSync(join(profileDirectory, '.codex', 'AGENTS.md'), 'utf8').includes(readFileSync(policyPath, 'utf8')));
 });
 
-test('a successful pstack install retains its skill block and gains the question block', (context) => {
+test('a successful pstack install omits the retired skill block and gains the question block', (context) => {
     const homeDirectory = makeScratchHome(context);
     const commandPath = join(homeDirectory, process.platform === 'win32' ? 'codex.cmd' : 'codex');
     writeFileSync(
@@ -182,6 +183,7 @@ test('a successful pstack install retains its skill block and gains the question
 
     const installation = installInScratchHome(homeDirectory, [], {
         CDE_INSTALL_PSTACK: '1',
+        CDE_INSTALL_DEEPSTACK: '0',
         CDE_INSTALL_USAGE_WRAPUP: '0',
         CDE_INSTALL_SUBAGENT_MODELS: '0',
         CDE_INSTALL_DEEPEN_FIRST_PROMPT: '0',
@@ -191,7 +193,7 @@ test('a successful pstack install retains its skill block and gains the question
 
     assert.equal(installation.status, 0, installation.stdout + installation.stderr);
     const guidanceText = readFileSync(join(homeDirectory, '.codex', 'AGENTS.md'), 'utf8');
-    assert.match(guidanceText, /<!-- claude-dev-env skill load: start -->/);
+    assert.doesNotMatch(guidanceText, /<!-- claude-dev-env skill load: start -->/);
     assert.match(guidanceText, /<!-- claude-dev-env question presentation: start -->/);
     assert.ok(guidanceText.includes(readFileSync(policyPath, 'utf8')));
 });
@@ -211,6 +213,7 @@ test('enabling pstack after a pstack-off install preserves question guidance', (
 
     const secondInstallation = installInScratchHome(homeDirectory, [], {
         CDE_INSTALL_PSTACK: '1',
+        CDE_INSTALL_DEEPSTACK: '0',
         CDE_INSTALL_USAGE_WRAPUP: '0',
         CDE_INSTALL_SUBAGENT_MODELS: '0',
         CDE_INSTALL_DEEPEN_FIRST_PROMPT: '0',
@@ -221,7 +224,7 @@ test('enabling pstack after a pstack-off install preserves question guidance', (
     assert.equal(secondInstallation.status, 0, secondInstallation.stdout + secondInstallation.stderr);
     const updatedGuidance = readFileSync(codexGuidancePath, 'utf8');
     assert.ok(updatedGuidance.includes(firstGuidance));
-    assert.match(updatedGuidance, /<!-- claude-dev-env skill load: start -->/);
+    assert.doesNotMatch(updatedGuidance, /<!-- claude-dev-env skill load: start -->/);
     assert.match(updatedGuidance, /^feature, refactoring: gpt-6-sol$/m);
     assert.match(readFileSync(join(homeDirectory, '.codex', 'pstack-models.md'), 'utf8'), /^session hook: on$/m);
 });
@@ -241,6 +244,7 @@ test('a failed pstack transition restores question-only guidance and removes its
 
     const failedInstallation = installInScratchHome(homeDirectory, [], {
         CDE_INSTALL_PSTACK: '1',
+        CDE_INSTALL_DEEPSTACK: '0',
         CDE_INSTALL_USAGE_WRAPUP: '0',
         CDE_INSTALL_SUBAGENT_MODELS: '0',
         CDE_INSTALL_DEEPEN_FIRST_PROMPT: '0',