claude-dev-env 2.14.1 → 2.15.1

package/bin/install.mjs

@@ -22,10 +22,14 @@ import {
     MANAGED_SKILLS_DIRECTORY_NAME,
     MANAGED_HOOKS_DIRECTORY_NAME,
     SETTINGS_FILE_NAME,
+    CODEX_RULES_PACKAGE_DIRECTORY_NAME,
+    CURSOR_SYNC_SCRIPT_FILE_NAME,
+    WINDOWS_PYTHON_LAUNCHER_COMMAND,
 } from './install-constants.mjs';
 import {
     resolveInstallRoot,
     parseExplicitTargetFromArgv,
+    isAllowedInstallDestination,
 } from './resolve-install-root.mjs';
 import {
     parseInstallTargetSelectionFromArgv,
@@ -110,6 +114,35 @@ const RETIRED_SKILL_REASON_LABEL = 'retired';
 const STALE_FILE_REASON_LABEL = 'stale';
 const MANIFEST_MANAGED_PERMISSIONS_KEY = 'managedPermissions';
 
+/**
+ * Managed-home-relative directories this package leaves to whoever deployed
+ * them: it writes nothing inside them and prunes nothing out of them.
+ *
+ * `scripts/profile-isolation-launchers` is the live CLI profile launcher. Its
+ * executable modules are deployed from a separate source, so a payload covering
+ * only part of that tree left config and code out of step. This package stopped
+ * shipping its part, and the stale-file prune reads a path the package no longer
+ * writes as stale, which would move the live files aside on the next install.
+ * Naming the directory here keeps both halves of the tree with their owner.
+ */
+const RETAINED_UNMANAGED_RELATIVE_PATHS = [
+    'scripts/profile-isolation-launchers',
+];
+
+/**
+ * Report whether a path a prior manifest recorded sits inside a directory this
+ * package leaves to another owner.
+ *
+ * @param {string} candidatePath The absolute path the prior manifest recorded.
+ * @param {string} managedHomeDirectory The managed home the relative names resolve against.
+ * @returns {boolean} True when the path sits inside a retained unmanaged directory.
+ */
+function isRetainedUnmanagedPath(candidatePath, managedHomeDirectory) {
+    return RETAINED_UNMANAGED_RELATIVE_PATHS.some(
+        relativePath => isInsideDirectory(candidatePath, join(managedHomeDirectory, relativePath)),
+    );
+}
+
 export const CORE_INCLUDE_DIRECTORIES = [
     'rules', 'docs', 'commands', 'agents', 'audit-rubrics', '_shared', 'scripts',
 ];
@@ -211,7 +244,7 @@ function discoverDependencyGroups() {
             readFileSync(join(dependencyRoot, 'package.json'), 'utf8')
         );
         const groupName = dependencyPackageJson.claudeDevEnv?.groupName
-            || dependencyName.replace(/^@[^/]+\//, '');
+            || dependencyName.replace(new RegExp('^@[^/]+/'), '');
         const group = {
             description: dependencyPackageJson.description || dependencyName,
             packageRoot: dependencyRoot,
@@ -257,6 +290,7 @@ export const INSTALL_GROUPS = {
         skills: CORE_SKILLS,
         includeDirectories: CORE_INCLUDE_DIRECTORIES,
         includeAllHooks: true,
+        includeCodexRules: true,
     },
     journal: {
         description: 'Session logging and memory',
@@ -302,6 +336,75 @@ export function isWindowsStorePythonStub(executablePath) {
     return /[\\/]windowsapps[\\/]/i.test(executablePath);
 }
 
+/**
+ * Split a stored Python command into an executable and prefix arguments.
+ *
+ * Args:
+ *   pythonCommand: The command the installer detected (`py -3`, `python3`, or a path).
+ *
+ * Returns:
+ *   `{ file, prefixArguments }` for `execFileSync`.
+ */
+export function pythonFileAndPrefixArguments(pythonCommand) {
+    if (pythonCommand === WINDOWS_PYTHON_LAUNCHER_COMMAND) {
+        return { file: 'py', prefixArguments: ['-3'] };
+    }
+    const unquoted = pythonCommand.replace(/^"(.*)"$/, '$1');
+    return { file: unquoted, prefixArguments: [] };
+}
+
+/**
+ * Read generated Cursor paths from the sync manifest under a Cursor home.
+ *
+ * Args:
+ *   cursorRoot: Absolute `.cursor` directory.
+ *
+ * Returns:
+ *   Absolute paths the installer may record, including the sync manifest.
+ */
+export function collectManagedCursorSyncPaths(cursorRoot) {
+    const manifestPath = join(cursorRoot, '.sync-manifest.json');
+    if (!existsSync(manifestPath)) return [];
+    const parsed = JSON.parse(readFileSync(manifestPath, 'utf8'));
+    const generatedPaths = [manifestPath];
+    const allEntries = { ...(parsed.entries || {}), ...(parsed.docs_entries || {}) };
+    for (const eachRelativePath of Object.keys(allEntries)) {
+        generatedPaths.push(join(cursorRoot, eachRelativePath));
+    }
+    return generatedPaths;
+}
+
+/**
+ * Run the installed Cursor rule generator against Claude and Cursor roots.
+ *
+ * Args:
+ *   pythonCommand: Interpreter command from install preflight.
+ *   scriptPath: Absolute `sync_to_cursor.py` path.
+ *   claudeRoot: Managed Claude root that holds `rules/` and `docs/`.
+ *   cursorRoot: Cursor home that receives `rules/*.mdc`.
+ *
+ * Returns:
+ *   void
+ */
+export function runCursorRuleSync(pythonCommand, scriptPath, claudeRoot, cursorRoot) {
+    mkdirSync(cursorRoot, { recursive: true });
+    const { file, prefixArguments } = pythonFileAndPrefixArguments(pythonCommand);
+    execFileSync(
+        file,
+        [
+            ...prefixArguments,
+            scriptPath,
+            '--force',
+            '--quiet',
+            '--claude-root',
+            claudeRoot,
+            '--cursor-root',
+            cursorRoot,
+        ],
+        { stdio: 'inherit' },
+    );
+}
+
 /**
  * Formats an absolute interpreter path as a settings.json hook command prefix:
  * forward-slash separators, double-quoted when the path contains a space so the
@@ -629,8 +732,7 @@ function isManagedPath(candidatePath, managedHomeDirectory = CLAUDE_HOME) {
  * @returns {boolean} True when the installer itself writes the path.
  */
 function isRemovableManifestRecord(candidatePath) {
-    if (isManagedPath(candidatePath)) return true;
-    return comparisonKeyForPath(candidatePath) === comparisonKeyForPath(MYPY_INI_INSTALL_PATH);
+    return isAllowedInstallDestination(candidatePath, INSTALL_ROOT_RESOLUTION);
 }
 
 /**
@@ -650,6 +752,10 @@ function owningManagedRoot(installedFilePath) {
         const managedRoot = join(CLAUDE_HOME, directoryName);
         if (isInsideDirectory(resolvedPath, managedRoot)) return managedRoot;
     }
+    const codexRulesDirectory = INSTALL_ROOT_RESOLUTION.codexRulesInstallDirectory;
+    if (isInsideDirectory(resolvedPath, codexRulesDirectory)) return codexRulesDirectory;
+    const cursorInstallDirectory = INSTALL_ROOT_RESOLUTION.cursorInstallDirectory;
+    if (isInsideDirectory(resolvedPath, cursorInstallDirectory)) return cursorInstallDirectory;
     return null;
 }
 
@@ -755,6 +861,7 @@ export function pruneStaleInstalledFiles(
         const stalePath = resolve(priorFile);
         if (!isInsideDirectory(stalePath, resolvedRoot)) continue;
         if (currentFileKeys.has(comparisonKeyForPath(stalePath, options))) continue;
+        if (isRetainedUnmanagedPath(stalePath, managedHomeDirectory)) continue;
         if (!isMovableStaleFile(stalePath)) continue;
         const backupRelativePath = relative(resolvedRoot, stalePath);
         const didMove = moveIntoRunBackup(
@@ -1856,7 +1963,7 @@ function executeInstallPlanMutations(plan, transactionHelpers) {
             `${PACKAGE_NAME}: --update — removing prior managed files under ${CLAUDE_HOME}, then reinstalling from the package.\n`,
         );
         purgeManagedInstallation({
-            requireManifest: false,
+            isManifestRequired: false,
             throwIfFault,
         });
     } else if (isUpdateRefresh) {
@@ -1940,6 +2047,30 @@ function executeInstallPlanMutations(plan, transactionHelpers) {
             }
         }
     }
+    const shouldInstallCodexRules = !selectedGroups
+        || activeGroups.some((eachGroup) => eachGroup.includeCodexRules);
+    if (shouldInstallCodexRules) {
+        const sourceDirectory = join(PACKAGE_ROOT, CODEX_RULES_PACKAGE_DIRECTORY_NAME);
+        if (existsSync(sourceDirectory)) {
+            const destinationDirectory = INSTALL_ROOT_RESOLUTION.codexRulesInstallDirectory;
+            const stats = copyTree(sourceDirectory, destinationDirectory);
+            summary.codexRules = stats;
+            allInstalledFiles.push(...stats.paths);
+        }
+    }
+    const shouldInstallCursorRules = !selectedGroups
+        || activeGroups.some((eachGroup) => (eachGroup.includeDirectories || []).includes('rules'));
+    if (shouldInstallCursorRules) {
+        const scriptPath = join(CLAUDE_HOME, 'scripts', CURSOR_SYNC_SCRIPT_FILE_NAME);
+        if (!existsSync(scriptPath)) {
+            throw new Error(`cursor rule sync script missing: ${scriptPath}`);
+        }
+        const cursorRoot = dirname(INSTALL_ROOT_RESOLUTION.cursorRulesInstallDirectory);
+        runCursorRuleSync(pythonCommand, scriptPath, CLAUDE_HOME, cursorRoot);
+        const generatedCursorPaths = collectManagedCursorSyncPaths(cursorRoot);
+        allInstalledFiles.push(...generatedCursorPaths);
+        summary.cursorRules = { created: generatedCursorPaths.length, updated: 0, paths: generatedCursorPaths };
+    }
     let skillsCreated = 0;
     let skillsUpdated = 0;
     const skillPaths = [];
@@ -2136,6 +2267,14 @@ function executeInstallPlanMutations(plan, transactionHelpers) {
             console.log(`  ${directory}: ${created + updated} files (${created} new, ${updated} updated)`);
         }
     }
+    if (summary.codexRules) {
+        const { created, updated } = summary.codexRules;
+        console.log(`  ${CODEX_RULES_PACKAGE_DIRECTORY_NAME}: ${created + updated} files (${created} new, ${updated} updated)`);
+    }
+    if (summary.cursorRules) {
+        const { created } = summary.cursorRules;
+        console.log(`  cursor-rules: ${created} generated files`);
+    }
     if (summary.skills) {
         const { created, updated, pruned } = summary.skills;
         const staleClause = pruned > 0 ? `, ${pruned} stale moved aside` : '';
@@ -2222,14 +2361,14 @@ function removeRecordedFile(filePath) {
 /**
  * Build the uninstall plan for this managed root.
  *
- * @param {boolean} requireManifest
+ * @param {boolean} isManifestRequired
  * @returns {ReturnType<typeof buildUninstallPlan>}
  */
-function resolveUninstallPlan(requireManifest) {
+function resolveUninstallPlan(isManifestRequired) {
     return buildUninstallPlan({
         managedRoot: CLAUDE_HOME,
         manifestFilePath: MANIFEST_FILE,
-        requireManifest,
+        requireManifest: isManifestRequired,
         isRemovableRecord: isRemovableManifestRecord,
     });
 }
@@ -2266,20 +2405,20 @@ function executeUninstallPlan(plan, helpers = {}) {
     }
     if (plan.skippedFiles.length > 0) {
         console.warn(
-            `  ${plan.skippedFiles.length} manifest record(s) skipped — each names a path outside ${CLAUDE_HOME} and outside ${MYPY_INI_INSTALL_PATH}`,
+            `  ${plan.skippedFiles.length} manifest record(s) skipped — each names a path outside ${CLAUDE_HOME}, outside ${MYPY_INI_INSTALL_PATH}, outside ${INSTALL_ROOT_RESOLUTION.codexRulesInstallDirectory}, and outside ${INSTALL_ROOT_RESOLUTION.cursorInstallDirectory}`,
         );
     }
     throwIfFault(FAULT_PHASES.AFTER_FILE_STAGING);
 
     if (existsSync(plan.settingsPath)) {
         const settings = JSON.parse(readFileSync(plan.settingsPath, 'utf8'));
-        let settingsChanged = false;
+        let didSettingsChange = false;
         if (settings.hooks) {
             const managedHookRelativePaths = managedHookScriptRelativePathsFromSourceRoots(
                 managedPackageSourceRoots(),
             );
             pruneManagedHooksFromSettings(settings, managedHookRelativePaths);
-            settingsChanged = true;
+            didSettingsChange = true;
             console.log('  Hook entries removed from settings.json');
         }
         const managedDenyFromPlan = plan.managedPermissionDenyEntries.length > 0
@@ -2288,13 +2427,13 @@ function executeUninstallPlan(plan, helpers = {}) {
         if (managedDenyFromPlan.length > 0) {
             const pruneOutcome = pruneManagedPermissionsFromSettings(settings, managedDenyFromPlan);
             if (pruneOutcome.removedCount > 0) {
-                settingsChanged = true;
+                didSettingsChange = true;
                 console.log(
                     `  Permission entries removed from settings.json: ${pruneOutcome.removedCount} managed deny(s)`,
                 );
             }
         }
-        if (settingsChanged) {
+        if (didSettingsChange) {
             writeFileSync(plan.settingsPath, JSON.stringify(settings, null, 4) + '\n');
         }
     }
@@ -2327,13 +2466,13 @@ function executeUninstallPlan(plan, helpers = {}) {
  * without nesting a second journal.
  *
  * @param {{
- *   requireManifest: boolean,
+ *   isManifestRequired: boolean,
  *   throwIfFault?: (phase: string) => void,
  * }} options
  * @returns {number|void} 0 when no manifest exists and none is required.
  */
-function purgeManagedInstallation({ requireManifest, throwIfFault }) {
-    const plan = resolveUninstallPlan(requireManifest);
+function purgeManagedInstallation({ isManifestRequired, throwIfFault }) {
+    const plan = resolveUninstallPlan(isManifestRequired);
     if (plan.isNoOp) {
         return 0;
     }
@@ -2433,6 +2572,8 @@ Examples:
 
 Install location: ~/.claude/ by default; CLAUDE_CONFIG_DIR or --target selects another managed root.
 Named profiles resolve under LLM_SETTINGS_PROFILES_ROOT or ~/.claude-profiles/<directoryName>.
+Codex exec-policy files copy into ~/.codex/rules, or CODEX_HOME/rules when CODEX_HOME is set.
+Cursor rule files generate into ~/.cursor/rules as stem-named mdc files, one per Claude rule.
 
 Root precedence: --target > CLAUDE_CONFIG_DIR > ~/.claude
 Profile selection (--profile/--profiles) is mutually exclusive with --target.
@@ -2479,13 +2620,15 @@ function realPathOrSelf(filesystemPath) {
 }
 
 /**
- * Load profile id → directoryName from the A1 launcher contract when present.
- * Falls back to identity mapping when the file is missing, unreadable, or empty.
+ * Load profile id → directoryName for the install targets this package resolves.
+ *
+ * Each profile's directory carries the profile's own name, so the map is an
+ * identity over the ids a multi-target install accepts.
  *
  * @returns {Record<string, string>}
  */
 function loadDirectoryNameByProfileId() {
-    const fallbackDirectoryNameByProfileId = {
+    return {
         main: 'main',
         editor: 'editor',
         mel: 'mel',
@@ -2493,35 +2636,6 @@ function loadDirectoryNameByProfileId() {
         master: 'master',
         kimi: 'kimi',
     };
-    const manifestPath = join(
-        PACKAGE_ROOT,
-        'scripts',
-        'profile-isolation-launchers',
-        'config',
-        'profiles.manifest.json',
-    );
-    if (!existsSync(manifestPath)) {
-        return fallbackDirectoryNameByProfileId;
-    }
-    try {
-        const document = JSON.parse(readFileSync(manifestPath, 'utf8'));
-        /** @type {Record<string, string>} */
-        const directoryNameByProfileId = {};
-        const profiles = document && typeof document === 'object' ? document.profiles : null;
-        if (profiles && typeof profiles === 'object') {
-            for (const [eachProfileId, eachProfile] of Object.entries(profiles)) {
-                if (eachProfile && typeof eachProfile === 'object' && typeof eachProfile.directoryName === 'string') {
-                    directoryNameByProfileId[eachProfileId] = eachProfile.directoryName;
-                }
-            }
-        }
-        if (Object.keys(directoryNameByProfileId).length === 0) {
-            return fallbackDirectoryNameByProfileId;
-        }
-        return directoryNameByProfileId;
-    } catch {
-        return fallbackDirectoryNameByProfileId;
-    }
 }
 
 /**
@@ -2564,7 +2678,7 @@ function runInstallForAllTargets(allTargets, childArgv) {
  * @returns {number | null}
  */
 function spawnInstallChild(target, childArgv) {
-    const result = spawnSync(
+    const childProcess = spawnSync(
         process.execPath,
         [
             fileURLToPath(import.meta.url),
@@ -2579,11 +2693,11 @@ function spawnInstallChild(target, childArgv) {
             env: process.env,
         },
     );
-    if (result.error) {
-        console.error(`ERROR: failed to spawn install child: ${result.error.message}`);
+    if (childProcess.error) {
+        console.error(`ERROR: failed to spawn install child: ${childProcess.error.message}`);
         return 1;
     }
-    return result.status === null ? 1 : result.status;
+    return childProcess.status === null ? 1 : childProcess.status;
 }
 
 if (invokedAsEntryPoint(import.meta.url, process.argv[1])) {

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

@@ -8,6 +8,7 @@ import { join, resolve } from 'node:path';
 import { mkdtempSync, rmSync, mkdirSync, readFileSync } from 'node:fs';
 import { tmpdir } from 'node:os';
 import { fileURLToPath } from 'node:url';
+import { CODEX_RULES_SHIPPED_FILE_NAME } from './install-constants.mjs';
 import {
     resolveInstallRoot,
     isPathWithinManagedRoot,
@@ -90,6 +91,13 @@ test('declared external mypy.ini is allowed; unrelated external paths are not',
         isAllowedInstallDestination(join(resolution.managedRoot, 'hooks', 'x.py'), resolution),
         true,
     );
+    assert.equal(
+        isAllowedInstallDestination(
+            join(resolution.codexRulesInstallDirectory, CODEX_RULES_SHIPPED_FILE_NAME),
+            resolution,
+        ),
+        true,
+    );
 });
 
 test('parseExplicitTargetFromArgv reads --target and --target=', () => {

package/bin/install.prune.test.mjs

@@ -238,6 +238,7 @@ function resolveInstallerInvocation(homeDirectory, options) {
         HOME: homeDirectory,
         USERPROFILE: homeDirectory,
         GIT_CONFIG_GLOBAL: join(homeDirectory, '.gitconfig'),
+        CODEX_HOME: join(homeDirectory, '.codex'),
     };
     if (dependencyResolvable) {
         childEnvironment.NODE_PATH = ensureDependencyStub(homeDirectory);
@@ -1227,7 +1228,7 @@ test('an uninstall removes the home-directory .mypy.ini the install wrote and sk
         assert.equal(
             existsSync(mypyIniPath),
             false,
-            'the uninstall removes the one file the install writes outside ~/.claude',
+            'the uninstall removes the mypy configuration the install writes outside ~/.claude',
         );
         assert.equal(
             installerOutput.includes(`skipping ${mypyIniPath}`),

package/bin/install.test.mjs

@@ -1281,25 +1281,59 @@ const README_BASENAME_PATTERN = /^readme\.md$/i;
 
 
 /**
- * Build a sandbox holding an installed skills root and a run backup root.
+ * Build a sandbox holding one installed managed root and a run backup root.
  *
- * @param {object} installedFiles Forward-slash relative paths under the skills root mapped to contents.
- * @returns {{root: string, skillsRoot: string, backupRoot: string}} The sandbox paths.
+ * @param {object} installedFiles Forward-slash relative paths under the installed root mapped to contents.
+ * @param {string} [managedRootName] The managed top-level directory the files sit under.
+ * @returns {{root: string, skillsRoot: string, installedRoot: string, backupRoot: string}} The sandbox paths.
  */
-function createStalePruneSandbox(installedFiles) {
+function createStalePruneSandbox(installedFiles, managedRootName = 'skills') {
     const root = mkdtempSync(join(tmpdir(), 'cdev-stale-prune-'));
-    const skillsRoot = join(root, 'skills');
+    const installedRoot = join(root, managedRootName);
     const backupRoot = join(root, 'pruned', 'run-timestamp');
-    mkdirSync(skillsRoot, { recursive: true });
+    mkdirSync(installedRoot, { recursive: true });
     for (const [relativePath, contents] of Object.entries(installedFiles)) {
-        const targetPath = join(skillsRoot, relativePath);
+        const targetPath = join(installedRoot, relativePath);
         mkdirSync(dirname(targetPath), { recursive: true });
         writeFileSync(targetPath, contents);
     }
-    return { root, skillsRoot, backupRoot };
+    return { root, skillsRoot: installedRoot, installedRoot, backupRoot };
 }
 
 
+test('pruneStaleInstalledFiles leaves a retained unmanaged path the package stopped shipping in place', () => {
+    const sandbox = createStalePruneSandbox({
+        'profile-isolation-launchers/config/mcp-bundles.json': '{"schemaVersion":1}\n',
+        'sync-to-cursor.py': 'print("shipped")\n',
+    }, 'scripts');
+    try {
+        const shippedFilePath = join(sandbox.installedRoot, 'sync-to-cursor.py');
+        const retainedFilePath = join(
+            sandbox.installedRoot, 'profile-isolation-launchers', 'config', 'mcp-bundles.json',
+        );
+
+        const pruneOutcome = pruneStaleInstalledFiles(
+            [shippedFilePath, retainedFilePath],
+            [shippedFilePath],
+            sandbox.installedRoot,
+            sandbox.backupRoot,
+            { managedHomeDirectory: sandbox.root },
+        );
+
+        assert.equal(pruneOutcome.prunedCount, 0, 'a retained unmanaged path never counts as pruned');
+        assert.deepEqual(pruneOutcome.failedPaths, [], 'skipping a retained path reports no failed move');
+        assert.equal(
+            existsSync(retainedFilePath),
+            true,
+            'the launcher file a prior install recorded stays where the live launcher reads it',
+        );
+        assert.equal(existsSync(shippedFilePath), true, 'a file this run wrote stays in place');
+    } finally {
+        rmSync(sandbox.root, { recursive: true, force: true });
+    }
+});
+
+
 /**
  * Run a callable with console.warn captured, returning its value and the warnings.
  *

package/bin/install.transaction.test.mjs

@@ -242,6 +242,7 @@ function runInstaller(homeDirectory, extraArguments, options = {}) {
         HOME: homeDirectory,
         USERPROFILE: homeDirectory,
         GIT_CONFIG_GLOBAL: join(homeDirectory, '.gitconfig'),
+        CODEX_HOME: join(homeDirectory, '.codex'),
     };
     if (options.faultPhase) {
         childEnvironment[INSTALL_FAULT_ENV] = options.faultPhase;

package/bin/install.uninstall-transaction.test.mjs

@@ -74,6 +74,7 @@ function runInstaller(homeDirectory, extraArguments, options = {}) {
         HOME: homeDirectory,
         USERPROFILE: homeDirectory,
         GIT_CONFIG_GLOBAL: join(homeDirectory, '.gitconfig'),
+        CODEX_HOME: join(homeDirectory, '.codex'),
     };
     if (options.faultPhase) {
         childEnvironment[INSTALL_FAULT_ENV] = options.faultPhase;

package/bin/resolve-install-root.mjs

@@ -11,7 +11,14 @@
 
 import { homedir } from 'node:os';
 import { join, normalize, resolve, sep } from 'node:path';
-import { MYPY_INI_FILE_NAME } from './install-constants.mjs';
+import {
+    MYPY_INI_FILE_NAME,
+    CODEX_HOME_ENVIRONMENT_VARIABLE,
+    DEFAULT_CODEX_DIRECTORY_NAME,
+    CODEX_RULES_DIRECTORY_NAME,
+    DEFAULT_CURSOR_DIRECTORY_NAME,
+    CURSOR_RULES_DIRECTORY_NAME,
+} from './install-constants.mjs';
 
 export const CLAUDE_CONFIG_DIR_ENVIRONMENT_VARIABLE = 'CLAUDE_CONFIG_DIR';
 export const DEFAULT_CLAUDE_DIRECTORY_NAME = '.claude';
@@ -33,6 +40,10 @@ export const MANIFEST_FILE_NAME = '.claude-dev-env-manifest.json';
  *   manifestFilePath: string,
  *   mypyIniInstallPath: string,
  *   allDeclaredExternalPaths: string[],
+ *   allDeclaredExternalDirectories: string[],
+ *   codexRulesInstallDirectory: string,
+ *   cursorInstallDirectory: string,
+ *   cursorRulesInstallDirectory: string,
  * }} InstallRootResolution
  */
 
@@ -69,6 +80,18 @@ export function resolveInstallRoot(options = {}) {
     }
 
     const mypyIniInstallPath = resolve(join(homeDirectory, MYPY_INI_FILE_NAME));
+    const codexHomeDirectory = normalizeOptionalPath(
+        environment[CODEX_HOME_ENVIRONMENT_VARIABLE],
+    ) ?? resolve(join(homeDirectory, DEFAULT_CODEX_DIRECTORY_NAME));
+    const codexRulesInstallDirectory = resolve(
+        join(codexHomeDirectory, CODEX_RULES_DIRECTORY_NAME),
+    );
+    const cursorInstallDirectory = resolve(
+        join(homeDirectory, DEFAULT_CURSOR_DIRECTORY_NAME),
+    );
+    const cursorRulesInstallDirectory = resolve(
+        join(cursorInstallDirectory, CURSOR_RULES_DIRECTORY_NAME),
+    );
     return {
         managedRoot,
         source,
@@ -76,6 +99,10 @@ export function resolveInstallRoot(options = {}) {
         manifestFilePath: join(managedRoot, MANIFEST_FILE_NAME),
         mypyIniInstallPath,
         allDeclaredExternalPaths: [mypyIniInstallPath],
+        allDeclaredExternalDirectories: [codexRulesInstallDirectory, cursorInstallDirectory],
+        codexRulesInstallDirectory,
+        cursorInstallDirectory,
+        cursorRulesInstallDirectory,
     };
 }
 
@@ -103,8 +130,9 @@ export function isPathWithinManagedRoot(candidatePath, managedRoot) {
 }
 
 /**
- * True when a write destination is allowed: inside the managed root or on
- * the declared external allowlist (today: ~/.mypy.ini under the home dir).
+ * True when a write destination is allowed: inside the managed root, the
+ * home-directory `.mypy.ini`, a file under the Codex rules directory, or a file
+ * under the Cursor rules directory.
  *
  * @param {string} candidatePath
  * @param {InstallRootResolution} resolution
@@ -115,8 +143,13 @@ export function isAllowedInstallDestination(candidatePath, resolution) {
         return true;
     }
     const normalizedCandidate = normalizePathForComparison(candidatePath);
-    return resolution.allDeclaredExternalPaths.some(
+    if (resolution.allDeclaredExternalPaths.some(
         (eachExternalPath) => normalizePathForComparison(eachExternalPath) === normalizedCandidate,
+    )) {
+        return true;
+    }
+    return (resolution.allDeclaredExternalDirectories ?? []).some(
+        (eachExternalDirectory) => isPathWithinManagedRoot(candidatePath, eachExternalDirectory),
     );
 }
 
@@ -130,18 +163,18 @@ export function parseExplicitTargetFromArgv(argv) {
     for (let index = 0; index < argv.length; index += 1) {
         const token = argv[index];
         if (token === '--target') {
-            const value = argv[index + 1];
-            if (!value || value.startsWith('--')) {
+            const targetPath = argv[index + 1];
+            if (!targetPath || targetPath.startsWith('--')) {
                 throw new Error('--target requires a path argument');
             }
-            return value;
+            return targetPath;
         }
         if (token.startsWith('--target=')) {
-            const value = token.slice('--target='.length);
-            if (!value) {
+            const targetPath = token.slice('--target='.length);
+            if (!targetPath) {
                 throw new Error('--target requires a path argument');
             }
-            return value;
+            return targetPath;
         }
     }
     return null;

package/codex-rules/claude-dev-env.rules

@@ -0,0 +1,12 @@
+# Shared Codex exec-policy prefix rules shipped by claude-dev-env.
+# Codex loads every *.rules file under $CODEX_HOME/rules (default ~/.codex/rules).
+# This file is named claude-dev-env.rules so a local default.rules stays in place.
+# Patterns use relative repo paths only. Personal home paths stay out of this file.
+
+prefix_rule(pattern=["gemini", "--version"], decision="allow")
+prefix_rule(pattern=["git", "status", "--short", "--branch"], decision="allow")
+prefix_rule(pattern=["git", "status", "--short"], decision="allow")
+prefix_rule(pattern=["git", "diff", "--", "packages/claude-dev-env/_shared/pr-loop/scripts/code_rules_gate_parts", "packages/claude-dev-env/_shared/pr-loop/scripts/tests/test_code_rules_gate.py"], decision="allow")
+prefix_rule(pattern=["Get-Content", "-LiteralPath", "packages/claude-dev-env/_shared/pr-loop/scripts/code_rules_gate_parts/tests/_repo_test_helpers.py"], decision="allow")
+prefix_rule(pattern=["rg", "-n", "-i", "--glob", "!**/__pycache__/**", "verified_commit_gate|verifier_verdict_minter|verdict_directory_write_blocker|verify-skip|code-verifier.*commit|commit.*code-verifier", "packages/claude-dev-env"], decision="allow")
+prefix_rule(pattern=["python", "-m", "pytest", "-q", "packages/claude-dev-env/hooks/hooks_constants/test_bash_pre_tool_use_dispatcher_constants.py", "packages/claude-dev-env/hooks/blocking/test_bash_pre_tool_use_dispatcher.py", "packages/claude-dev-env/hooks/blocking/test_pre_tool_use_dispatcher.py", "packages/claude-dev-env/hooks/blocking/test_verdict_directory_write_blocker.py"], decision="allow")

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "claude-dev-env",
-    "version": "2.14.1",
+    "version": "2.15.1",
     "description": "Claude Code development standards — rules, hooks, agents, commands, and skills",
     "type": "module",
     "bin": {
@@ -8,7 +8,7 @@
         "codex-compat": "bin/codex-compat.mjs"
     },
     "scripts": {
-        "test": "node --test \"bin/*.test.mjs\" \"skills/**/*.test.mjs\" \"scripts/profile-isolation-launchers/**/*.test.mjs\" \"tests/fresh-session/**/*.test.mjs\""
+        "test": "node --test \"bin/*.test.mjs\" \"skills/**/*.test.mjs\" \"tests/fresh-session/**/*.test.mjs\""
     },
     "files": [
         "bin/",
@@ -26,6 +26,7 @@
         "installable-surfaces.manifest.json",
         "_shared/",
         "audit-rubrics/",
+        "codex-rules/",
         "AGENTS.md",
         "CLAUDE.md",
         "!**/__pycache__/**",