claude-dev-env 8.88.2 → 8.88.4

package/bin/codex-trimmed-sol.mjs

@@ -1,5 +1,8 @@
-import { lstatSync, mkdirSync, readFileSync, rmSync, unlinkSync, writeFileSync } from 'node:fs';
-import { join } from 'node:path';
+import { lstatSync, mkdirSync, readFileSync, rmSync, statSync, unlinkSync, writeFileSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { dirname, join } from 'node:path';
+
+import { DEFAULT_CODEX_DIRECTORY_NAME } from './install-constants.mjs';
 
 export const SOL_PROMPT_DIRECTORY_NAME = 'system-prompts';
 export const SOL_PROMPT_FILE_NAME = 'codex-sol.md';
@@ -53,34 +56,87 @@ function readCodexConfig(configPath) {
     return { isReadable: true, currentText: readFileSync(configPath, 'utf8') };
 }
 
+/**
+ * Return the Codex home whose folder holds the prompt the config.toml setting names.
+ *
+ * Account sync links each account home's config.toml to the main Codex
+ * home's file: a symbolic link, or a hard link when the account cannot
+ * create one. Every home that shares that file shares one setting, so the
+ * prompt it names belongs in the main home. Any other home uses its own
+ * folder, including a home whose config.toml links into a dotfiles folder.
+ *
+ * @param {string} codexHome
+ * @returns {string}
+ */
+export function codexConfigDirectory(codexHome) {
+    const mainCodexHome = join(homedir(), DEFAULT_CODEX_DIRECTORY_NAME);
+    return sharesMainConfig(codexHome, mainCodexHome) ? mainCodexHome : codexHome;
+}
+
+function sharesMainConfig(codexHome, mainCodexHome) {
+    return isSameFile(join(codexHome, CODEX_CONFIG_FILE_NAME), join(mainCodexHome, CODEX_CONFIG_FILE_NAME));
+}
+
+function isSameFile(firstPath, secondPath) {
+    try {
+        const firstEntry = statSync(firstPath, { bigint: true, throwIfNoEntry: false });
+        const secondEntry = statSync(secondPath, { bigint: true, throwIfNoEntry: false });
+        return Boolean(firstEntry && secondEntry && firstEntry.dev === secondEntry.dev && firstEntry.ino === secondEntry.ino);
+    } catch {
+        return false;
+    }
+}
+
+/**
+ * True when CODEX_HOME is an account home whose config.toml is the main Codex home's file.
+ *
+ * Such a home borrows the setting and the prompt from the main home, so
+ * uninstalling from it leaves both alone. The homes are compared as folders
+ * on disk, so a CODEX_HOME spelled with other letter case or through a link
+ * still counts as the main home.
+ *
+ * @param {string} codexHome
+ * @returns {boolean}
+ */
+export function codexConfigIsBorrowed(codexHome) {
+    const mainCodexHome = join(homedir(), DEFAULT_CODEX_DIRECTORY_NAME);
+    return sharesMainConfig(codexHome, mainCodexHome) && !isSameFile(codexHome, mainCodexHome);
+}
+
 /**
  * Return where the installer keeps the Codex copy of the trimmed Sol prompt.
  *
- * The copy lives in CODEX_HOME beside config.toml, so the file the setting
- * names stays put when any claude-dev-env version, older ones included,
- * prunes or rewrites the managed files under ~/.claude. A missing file makes
- * every Codex command fail before it starts.
+ * The copy sits in CODEX_HOME, or in the main Codex home when CODEX_HOME is
+ * an account home that shares its config.toml, so the file the setting names
+ * stays put when any claude-dev-env version, older ones included, prunes or
+ * rewrites the managed files under ~/.claude, and every home that shares that
+ * config.toml names the same copy. A missing file makes every Codex command
+ * fail before it starts.
  *
  * @param {string} codexHome
  * @returns {string}
  */
 export function codexSolPromptPath(codexHome) {
-    return join(codexHome, SOL_PROMPT_FILE_NAME);
+    return join(codexConfigDirectory(codexHome), SOL_PROMPT_FILE_NAME);
 }
 
 /**
- * Copy the trimmed Sol prompt into CODEX_HOME.
+ * Copy the trimmed Sol prompt to the folder `codexSolPromptPath` names.
+ *
+ * An account home that shares the main config.toml also loses the copy an earlier
+ * install left in its own folder, since no setting names that copy any more.
  *
  * @param {string} codexHome
  * @param {string} sourcePromptPath The prompt file the package ships.
- * @returns {string|null} The Codex copy's path when this call wrote it, and null when it was already current.
+ * @returns {string|null} The prompt copy's path when this call wrote it, and null when it was already current.
  */
 export function installCodexSolPrompt(codexHome, sourcePromptPath) {
+    if (codexConfigIsBorrowed(codexHome)) rmSync(join(codexHome, SOL_PROMPT_FILE_NAME), { force: true });
     const promptPath = codexSolPromptPath(codexHome);
     const promptText = readFileSync(sourcePromptPath, 'utf8');
     const promptEntry = lstatSync(promptPath, { throwIfNoEntry: false });
     if (promptEntry?.isFile() && readFileSync(promptPath, 'utf8') === promptText) return null;
-    mkdirSync(codexHome, { recursive: true });
+    mkdirSync(dirname(promptPath), { recursive: true });
     writeFileSync(promptPath, promptText, 'utf8');
     return promptPath;
 }
@@ -120,14 +176,20 @@ export function writeCodexSolSetting(codexHome, instructionsPath) {
  * Remove the package's `model_instructions_file` line from CODEX_HOME/config.toml.
  *
  * The rest of the file stays as the user wrote it. A file that held only the
- * package line is removed. The Codex copy of the prompt is removed in every
- * case, because install writes it even when the user's own setting kept the
- * package line out.
+ * package line is removed. The prompt copy is removed in every case, because
+ * install writes it even when the user's own setting kept the package line
+ * out. An account home that shares the main config.toml only drops its own
+ * leftover copy: the shared setting and prompt belong to the main home, and
+ * other homes still read them.
  *
  * @param {string} codexHome
  * @returns {string|null} The config path when it changed, or null when nothing was removed.
  */
 export function removeCodexSolSetting(codexHome) {
+    if (codexConfigIsBorrowed(codexHome)) {
+        rmSync(join(codexHome, SOL_PROMPT_FILE_NAME), { force: true });
+        return null;
+    }
     rmSync(codexSolPromptPath(codexHome), { force: true });
     const configPath = join(codexHome, CODEX_CONFIG_FILE_NAME);
     const { isReadable, currentText } = readCodexConfig(configPath);

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

@@ -1,7 +1,7 @@
 import { test } from 'node:test';
 import { strict as assert } from 'node:assert';
 import { spawnSync } from 'node:child_process';
-import { existsSync, mkdirSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from 'node:fs';
+import { existsSync, linkSync, mkdirSync, mkdtempSync, readFileSync, rmSync, symlinkSync, writeFileSync } from 'node:fs';
 import { tmpdir } from 'node:os';
 import { join } from 'node:path';
 import { fileURLToPath } from 'node:url';
@@ -264,3 +264,118 @@ test('uninstall removes the Codex copy of the prompt when the user wrote their o
     assert.equal(existsSync(promptPath), false);
     assert.equal(readFileSync(configPath, 'utf8'), userText);
 });
+
+
+function makeLinkedCodexHomes(context) {
+    const homeDirectory = makeScratchHome(context);
+    const ownerHome = join(homeDirectory, '.codex');
+    const linkedHome = join(homeDirectory, '.codex-editor');
+    mkdirSync(ownerHome, { recursive: true });
+    mkdirSync(linkedHome, { recursive: true });
+    writeFileSync(join(ownerHome, CODEX_CONFIG_FILE_NAME), 'approval_policy = "never"\n');
+    try {
+        symlinkSync(join(ownerHome, CODEX_CONFIG_FILE_NAME), join(linkedHome, CODEX_CONFIG_FILE_NAME), 'file');
+    } catch (error) {
+        if (error.code === 'EPERM') return null;
+        throw error;
+    }
+    return { homeDirectory, ownerHome, linkedHome };
+}
+
+test('a home whose config.toml links to another home names the prompt beside the real file', (context) => {
+    const homes = makeLinkedCodexHomes(context);
+    if (!homes) return context.skip('this account cannot create symlinks');
+    const { homeDirectory, ownerHome, linkedHome } = homes;
+    writeFileSync(join(linkedHome, 'codex-sol.md'), 'left by an earlier install\n');
+
+    assert.equal(installInScratchHome(homeDirectory, [], { CODEX_HOME: ownerHome }).status, 0);
+    const linkedInstallation = installInScratchHome(homeDirectory, [], { CODEX_HOME: linkedHome });
+
+    assert.equal(linkedInstallation.status, 0, linkedInstallation.stderr);
+    const configText = readFileSync(join(ownerHome, CODEX_CONFIG_FILE_NAME), 'utf8');
+    assert.ok(configText.includes(`model_instructions_file = ${JSON.stringify(join(ownerHome, 'codex-sol.md'))}`), configText);
+    assert.equal(readFileSync(join(ownerHome, 'codex-sol.md'), 'utf8'), readFileSync(shippedPromptPath, 'utf8'));
+    assert.equal(existsSync(join(linkedHome, 'codex-sol.md')), false);
+});
+
+test('uninstall from a home whose config.toml is linked keeps the shared setting and prompt', (context) => {
+    const homes = makeLinkedCodexHomes(context);
+    if (!homes) return context.skip('this account cannot create symlinks');
+    const { homeDirectory, ownerHome, linkedHome } = homes;
+    assert.equal(installInScratchHome(homeDirectory, [], { CODEX_HOME: ownerHome }).status, 0);
+    assert.equal(installInScratchHome(homeDirectory, [], { CODEX_HOME: linkedHome }).status, 0);
+
+    const uninstallation = installInScratchHome(homeDirectory, ['--uninstall'], { CODEX_HOME: linkedHome });
+
+    assert.equal(uninstallation.status, 0, uninstallation.stderr);
+    const configText = readFileSync(join(ownerHome, CODEX_CONFIG_FILE_NAME), 'utf8');
+    assert.ok(configText.includes(`model_instructions_file = ${JSON.stringify(join(ownerHome, 'codex-sol.md'))}`), configText);
+    assert.equal(existsSync(join(ownerHome, 'codex-sol.md')), true);
+});
+
+test('a home whose config.toml is a hard link to the main home\'s file names the prompt in the main home', (context) => {
+    const homeDirectory = makeScratchHome(context);
+    const mainHome = join(homeDirectory, '.codex');
+    const linkedHome = join(homeDirectory, '.codex-editor');
+    mkdirSync(mainHome, { recursive: true });
+    mkdirSync(linkedHome, { recursive: true });
+    writeFileSync(join(mainHome, CODEX_CONFIG_FILE_NAME), 'approval_policy = "never"\n');
+    linkSync(join(mainHome, CODEX_CONFIG_FILE_NAME), join(linkedHome, CODEX_CONFIG_FILE_NAME));
+    assert.equal(installInScratchHome(homeDirectory, [], { CODEX_HOME: mainHome }).status, 0);
+
+    const linkedInstallation = installInScratchHome(homeDirectory, [], { CODEX_HOME: linkedHome });
+    assert.equal(linkedInstallation.status, 0, linkedInstallation.stderr);
+    const sharedLine = `model_instructions_file = ${JSON.stringify(join(mainHome, 'codex-sol.md'))}`;
+    assert.ok(readFileSync(join(mainHome, CODEX_CONFIG_FILE_NAME), 'utf8').includes(sharedLine));
+    assert.equal(existsSync(join(linkedHome, 'codex-sol.md')), false);
+
+    const uninstallation = installInScratchHome(homeDirectory, ['--uninstall'], { CODEX_HOME: linkedHome });
+    assert.equal(uninstallation.status, 0, uninstallation.stderr);
+    assert.ok(readFileSync(join(mainHome, CODEX_CONFIG_FILE_NAME), 'utf8').includes(sharedLine));
+    assert.equal(existsSync(join(mainHome, 'codex-sol.md')), true);
+});
+
+test('a main home whose config.toml links into a dotfiles folder keeps the prompt in CODEX_HOME, and uninstall removes the line', (context) => {
+    const homeDirectory = makeScratchHome(context);
+    const mainHome = join(homeDirectory, '.codex');
+    const dotfilesDirectory = join(homeDirectory, 'dotfiles', 'codex');
+    mkdirSync(mainHome, { recursive: true });
+    mkdirSync(dotfilesDirectory, { recursive: true });
+    writeFileSync(join(dotfilesDirectory, CODEX_CONFIG_FILE_NAME), 'approval_policy = "never"\n');
+    try {
+        symlinkSync(join(dotfilesDirectory, CODEX_CONFIG_FILE_NAME), join(mainHome, CODEX_CONFIG_FILE_NAME), 'file');
+    } catch (error) {
+        if (error.code === 'EPERM') return context.skip('this account cannot create symlinks');
+        throw error;
+    }
+
+    assert.equal(installInScratchHome(homeDirectory, [], { CODEX_HOME: mainHome }).status, 0);
+    assert.ok(readFileSync(join(dotfilesDirectory, CODEX_CONFIG_FILE_NAME), 'utf8')
+        .includes(`model_instructions_file = ${JSON.stringify(join(mainHome, 'codex-sol.md'))}`));
+    assert.equal(existsSync(join(dotfilesDirectory, 'codex-sol.md')), false);
+
+    assert.equal(installInScratchHome(homeDirectory, ['--uninstall'], { CODEX_HOME: mainHome }).status, 0);
+    assert.equal(readFileSync(join(dotfilesDirectory, CODEX_CONFIG_FILE_NAME), 'utf8'), 'approval_policy = "never"\n');
+    assert.equal(existsSync(join(mainHome, 'codex-sol.md')), false);
+});
+
+test('CODEX_HOME that reaches the main home through a folder link still uninstalls the line', (context) => {
+    const homeDirectory = makeScratchHome(context);
+    const mainHome = join(homeDirectory, '.codex');
+    const folderLink = join(homeDirectory, 'codex-home-link');
+    mkdirSync(mainHome, { recursive: true });
+    writeFileSync(join(mainHome, CODEX_CONFIG_FILE_NAME), 'approval_policy = "never"\n');
+    try {
+        symlinkSync(mainHome, folderLink, 'junction');
+    } catch (error) {
+        if (error.code === 'EPERM') return context.skip('this account cannot create links');
+        throw error;
+    }
+
+    assert.equal(installInScratchHome(homeDirectory, [], { CODEX_HOME: folderLink }).status, 0);
+    assert.equal(existsSync(join(mainHome, 'codex-sol.md')), true);
+
+    assert.equal(installInScratchHome(homeDirectory, ['--uninstall'], { CODEX_HOME: folderLink }).status, 0);
+    assert.equal(readFileSync(join(mainHome, CODEX_CONFIG_FILE_NAME), 'utf8'), 'approval_policy = "never"\n');
+    assert.equal(existsSync(join(mainHome, 'codex-sol.md')), false);
+});

package/bin/install.mjs

@@ -129,6 +129,13 @@ import {
     runWithInstallTransaction,
 } from './install-transaction.mjs';
 import { findShadowingGlobalInstall, shadowingGlobalAdvice } from './global-install-shadow.mjs';
+import {
+    addOpenTasksGateToProfiles,
+    otherProfileSettingsPaths,
+    removeOpenTasksGateFromProfiles,
+    splitUnreadableProfileSettings,
+    unparsedSettingsMayHoldGate,
+} from './profile-stop-gate.mjs';
 import { pythonExecutableProbeCommand } from './python-probe.mjs';
 
 const PACKAGE_ROOT = resolve(dirname(fileURLToPath(import.meta.url)), '..');
@@ -2695,18 +2702,81 @@ function install(selectedGroups, options = {}) {
     executeInstallPlan(plan);
 }
 
+/**
+ * List the profile settings paths that get the open-tasks Stop gate.
+ *
+ * Only an install into the main ~/.claude does this, because the gate entry
+ * names the main home's hook script.
+ *
+ * @param {string} mainSettingsPath
+ * @returns {string[]}
+ */
+function profileSettingsPathsForStopGate(mainSettingsPath) {
+    if (!pathsAreEquivalent(CLAUDE_HOME, join(homedir(), '.claude'))) return [];
+    return otherProfileSettingsPaths({ homeDirectory: homedir(), environment: process.env, mainSettingsPath });
+}
+
+/**
+ * Return the profile settings the gate step can parse, and add an Action needed line for each one it cannot.
+ *
+ * @param {string} mainSettingsPath
+ * @returns {string[]}
+ */
+function readableProfileSettingsPathsForStopGate(mainSettingsPath) {
+    const { allReadablePaths, allUnreadable } = splitUnreadableProfileSettings(
+        profileSettingsPathsForStopGate(mainSettingsPath),
+    );
+    for (const { settingsPath, reason } of allUnreadable) {
+        const actionLine = `Profile settings: ${settingsPath} was left unchanged because it is not valid JSON (${reason}).`
+            + ' Fix the file and run the install again to add the open-tasks Stop gate there.';
+        console.warn(`  ${actionLine}`);
+        allActionNeededLines.push(actionLine);
+    }
+    return allReadablePaths;
+}
+
+/**
+ * Return the profile settings the uninstall removes the gate from, or the reason it must stop first.
+ *
+ * A profile file that does not parse and may still hold the gate stops the
+ * uninstall before it changes anything. The manifest then stays, so running
+ * --uninstall again after fixing the file removes the gate. A file that does
+ * not parse and does not name the gate has nothing to remove and is left as
+ * it is.
+ *
+ * @param {string} mainSettingsPath
+ * @returns {{ allReadablePaths: string[], blockingReason: string|null }}
+ */
+function profileSettingsPathsForGateRemoval(mainSettingsPath) {
+    const { allReadablePaths, allUnreadable } = splitUnreadableProfileSettings(
+        profileSettingsPathsForStopGate(mainSettingsPath),
+    );
+    const allHoldingGate = allUnreadable.filter(
+        ({ settingsPath }) => unparsedSettingsMayHoldGate(settingsPath, CLAUDE_HOME),
+    );
+    if (allHoldingGate.length === 0) return { allReadablePaths, blockingReason: null };
+    const fileLines = allHoldingGate.map(({ settingsPath, reason }) => `  ${settingsPath}: not valid JSON (${reason})`);
+    const blockingReason = [
+        'ERROR: uninstall stopped before changing anything. These profile settings files still name the open-tasks Stop gate, and they are not valid JSON, so the gate cannot be removed from them:',
+        ...fileLines,
+        'Fix each file and run --uninstall again.',
+    ].join('\n');
+    return { allReadablePaths, blockingReason };
+}
+
 function executeInstallPlan(plan) {
     const faultPhase = resolveFaultPhaseFromEnvironment(process.env);
     const snapshot = capturePriorInstallSnapshot({
         managedRoot: CLAUDE_HOME,
         manifestFilePath: MANIFEST_FILE,
         settingsPath: plan.settingsPath,
-        additionalSettingsPaths: [CODEX_HOOKS_CONFIGURATION_PATH],
+        additionalSettingsPaths: [CODEX_HOOKS_CONFIGURATION_PATH, ...profileSettingsPathsForStopGate(plan.settingsPath)],
         priorManifestFiles: [
             ...(plan.priorManifest.files || []),
             join(INSTALL_ROOT_RESOLUTION.codexHomeDirectory, 'AGENTS.md'),
             ...codexSolSettingSnapshotPaths(INSTALL_ROOT_RESOLUTION.codexHomeDirectory),
             codexSolPromptPath(INSTALL_ROOT_RESOLUTION.codexHomeDirectory),
+            join(INSTALL_ROOT_RESOLUTION.codexHomeDirectory, SOL_PROMPT_FILE_NAME),
         ],
         journalParentDirectory: join(CLAUDE_HOME, TRANSACTION_JOURNAL_DIRECTORY_NAME),
     });
@@ -3185,6 +3255,16 @@ function executeInstallPlanMutations(plan, transactionHelpers) {
     for (const eachLine of describeProfileSettingsOutcome(mergeOutcome, false)) {
         console.log(`  Profile settings: ${eachLine}`);
     }
+    for (const eachOutcome of addOpenTasksGateToProfiles({
+        mainSettingsPath: join(CLAUDE_HOME, SETTINGS_FILE_NAME),
+        claudeHome: CLAUDE_HOME,
+        allProfileSettingsPaths: readableProfileSettingsPathsForStopGate(join(CLAUDE_HOME, SETTINGS_FILE_NAME)),
+        homeDirectory: homedir(),
+    })) {
+        if (eachOutcome.additions.length > 0) {
+            console.log(`  Profile settings: open-tasks Stop gate added to ${eachOutcome.settingsPath}`);
+        }
+    }
 
     const agentsHubSource = join(PACKAGE_ROOT, 'AGENTS.md');
     if (existsSync(agentsHubSource)) {
@@ -3466,6 +3546,12 @@ function executeUninstallPlan(plan, helpers = {}) {
             writeFileSync(plan.settingsPath, JSON.stringify(settings, null, 4) + '\n');
         }
     }
+    for (const eachChangedPath of removeOpenTasksGateFromProfiles({
+        claudeHome: CLAUDE_HOME,
+        allProfileSettingsPaths: helpers.allProfileSettingsPaths,
+    })) {
+        console.log(`  Profile settings: open-tasks Stop gate removed from ${eachChangedPath}`);
+    }
     if (!codexRoutingHookExists()) {
         pruneManagedHooksFromHostConfiguration(CODEX_HOOKS_CONFIGURATION_PATH, 2);
     }
@@ -3518,18 +3604,24 @@ function uninstall() {
     if (plan.isNoOp) {
         return;
     }
+    const gateRemoval = profileSettingsPathsForGateRemoval(plan.settingsPath);
+    if (gateRemoval.blockingReason) {
+        console.error(gateRemoval.blockingReason);
+        process.exit(1);
+    }
 
     const faultPhase = resolveFaultPhaseFromEnvironment(process.env);
     const snapshot = capturePriorInstallSnapshot({
         managedRoot: CLAUDE_HOME,
         manifestFilePath: MANIFEST_FILE,
         settingsPath: plan.settingsPath,
-        additionalSettingsPaths: [CODEX_HOOKS_CONFIGURATION_PATH],
+        additionalSettingsPaths: [CODEX_HOOKS_CONFIGURATION_PATH, ...profileSettingsPathsForStopGate(plan.settingsPath)],
         priorManifestFiles: [
             ...plan.removableFiles,
             join(INSTALL_ROOT_RESOLUTION.codexHomeDirectory, 'AGENTS.md'),
             ...codexSolSettingSnapshotPaths(INSTALL_ROOT_RESOLUTION.codexHomeDirectory),
             codexSolPromptPath(INSTALL_ROOT_RESOLUTION.codexHomeDirectory),
+            join(INSTALL_ROOT_RESOLUTION.codexHomeDirectory, SOL_PROMPT_FILE_NAME),
         ],
         journalParentDirectory: join(CLAUDE_HOME, TRANSACTION_JOURNAL_DIRECTORY_NAME),
     });
@@ -3539,7 +3631,7 @@ function uninstall() {
             snapshot,
             faultPhase,
             runMutations: ({ throwIfFault }) => {
-                executeUninstallPlan(plan, { throwIfFault });
+                executeUninstallPlan(plan, { throwIfFault, allProfileSettingsPaths: gateRemoval.allReadablePaths });
             },
         });
     } catch (mutationError) {

package/bin/install.test.mjs

@@ -3687,3 +3687,143 @@ test('install prints no Action needed block when every side step finished', (con
     assert.equal(result.status, 0, result.stderr);
     assert.equal(result.stderr.includes('Action needed'), false, result.stderr);
 });
+
+test('install adds the open-tasks Stop gate to every profile with its own settings.json, and uninstall removes it', (context) => {
+    const homeDirectory = mkdtempSync(join(tmpdir(), 'cde-profile-gate-install-'));
+    context.after(() => rmSync(homeDirectory, { recursive: true, force: true }));
+    const profileSettingsPath = join(homeDirectory, '.claude-profiles', 'prefs-only', 'settings.json');
+    mkdirSync(dirname(profileSettingsPath), { recursive: true });
+    writeFileSync(profileSettingsPath, JSON.stringify({ outputStyle: 'plain' }, null, 4));
+    const runInstaller = (argumentsList) => spawnSync(process.execPath, [join(dirname(fileURLToPath(import.meta.url)), 'install.mjs'), ...argumentsList], {
+        cwd: dirname(dirname(fileURLToPath(import.meta.url))),
+        encoding: 'utf8',
+        env: {
+            ...process.env,
+            CLAUDE_CONFIG_DIR: undefined,
+            LLM_SETTINGS_PROFILES_ROOT: undefined,
+            CLAUDE_DEV_ENV_INSTALL_FAULT: 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',
+            HOME: homeDirectory,
+            USERPROFILE: homeDirectory,
+            CODEX_HOME: join(homeDirectory, '.codex'),
+            GIT_CONFIG_GLOBAL: join(homeDirectory, '.gitconfig'),
+            TEMP: homeDirectory,
+            TMP: homeDirectory,
+        },
+    });
+    const profileStopCommands = () => (JSON.parse(readFileSync(profileSettingsPath, 'utf8')).hooks?.Stop ?? [])
+        .flatMap((eachGroup) => eachGroup.hooks.map((eachHook) => eachHook.command));
+
+    const installation = runInstaller([]);
+    assert.equal(installation.status, 0, installation.stderr);
+    assert.equal(profileStopCommands().filter((eachCommand) => eachCommand.includes('open_tasks_stop_gate.py')).length, 1);
+
+    const uninstallation = runInstaller(['--uninstall']);
+    assert.equal(uninstallation.status, 0, uninstallation.stderr);
+    assert.deepEqual(JSON.parse(readFileSync(profileSettingsPath, 'utf8')), { outputStyle: 'plain' });
+});
+
+test('a profile settings.json that is not valid JSON is left alone and named under Action needed, and the rest of the install and uninstall go through', (context) => {
+    const homeDirectory = mkdtempSync(join(tmpdir(), 'cde-profile-gate-malformed-'));
+    context.after(() => rmSync(homeDirectory, { recursive: true, force: true }));
+    const brokenSettingsPath = join(homeDirectory, '.claude-profiles', 'broken', 'settings.json');
+    const goodSettingsPath = join(homeDirectory, '.claude-profiles', 'good', 'settings.json');
+    const brokenSettingsText = '{"hooks":{},}\n';
+    mkdirSync(dirname(brokenSettingsPath), { recursive: true });
+    mkdirSync(dirname(goodSettingsPath), { recursive: true });
+    writeFileSync(brokenSettingsPath, brokenSettingsText);
+    writeFileSync(goodSettingsPath, JSON.stringify({ outputStyle: 'plain' }, null, 4));
+    const runInstaller = (argumentsList) => spawnSync(process.execPath, [join(dirname(fileURLToPath(import.meta.url)), 'install.mjs'), ...argumentsList], {
+        cwd: dirname(dirname(fileURLToPath(import.meta.url))),
+        encoding: 'utf8',
+        env: {
+            ...process.env,
+            CLAUDE_CONFIG_DIR: undefined,
+            LLM_SETTINGS_PROFILES_ROOT: undefined,
+            CLAUDE_DEV_ENV_INSTALL_FAULT: 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',
+            HOME: homeDirectory,
+            USERPROFILE: homeDirectory,
+            CODEX_HOME: join(homeDirectory, '.codex'),
+            GIT_CONFIG_GLOBAL: join(homeDirectory, '.gitconfig'),
+            TEMP: homeDirectory,
+            TMP: homeDirectory,
+        },
+    });
+    const goodGateCount = () => (JSON.parse(readFileSync(goodSettingsPath, 'utf8')).hooks?.Stop ?? [])
+        .flatMap((eachGroup) => eachGroup.hooks.map((eachHook) => eachHook.command))
+        .filter((eachCommand) => eachCommand.includes('open_tasks_stop_gate.py')).length;
+    const actionNeededSection = (stderrText) => stderrText.slice(stderrText.indexOf('Action needed'));
+
+    const installation = runInstaller([]);
+    assert.equal(installation.status, 0, installation.stderr);
+    assert.equal(readFileSync(brokenSettingsPath, 'utf8'), brokenSettingsText);
+    assert.equal(goodGateCount(), 1);
+    assert.match(actionNeededSection(installation.stderr), /Action needed \(1\):/);
+    assert.ok(actionNeededSection(installation.stderr).includes(brokenSettingsPath));
+    assert.match(actionNeededSection(installation.stderr), /not valid JSON \(.+\)/);
+
+    const uninstallation = runInstaller(['--uninstall']);
+    assert.equal(uninstallation.status, 0, uninstallation.stderr);
+    assert.equal(readFileSync(brokenSettingsPath, 'utf8'), brokenSettingsText);
+    assert.equal(goodGateCount(), 0);
+});
+
+test('uninstall stops before changing anything while a profile settings.json that is not valid JSON still names the gate, and a rerun after the fix removes it', (context) => {
+    const homeDirectory = mkdtempSync(join(tmpdir(), 'cde-profile-gate-uninstall-malformed-'));
+    context.after(() => rmSync(homeDirectory, { recursive: true, force: true }));
+    const profileSettingsPath = join(homeDirectory, '.claude-profiles', 'prefs-only', 'settings.json');
+    mkdirSync(dirname(profileSettingsPath), { recursive: true });
+    writeFileSync(profileSettingsPath, JSON.stringify({ outputStyle: 'plain' }, null, 4));
+    const runInstaller = (argumentsList) => spawnSync(process.execPath, [join(dirname(fileURLToPath(import.meta.url)), 'install.mjs'), ...argumentsList], {
+        cwd: dirname(dirname(fileURLToPath(import.meta.url))),
+        encoding: 'utf8',
+        env: {
+            ...process.env,
+            CLAUDE_CONFIG_DIR: undefined,
+            LLM_SETTINGS_PROFILES_ROOT: undefined,
+            CLAUDE_DEV_ENV_INSTALL_FAULT: 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',
+            HOME: homeDirectory,
+            USERPROFILE: homeDirectory,
+            CODEX_HOME: join(homeDirectory, '.codex'),
+            GIT_CONFIG_GLOBAL: join(homeDirectory, '.gitconfig'),
+            TEMP: homeDirectory,
+            TMP: homeDirectory,
+        },
+    });
+    const manifestPath = join(homeDirectory, '.claude', '.claude-dev-env-manifest.json');
+
+    const installation = runInstaller([]);
+    assert.equal(installation.status, 0, installation.stderr);
+    const validText = readFileSync(profileSettingsPath, 'utf8');
+    assert.ok(validText.includes('open_tasks_stop_gate.py'));
+    const brokenText = validText.trimEnd().replace(/\}$/, ',}') + '\n';
+    writeFileSync(profileSettingsPath, brokenText);
+
+    const stoppedUninstall = runInstaller(['--uninstall']);
+    assert.equal(stoppedUninstall.status, 1, stoppedUninstall.stdout);
+    assert.ok(stoppedUninstall.stderr.includes(profileSettingsPath), stoppedUninstall.stderr);
+    assert.match(stoppedUninstall.stderr, /not valid JSON \(.+\)/);
+    assert.match(stoppedUninstall.stderr, /run --uninstall again/);
+    assert.equal(readFileSync(profileSettingsPath, 'utf8'), brokenText);
+    assert.ok(existsSync(manifestPath));
+
+    writeFileSync(profileSettingsPath, validText);
+    const rerunUninstall = runInstaller(['--uninstall']);
+    assert.equal(rerunUninstall.status, 0, rerunUninstall.stderr);
+    assert.deepEqual(JSON.parse(readFileSync(profileSettingsPath, 'utf8')), { outputStyle: 'plain' });
+    assert.equal(existsSync(manifestPath), false);
+});

package/bin/profile-stop-gate.mjs

@@ -0,0 +1,242 @@
+import { existsSync, readFileSync, realpathSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+
+import { CURSOR_OPEN_TASKS_HOOK_RELATIVE_PATH } from './install-constants.mjs';
+import {
+    discoverProfileSettingsPaths,
+    hostConfigurationIndent,
+    mergeProfileSettingsFile,
+} from './merge_profile_settings.mjs';
+import { normalizePathForComparison } from './resolve-install-root.mjs';
+
+const STOP_EVENT_NAME = 'Stop';
+const MANAGED_HOOKS_DIRECTORY_NAME = 'hooks';
+const SETTINGS_INDENT = '    ';
+
+function comparablePath(filesystemPath) {
+    try {
+        return normalizePathForComparison(realpathSync(filesystemPath));
+    } catch {
+        return normalizePathForComparison(filesystemPath);
+    }
+}
+
+function comparableCommand(command) {
+    const forwardSlashed = command.replace(/\\/g, '/');
+    return process.platform === 'win32' ? forwardSlashed.toLowerCase() : forwardSlashed;
+}
+
+/**
+ * Return the gate script's path under a Claude home, in the spelling hook commands compare by.
+ *
+ * @param {string} claudeHome
+ * @returns {string}
+ */
+export function gateScriptCommandFragment(claudeHome) {
+    return comparableCommand(join(claudeHome, MANAGED_HOOKS_DIRECTORY_NAME, ...CURSOR_OPEN_TASKS_HOOK_RELATIVE_PATH));
+}
+
+function isGateHook(eachHook, claudeHome) {
+    return typeof eachHook?.command === 'string'
+        && comparableCommand(eachHook.command).includes(gateScriptCommandFragment(claudeHome));
+}
+
+/**
+ * Find the open-tasks Stop gate hook the install wrote into the main settings.
+ *
+ * @param {string} mainSettingsPath
+ * @param {string} claudeHome
+ * @returns {Record<string, unknown>|null} A copy of the hook entry, or null when the main settings hold none.
+ */
+export function mainOpenTasksGateHook(mainSettingsPath, claudeHome) {
+    if (!existsSync(mainSettingsPath)) return null;
+    const settings = JSON.parse(readFileSync(mainSettingsPath, 'utf8'));
+    for (const eachGroup of settings?.hooks?.[STOP_EVENT_NAME] ?? []) {
+        for (const eachHook of eachGroup?.hooks ?? []) {
+            if (isGateHook(eachHook, claudeHome)) return structuredClone(eachHook);
+        }
+    }
+    return null;
+}
+
+/**
+ * List the settings.json of every other Claude profile on this machine.
+ *
+ * A profile whose settings.json links to the main settings already reads the
+ * main hooks, so it is left out, and so is the main file itself.
+ *
+ * @param {{ homeDirectory: string, environment?: Record<string, string|undefined>, mainSettingsPath: string }} options
+ * @returns {string[]}
+ */
+export function otherProfileSettingsPaths(options) {
+    const mainKey = comparablePath(options.mainSettingsPath);
+    const seenKeys = new Set([mainKey]);
+    const allOtherPaths = [];
+    for (const eachPath of discoverProfileSettingsPaths(options)) {
+        if (!existsSync(eachPath)) continue;
+        const pathKey = comparablePath(eachPath);
+        if (seenKeys.has(pathKey)) continue;
+        seenKeys.add(pathKey);
+        allOtherPaths.push(eachPath);
+    }
+    return allOtherPaths;
+}
+
+/**
+ * Split profile settings paths into the ones whose settings.json parses and the ones that do not.
+ *
+ * A profile file that is not valid JSON is left as it is. The caller names
+ * each one, with its parse error, so the user can fix it and run the install
+ * again. An empty file counts as readable.
+ *
+ * @param {string[]} allProfileSettingsPaths
+ * @returns {{ allReadablePaths: string[], allUnreadable: { settingsPath: string, reason: string }[] }}
+ */
+export function splitUnreadableProfileSettings(allProfileSettingsPaths) {
+    const allReadablePaths = [];
+    const allUnreadable = [];
+    for (const eachPath of allProfileSettingsPaths) {
+        try {
+            const settingsText = readFileSync(eachPath, 'utf8');
+            if (settingsText.trim()) JSON.parse(settingsText);
+            allReadablePaths.push(eachPath);
+        } catch (readError) {
+            allUnreadable.push({
+                settingsPath: eachPath,
+                reason: readError instanceof Error ? readError.message : String(readError),
+            });
+        }
+    }
+    return { allReadablePaths, allUnreadable };
+}
+
+/**
+ * True when a settings.json that does not parse may still hold this Claude home's open-tasks gate.
+ *
+ * The raw text is searched for the gate script path, with JSON-escaped
+ * backslashes read as path separators. A file that cannot be read counts as
+ * one that may hold the gate.
+ *
+ * @param {string} settingsPath
+ * @param {string} claudeHome
+ * @returns {boolean}
+ */
+export function unparsedSettingsMayHoldGate(settingsPath, claudeHome) {
+    let settingsText;
+    try {
+        settingsText = readFileSync(settingsPath, 'utf8');
+    } catch {
+        return true;
+    }
+    return comparableCommand(settingsText.replace(/\\\\/g, '/')).includes(gateScriptCommandFragment(claudeHome));
+}
+
+function stopHooks(settingsPath) {
+    const settingsText = readFileSync(settingsPath, 'utf8');
+    if (!settingsText.trim()) return [];
+    const settings = JSON.parse(settingsText);
+    const stopGroups = settings?.hooks?.[STOP_EVENT_NAME];
+    if (!Array.isArray(stopGroups)) return [];
+    return stopGroups.flatMap((eachGroup) => (Array.isArray(eachGroup?.hooks) ? eachGroup.hooks : []));
+}
+
+function profileGateCommands(settingsPath, claudeHome) {
+    return stopHooks(settingsPath)
+        .filter((eachHook) => isGateHook(eachHook, claudeHome))
+        .map((eachHook) => eachHook.command);
+}
+
+/**
+ * True when a profile's settings.json already runs a gate script from another Claude home.
+ *
+ * An install with CLAUDE_CONFIG_DIR set to the profile writes a gate entry
+ * for the profile's own copy of the script, and a second entry for the main
+ * home's copy would run the gate twice on every stop.
+ *
+ * @param {string} settingsPath
+ * @param {string} claudeHome
+ * @returns {boolean}
+ */
+export function profileRunsItsOwnGate(settingsPath, claudeHome) {
+    const scriptPathSuffix = `/${comparableCommand(join(MANAGED_HOOKS_DIRECTORY_NAME, ...CURSOR_OPEN_TASKS_HOOK_RELATIVE_PATH))}`;
+    return stopHooks(settingsPath).some((eachHook) => typeof eachHook?.command === 'string'
+        && comparableCommand(eachHook.command).includes(scriptPathSuffix)
+        && !isGateHook(eachHook, claudeHome));
+}
+
+/**
+ * Add the main settings' open-tasks Stop gate to every other profile's settings.json.
+ *
+ * A profile keeps its own settings and hooks. The merge adds the one gate
+ * entry, in the spelling the main settings use, only where it is missing;
+ * an entry left with an older interpreter spelling is replaced. The file as
+ * it was before either change is copied to a timestamped `.bak`. A profile
+ * that already runs its own copy of the gate script is left as it is.
+ *
+ * @param {{ mainSettingsPath: string, claudeHome: string, allProfileSettingsPaths: string[],
+ *   homeDirectory: string, now?: Date }} options
+ * @returns {{ settingsPath: string, additions: string[], backupPath: string|null }[]}
+ */
+export function addOpenTasksGateToProfiles(options) {
+    const gateHook = mainOpenTasksGateHook(options.mainSettingsPath, options.claudeHome);
+    if (!gateHook) return [];
+    const timestamp = (options.now ?? new Date()).toISOString().replace(/[:.]/g, '-');
+    const declaredSettings = [{ keyPath: ['hooks', STOP_EVENT_NAME], items: [{ hooks: [gateHook] }] }];
+    const allTargetPaths = options.allProfileSettingsPaths.filter(
+        (eachPath) => !profileRunsItsOwnGate(eachPath, options.claudeHome),
+    );
+    const allStalePaths = allTargetPaths.filter(
+        (eachPath) => profileGateCommands(eachPath, options.claudeHome)
+            .some((eachCommand) => eachCommand !== gateHook.command),
+    );
+    const originalTextByStalePath = new Map(allStalePaths.map((eachPath) => [eachPath, readFileSync(eachPath, 'utf8')]));
+    removeOpenTasksGateFromProfiles({ claudeHome: options.claudeHome, allProfileSettingsPaths: allStalePaths });
+    return allTargetPaths.map((eachPath) => {
+        const outcome = mergeProfileSettingsFile(eachPath, {
+            dryRun: false,
+            homeDirectory: options.homeDirectory,
+            timestamp,
+            declaredSettings,
+        });
+        if (outcome.backupPath && originalTextByStalePath.has(eachPath)) {
+            writeFileSync(outcome.backupPath, originalTextByStalePath.get(eachPath));
+        }
+        return outcome;
+    });
+}
+
+/**
+ * Remove the gate entry that points at the main Claude home from each listed profile settings path.
+ *
+ * Only a hook whose command runs the main home's gate script goes. A Stop
+ * group left empty goes too, and so does an emptied Stop list or hooks object.
+ *
+ * @param {{ claudeHome: string, allProfileSettingsPaths: string[] }} options
+ * @returns {string[]} The settings paths that changed.
+ */
+export function removeOpenTasksGateFromProfiles(options) {
+    const allChangedPaths = [];
+    for (const eachPath of options.allProfileSettingsPaths) {
+        const settingsText = readFileSync(eachPath, 'utf8');
+        if (!settingsText.trim()) continue;
+        const settings = JSON.parse(settingsText);
+        const stopGroups = settings?.hooks?.[STOP_EVENT_NAME];
+        if (!Array.isArray(stopGroups)) continue;
+        let removedCount = 0;
+        for (const eachGroup of stopGroups) {
+            if (!Array.isArray(eachGroup?.hooks)) continue;
+            const keptHooks = eachGroup.hooks.filter((eachHook) => !isGateHook(eachHook, options.claudeHome));
+            removedCount += eachGroup.hooks.length - keptHooks.length;
+            eachGroup.hooks = keptHooks;
+        }
+        if (removedCount === 0) continue;
+        settings.hooks[STOP_EVENT_NAME] = stopGroups.filter(
+            (eachGroup) => !Array.isArray(eachGroup?.hooks) || eachGroup.hooks.length > 0,
+        );
+        if (settings.hooks[STOP_EVENT_NAME].length === 0) delete settings.hooks[STOP_EVENT_NAME];
+        if (Object.keys(settings.hooks).length === 0) delete settings.hooks;
+        writeFileSync(eachPath, JSON.stringify(settings, null, hostConfigurationIndent(settingsText, SETTINGS_INDENT)) + '\n');
+        allChangedPaths.push(eachPath);
+    }
+    return allChangedPaths;
+}

package/bin/profile-stop-gate.test.mjs

@@ -0,0 +1,160 @@
+import { test } from 'node:test';
+import { strict as assert } from 'node:assert';
+import { mkdirSync, mkdtempSync, readFileSync, rmSync, symlinkSync, writeFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+
+import {
+    addOpenTasksGateToProfiles,
+    otherProfileSettingsPaths,
+    removeOpenTasksGateFromProfiles,
+    splitUnreadableProfileSettings,
+    unparsedSettingsMayHoldGate,
+} from './profile-stop-gate.mjs';
+
+function makeHome(context) {
+    const homeDirectory = mkdtempSync(join(tmpdir(), 'cde-profile-gate-'));
+    context.after(() => rmSync(homeDirectory, { recursive: true, force: true }));
+    const claudeHome = join(homeDirectory, '.claude');
+    mkdirSync(claudeHome, { recursive: true });
+    const gateCommand = `python3 ${join(claudeHome, 'hooks', 'blocking', 'open_tasks_stop_gate.py').replace(/\\/g, '/')}`;
+    const mainSettingsPath = join(claudeHome, 'settings.json');
+    writeFileSync(mainSettingsPath, JSON.stringify({
+        hooks: { Stop: [{ hooks: [{ type: 'command', command: gateCommand, timeout: 10 }] }] },
+    }, null, 4));
+    return { homeDirectory, claudeHome, mainSettingsPath, gateCommand };
+}
+
+function writeProfile(homeDirectory, name, settings) {
+    const profileDirectory = join(homeDirectory, '.claude-profiles', name);
+    mkdirSync(profileDirectory, { recursive: true });
+    const settingsPath = join(profileDirectory, 'settings.json');
+    if (settings !== undefined) writeFileSync(settingsPath, JSON.stringify(settings, null, 4));
+    return settingsPath;
+}
+
+function stopCommands(settingsPath) {
+    const settings = JSON.parse(readFileSync(settingsPath, 'utf8'));
+    return (settings.hooks?.Stop ?? []).flatMap((eachGroup) => eachGroup.hooks.map((eachHook) => eachHook.command));
+}
+
+test('every profile with its own settings.json gets the main gate entry', (context) => {
+    const { homeDirectory, claudeHome, mainSettingsPath, gateCommand } = makeHome(context);
+    const ownHooksPath = writeProfile(homeDirectory, 'own-hooks', {
+        hooks: { Stop: [{ hooks: [{ type: 'command', command: 'python3 /opt/own/stop.py' }] }] },
+    });
+    const prefsOnlyPath = writeProfile(homeDirectory, 'prefs-only', { outputStyle: 'plain' });
+    writeProfile(homeDirectory, 'no-settings');
+
+    const allProfilePaths = otherProfileSettingsPaths({ homeDirectory, environment: {}, mainSettingsPath });
+    addOpenTasksGateToProfiles({ mainSettingsPath, claudeHome, allProfileSettingsPaths: allProfilePaths, homeDirectory });
+
+    assert.deepEqual(allProfilePaths.sort(), [ownHooksPath, prefsOnlyPath].sort());
+    assert.deepEqual(stopCommands(ownHooksPath), ['python3 /opt/own/stop.py', gateCommand]);
+    assert.deepEqual(stopCommands(prefsOnlyPath), [gateCommand]);
+    assert.equal(JSON.parse(readFileSync(prefsOnlyPath, 'utf8')).outputStyle, 'plain');
+});
+
+test('a profile whose settings.json links to the main settings is left out', (context) => {
+    const { homeDirectory, mainSettingsPath } = makeHome(context);
+    const linkedPath = writeProfile(homeDirectory, 'linked');
+    try {
+        symlinkSync(mainSettingsPath, linkedPath, 'file');
+    } catch (error) {
+        if (error.code === 'EPERM') return context.skip('this account cannot create symlinks');
+        throw error;
+    }
+
+    assert.deepEqual(otherProfileSettingsPaths({ homeDirectory, environment: {}, mainSettingsPath }), []);
+});
+
+test('a second run adds nothing, and an older interpreter spelling is replaced', (context) => {
+    const { homeDirectory, claudeHome, mainSettingsPath, gateCommand } = makeHome(context);
+    const staleCommand = gateCommand.replace(/^python3/, '/usr/bin/python3.9');
+    const profilePath = writeProfile(homeDirectory, 'stale', {
+        hooks: { Stop: [{ hooks: [{ type: 'command', command: staleCommand }] }] },
+    });
+    const options = { mainSettingsPath, claudeHome, allProfileSettingsPaths: [profilePath], homeDirectory };
+
+    addOpenTasksGateToProfiles(options);
+    const secondOutcome = addOpenTasksGateToProfiles(options);
+
+    assert.deepEqual(stopCommands(profilePath), [gateCommand]);
+    assert.deepEqual(secondOutcome[0].additions, []);
+});
+
+test('replacing an older spelling backs up the file as it was before the replacement', (context) => {
+    const { homeDirectory, claudeHome, mainSettingsPath, gateCommand } = makeHome(context);
+    const staleCommand = gateCommand.replace(/^python3/, '/usr/bin/python3.9');
+    const profilePath = writeProfile(homeDirectory, 'stale', {
+        hooks: { Stop: [{ hooks: [{ type: 'command', command: staleCommand }] }] },
+    });
+    const originalText = readFileSync(profilePath, 'utf8');
+
+    const [outcome] = addOpenTasksGateToProfiles({ mainSettingsPath, claudeHome, allProfileSettingsPaths: [profilePath], homeDirectory });
+
+    assert.equal(readFileSync(outcome.backupPath, 'utf8'), originalText);
+});
+
+test('removal takes out only the main gate entry and leaves the profile as it was', (context) => {
+    const { homeDirectory, claudeHome, mainSettingsPath } = makeHome(context);
+    const ownHooksPath = writeProfile(homeDirectory, 'own-hooks', {
+        hooks: { Stop: [{ hooks: [{ type: 'command', command: 'python3 /opt/own/stop.py' }] }] },
+    });
+    const prefsOnlyPath = writeProfile(homeDirectory, 'prefs-only', { outputStyle: 'plain' });
+    const allProfilePaths = [ownHooksPath, prefsOnlyPath];
+    addOpenTasksGateToProfiles({ mainSettingsPath, claudeHome, allProfileSettingsPaths: allProfilePaths, homeDirectory });
+
+    const allChangedPaths = removeOpenTasksGateFromProfiles({ claudeHome, allProfileSettingsPaths: allProfilePaths });
+
+    assert.deepEqual(allChangedPaths, allProfilePaths);
+    assert.deepEqual(stopCommands(ownHooksPath), ['python3 /opt/own/stop.py']);
+    assert.deepEqual(JSON.parse(readFileSync(prefsOnlyPath, 'utf8')), { outputStyle: 'plain' });
+});
+
+test('a profile that already runs its own copy of the gate script gets no second entry', (context) => {
+    const { homeDirectory, claudeHome, mainSettingsPath } = makeHome(context);
+    const ownGateCommand = `python3 ${join(homeDirectory, '.claude-profiles', 'isolated', 'hooks', 'blocking', 'open_tasks_stop_gate.py').replace(/\\/g, '/')}`;
+    const profilePath = writeProfile(homeDirectory, 'isolated', {
+        hooks: { Stop: [{ hooks: [{ type: 'command', command: ownGateCommand }] }] },
+    });
+
+    const allOutcomes = addOpenTasksGateToProfiles({ mainSettingsPath, claudeHome, allProfileSettingsPaths: [profilePath], homeDirectory });
+
+    assert.deepEqual(allOutcomes, []);
+    assert.deepEqual(stopCommands(profilePath), [ownGateCommand]);
+});
+
+test('a settings.json that is not valid JSON is reported with its parse error, and an empty one counts as readable', (context) => {
+    const { homeDirectory } = makeHome(context);
+    const goodPath = writeProfile(homeDirectory, 'good', { outputStyle: 'plain' });
+    const emptyPath = writeProfile(homeDirectory, 'empty');
+    writeFileSync(emptyPath, '');
+    const brokenPath = writeProfile(homeDirectory, 'broken');
+    writeFileSync(brokenPath, '{"hooks":{},}');
+
+    const { allReadablePaths, allUnreadable } = splitUnreadableProfileSettings([goodPath, emptyPath, brokenPath]);
+
+    assert.deepEqual(allReadablePaths, [goodPath, emptyPath]);
+    assert.equal(allUnreadable.length, 1);
+    assert.equal(allUnreadable[0].settingsPath, brokenPath);
+    assert.match(allUnreadable[0].reason, /JSON/);
+});
+
+test('a settings.json that does not parse may hold the gate when its text names this home\'s gate script, in either slash spelling', (context) => {
+    const { homeDirectory, claudeHome, gateCommand } = makeHome(context);
+    const forwardPath = writeProfile(homeDirectory, 'forward');
+    writeFileSync(forwardPath, `{"hooks":{"Stop":[{"hooks":[{"command":"${gateCommand}"}]}]},}`);
+    const escapedPath = writeProfile(homeDirectory, 'escaped');
+    writeFileSync(escapedPath, `{"hooks":{"Stop":[{"hooks":[{"command":"${gateCommand.replace(/\//g, '\\\\')}"}]}]},}`);
+    const otherHomePath = writeProfile(homeDirectory, 'other-home');
+    writeFileSync(otherHomePath, '{"hooks":{"Stop":[{"hooks":[{"command":"python3 /opt/other/.claude/hooks/blocking/open_tasks_stop_gate.py"}]}]},}');
+    const noGatePath = writeProfile(homeDirectory, 'no-gate');
+    writeFileSync(noGatePath, '{"hooks":{},}');
+
+    assert.equal(unparsedSettingsMayHoldGate(forwardPath, claudeHome), true);
+    assert.equal(unparsedSettingsMayHoldGate(escapedPath, claudeHome), true);
+    assert.equal(unparsedSettingsMayHoldGate(otherHomePath, claudeHome), false);
+    assert.equal(unparsedSettingsMayHoldGate(noGatePath, claudeHome), false);
+    assert.equal(unparsedSettingsMayHoldGate(join(homeDirectory, 'missing', 'settings.json'), claudeHome), true);
+});

package/docs/agents-guidance/asks.md

@@ -25,7 +25,7 @@ When the host keeps an asks ledger with `ledger.py` and `asks_check.py`, record
 
 The installer registers `open_tasks_stop_gate.py` as a Stop hook for each host:
 
-- Claude Code: `hooks.json`. A block returns the open items as the reason, and the session keeps working.
+- Claude Code: `hooks.json`. A block returns the open items as the reason, and the session keeps working. An install into `~/.claude` also adds the same Stop entry to every profile under `~/.claude-profiles` that has its own `settings.json` and does not already run its own copy of the gate. A profile whose `settings.json` links to `~/.claude/settings.json` already has it. Uninstall removes only that entry. On install, a profile `settings.json` that is not valid JSON is left unchanged and listed under Action needed with its path and parse error, and the rest of the install goes on. On uninstall, such a file that still names the gate stops the uninstall before anything changes, so the manifest stays and a rerun after the fix removes the gate; one that does not name the gate is left as it is.
 - Codex: `$CODEX_HOME/hooks.json`. Codex turns the reason into a continuation prompt.
 - Cursor: a native `stop` entry in `~/.cursor/hooks.json`. The reason comes back as `followup_message`, the next user message. A stop with status `aborted` or `error` passes, so a turn the user cancels stays silent.
 

package/docs/codex-accounts.md

@@ -142,8 +142,17 @@ package rules rewritten. The line names no model, so every Codex run uses the
 file, whichever model it selects. `sync` links `config.toml` into every account
 home, so every account gets the line.
 
+When `CODEX_HOME/config.toml` is the same file as `~/.codex/config.toml`, the
+copy goes in `~/.codex`. `sync` makes that file a symbolic link, or a hard link
+when the account cannot create symbolic links. Installing from an account home
+then names the shared copy in `~/.codex`, and deleting or uninstalling that
+account home leaves the other homes working. A `config.toml` that links
+anywhere else, such as a dotfiles folder, keeps the copy in `CODEX_HOME`.
+
 A `model_instructions_file` the user wrote at the top level keeps the config as
-it is. Uninstall removes only the package line.
+it is. Uninstall removes only the package line and the copy. Uninstalling from
+an account home that shares `~/.codex/config.toml` leaves both alone, because
+`~/.codex` still uses them.
 
 To see which prompt Codex uses, read the setting:
 

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "claude-dev-env",
-    "version": "8.88.2",
+    "version": "8.88.4",
     "description": "Claude Code development standards — rules, hooks, agents, commands, and skills",
     "type": "module",
     "bin": {