claude-dev-env 2.15.1 → 2.17.0

package/bin/install.mjs

@@ -20,7 +20,9 @@ import {
     SKIPPED_SOURCE_FILE_EXTENSIONS,
     RUN_BACKUP_DIRECTORY_NAME_PATTERN,
     MANAGED_SKILLS_DIRECTORY_NAME,
+    MANAGED_AGENTS_DIRECTORY_NAME,
     MANAGED_HOOKS_DIRECTORY_NAME,
+    MANAGED_SCRIPTS_DIRECTORY_NAME,
     SETTINGS_FILE_NAME,
     CODEX_RULES_PACKAGE_DIRECTORY_NAME,
     CURSOR_SYNC_SCRIPT_FILE_NAME,
@@ -31,6 +33,12 @@ import {
     parseExplicitTargetFromArgv,
     isAllowedInstallDestination,
 } from './resolve-install-root.mjs';
+import {
+    resolvePackageManagedDirectory,
+} from './resolve-package-managed-directory.mjs';
+import {
+    ensureDirectoryPointer,
+} from './publish-directory-pointer.mjs';
 import {
     parseInstallTargetSelectionFromArgv,
     resolveInstallTargets,
@@ -67,6 +75,7 @@ const INSTALL_ROOT_RESOLUTION = resolveInstallRoot({
     })(),
 });
 const CLAUDE_HOME = INSTALL_ROOT_RESOLUTION.managedRoot;
+const AGENTS_HOME = INSTALL_ROOT_RESOLUTION.agentsHome;
 const MANIFEST_FILE = INSTALL_ROOT_RESOLUTION.manifestFilePath;
 const MYPY_INI_INSTALL_PATH = INSTALL_ROOT_RESOLUTION.mypyIniInstallPath;
 const PACKAGE_NAME = 'claude-dev-env';
@@ -92,18 +101,22 @@ const INSTALL_TARGET_IDENTITY = (() => {
     }
 })();
 
-export const CONTENT_DIRECTORIES = ['rules', 'docs', 'commands', 'agents', 'system-prompts', 'scripts', '_shared', 'audit-rubrics'];
+export const CONTENT_DIRECTORIES = ['rules', 'docs', 'commands', 'system-prompts', '_shared', 'audit-rubrics'];
 
 /**
- * Every top-level directory under ~/.claude the installer writes into: the
- * content directories plus the two it fills through their own copy loops. The
- * uninstall purge walks this list to find the root a recorded file belongs to and
- * to drop a managed directory the purge empties, and the full-install stale-file
- * prune walks it to give each root its own diff.
+ * Every top-level lookup directory the installer writes into under ~/.claude:
+ * the content directories plus skills, agents, and hooks. Skills and agents
+ * live under the agents home; `~/.claude/skills` and `~/.claude/agents` are
+ * directory pointers to that home. The uninstall purge walks this list to find
+ * the root a recorded file belongs to and to drop a managed directory the purge
+ * empties, and the full-install stale-file prune walks it to give each root its
+ * own diff.
  */
 export const MANAGED_TOP_LEVEL_DIRECTORY_NAMES = [
     ...CONTENT_DIRECTORIES,
     MANAGED_SKILLS_DIRECTORY_NAME,
+    MANAGED_AGENTS_DIRECTORY_NAME,
+    MANAGED_SCRIPTS_DIRECTORY_NAME,
     MANAGED_HOOKS_DIRECTORY_NAME,
 ];
 
@@ -148,14 +161,14 @@ export const CORE_INCLUDE_DIRECTORIES = [
 ];
 
 export const CORE_SKILLS = [
-    'orchestrator', 'orchestrator-refresh', 'team-advisor', 'grokify',
+    'orchestrator', 'orchestrator-refresh', 'team-advisor',
     'grok-spawn',
-    'small-cl', 'comments', 'reviews', 'descriptions', 'emergencies',
-    'anthropic-plan', 'everything-search',
+    'small-cl',
+    'everything-search',
     'privacy-hygiene',
     'issue-tracker',
-    'recall', 'remember', 'task-build',
-    'show',
+    'task-build',
+    'eli5',
 ];
 
 export function collectPackageSourceConflicts(packageDirectory) {
@@ -249,7 +262,10 @@ function discoverDependencyGroups() {
             description: dependencyPackageJson.description || dependencyName,
             packageRoot: dependencyRoot,
         };
-        const skillsDirectory = join(dependencyRoot, MANAGED_SKILLS_DIRECTORY_NAME);
+        const skillsDirectory = resolvePackageManagedDirectory(
+            dependencyRoot,
+            MANAGED_SKILLS_DIRECTORY_NAME,
+        );
         if (existsSync(skillsDirectory)) {
             group.skills = readdirSync(skillsDirectory, { withFileTypes: true })
                 .filter(entry => entry.isDirectory())
@@ -752,13 +768,63 @@ function owningManagedRoot(installedFilePath) {
         const managedRoot = join(CLAUDE_HOME, directoryName);
         if (isInsideDirectory(resolvedPath, managedRoot)) return managedRoot;
     }
+    for (const directoryName of [
+        MANAGED_SKILLS_DIRECTORY_NAME,
+        MANAGED_AGENTS_DIRECTORY_NAME,
+        MANAGED_HOOKS_DIRECTORY_NAME,
+        MANAGED_SCRIPTS_DIRECTORY_NAME,
+    ]) {
+        const agentsRoot = join(AGENTS_HOME, directoryName);
+        if (isInsideDirectory(resolvedPath, agentsRoot)) return agentsRoot;
+    }
     const codexRulesDirectory = INSTALL_ROOT_RESOLUTION.codexRulesInstallDirectory;
     if (isInsideDirectory(resolvedPath, codexRulesDirectory)) return codexRulesDirectory;
+    const codexHooksDirectory = INSTALL_ROOT_RESOLUTION.codexHooksInstallDirectory;
+    if (isInsideDirectory(resolvedPath, codexHooksDirectory)) return codexHooksDirectory;
     const cursorInstallDirectory = INSTALL_ROOT_RESOLUTION.cursorInstallDirectory;
     if (isInsideDirectory(resolvedPath, cursorInstallDirectory)) return cursorInstallDirectory;
     return null;
 }
 
+/**
+ * Publish harness lookup paths as directory pointers to the agents home.
+ *
+ * Skills and agents live under `~/.agents` (or the per-root agents home).
+ * Claude Code discovers them at the lookup paths under the managed Claude root,
+ * so those two paths are pointers. A real directory from an older install at a
+ * lookup path is merged into the agents home before the pointer is written.
+ *
+ * @returns {string[]} The lookup paths this run published.
+ */
+function publishManagedLookupPointers() {
+    const pointerPairs = [
+        [
+            INSTALL_ROOT_RESOLUTION.skillsLookupDirectory,
+            INSTALL_ROOT_RESOLUTION.skillsInstallDirectory,
+        ],
+        [
+            INSTALL_ROOT_RESOLUTION.agentsLookupDirectory,
+            INSTALL_ROOT_RESOLUTION.agentsInstallDirectory,
+        ],
+        [
+            INSTALL_ROOT_RESOLUTION.hooksLookupDirectory,
+            INSTALL_ROOT_RESOLUTION.hooksInstallDirectory,
+        ],
+        [
+            INSTALL_ROOT_RESOLUTION.scriptsLookupDirectory,
+            INSTALL_ROOT_RESOLUTION.scriptsInstallDirectory,
+        ],
+        [
+            INSTALL_ROOT_RESOLUTION.codexHooksInstallDirectory,
+            INSTALL_ROOT_RESOLUTION.hooksInstallDirectory,
+        ],
+    ];
+    for (const [pointerPath, targetPath] of pointerPairs) {
+        ensureDirectoryPointer(pointerPath, targetPath);
+    }
+    return pointerPairs.map(([pointerPath]) => pointerPath);
+}
+
 /**
  * Report whether a path the prior manifest recorded is still a plain file this
  * run may move.
@@ -1046,7 +1112,6 @@ export const FOLDED_HOOK_RELATIVE_PATHS = new Set([
     'blocking/env_var_table_code_drift_blocker.py',
     'blocking/pytest_testpaths_orphan_blocker.py',
     'blocking/open_questions_in_plans_blocker.py',
-    'blocking/plain_language_blocker.py',
     'blocking/md_to_html_blocker.py',
 ]);
 
@@ -1554,7 +1619,11 @@ function loadClaudeSettingsObjectOrExit(settingsPath) {
  * @returns {number} Count of matcher groups merged.
  */
 function mergeHooks(hooksSourceRoot, pythonCommand) {
-    const hooksJsonPath = join(hooksSourceRoot, MANAGED_HOOKS_DIRECTORY_NAME, 'hooks.json');
+    const hooksSource = resolvePackageManagedDirectory(
+        hooksSourceRoot,
+        MANAGED_HOOKS_DIRECTORY_NAME,
+    );
+    const hooksJsonPath = join(hooksSource, 'hooks.json');
     if (!existsSync(hooksJsonPath)) return 0;
     const hooksConfig = JSON.parse(readFileSync(hooksJsonPath, 'utf8'));
     const settingsPath = join(CLAUDE_HOME, SETTINGS_FILE_NAME);
@@ -1974,6 +2043,7 @@ function executeInstallPlanMutations(plan, transactionHelpers) {
     console.log(`\nInstalling ${PACKAGE_NAME} (${groupLabel})...\n`);
     console.log(`  Python: ${pythonCommand}`);
     mkdirSync(CLAUDE_HOME, { recursive: true });
+    const publishedPointerPaths = publishManagedLookupPointers();
 
     const activeGroups = selectedGroups
         ? selectedGroups.map(groupName => ({ groupName, ...INSTALL_GROUPS[groupName] }))
@@ -2047,6 +2117,48 @@ function executeInstallPlanMutations(plan, transactionHelpers) {
             }
         }
     }
+    const shouldCopyAgents = !allowedDirectories
+        || allowedDirectories.has(MANAGED_AGENTS_DIRECTORY_NAME);
+    if (shouldCopyAgents) {
+        for (const sourceRoot of allSourceRoots) {
+            const agentsSource = resolvePackageManagedDirectory(
+                sourceRoot,
+                MANAGED_AGENTS_DIRECTORY_NAME,
+            );
+            if (!existsSync(agentsSource)) continue;
+            const agentsDestination = INSTALL_ROOT_RESOLUTION.agentsLookupDirectory;
+            const stats = copyTree(agentsSource, agentsDestination);
+            if (!summary[MANAGED_AGENTS_DIRECTORY_NAME]) {
+                summary[MANAGED_AGENTS_DIRECTORY_NAME] = stats;
+            } else {
+                summary[MANAGED_AGENTS_DIRECTORY_NAME].created += stats.created;
+                summary[MANAGED_AGENTS_DIRECTORY_NAME].updated += stats.updated;
+                summary[MANAGED_AGENTS_DIRECTORY_NAME].paths.push(...stats.paths);
+            }
+            allInstalledFiles.push(...stats.paths);
+        }
+    }
+    const shouldCopyScripts = !allowedDirectories
+        || allowedDirectories.has(MANAGED_SCRIPTS_DIRECTORY_NAME);
+    if (shouldCopyScripts) {
+        for (const sourceRoot of allSourceRoots) {
+            const scriptsSource = resolvePackageManagedDirectory(
+                sourceRoot,
+                MANAGED_SCRIPTS_DIRECTORY_NAME,
+            );
+            if (!existsSync(scriptsSource)) continue;
+            const scriptsDestination = INSTALL_ROOT_RESOLUTION.scriptsLookupDirectory;
+            const stats = copyTree(scriptsSource, scriptsDestination);
+            if (!summary[MANAGED_SCRIPTS_DIRECTORY_NAME]) {
+                summary[MANAGED_SCRIPTS_DIRECTORY_NAME] = stats;
+            } else {
+                summary[MANAGED_SCRIPTS_DIRECTORY_NAME].created += stats.created;
+                summary[MANAGED_SCRIPTS_DIRECTORY_NAME].updated += stats.updated;
+                summary[MANAGED_SCRIPTS_DIRECTORY_NAME].paths.push(...stats.paths);
+            }
+            allInstalledFiles.push(...stats.paths);
+        }
+    }
     const shouldInstallCodexRules = !selectedGroups
         || activeGroups.some((eachGroup) => eachGroup.includeCodexRules);
     if (shouldInstallCodexRules) {
@@ -2077,7 +2189,10 @@ function executeInstallPlanMutations(plan, transactionHelpers) {
     const installedSkillNames = new Set();
     const copiedSkillNames = new Set();
     for (const sourceRoot of allSourceRoots) {
-        const skillsSource = join(sourceRoot, MANAGED_SKILLS_DIRECTORY_NAME);
+        const skillsSource = resolvePackageManagedDirectory(
+            sourceRoot,
+            MANAGED_SKILLS_DIRECTORY_NAME,
+        );
         if (!existsSync(skillsSource)) continue;
         const skillDirs = readdirSync(skillsSource, { withFileTypes: true }).filter(entry => entry.isDirectory());
         for (const skillDir of skillDirs) {
@@ -2096,7 +2211,7 @@ function executeInstallPlanMutations(plan, transactionHelpers) {
     }
     summary.skills = { created: skillsCreated, updated: skillsUpdated, pruned: 0, paths: skillPaths };
     allInstalledFiles.push(...skillPaths);
-    syncWrittenPaths(allInstalledFiles);
+    syncWrittenPaths([...allInstalledFiles, ...publishedPointerPaths]);
     throwIfFault(FAULT_PHASES.AFTER_FILE_STAGING);
     throwIfFault(FAULT_PHASES.BEFORE_DURABLE_PROMOTION);
     const shouldInstallAnyHooks = shouldInstallAllHooks || (allowedHookFiles && allowedHookFiles.size > 0);
@@ -2105,7 +2220,10 @@ function executeInstallPlanMutations(plan, transactionHelpers) {
         let totalHooksUpdated = 0;
         let totalHookGroups = 0;
         for (const sourceRoot of allSourceRoots) {
-            const hooksSource = join(sourceRoot, MANAGED_HOOKS_DIRECTORY_NAME);
+            const hooksSource = resolvePackageManagedDirectory(
+                sourceRoot,
+                MANAGED_HOOKS_DIRECTORY_NAME,
+            );
             if (!existsSync(hooksSource)) continue;
             const hooksDestination = join(CLAUDE_HOME, MANAGED_HOOKS_DIRECTORY_NAME);
             const filesToCopy = collectFiles(hooksSource)
@@ -2131,7 +2249,7 @@ function executeInstallPlanMutations(plan, transactionHelpers) {
         console.log(`  Hook files: ${totalHooksCreated} new, ${totalHooksUpdated} updated`);
         summary.hookGroups = totalHookGroups;
         console.log(`  Hook groups: ${totalHookGroups} merged into settings.json`);
-        syncWrittenPaths(allInstalledFiles);
+        syncWrittenPaths([...allInstalledFiles, ...publishedPointerPaths]);
         throwIfFault(FAULT_PHASES.AFTER_SETTINGS_WRITE);
 
         console.warn(
@@ -2153,7 +2271,7 @@ function executeInstallPlanMutations(plan, transactionHelpers) {
             console.warn(`  Git hooks: ${gitHookInstallationResult.hooksPathConfigurationResult.reason}`);
         }
         console.log(`  Git hook shims: ${gitHookInstallationResult.createdShimPaths.length} files (pre-commit, pre-push, post-commit)`);
-        syncWrittenPaths(allInstalledFiles);
+        syncWrittenPaths([...allInstalledFiles, ...publishedPointerPaths]);
         throwIfFault(FAULT_PHASES.AFTER_GIT_CONFIG);
         throwIfFault(FAULT_PHASES.AFTER_LINK_PUBLICATION);
 
@@ -2173,7 +2291,7 @@ function executeInstallPlanMutations(plan, transactionHelpers) {
             console.warn(`      ${mypyIniInstallResult.expectedLine}`);
         }
     } else {
-        syncWrittenPaths(allInstalledFiles);
+        syncWrittenPaths([...allInstalledFiles, ...publishedPointerPaths]);
         throwIfFault(FAULT_PHASES.AFTER_SETTINGS_WRITE);
         throwIfFault(FAULT_PHASES.AFTER_GIT_CONFIG);
         throwIfFault(FAULT_PHASES.AFTER_LINK_PUBLICATION);
@@ -2192,7 +2310,7 @@ function executeInstallPlanMutations(plan, transactionHelpers) {
         );
     }
 
-    const claudeHubSource = join(PACKAGE_ROOT, 'CLAUDE.md');
+    const claudeHubSource = join(PACKAGE_ROOT, '.claude', 'CLAUDE.md');
     if (existsSync(claudeHubSource)) {
         const claudeHubDest = join(CLAUDE_HOME, 'CLAUDE.md');
         const backupPath = backupHubBeforeOverwrite(claudeHubDest, claudeHubSource, 'CLAUDE.md');
@@ -2258,7 +2376,7 @@ function executeInstallPlanMutations(plan, transactionHelpers) {
             ? { deny: managedPermissionDenyEntries }
             : null,
     );
-    syncWrittenPaths([...allInstalledFiles, MANIFEST_FILE, plan.settingsPath]);
+    syncWrittenPaths([...allInstalledFiles, MANIFEST_FILE, plan.settingsPath, ...publishedPointerPaths]);
     throwIfFault(FAULT_PHASES.AFTER_MANIFEST_WRITE);
     console.log(`\nInstalled ${PACKAGE_NAME}:`);
     for (const directory of CONTENT_DIRECTORIES) {
@@ -2275,6 +2393,14 @@ function executeInstallPlanMutations(plan, transactionHelpers) {
         const { created } = summary.cursorRules;
         console.log(`  cursor-rules: ${created} generated files`);
     }
+    if (summary[MANAGED_AGENTS_DIRECTORY_NAME]) {
+        const { created, updated } = summary[MANAGED_AGENTS_DIRECTORY_NAME];
+        console.log(`  ${MANAGED_AGENTS_DIRECTORY_NAME}: ${created + updated} files (${created} new, ${updated} updated)`);
+    }
+    if (summary[MANAGED_SCRIPTS_DIRECTORY_NAME]) {
+        const { created, updated } = summary[MANAGED_SCRIPTS_DIRECTORY_NAME];
+        console.log(`  ${MANAGED_SCRIPTS_DIRECTORY_NAME}: ${created + updated} files (${created} new, ${updated} updated)`);
+    }
     if (summary.skills) {
         const { created, updated, pruned } = summary.skills;
         const staleClause = pruned > 0 ? `, ${pruned} stale moved aside` : '';
@@ -2405,7 +2531,7 @@ 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}, outside ${MYPY_INI_INSTALL_PATH}, outside ${INSTALL_ROOT_RESOLUTION.codexRulesInstallDirectory}, and outside ${INSTALL_ROOT_RESOLUTION.cursorInstallDirectory}`,
+            `  ${plan.skippedFiles.length} manifest record(s) skipped — each names a path outside ${CLAUDE_HOME}, outside ${MYPY_INI_INSTALL_PATH}, outside ${INSTALL_ROOT_RESOLUTION.codexRulesInstallDirectory}, outside ${INSTALL_ROOT_RESOLUTION.cursorInstallDirectory}, and outside ${AGENTS_HOME}`,
         );
     }
     throwIfFault(FAULT_PHASES.AFTER_FILE_STAGING);
@@ -2453,6 +2579,9 @@ function executeUninstallPlan(plan, helpers = {}) {
             }
         } catch { /* leave non-empty dirs */ }
     }
+    removeEmptyDirectoryTree(INSTALL_ROOT_RESOLUTION.skillsInstallDirectory);
+    removeEmptyDirectoryTree(INSTALL_ROOT_RESOLUTION.agentsInstallDirectory);
+    removeEmptyDirectoryTree(AGENTS_HOME);
     console.log(`\nRemoved ${removed} files.\n`);
     return removed;
 }
@@ -2571,6 +2700,7 @@ Examples:
   npx ${PACKAGE_NAME} --profiles editor,mel --only core
 
 Install location: ~/.claude/ by default; CLAUDE_CONFIG_DIR or --target selects another managed root.
+Skills and agents live under ~/.agents (sibling of ~/.claude). ~/.claude/skills and ~/.claude/agents are directory pointers to that home.
 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.

package/bin/install.plan.test.mjs

@@ -180,6 +180,7 @@ test('update plan marks purge and lists E2 mutation kinds; journal omits hooks',
         assert.equal(plan.shouldPurgeBeforeReinstall, true);
         const allMutations = describeInstallMutations(plan);
         assert.ok(allMutations.includes('purge_managed_installation'));
+        assert.ok(allMutations.includes('publish_directory_pointers'));
         assert.ok(allMutations.includes('merge_hooks_settings'));
         assert.ok(allMutations.includes('write_manifest'));
         assert.ok(Object.isFrozen(allMutations));

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

@@ -11,11 +11,13 @@ import { fileURLToPath } from 'node:url';
 import { CODEX_RULES_SHIPPED_FILE_NAME } from './install-constants.mjs';
 import {
     resolveInstallRoot,
+    resolveAgentsHome,
     isPathWithinManagedRoot,
     isAllowedInstallDestination,
     parseExplicitTargetFromArgv,
     CLAUDE_CONFIG_DIR_ENVIRONMENT_VARIABLE,
     DEFAULT_CLAUDE_DIRECTORY_NAME,
+    DEFAULT_AGENTS_DIRECTORY_NAME,
 } from './resolve-install-root.mjs';
 
 const BIN_DIRECTORY = fileURLToPath(new URL('.', import.meta.url));
@@ -30,6 +32,23 @@ test('default target remains join(homeDirectory, .claude)', () => {
     });
     assert.equal(resolution.managedRoot, resolve(join(homeDirectory, DEFAULT_CLAUDE_DIRECTORY_NAME)));
     assert.equal(resolution.source, 'default-home');
+    assert.equal(resolution.agentsHome, resolve(join(homeDirectory, DEFAULT_AGENTS_DIRECTORY_NAME)));
+    assert.equal(
+        resolution.skillsInstallDirectory,
+        join(resolution.agentsHome, 'skills'),
+    );
+    assert.equal(
+        resolution.skillsLookupDirectory,
+        join(resolution.managedRoot, 'skills'),
+    );
+    assert.equal(
+        resolution.agentsInstallDirectory,
+        join(resolution.agentsHome, 'agents'),
+    );
+    assert.equal(
+        resolution.agentsLookupDirectory,
+        join(resolution.managedRoot, 'agents'),
+    );
 });
 
 test('CLAUDE_CONFIG_DIR selects the profile root over the home default', () => {
@@ -63,7 +82,7 @@ test('explicit target has precedence over CLAUDE_CONFIG_DIR and the home default
 
 test('isPathWithinManagedRoot requires a separator boundary', () => {
     const managedRoot = resolve(join(tmpdir(), 'containment-root', '.claude'));
-    const insideFile = join(managedRoot, 'rules', 'plain-language.md');
+    const insideFile = join(managedRoot, 'rules', 'asd-ste100-language.md');
     const evilSibling = `${managedRoot}-evil`;
     const evilChild = join(`${managedRoot}-evil`, 'rules', 'x.md');
 
@@ -98,6 +117,20 @@ test('declared external mypy.ini is allowed; unrelated external paths are not',
         ),
         true,
     );
+    assert.equal(
+        isAllowedInstallDestination(
+            join(resolution.skillsInstallDirectory, 'privacy-hygiene', 'SKILL.md'),
+            resolution,
+        ),
+        true,
+    );
+    assert.equal(
+        isAllowedInstallDestination(
+            join(resolution.agentsInstallDirectory, 'clean-coder.md'),
+            resolution,
+        ),
+        true,
+    );
 });
 
 test('parseExplicitTargetFromArgv reads --target and --target=', () => {
@@ -143,7 +176,27 @@ test('installer destinations for disposable main, profile-a, and profile-b stay
                 isAllowedInstallDestination(resolution.mypyIniInstallPath, resolution),
                 true,
             );
+            assert.equal(
+                isAllowedInstallDestination(
+                    join(resolution.skillsInstallDirectory, 'fixture-skill', 'SKILL.md'),
+                    resolution,
+                ),
+                true,
+                `${eachProfileId}: skills install directory is an allowed destination`,
+            );
+            assert.equal(
+                resolution.agentsHome,
+                resolveAgentsHome(profileRoot),
+            );
+            assert.notEqual(
+                resolution.agentsHome,
+                resolve(join(homeDirectory, DEFAULT_AGENTS_DIRECTORY_NAME)),
+                `${eachProfileId}: a profile root keeps its own agents home`,
+            );
         }
+        const profileAHome = resolveAgentsHome(join(runRoot, 'profile-a'));
+        const profileBHome = resolveAgentsHome(join(runRoot, 'profile-b'));
+        assert.notEqual(profileAHome, profileBHome);
     } finally {
         rmSync(runRoot, { recursive: true, force: true });
     }