claude-dev-env 8.106.5 → 8.107.1

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
@@ -33,6 +33,7 @@ function installInScratchHome(homeDirectory, argumentsList = [], environment = {
33
33
  LLM_SETTINGS_PROFILES_ROOT: undefined,
34
34
  CDE_INSTALL_PSTACK: '0',
35
35
  CDE_INSTALL_DEEPSTACK: '0',
36
+ CDE_INSTALL_PELE: '0',
36
37
  CDE_INSTALL_USAGE_WRAPUP: '0',
37
38
  CDE_INSTALL_SUBAGENT_MODELS: '0',
38
39
  CDE_INSTALL_SECURITY_GUIDANCE: '0',
@@ -0,0 +1,161 @@
1
+ import { existsSync, mkdirSync, readFileSync, rmSync, writeFileSync } from 'node:fs';
2
+ import { dirname, join } from 'node:path';
3
+ import { namesAnAbsentCommand, runHostCommand, singleLineDetail } from './install-pstack-plugin.mjs';
4
+
5
+ export const PELE_PACKAGE_NAME = 'pele';
6
+ export const PELE_PACKAGE_OPT_OUT_FLAG = '--no-pele';
7
+ export const PELE_PACKAGE_OPT_OUT_VARIABLE = 'CDE_INSTALL_PELE';
8
+ export const PELE_TOOLS_DIRECTORY_NAME = 'tools';
9
+ const PELE_HOST_PACKAGE_NAME = 'claude-dev-env-pele-host';
10
+ const NPM_COMMAND_TIMEOUT_MILLISECONDS = 120000;
11
+ const PELE_REMOVAL_RETRIES = 3;
12
+ const VERSION_PATTERN = /^(\d+)\.(\d+)\.(\d+)/;
13
+ const PLAIN_VERSION_PATTERN = /^\d+\.\d+\.\d+(-[0-9A-Za-z.-]+)?$/;
14
+
15
+ export const PELE_PACKAGE_SPEC = Object.freeze({
16
+ optOutFlag: PELE_PACKAGE_OPT_OUT_FLAG,
17
+ optOutVariable: PELE_PACKAGE_OPT_OUT_VARIABLE,
18
+ });
19
+
20
+ /**
21
+ * Name the folder one managed root keeps its Pele install in.
22
+ *
23
+ * @param {string} managedRoot The managed Claude root.
24
+ * @returns {string} `<managedRoot>/tools/pele`.
25
+ */
26
+ export function peleInstallDirectory(managedRoot) {
27
+ return join(managedRoot, PELE_TOOLS_DIRECTORY_NAME, PELE_PACKAGE_NAME);
28
+ }
29
+
30
+ /**
31
+ * Read the Pele version an install folder holds.
32
+ *
33
+ * @param {string} installDirectory The folder `npm install` ran in.
34
+ * @returns {string|null} The version, or null when Pele is absent or its manifest is unreadable.
35
+ */
36
+ export function installedPeleVersion(installDirectory) {
37
+ const manifestPath = join(installDirectory, 'node_modules', PELE_PACKAGE_NAME, 'package.json');
38
+ if (!existsSync(manifestPath)) return null;
39
+ try {
40
+ const manifest = JSON.parse(readFileSync(manifestPath, 'utf8'));
41
+ return typeof manifest.version === 'string' ? manifest.version : null;
42
+ } catch {
43
+ return null;
44
+ }
45
+ }
46
+
47
+ function versionParts(versionText) {
48
+ const match = VERSION_PATTERN.exec(versionText ?? '');
49
+ return match ? match.slice(1).map(Number) : null;
50
+ }
51
+
52
+ function isNewerVersion(candidateVersion, baselineVersion) {
53
+ const candidateParts = versionParts(candidateVersion);
54
+ const baselineParts = versionParts(baselineVersion);
55
+ if (!candidateParts || !baselineParts) return candidateVersion !== baselineVersion;
56
+ for (let index = 0; index < candidateParts.length; index += 1) {
57
+ if (candidateParts[index] !== baselineParts[index]) return candidateParts[index] > baselineParts[index];
58
+ }
59
+ return false;
60
+ }
61
+
62
+ function nearestExistingDirectory(directory) {
63
+ let candidate = directory;
64
+ while (!existsSync(candidate) && dirname(candidate) !== candidate) candidate = dirname(candidate);
65
+ return candidate;
66
+ }
67
+
68
+ function runNpm(commandArguments, options = {}) {
69
+ return runHostCommand('npm', commandArguments, {
70
+ cwd: options.cwd,
71
+ timeoutMilliseconds: NPM_COMMAND_TIMEOUT_MILLISECONDS,
72
+ });
73
+ }
74
+
75
+ function failureDetail(outcome, fallback) {
76
+ const cause = outcome.error?.code === 'ETIMEDOUT'
77
+ ? `timed out after ${NPM_COMMAND_TIMEOUT_MILLISECONDS} ms`
78
+ : outcome.error?.message;
79
+ return singleLineDetail([cause, outcome.stderr].filter(Boolean).join(' ') || fallback);
80
+ }
81
+
82
+ function prepareInstallDirectory(installDirectory) {
83
+ mkdirSync(installDirectory, { recursive: true });
84
+ const hostManifestPath = join(installDirectory, 'package.json');
85
+ if (!existsSync(hostManifestPath)) {
86
+ writeFileSync(hostManifestPath, `${JSON.stringify({ name: PELE_HOST_PACKAGE_NAME, private: true }, null, 2)}\n`);
87
+ }
88
+ }
89
+
90
+ /**
91
+ * Install Pele from the npm registry, or move an older copy to the latest version.
92
+ *
93
+ * Pele is a JavaScript library, so it lands in a private folder under the managed
94
+ * root instead of the global npm prefix. A newer local copy stays as it is. A
95
+ * registry or install failure leaves any existing copy in place and reports a
96
+ * warning, so the rest of the install still completes.
97
+ *
98
+ * @param {{installDirectory: string, run?: (commandArguments: string[], options?: {cwd?: string}) => {status: number|null, stdout: string, stderr: string, error?: Error}}} options
99
+ * The install folder and an optional npm runner.
100
+ * @returns {{status: 'installed'|'updated'|'current'|'skipped'|'failed', installedVersion: string|null, previousVersion: string|null, warning: string|null}} The outcome.
101
+ */
102
+ export function installPelePackage({ installDirectory, run = runNpm }) {
103
+ const previousVersion = installedPeleVersion(installDirectory);
104
+ const outcome = (status, installedVersion, warning = null) => ({
105
+ status,
106
+ installedVersion,
107
+ previousVersion,
108
+ warning,
109
+ });
110
+ const lookup = run(['view', PELE_PACKAGE_NAME, 'version'], {
111
+ cwd: nearestExistingDirectory(installDirectory),
112
+ });
113
+ if (namesAnAbsentCommand(lookup)) {
114
+ return outcome('skipped', previousVersion, 'npm was not found on PATH');
115
+ }
116
+ const latestVersion = lookup.status === 0 ? lookup.stdout.trim() : '';
117
+ if (!PLAIN_VERSION_PATTERN.test(latestVersion)) {
118
+ const detail = lookup.status === 0
119
+ ? `npm view ${PELE_PACKAGE_NAME} returned something that is not a version`
120
+ : `npm view ${PELE_PACKAGE_NAME} failed: ${failureDetail(lookup, 'no version returned')}`;
121
+ return previousVersion
122
+ ? outcome('current', previousVersion, detail)
123
+ : outcome('failed', null, detail);
124
+ }
125
+ if (previousVersion && !isNewerVersion(latestVersion, previousVersion)) {
126
+ return outcome('current', previousVersion);
127
+ }
128
+ prepareInstallDirectory(installDirectory);
129
+ const installation = run(
130
+ ['install', '--ignore-scripts', '--no-audit', '--no-fund', '--loglevel=error', `${PELE_PACKAGE_NAME}@${latestVersion}`],
131
+ { cwd: installDirectory },
132
+ );
133
+ if (installation.status !== 0) {
134
+ return outcome(
135
+ 'failed',
136
+ previousVersion,
137
+ `npm install ${PELE_PACKAGE_NAME}@${latestVersion} failed: ${failureDetail(installation, 'no output')}`,
138
+ );
139
+ }
140
+ const installedVersion = installedPeleVersion(installDirectory);
141
+ if (installedVersion !== latestVersion) {
142
+ return outcome(
143
+ 'failed',
144
+ installedVersion,
145
+ `npm install finished but ${PELE_PACKAGE_NAME} ${latestVersion} is not in ${installDirectory}`,
146
+ );
147
+ }
148
+ return outcome(previousVersion ? 'updated' : 'installed', installedVersion);
149
+ }
150
+
151
+ /**
152
+ * Delete the Pele install directory an earlier install created.
153
+ *
154
+ * @param {string} installDirectory The folder `installPelePackage` filled.
155
+ * @returns {boolean} True when a folder was removed.
156
+ */
157
+ export function removePelePackage(installDirectory) {
158
+ if (!existsSync(installDirectory)) return false;
159
+ rmSync(installDirectory, { recursive: true, force: true, maxRetries: PELE_REMOVAL_RETRIES });
160
+ return true;
161
+ }
@@ -0,0 +1,269 @@
1
+ import { test } from 'node:test';
2
+ import { strict as assert } from 'node:assert';
3
+ import { spawnSync } from 'node:child_process';
4
+ import { chmodSync, existsSync, mkdirSync, mkdtempSync, readFileSync, realpathSync, rmSync, writeFileSync } from 'node:fs';
5
+ import { tmpdir } from 'node:os';
6
+ import { join } from 'node:path';
7
+ import { fileURLToPath } from 'node:url';
8
+ import {
9
+ PELE_PACKAGE_NAME,
10
+ PELE_PACKAGE_SPEC,
11
+ installPelePackage,
12
+ installedPeleVersion,
13
+ peleInstallDirectory,
14
+ removePelePackage,
15
+ } from './install-pele-package.mjs';
16
+ import { shouldInstallMarketplacePlugin } from './install-pstack-plugin.mjs';
17
+
18
+ function writeInstalledPele(installDirectory, version) {
19
+ const packageDirectory = join(installDirectory, 'node_modules', PELE_PACKAGE_NAME);
20
+ mkdirSync(packageDirectory, { recursive: true });
21
+ writeFileSync(join(packageDirectory, 'package.json'), JSON.stringify({ name: PELE_PACKAGE_NAME, version }));
22
+ }
23
+
24
+ function fakeNpm({ latestVersion, installedAfterInstall, failOn }) {
25
+ const recordedCalls = [];
26
+ const recordedOptions = [];
27
+ const run = (commandArguments, options) => {
28
+ recordedCalls.push(commandArguments);
29
+ recordedOptions.push(options);
30
+ if (failOn === commandArguments[0]) return { status: 1, stdout: '', stderr: `${failOn} exploded` };
31
+ if (commandArguments[0] === 'view') return { status: 0, stdout: `${latestVersion}\n`, stderr: '' };
32
+ writeInstalledPele(options.cwd, installedAfterInstall ?? latestVersion);
33
+ return { status: 0, stdout: '', stderr: '' };
34
+ };
35
+ return { run, recordedCalls, recordedOptions };
36
+ }
37
+
38
+ function withInstallDirectory(body) {
39
+ const managedRoot = mkdtempSync(join(tmpdir(), 'cde-pele-'));
40
+ try {
41
+ body(peleInstallDirectory(managedRoot));
42
+ } finally {
43
+ rmSync(managedRoot, { recursive: true, force: true });
44
+ }
45
+ }
46
+
47
+ test('the install directory sits under the managed root and the package is named pele', () => {
48
+ assert.equal(PELE_PACKAGE_NAME, 'pele');
49
+ assert.match(peleInstallDirectory('/home/dev/.claude').replaceAll('\\', '/'), /\/home\/dev\/\.claude\/tools\/pele$/);
50
+ });
51
+
52
+ test('the registry lookup runs beside the install folder, not in the caller directory', () => {
53
+ const managedRoot = mkdtempSync(join(tmpdir(), 'cde-pele-'));
54
+ try {
55
+ const installDirectory = peleInstallDirectory(managedRoot);
56
+ const { run, recordedOptions } = fakeNpm({ latestVersion: '1.2.0' });
57
+ installPelePackage({ installDirectory, run });
58
+ assert.equal(recordedOptions[0].cwd, managedRoot);
59
+ assert.equal(recordedOptions[1].cwd, installDirectory);
60
+ } finally {
61
+ rmSync(managedRoot, { recursive: true, force: true });
62
+ }
63
+ });
64
+
65
+ test('a timed out npm call names the limit and keeps the partial output', () => {
66
+ withInstallDirectory(installDirectory => {
67
+ const timedOut = () => ({
68
+ status: null,
69
+ stdout: '',
70
+ stderr: 'npm warn config old setting',
71
+ error: Object.assign(new Error('spawnSync npm ETIMEDOUT'), { code: 'ETIMEDOUT' }),
72
+ });
73
+ const outcome = installPelePackage({ installDirectory, run: timedOut });
74
+ assert.equal(outcome.status, 'failed');
75
+ assert.match(outcome.warning, /timed out after 120000 ms npm warn config old setting/);
76
+ });
77
+ });
78
+
79
+ test('a missing install is installed at the latest registry version', () => {
80
+ withInstallDirectory(installDirectory => {
81
+ const { run, recordedCalls } = fakeNpm({ latestVersion: '1.2.0' });
82
+ const outcome = installPelePackage({ installDirectory, run });
83
+ assert.equal(outcome.status, 'installed');
84
+ assert.equal(outcome.installedVersion, '1.2.0');
85
+ assert.equal(installedPeleVersion(installDirectory), '1.2.0');
86
+ assert.deepEqual(recordedCalls[1], ['install', '--ignore-scripts', '--no-audit', '--no-fund', '--loglevel=error', 'pele@1.2.0']);
87
+ });
88
+ });
89
+
90
+ test('an outdated install is updated and reports both versions', () => {
91
+ withInstallDirectory(installDirectory => {
92
+ writeInstalledPele(installDirectory, '1.0.0');
93
+ const { run } = fakeNpm({ latestVersion: '1.2.0' });
94
+ const outcome = installPelePackage({ installDirectory, run });
95
+ assert.equal(outcome.status, 'updated');
96
+ assert.equal(outcome.previousVersion, '1.0.0');
97
+ assert.equal(outcome.installedVersion, '1.2.0');
98
+ });
99
+ });
100
+
101
+ test('a current install runs no install command', () => {
102
+ withInstallDirectory(installDirectory => {
103
+ writeInstalledPele(installDirectory, '1.2.0');
104
+ const { run, recordedCalls } = fakeNpm({ latestVersion: '1.2.0' });
105
+ const outcome = installPelePackage({ installDirectory, run });
106
+ assert.equal(outcome.status, 'current');
107
+ assert.deepEqual(recordedCalls.map(eachCall => eachCall[0]), ['view']);
108
+ });
109
+ });
110
+
111
+ test('a registry lookup failure keeps an existing install and fails a missing one', () => {
112
+ withInstallDirectory(installDirectory => {
113
+ const missing = installPelePackage({ installDirectory, run: fakeNpm({ failOn: 'view' }).run });
114
+ assert.equal(missing.status, 'failed');
115
+ assert.match(missing.warning, /view exploded/);
116
+ writeInstalledPele(installDirectory, '1.0.0');
117
+ const kept = installPelePackage({ installDirectory, run: fakeNpm({ failOn: 'view' }).run });
118
+ assert.equal(kept.status, 'current');
119
+ assert.equal(kept.installedVersion, '1.0.0');
120
+ assert.match(kept.warning, /view exploded/);
121
+ });
122
+ });
123
+
124
+ test('a registry answer that is not a plain version never reaches the install command', () => {
125
+ for (const hostileAnswer of ['1.2.0 & echo pwned', '1.2.0\n&& calc', '^1.2.0', 'latest', '1.2', '1.2.0;rm']) {
126
+ withInstallDirectory(installDirectory => {
127
+ const { run, recordedCalls } = fakeNpm({ latestVersion: hostileAnswer });
128
+ const outcome = installPelePackage({ installDirectory, run });
129
+ assert.equal(outcome.status, 'failed', hostileAnswer);
130
+ assert.match(outcome.warning, /not a version/);
131
+ assert.deepEqual(recordedCalls.map(eachCall => eachCall[0]), ['view'], hostileAnswer);
132
+ assert.equal(existsSync(join(installDirectory, 'package.json')), false);
133
+ });
134
+ }
135
+ });
136
+
137
+ test('a failing install command is reported and leaves the older version in place', () => {
138
+ withInstallDirectory(installDirectory => {
139
+ writeInstalledPele(installDirectory, '1.0.0');
140
+ const outcome = installPelePackage({ installDirectory, run: fakeNpm({ latestVersion: '1.2.0', failOn: 'install' }).run });
141
+ assert.equal(outcome.status, 'failed');
142
+ assert.match(outcome.warning, /install exploded/);
143
+ assert.equal(installedPeleVersion(installDirectory), '1.0.0');
144
+ });
145
+ });
146
+
147
+ test('an install that does not land the requested version is reported as failed', () => {
148
+ withInstallDirectory(installDirectory => {
149
+ const outcome = installPelePackage({
150
+ installDirectory,
151
+ run: fakeNpm({ latestVersion: '1.2.0', installedAfterInstall: '0.9.0' }).run,
152
+ });
153
+ assert.equal(outcome.status, 'failed');
154
+ assert.match(outcome.warning, /1\.2\.0/);
155
+ });
156
+ });
157
+
158
+ test('a newer local copy is kept and never downgraded', () => {
159
+ withInstallDirectory(installDirectory => {
160
+ writeInstalledPele(installDirectory, '1.10.0');
161
+ const { run, recordedCalls } = fakeNpm({ latestVersion: '1.9.3' });
162
+ const outcome = installPelePackage({ installDirectory, run });
163
+ assert.equal(outcome.status, 'current');
164
+ assert.equal(outcome.installedVersion, '1.10.0');
165
+ assert.deepEqual(recordedCalls.map(eachCall => eachCall[0]), ['view']);
166
+ });
167
+ });
168
+
169
+ test('a missing npm skips the step and a fresh install writes its own host manifest', () => {
170
+ withInstallDirectory(installDirectory => {
171
+ const absentNpm = () => ({ status: null, stdout: '', stderr: '', error: Object.assign(new Error('spawn npm ENOENT'), { code: 'ENOENT' }) });
172
+ const skipped = installPelePackage({ installDirectory, run: absentNpm });
173
+ assert.equal(skipped.status, 'skipped');
174
+ assert.equal(existsSync(join(installDirectory, 'package.json')), false);
175
+ installPelePackage({ installDirectory, run: fakeNpm({ latestVersion: '1.2.0' }).run });
176
+ const hostManifest = JSON.parse(readFileSync(join(installDirectory, 'package.json'), 'utf8'));
177
+ assert.equal(hostManifest.private, true);
178
+ });
179
+ });
180
+
181
+ test('removing the install folder deletes it once and reports an absent folder', () => {
182
+ withInstallDirectory(installDirectory => {
183
+ writeInstalledPele(installDirectory, '1.2.0');
184
+ assert.equal(removePelePackage(installDirectory), true);
185
+ assert.equal(existsSync(installDirectory), false);
186
+ assert.equal(removePelePackage(installDirectory), false);
187
+ });
188
+ });
189
+
190
+ test('a corrupt installed package.json reads as not installed', () => {
191
+ withInstallDirectory(installDirectory => {
192
+ const packageDirectory = join(installDirectory, 'node_modules', PELE_PACKAGE_NAME);
193
+ mkdirSync(packageDirectory, { recursive: true });
194
+ writeFileSync(join(packageDirectory, 'package.json'), '{not json');
195
+ assert.equal(installedPeleVersion(installDirectory), null);
196
+ assert.equal(existsSync(join(packageDirectory, 'package.json')), true);
197
+ assert.equal(readFileSync(join(packageDirectory, 'package.json'), 'utf8'), '{not json');
198
+ });
199
+ });
200
+
201
+ test('--no-pele and CDE_INSTALL_PELE=0 skip the step', () => {
202
+ assert.equal(shouldInstallMarketplacePlugin(PELE_PACKAGE_SPEC, [], {}), true);
203
+ assert.equal(shouldInstallMarketplacePlugin(PELE_PACKAGE_SPEC, ['--no-pele'], {}), false);
204
+ assert.equal(shouldInstallMarketplacePlugin(PELE_PACKAGE_SPEC, [], { CDE_INSTALL_PELE: '0' }), false);
205
+ });
206
+
207
+ const INSTALLER_PATH = fileURLToPath(new URL('./install.mjs', import.meta.url));
208
+ const STUB_NPM_SOURCE = `#!/usr/bin/env node
209
+ const fs = require('node:fs');
210
+ const path = require('node:path');
211
+ fs.appendFileSync(process.env.STUB_NPM_LOG, process.argv.slice(2).join(' ') + '\\n');
212
+ fs.appendFileSync(process.env.STUB_NPM_CWD_LOG, process.argv[2] + ' ' + process.cwd() + '\\n');
213
+ if (process.argv[2] === 'view') { process.stdout.write('3.4.5\\n'); process.exit(0); }
214
+ const packageDirectory = path.join(process.cwd(), 'node_modules', 'pele');
215
+ fs.mkdirSync(packageDirectory, { recursive: true });
216
+ fs.writeFileSync(path.join(packageDirectory, 'package.json'), JSON.stringify({ name: 'pele', version: '3.4.5' }));
217
+ `;
218
+
219
+ test('a full install adds Pele once, skips it on a rerun, and --uninstall removes it', { skip: process.platform === 'win32' }, () => {
220
+ const scratchRoot = mkdtempSync(join(tmpdir(), 'cde-pele-full-'));
221
+ try {
222
+ const stubDirectory = join(scratchRoot, 'stub-bin');
223
+ const homeDirectory = join(scratchRoot, 'home');
224
+ const callLog = join(scratchRoot, 'npm-calls.log');
225
+ const cwdLog = join(scratchRoot, 'npm-cwds.log');
226
+ mkdirSync(stubDirectory, { recursive: true });
227
+ mkdirSync(homeDirectory, { recursive: true });
228
+ writeFileSync(join(stubDirectory, 'npm'), STUB_NPM_SOURCE);
229
+ chmodSync(join(stubDirectory, 'npm'), 0o755);
230
+ writeFileSync(join(homeDirectory, '.gitconfig'), '');
231
+ const environment = {
232
+ ...process.env,
233
+ PATH: `${stubDirectory}:${process.env.PATH}`,
234
+ STUB_NPM_LOG: callLog,
235
+ STUB_NPM_CWD_LOG: cwdLog,
236
+ LLM_SETTINGS_PROFILES_ROOT: undefined,
237
+ HOME: homeDirectory,
238
+ USERPROFILE: homeDirectory,
239
+ CLAUDE_CONFIG_DIR: '',
240
+ GIT_CONFIG_GLOBAL: join(homeDirectory, '.gitconfig'),
241
+ CDE_INSTALL_PSTACK: '0',
242
+ CDE_INSTALL_DEEPSTACK: '0',
243
+ CDE_INSTALL_USAGE_WRAPUP: '0',
244
+ CDE_INSTALL_SUBAGENT_MODELS: '0',
245
+ CDE_INSTALL_SECURITY_GUIDANCE: '0',
246
+ };
247
+ const peleDirectory = join(homeDirectory, '.claude', 'tools', 'pele');
248
+ const firstRun = spawnSync(process.execPath, [INSTALLER_PATH], { encoding: 'utf8', env: environment });
249
+ assert.equal(firstRun.status, 0, firstRun.stdout + firstRun.stderr);
250
+ assert.match(firstRun.stdout, /Pele 3\.4\.5: installed/);
251
+ assert.equal(installedPeleVersion(peleDirectory), '3.4.5');
252
+ const secondRun = spawnSync(process.execPath, [INSTALLER_PATH], { encoding: 'utf8', env: environment });
253
+ assert.equal(secondRun.status, 0, secondRun.stdout + secondRun.stderr);
254
+ assert.match(secondRun.stdout, /Pele 3\.4\.5: current/);
255
+ const installCalls = readFileSync(callLog, 'utf8').split('\n').filter(eachLine => eachLine.startsWith('install '));
256
+ assert.equal(installCalls.length, 1);
257
+ const viewLine = readFileSync(cwdLog, 'utf8').split('\n').find(eachLine => eachLine.startsWith('view '));
258
+ assert.ok(viewLine, 'the installer never ran npm view');
259
+ assert.equal(viewLine.slice('view '.length), realpathSync(join(homeDirectory, '.claude')));
260
+ const optedOut = spawnSync(process.execPath, [INSTALLER_PATH, '--no-pele'], { encoding: 'utf8', env: environment });
261
+ assert.equal(optedOut.status, 0, optedOut.stdout + optedOut.stderr);
262
+ assert.doesNotMatch(optedOut.stdout, /Pele/);
263
+ const uninstall = spawnSync(process.execPath, [INSTALLER_PATH, '--uninstall'], { encoding: 'utf8', env: environment });
264
+ assert.equal(uninstall.status, 0, uninstall.stdout + uninstall.stderr);
265
+ assert.equal(existsSync(peleDirectory), false);
266
+ } finally {
267
+ rmSync(scratchRoot, { recursive: true, force: true });
268
+ }
269
+ });
@@ -201,15 +201,20 @@ export function shouldInstallMarketplacePlugin(
201
201
  return environment[spec.optOutVariable] !== '0';
202
202
  }
203
203
 
204
+ const BARE_COMMAND_NAME_PATTERN = /^[A-Za-z0-9_][\w.-]*$/;
205
+
204
206
  /**
205
207
  * Build the process launch one platform needs to run a host command.
206
208
  *
207
- * Both hosts ship on Windows as a `.cmd` shim, and Node's synchronous spawn
208
- * rejects a batch file with `EINVAL` unless a shell runs it, so Windows goes
209
- * through `cmd.exe /d /s /c` with the whole command line as one verbatim
210
- * argument. The executable carries its own quotes inside that line, which is
211
- * why the line is passed verbatim rather than quoted again by Node. Every
212
- * other platform launches the executable directly.
209
+ * The hosts, `claude`, `codex` and the `npm` that installs Pele, ship on
210
+ * Windows as a `.cmd` shim. Node's synchronous spawn rejects a batch file with
211
+ * `EINVAL` unless a shell runs it, so Windows goes through `cmd.exe /d /s /c`
212
+ * with the whole command line as one verbatim argument. A path carries its own
213
+ * quotes inside that line, which is why the line is passed verbatim rather than
214
+ * quoted again by Node. A bare name stays unquoted because `cmd.exe` hands a
215
+ * quoted bare name to a shim as `%0`, and the shim then resolves `%~dp0`
216
+ * against the working directory instead of its own folder. Every other
217
+ * platform launches the executable directly.
213
218
  *
214
219
  * @param {string} executable The host command, a bare name or a path.
215
220
  * @param {string[]} commandArguments The arguments after the executable.
@@ -226,7 +231,8 @@ export function hostCommandInvocation(
226
231
  if (platform !== 'win32') {
227
232
  return { file: executable, args: [...commandArguments], windowsVerbatimArguments: false };
228
233
  }
229
- const commandLine = [`"${executable}"`, ...commandArguments].join(' ');
234
+ const launchedExecutable = BARE_COMMAND_NAME_PATTERN.test(executable) ? executable : `"${executable}"`;
235
+ const commandLine = [launchedExecutable, ...commandArguments].join(' ');
230
236
  return {
231
237
  file: environment.ComSpec || 'cmd.exe',
232
238
  args: ['/d', '/s', '/c', `"${commandLine}"`],
@@ -234,11 +240,13 @@ export function hostCommandInvocation(
234
240
  };
235
241
  }
236
242
 
237
- function runHostCommand(executable, commandArguments, options) {
243
+ export function runHostCommand(executable, commandArguments, options = {}) {
238
244
  const invocation = hostCommandInvocation(executable, commandArguments);
239
245
  const spawned = spawnSync(invocation.file, invocation.args, {
240
246
  encoding: 'utf8',
241
247
  env: { ...process.env, ...options.environment },
248
+ cwd: options.cwd,
249
+ timeout: options.timeoutMilliseconds,
242
250
  windowsVerbatimArguments: invocation.windowsVerbatimArguments,
243
251
  });
244
252
  return {
@@ -252,13 +260,13 @@ function runHostCommand(executable, commandArguments, options) {
252
260
  const COMMAND_NOT_FOUND_EXIT_CODE = 9009;
253
261
  const COMMAND_NOT_FOUND_PATTERN = /is not recognized as an internal or external command/;
254
262
 
255
- function namesAnAbsentCommand(outcome) {
263
+ export function namesAnAbsentCommand(outcome) {
256
264
  if (outcome.error?.code === 'ENOENT') return true;
257
265
  return outcome.status === COMMAND_NOT_FOUND_EXIT_CODE
258
266
  && COMMAND_NOT_FOUND_PATTERN.test(outcome.stderr ?? '');
259
267
  }
260
268
 
261
- function singleLineDetail(text) {
269
+ export function singleLineDetail(text) {
262
270
  return (text ?? '').split(/\r?\n/).map(eachLine => eachLine.trim()).filter(Boolean).join(' ');
263
271
  }
264
272
 
@@ -19,6 +19,7 @@ import {
19
19
  removeStaleMarketplaceClone,
20
20
  removeRetiredMarketplacePlugins,
21
21
  restartNotice,
22
+ runHostCommand,
22
23
  shouldInstallMarketplacePlugin,
23
24
  } from './install-pstack-plugin.mjs';
24
25
 
@@ -265,11 +266,37 @@ test('Windows launches the host command through cmd.exe, which alone can run a .
265
266
  '/d',
266
267
  '/s',
267
268
  '/c',
268
- `""claude" plugin install ${PSTACK_PLUGIN_IDENTIFIER}"`,
269
+ `"claude plugin install ${PSTACK_PLUGIN_IDENTIFIER}"`,
269
270
  ]);
270
271
  assert.equal(invocation.windowsVerbatimArguments, true);
271
272
  });
272
273
 
274
+ test('a bare Windows command name stays unquoted so a .cmd shim finds its own folder through %~dp0', () => {
275
+ const invocation = hostCommandInvocation('npm', ['view', 'pele', 'version'], 'win32', WINDOWS_ENVIRONMENT);
276
+ assert.equal(invocation.args.at(-1), '"npm view pele version"');
277
+ });
278
+
279
+ test('npm runs from a folder away from its own install on Windows', { skip: process.platform !== 'win32' }, () => {
280
+ const workingDirectory = mkdtempSync(join(tmpdir(), 'cde-npm-launch-'));
281
+ try {
282
+ const outcome = runHostCommand('npm', ['--version'], { cwd: workingDirectory });
283
+ assert.equal(outcome.status, 0, outcome.stderr);
284
+ assert.match(outcome.stdout, /^\d+\.\d+\.\d+/);
285
+ } finally {
286
+ rmSync(workingDirectory, { recursive: true, force: true });
287
+ }
288
+ });
289
+
290
+ test('a Windows executable name with a shell metacharacter stays quoted', () => {
291
+ const invocation = hostCommandInvocation('npm&calc', ['view'], 'win32', WINDOWS_ENVIRONMENT);
292
+ assert.equal(invocation.args.at(-1), '""npm&calc" view"');
293
+ });
294
+
295
+ test('a Windows executable name that is a dot path or starts with a dash stays quoted', () => {
296
+ assert.equal(hostCommandInvocation('..', ['view'], 'win32', WINDOWS_ENVIRONMENT).args.at(-1), '"".." view"');
297
+ assert.equal(hostCommandInvocation('-npm', ['view'], 'win32', WINDOWS_ENVIRONMENT).args.at(-1), '""-npm" view"');
298
+ });
299
+
273
300
  test('a Windows executable path holding a space stays one quoted token', () => {
274
301
  const invocation = hostCommandInvocation(
275
302
  'C:\\Program Files\\nodejs\\claude.cmd',
@@ -54,6 +54,7 @@ function runInstaller(homeDirectory, extraArguments, environmentOverrides = {})
54
54
  LLM_SETTINGS_PROFILES_ROOT: undefined,
55
55
  CDE_INSTALL_PSTACK: '0',
56
56
  CDE_INSTALL_DEEPSTACK: '0',
57
+ CDE_INSTALL_PELE: '0',
57
58
  CDE_INSTALL_USAGE_WRAPUP: '0',
58
59
  CDE_INSTALL_SUBAGENT_MODELS: '0',
59
60
  CDE_INSTALL_SECURITY_GUIDANCE: '0',
@@ -60,6 +60,7 @@ function runInstaller(homeDirectory, extraArguments) {
60
60
  LLM_SETTINGS_PROFILES_ROOT: undefined,
61
61
  CDE_INSTALL_PSTACK: '0',
62
62
  CDE_INSTALL_DEEPSTACK: '0',
63
+ CDE_INSTALL_PELE: '0',
63
64
  CDE_INSTALL_USAGE_WRAPUP: '0',
64
65
  CDE_INSTALL_SUBAGENT_MODELS: '0',
65
66
  CDE_INSTALL_SECURITY_GUIDANCE: '0',
@@ -94,6 +95,7 @@ function scanTextWithProductionPiiScanner(scannedText) {
94
95
  LLM_SETTINGS_PROFILES_ROOT: undefined,
95
96
  CDE_INSTALL_PSTACK: '0',
96
97
  CDE_INSTALL_DEEPSTACK: '0',
98
+ CDE_INSTALL_PELE: '0',
97
99
  CDE_INSTALL_USAGE_WRAPUP: '0',
98
100
  CDE_INSTALL_SUBAGENT_MODELS: '0',
99
101
  CDE_INSTALL_SECURITY_GUIDANCE: '0',
@@ -34,6 +34,7 @@ function runInstaller(homeDirectory, extraArguments, environmentOverrides = {})
34
34
  LLM_SETTINGS_PROFILES_ROOT: undefined,
35
35
  CDE_INSTALL_PSTACK: '0',
36
36
  CDE_INSTALL_DEEPSTACK: '0',
37
+ CDE_INSTALL_PELE: '0',
37
38
  CDE_INSTALL_USAGE_WRAPUP: '0',
38
39
  CDE_INSTALL_SUBAGENT_MODELS: '0',
39
40
  CDE_INSTALL_SECURITY_GUIDANCE: '0',
package/bin/install.mjs CHANGED
@@ -71,6 +71,12 @@ import {
71
71
  removeDeepStackCursorHooks,
72
72
  removeRetiredCursorFirstTaskHook,
73
73
  } from './install-deepstack-plugin.mjs';
74
+ import {
75
+ PELE_PACKAGE_SPEC,
76
+ installPelePackage,
77
+ peleInstallDirectory,
78
+ removePelePackage,
79
+ } from './install-pele-package.mjs';
74
80
  import { seedCodexPstackModels } from './seed-codex-pstack-models.mjs';
75
81
  import {
76
82
  removeCursorAgentsGuidanceHooks,
@@ -3110,6 +3116,16 @@ function executeInstallPlanMutations(plan, transactionHelpers) {
3110
3116
  allActionNeededLines.push(`DeepStack (cursor): failed — ${cursorOutcome.warning}`);
3111
3117
  }
3112
3118
  }
3119
+ if (!selectedGroups && shouldInstallMarketplacePlugin(PELE_PACKAGE_SPEC)) {
3120
+ const pelePackage = installPelePackage({ installDirectory: peleInstallDirectory(CLAUDE_HOME) });
3121
+ summary.pelePackage = pelePackage;
3122
+ const peleVersionText = pelePackage.installedVersion ? ` ${pelePackage.installedVersion}` : '';
3123
+ const peleLine = pelePackage.warning
3124
+ ? `Pele${peleVersionText}: ${pelePackage.status} — ${pelePackage.warning}`
3125
+ : `Pele${peleVersionText}: ${pelePackage.status}`;
3126
+ console.log(` ${peleLine}`);
3127
+ if (pelePackage.status === 'failed') allActionNeededLines.push(peleLine);
3128
+ }
3113
3129
  if (!selectedGroups) {
3114
3130
  const retiredCursorHooksPath = removeRetiredCursorFirstTaskHook(
3115
3131
  INSTALL_ROOT_RESOLUTION.cursorInstallDirectory,
@@ -3667,6 +3683,7 @@ function uninstall() {
3667
3683
  faultPhase,
3668
3684
  runMutations: ({ throwIfFault }) => {
3669
3685
  executeUninstallPlan(plan, { throwIfFault, allProfileSettingsPaths: gateRemoval.allReadablePaths });
3686
+ if (removePelePackage(peleInstallDirectory(CLAUDE_HOME))) console.log(' Pele: install directory removed');
3670
3687
  },
3671
3688
  });
3672
3689
  } catch (mutationError) {
@@ -3712,6 +3729,7 @@ Usage:
3712
3729
  npx ${PACKAGE_NAME} --no-usage-wrapup Full install without the usage-wrapup plugin (also CDE_INSTALL_USAGE_WRAPUP=0)
3713
3730
  npx ${PACKAGE_NAME} --no-subagent-models Full install without the subagent-models plugin (also CDE_INSTALL_SUBAGENT_MODELS=0)
3714
3731
  npx ${PACKAGE_NAME} --no-security-guidance Full install without Anthropic's security-guidance plugin (also CDE_INSTALL_SECURITY_GUIDANCE=0)
3732
+ npx ${PACKAGE_NAME} --no-pele Full install without the Pele Mermaid renderer npm package (also CDE_INSTALL_PELE=0)
3715
3733
  npx ${PACKAGE_NAME} --uninstall Remove installed files from the selected root
3716
3734
  npx ${PACKAGE_NAME} --help Show this help
3717
3735
 
@@ -22,7 +22,7 @@ test('packed full and core installs ship the runnable PR visual skill to the sha
22
22
  const homeDirectory = join(sandbox, `home-${eachIndex}`);
23
23
  execFileSync(process.execPath, [join(packaged, 'bin/install.mjs'), ...eachArguments], {
24
24
  encoding: 'utf8',
25
- 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_SECURITY_GUIDANCE: '0', CDE_INSTALL_DEEPEN_FIRST_PROMPT: '0' },
25
+ 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_PELE: '0', CDE_INSTALL_USAGE_WRAPUP: '0', CDE_INSTALL_SUBAGENT_MODELS: '0', CDE_INSTALL_SECURITY_GUIDANCE: '0', CDE_INSTALL_DEEPEN_FIRST_PROMPT: '0' },
26
26
  });
27
27
  const installed = join(homeDirectory, ...SKILL_PATH_SEGMENTS);
28
28
  for (const eachFile of REQUIRED_FILES) assert.deepEqual(readFileSync(join(installed, eachFile)), readFileSync(join(packaged, ...SKILL_PATH_SEGMENTS, eachFile)));
@@ -32,6 +32,7 @@ function installEnvironment(homeDirectory) {
32
32
  CODEX_HOME: join(homeDirectory, '.codex'),
33
33
  CDE_INSTALL_PSTACK: '0',
34
34
  CDE_INSTALL_DEEPSTACK: '0',
35
+ CDE_INSTALL_PELE: '0',
35
36
  CDE_INSTALL_USAGE_WRAPUP: '0',
36
37
  };
37
38
  }
@@ -266,6 +266,7 @@ function resolveInstallerInvocation(homeDirectory) {
266
266
  LLM_SETTINGS_PROFILES_ROOT: undefined,
267
267
  CDE_INSTALL_PSTACK: '0',
268
268
  CDE_INSTALL_DEEPSTACK: '0',
269
+ CDE_INSTALL_PELE: '0',
269
270
  CDE_INSTALL_USAGE_WRAPUP: '0',
270
271
  CDE_INSTALL_SUBAGENT_MODELS: '0',
271
272
  CDE_INSTALL_SECURITY_GUIDANCE: '0',
@@ -26,6 +26,7 @@ function installInScratchHome(homeDirectory, argumentsList = [], extraEnvironmen
26
26
  LLM_SETTINGS_PROFILES_ROOT: undefined,
27
27
  CDE_INSTALL_PSTACK: '0',
28
28
  CDE_INSTALL_DEEPSTACK: '0',
29
+ CDE_INSTALL_PELE: '0',
29
30
  CDE_INSTALL_USAGE_WRAPUP: '0',
30
31
  CDE_INSTALL_SUBAGENT_MODELS: '0',
31
32
  CDE_INSTALL_SECURITY_GUIDANCE: '0',
@@ -184,6 +185,7 @@ test('a successful pstack install omits the retired skill block and gains the qu
184
185
  const installation = installInScratchHome(homeDirectory, [], {
185
186
  CDE_INSTALL_PSTACK: '1',
186
187
  CDE_INSTALL_DEEPSTACK: '0',
188
+ CDE_INSTALL_PELE: '0',
187
189
  CDE_INSTALL_USAGE_WRAPUP: '0',
188
190
  CDE_INSTALL_SUBAGENT_MODELS: '0',
189
191
  CDE_INSTALL_SECURITY_GUIDANCE: '0',
@@ -214,6 +216,7 @@ test('enabling pstack after a pstack-off install preserves question guidance', (
214
216
  const secondInstallation = installInScratchHome(homeDirectory, [], {
215
217
  CDE_INSTALL_PSTACK: '1',
216
218
  CDE_INSTALL_DEEPSTACK: '0',
219
+ CDE_INSTALL_PELE: '0',
217
220
  CDE_INSTALL_USAGE_WRAPUP: '0',
218
221
  CDE_INSTALL_SUBAGENT_MODELS: '0',
219
222
  CDE_INSTALL_SECURITY_GUIDANCE: '0',
@@ -245,6 +248,7 @@ test('a failed pstack transition restores question-only guidance and removes its
245
248
  const failedInstallation = installInScratchHome(homeDirectory, [], {
246
249
  CDE_INSTALL_PSTACK: '1',
247
250
  CDE_INSTALL_DEEPSTACK: '0',
251
+ CDE_INSTALL_PELE: '0',
248
252
  CDE_INSTALL_USAGE_WRAPUP: '0',
249
253
  CDE_INSTALL_SUBAGENT_MODELS: '0',
250
254
  CDE_INSTALL_SECURITY_GUIDANCE: '0',
@@ -72,6 +72,7 @@ function runInstallerInSandbox(sandboxHome, installerArguments = []) {
72
72
  LLM_SETTINGS_PROFILES_ROOT: undefined,
73
73
  CDE_INSTALL_PSTACK: '0',
74
74
  CDE_INSTALL_DEEPSTACK: '0',
75
+ CDE_INSTALL_PELE: '0',
75
76
  CDE_INSTALL_USAGE_WRAPUP: '0',
76
77
  CDE_INSTALL_SUBAGENT_MODELS: '0',
77
78
  CDE_INSTALL_SECURITY_GUIDANCE: '0',
@@ -32,6 +32,7 @@ function installEnvironment(homeDirectory) {
32
32
  GIT_CONFIG_GLOBAL: join(homeDirectory, '.gitconfig'),
33
33
  CDE_INSTALL_PSTACK: '0',
34
34
  CDE_INSTALL_DEEPSTACK: '0',
35
+ CDE_INSTALL_PELE: '0',
35
36
  CDE_INSTALL_USAGE_WRAPUP: '0',
36
37
  CDE_INSTALL_SUBAGENT_MODELS: '0',
37
38
  CDE_INSTALL_SECURITY_GUIDANCE: '0',
@@ -3049,6 +3049,7 @@ test('a failed update preserves an existing skills lookup pointer', () => {
3049
3049
  GIT_CONFIG_GLOBAL: join(homeDirectory, '.gitconfig'),
3050
3050
  CDE_INSTALL_PSTACK: '0',
3051
3051
  CDE_INSTALL_DEEPSTACK: '0',
3052
+ CDE_INSTALL_PELE: '0',
3052
3053
  CDE_INSTALL_USAGE_WRAPUP: '0',
3053
3054
  CDE_INSTALL_SUBAGENT_MODELS: '0',
3054
3055
  CDE_INSTALL_SECURITY_GUIDANCE: '0',
@@ -3104,6 +3105,7 @@ function runPstackInstaller(homeDirectory, extraArguments, environmentOverrides
3104
3105
  GIT_CONFIG_GLOBAL: join(homeDirectory, '.gitconfig'),
3105
3106
  CDE_INSTALL_PSTACK: '1',
3106
3107
  CDE_INSTALL_DEEPSTACK: '0',
3108
+ CDE_INSTALL_PELE: '0',
3107
3109
  CDE_INSTALL_USAGE_WRAPUP: '0',
3108
3110
  CDE_INSTALL_SUBAGENT_MODELS: '0',
3109
3111
  CDE_INSTALL_SECURITY_GUIDANCE: '0',
@@ -3189,6 +3191,7 @@ test('a full install adds DeepStack for Claude, Codex, and Cursor', t => {
3189
3191
  ...sandbox.environment,
3190
3192
  CDE_INSTALL_PSTACK: '0',
3191
3193
  CDE_INSTALL_DEEPSTACK: '1',
3194
+ CDE_INSTALL_PELE: '0',
3192
3195
  CDE_DEEPSTACK_SOURCE: sourceDirectory,
3193
3196
  });
3194
3197
 
@@ -3484,6 +3487,7 @@ test('the help output names the usage-wrapup opt-out beside the pstack one', ()
3484
3487
 
3485
3488
  assert.equal(helpRun.status, 0, helpRun.stderr);
3486
3489
  assert.match(helpRun.stdout, /--no-pstack .*\n.*--no-deepstack .*CDE_INSTALL_DEEPSTACK=0.*\n.*--no-usage-wrapup .*CDE_INSTALL_USAGE_WRAPUP=0/);
3490
+ assert.match(helpRun.stdout, /--no-security-guidance .*\n.*--no-pele .*CDE_INSTALL_PELE=0/);
3487
3491
  assert.doesNotMatch(helpRun.stdout, /--no-deepen-first-prompt/);
3488
3492
  });
3489
3493
 
@@ -3672,6 +3676,7 @@ function installWithGlobalPrefix(context, globalPrefix) {
3672
3676
  CLAUDE_DEV_ENV_INSTALL_FAULT: undefined,
3673
3677
  CDE_INSTALL_PSTACK: '0',
3674
3678
  CDE_INSTALL_DEEPSTACK: '0',
3679
+ CDE_INSTALL_PELE: '0',
3675
3680
  CDE_INSTALL_USAGE_WRAPUP: '0',
3676
3681
  CDE_INSTALL_SUBAGENT_MODELS: '0',
3677
3682
  CDE_INSTALL_SECURITY_GUIDANCE: '0',
@@ -3729,6 +3734,7 @@ test('install adds the open-tasks Stop gate to every profile with its own settin
3729
3734
  CLAUDE_DEV_ENV_INSTALL_FAULT: undefined,
3730
3735
  CDE_INSTALL_PSTACK: '0',
3731
3736
  CDE_INSTALL_DEEPSTACK: '0',
3737
+ CDE_INSTALL_PELE: '0',
3732
3738
  CDE_INSTALL_USAGE_WRAPUP: '0',
3733
3739
  CDE_INSTALL_SUBAGENT_MODELS: '0',
3734
3740
  CDE_INSTALL_SECURITY_GUIDANCE: '0',
@@ -3772,6 +3778,7 @@ test('a profile settings.json that is not valid JSON is left alone and named und
3772
3778
  CLAUDE_DEV_ENV_INSTALL_FAULT: undefined,
3773
3779
  CDE_INSTALL_PSTACK: '0',
3774
3780
  CDE_INSTALL_DEEPSTACK: '0',
3781
+ CDE_INSTALL_PELE: '0',
3775
3782
  CDE_INSTALL_USAGE_WRAPUP: '0',
3776
3783
  CDE_INSTALL_SUBAGENT_MODELS: '0',
3777
3784
  CDE_INSTALL_SECURITY_GUIDANCE: '0',
@@ -3818,6 +3825,7 @@ test('uninstall stops before changing anything while a profile settings.json tha
3818
3825
  CLAUDE_DEV_ENV_INSTALL_FAULT: undefined,
3819
3826
  CDE_INSTALL_PSTACK: '0',
3820
3827
  CDE_INSTALL_DEEPSTACK: '0',
3828
+ CDE_INSTALL_PELE: '0',
3821
3829
  CDE_INSTALL_USAGE_WRAPUP: '0',
3822
3830
  CDE_INSTALL_SUBAGENT_MODELS: '0',
3823
3831
  CDE_INSTALL_SECURITY_GUIDANCE: '0',
@@ -89,6 +89,7 @@ test('capture and restore recover settings, manifest, files, and hooksPath', ()
89
89
  LLM_SETTINGS_PROFILES_ROOT: undefined,
90
90
  CDE_INSTALL_PSTACK: '0',
91
91
  CDE_INSTALL_DEEPSTACK: '0',
92
+ CDE_INSTALL_PELE: '0',
92
93
  CDE_INSTALL_USAGE_WRAPUP: '0',
93
94
  CDE_INSTALL_SUBAGENT_MODELS: '0',
94
95
  CDE_INSTALL_SECURITY_GUIDANCE: '0',
@@ -156,6 +157,7 @@ test('capture and restore recover an additional host settings file', () => {
156
157
  LLM_SETTINGS_PROFILES_ROOT: undefined,
157
158
  CDE_INSTALL_PSTACK: '0',
158
159
  CDE_INSTALL_DEEPSTACK: '0',
160
+ CDE_INSTALL_PELE: '0',
159
161
  CDE_INSTALL_USAGE_WRAPUP: '0',
160
162
  CDE_INSTALL_SUBAGENT_MODELS: '0',
161
163
  CDE_INSTALL_SECURITY_GUIDANCE: '0',
@@ -196,6 +198,7 @@ test('runWithInstallTransaction restores prior state on injected fault', () => {
196
198
  LLM_SETTINGS_PROFILES_ROOT: undefined,
197
199
  CDE_INSTALL_PSTACK: '0',
198
200
  CDE_INSTALL_DEEPSTACK: '0',
201
+ CDE_INSTALL_PELE: '0',
199
202
  CDE_INSTALL_USAGE_WRAPUP: '0',
200
203
  CDE_INSTALL_SUBAGENT_MODELS: '0',
201
204
  CDE_INSTALL_SECURITY_GUIDANCE: '0',
@@ -255,6 +258,7 @@ test('runWithInstallTransaction commits and discards journal on success', () =>
255
258
  LLM_SETTINGS_PROFILES_ROOT: undefined,
256
259
  CDE_INSTALL_PSTACK: '0',
257
260
  CDE_INSTALL_DEEPSTACK: '0',
261
+ CDE_INSTALL_PELE: '0',
258
262
  CDE_INSTALL_USAGE_WRAPUP: '0',
259
263
  CDE_INSTALL_SUBAGENT_MODELS: '0',
260
264
  CDE_INSTALL_SECURITY_GUIDANCE: '0',
@@ -303,6 +307,7 @@ function runInstaller(homeDirectory, extraArguments, options = {}) {
303
307
  LLM_SETTINGS_PROFILES_ROOT: undefined,
304
308
  CDE_INSTALL_PSTACK: '0',
305
309
  CDE_INSTALL_DEEPSTACK: '0',
310
+ CDE_INSTALL_PELE: '0',
306
311
  CDE_INSTALL_USAGE_WRAPUP: '0',
307
312
  CDE_INSTALL_SUBAGENT_MODELS: '0',
308
313
  CDE_INSTALL_SECURITY_GUIDANCE: '0',
@@ -341,6 +346,7 @@ test('a later install fault removes newly seeded Codex pstack files', () => {
341
346
  environment: {
342
347
  CDE_INSTALL_PSTACK: '1',
343
348
  CDE_INSTALL_DEEPSTACK: '0',
349
+ CDE_INSTALL_PELE: '0',
344
350
  CDE_INSTALL_USAGE_WRAPUP: '0',
345
351
  CDE_INSTALL_SUBAGENT_MODELS: '0',
346
352
  CDE_INSTALL_SECURITY_GUIDANCE: '0',
@@ -489,6 +495,7 @@ test('installer fault after_git_config restores prior core.hooksPath', () => {
489
495
  LLM_SETTINGS_PROFILES_ROOT: undefined,
490
496
  CDE_INSTALL_PSTACK: '0',
491
497
  CDE_INSTALL_DEEPSTACK: '0',
498
+ CDE_INSTALL_PELE: '0',
492
499
  CDE_INSTALL_USAGE_WRAPUP: '0',
493
500
  CDE_INSTALL_SUBAGENT_MODELS: '0',
494
501
  CDE_INSTALL_SECURITY_GUIDANCE: '0',
@@ -511,6 +518,7 @@ test('installer fault after_git_config restores prior core.hooksPath', () => {
511
518
  LLM_SETTINGS_PROFILES_ROOT: undefined,
512
519
  CDE_INSTALL_PSTACK: '0',
513
520
  CDE_INSTALL_DEEPSTACK: '0',
521
+ CDE_INSTALL_PELE: '0',
514
522
  CDE_INSTALL_USAGE_WRAPUP: '0',
515
523
  CDE_INSTALL_SUBAGENT_MODELS: '0',
516
524
  CDE_INSTALL_SECURITY_GUIDANCE: '0',
@@ -75,6 +75,7 @@ function runInstaller(homeDirectory, extraArguments, options = {}) {
75
75
  LLM_SETTINGS_PROFILES_ROOT: undefined,
76
76
  CDE_INSTALL_PSTACK: '0',
77
77
  CDE_INSTALL_DEEPSTACK: '0',
78
+ CDE_INSTALL_PELE: '0',
78
79
  CDE_INSTALL_USAGE_WRAPUP: '0',
79
80
  CDE_INSTALL_SUBAGENT_MODELS: '0',
80
81
  CDE_INSTALL_SECURITY_GUIDANCE: '0',
@@ -314,6 +315,7 @@ test('uninstall fault after_git_config restores prior core.hooksPath', () => {
314
315
  LLM_SETTINGS_PROFILES_ROOT: undefined,
315
316
  CDE_INSTALL_PSTACK: '0',
316
317
  CDE_INSTALL_DEEPSTACK: '0',
318
+ CDE_INSTALL_PELE: '0',
317
319
  CDE_INSTALL_USAGE_WRAPUP: '0',
318
320
  CDE_INSTALL_SUBAGENT_MODELS: '0',
319
321
  CDE_INSTALL_SECURITY_GUIDANCE: '0',
@@ -26,6 +26,7 @@ function installerEnvironment(homeDirectory) {
26
26
  LLM_SETTINGS_PROFILES_ROOT: undefined,
27
27
  CDE_INSTALL_PSTACK: '0',
28
28
  CDE_INSTALL_DEEPSTACK: '0',
29
+ CDE_INSTALL_PELE: '0',
29
30
  CDE_INSTALL_USAGE_WRAPUP: '0',
30
31
  CDE_INSTALL_SUBAGENT_MODELS: '0',
31
32
  CDE_INSTALL_SECURITY_GUIDANCE: '0',
package/package.json CHANGED
@@ -1,6 +1,6 @@
1
1
  {
2
2
  "name": "claude-dev-env",
3
- "version": "8.106.5",
3
+ "version": "8.107.1",
4
4
  "description": "Claude Code development standards — rules, hooks, agents, commands, and skills",
5
5
  "type": "module",
6
6
  "bin": {
@@ -59,7 +59,7 @@ test('an install into a scratch home leaves the caller Codex home config alone',
59
59
  process.env.CODEX_HOME = callerCodexHome;
60
60
  const scratchHome = createScratchHome();
61
61
  try {
62
- const install = runInstaller(scratchHome, []);
62
+ const install = runInstaller(scratchHome, ['--no-pele']);
63
63
  assert.equal(install.status, 0, `${install.stdout}\n${install.stderr}`);
64
64
  assert.equal(readFileSync(callerConfigPath, 'utf8'), callerConfigBody);
65
65
  } finally {