claude-dev-env 8.85.1 → 8.85.3

package/.agents/skills/efficient-review/SKILL.md

@@ -0,0 +1,79 @@
+---
+name: efficient-review
+description: >-
+  Run one low-cost code review of the current branch, or of a branch in another
+  repository, as a headless Claude run on haiku with the slim review profile.
+  An auto run lets the account broker pick the account. A headless run names
+  the account. Triggers: /efficient-review, "efficient review", "cheap review",
+  "haiku review of this branch".
+---
+
+# Efficient review
+
+This skill runs one headless code review of a branch on haiku and prints its findings. Pick the mode, run the planner, then run the review on the machine that holds the Claude accounts, or through the agent-pc runner from a cloud session.
+
+Argument shape: `/efficient-review [auto|headless] [account] [model=] [effort=] [level=] [base=]`. Pass `model=` only as the Defaults section allows.
+A blank argument comes from [`defaults.json`](defaults.json).
+
+## Defaults
+
+**Always run the review on haiku.** `defaults.json` names `haiku`, and a blank `model` input runs it. Pass `model=` or the workflow's `model` input only when the owner's own message names the family as a directive, such as "run this review on sonnet". Then run it on that family. Do not ask which model to use. Do not change the model on your own, for depth, for cost, or because passes keep finding issues. A stream of findings is a reason to fix the findings and run haiku again.
+
+**The review must run headless.** Never spawn the review as an Agent subagent in this session. A subagent runs inside the parent session, so it cannot load the slim profile's setting sources, plugin folder, MCP config, or auto-compact window. `defaults.json` holds a headless mode, and `load_defaults` refuses any other mode.
+
+## Subcommands
+
+Run each one as `python -m tools.efficient_review <subcommand> <arguments>` from the checkout that contains `tools/efficient_review.py`.
+
+| Subcommand | Action |
+|---|---|
+| `plan` | Prints the mode, account, model family, harness, effort, level, base, and the prompt. |
+| `accounts` | Lists the Claude accounts a headless run can name. |
+| `run` | Runs a headless or auto review and prints the review, the served models, and the saved file. |
+
+## Modes
+
+| Mode | Picked when | Account |
+|---|---|---|
+| auto | No mode word and no account. The word `auto` picks it too. | The account broker picks it. Ask nothing. |
+| headless | The word `headless`, or an account launcher name. | Required. With no account named, ask for one. |
+
+A model is a family name: haiku, sonnet, opus, sol, or luna. The planner refuses a versioned model ID. `codex review` takes no level, so the planner refuses `level=` with sol or luna.
+
+## 1. Headless mode with no account
+
+Run `python -m tools.efficient_review accounts`. Ask with the session's question tool, one option per listed account, and wait for the answer. The answer is the account. On the machine that holds the launchers, the list comes from the `claude-*.cmd` launchers, without `claude-base`, `claude-raw`, and `claude-kimi`. In the cloud the list is the known roster.
+
+## 2. Headless or auto on that machine
+
+Run `python -m tools.efficient_review run <arguments> --repository <checkout>`. When the checkout has no launcher folder, go to step 3.
+
+- It builds the slim profile from `tools.review_profile` into a temp folder.
+- Auto asks `account_broker.py choose --product claude` for the account.
+- It runs the account launcher with `-p`, the model alias, the effort, the profile arguments, and the environment. The system prompt file holds the review rules from the checkout that contains the runner, and the code standards. The prompt and the diff against the base go on standard input.
+- A sol or luna family runs `codex review` on the newest slug of that family. The log prints that slug.
+- It prints the review, the served models from the stream's `modelUsage` keys, and the saved file. The review and its record go to a temp folder outside the repository.
+
+## 3. Headless or auto from a cloud session
+
+The cloud container has no other Claude accounts, so the review runs on the agent-pc runner. Read [reference/cloud-session.md](reference/cloud-session.md).
+
+## Reading guide
+
+| File | What it does |
+|---|---|
+| [`reference/cloud-session.md`](reference/cloud-session.md) | Dispatching the review from a cloud session and reading its results branch. |
+| [`defaults.json`](defaults.json) | The default model family, effort, level, prompt, base, profile, advisor, validator, mode, and timeout. |
+
+## Common pitfalls
+
+- **Picking a stronger model after several passes.** Fix the findings and run haiku again.
+- **Setting a valid finding aside.** Check each finding against the code. Fix every one that holds in the same branch, even when it reaches files the diff did not touch. Answer only the findings that fail the check, with the file and line that rules each out.
+- **Asking which model to use.** The answer is haiku. When the owner names another family, run it without a confirmation question.
+- **Spawning the review as a subagent.** The review loses the slim profile. Run it headless.
+- **Dispatching from the branch under review.** The workflow runs only from `main`.
+
+## Out of scope
+
+- The `validator` default stays `off`.
+- A fixer step after the review. The skill has no fixer step.

package/.agents/skills/efficient-review/defaults.json

@@ -0,0 +1,12 @@
+{
+  "model": "haiku",
+  "effort": "high",
+  "level": "high",
+  "prompt": "/code-review {level} --max-findings all {base}",
+  "base": "main",
+  "profile": "slim",
+  "advisor": "none",
+  "validator": "off",
+  "mode": "auto",
+  "timeout_minutes": 60
+}

package/.agents/skills/efficient-review/reference/cloud-session.md

@@ -0,0 +1,13 @@
+# Headless or auto from a cloud session
+
+The cloud container has no other Claude accounts, so the review runs on the agent-pc runner.
+
+1. From the checkout that contains `tools/efficient_review.py`, dispatch `.github/workflows/efficient-review.yml` on ref `main`. The job runs only from `main`, so the runner executes the reviewed tool code and never the branch under review. Inputs: `account` (blank means auto), `effort`, `level`, `base`, `ref` (the branch to review), and `repository` (the `owner/name` to review when it is not that checkout). Leave `model` blank.
+2. Wait for the run to finish.
+3. Read `review.md` from the results branch `efficient-review-results/<run id>-<attempt>`. The branch holds that file and `review.json`. The commit message names the account, the launcher, and the served models. Print the review and the served models.
+
+A review of another repository checks it out with the read token configured for that workflow.
+
+To review a pull request in the checkout that contains the workflow, pass its number as `pull_request` and leave `ref` blank. The run reviews the pull request head, then posts each finding on it as a review thread.
+
+For a pull request in this package's public repository, pass `repository` as `jl-cmd/claude-dev-env` and `pull_request` together. The workflow accepts that repository name. The run posts nothing on the public pull request. When the review lists findings, it dispatches the landing repair with the pull request number and the results branch.

package/bin/codex-trimmed-sol.test.mjs

@@ -32,6 +32,7 @@ function installInScratchHome(homeDirectory, argumentsList = [], environment = {
             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/ever-shipped-skills.mjs

@@ -28,6 +28,7 @@ export const EVER_SHIPPED_SKILL_NAMES = new Set([
     'descriptions',
     'e-code-review',
     'e-simplify',
+    'efficient-review',
     'eli5',
     'emergencies',
     'everything-search',

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',