claude-dev-env 2.9.0 → 2.10.0

package/bin/install.plan.test.mjs

@@ -0,0 +1,194 @@
+/**
+ * Read-only installation plan and preflight contract (control-plane E1 / P-17).
+ */
+
+import { test } from 'node:test';
+import { strict as assert } from 'node:assert';
+import {
+    mkdtempSync,
+    rmSync,
+    mkdirSync,
+    writeFileSync,
+    readFileSync,
+    existsSync,
+    readdirSync,
+    statSync,
+} from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import {
+    buildInstallPlan,
+    InstallPlanPreflightError,
+    PREFLIGHT_ERROR_CODES,
+    planShouldInstallHooks,
+    describeInstallMutations,
+    readPriorManifestArraysFromPath,
+} from './install-plan.mjs';
+
+const GROUPS = {
+    core: { skills: ['a'], includeDirectories: ['rules'], includeAllHooks: true },
+    journal: { skills: ['session-log'] },
+};
+
+function sandbox() {
+    const root = mkdtempSync(join(tmpdir(), 'cdev-install-plan-'));
+    const managedRoot = join(root, 'managed');
+    const packageRoot = join(root, 'package');
+    mkdirSync(managedRoot, { recursive: true });
+    mkdirSync(packageRoot, { recursive: true });
+    return { root, managedRoot, packageRoot };
+}
+
+function treeStamp(directoryPath) {
+    if (!existsSync(directoryPath)) {
+        return '';
+    }
+    const allParts = [];
+    function walk(currentPath) {
+        const stats = statSync(currentPath);
+        if (stats.isDirectory()) {
+            for (const eachName of readdirSync(currentPath).sort()) {
+                walk(join(currentPath, eachName));
+            }
+            return;
+        }
+        allParts.push(`${currentPath}:${stats.size}:${stats.mtimeMs}`);
+    }
+    walk(directoryPath);
+    return allParts.join('|');
+}
+
+function planInput(packageRoot, managedRoot, overrides = {}) {
+    return {
+        packageRoot,
+        managedRoot,
+        manifestFilePath: join(managedRoot, '.claude-dev-env-manifest.json'),
+        targetIdentity: 'main',
+        selectedGroups: null,
+        isUpdateRefresh: false,
+        installGroups: GROUPS,
+        collectSourceConflicts: () => [],
+        detectPythonCommand: () => 'python3',
+        ...overrides,
+    };
+}
+
+test('planShouldInstallHooks covers full, core, and journal', () => {
+    assert.equal(planShouldInstallHooks(null, GROUPS), true);
+    assert.equal(planShouldInstallHooks(['core'], GROUPS), true);
+    assert.equal(planShouldInstallHooks(['journal'], GROUPS), false);
+});
+
+test('buildInstallPlan is zero-write and freezes a success plan', () => {
+    const { root, managedRoot, packageRoot } = sandbox();
+    try {
+        writeFileSync(join(managedRoot, 'settings.json'), '{"hooks":{}}\n');
+        writeFileSync(
+            join(managedRoot, '.claude-dev-env-manifest.json'),
+            JSON.stringify({ files: ['a'], skills: ['a'] }) + '\n',
+        );
+        const before = treeStamp(managedRoot) + '//' + treeStamp(packageRoot);
+        const plan = buildInstallPlan(planInput(packageRoot, managedRoot));
+        assert.equal(plan.pythonCommand, 'python3');
+        assert.equal(plan.shouldInstallHooks, true);
+        assert.equal(plan.shouldPurgeBeforeReinstall, false);
+        assert.deepEqual(plan.priorManifest.skills, ['a']);
+        assert.ok(Object.isFrozen(plan));
+        assert.equal(treeStamp(managedRoot) + '//' + treeStamp(packageRoot), before);
+    } finally {
+        rmSync(root, { recursive: true, force: true });
+    }
+});
+
+test('preflight fails closed without writing for conflicts, python, and bad root', () => {
+    const { root, managedRoot, packageRoot } = sandbox();
+    try {
+        writeFileSync(join(managedRoot, 'marker.txt'), 'keep\n');
+        const before = treeStamp(managedRoot);
+        assert.throws(
+            () => buildInstallPlan(planInput(packageRoot, managedRoot, {
+                isUpdateRefresh: true,
+                collectSourceConflicts: () => [{ statusCode: 'UU', path: 'x.md' }],
+            })),
+            (error) => error instanceof InstallPlanPreflightError
+                && error.code === PREFLIGHT_ERROR_CODES.SOURCE_CONFLICTS,
+        );
+        assert.throws(
+            () => buildInstallPlan(planInput(packageRoot, managedRoot, {
+                detectPythonCommand: () => null,
+            })),
+            (error) => error instanceof InstallPlanPreflightError
+                && error.code === PREFLIGHT_ERROR_CODES.MISSING_PYTHON,
+        );
+        assert.equal(treeStamp(managedRoot), before);
+        assert.equal(readFileSync(join(managedRoot, 'marker.txt'), 'utf8'), 'keep\n');
+        const fileAsRoot = join(root, 'file-root');
+        writeFileSync(fileAsRoot, 'x\n');
+        assert.throws(
+            () => buildInstallPlan(planInput(packageRoot, fileAsRoot)),
+            (error) => error.code === PREFLIGHT_ERROR_CODES.INVALID_MANAGED_ROOT,
+        );
+        assert.throws(
+            () => buildInstallPlan(planInput(packageRoot, '')),
+            (error) => error.code === PREFLIGHT_ERROR_CODES.INVALID_MANAGED_ROOT,
+        );
+    } finally {
+        rmSync(root, { recursive: true, force: true });
+    }
+});
+
+test('settings preflight is hooks-gated; broken manifest stays tolerant', () => {
+    const { root, managedRoot, packageRoot } = sandbox();
+    try {
+        writeFileSync(join(managedRoot, 'settings.json'), '{not-json');
+        assert.throws(
+            () => buildInstallPlan(planInput(packageRoot, managedRoot, { selectedGroups: ['core'] })),
+            (error) => error.code === PREFLIGHT_ERROR_CODES.MALFORMED_SETTINGS,
+        );
+        assert.equal(
+            buildInstallPlan(planInput(packageRoot, managedRoot, { selectedGroups: ['journal'] }))
+                .shouldInstallHooks,
+            false,
+        );
+        const manifestFilePath = join(managedRoot, '.claude-dev-env-manifest.json');
+        writeFileSync(manifestFilePath, '{broken');
+        const plan = buildInstallPlan(planInput(packageRoot, managedRoot, {
+            selectedGroups: ['journal'],
+            manifestFilePath,
+        }));
+        assert.deepEqual(plan.priorManifest, { files: null, skills: null });
+        assert.deepEqual(readPriorManifestArraysFromPath(manifestFilePath), {
+            files: null,
+            skills: null,
+        });
+    } finally {
+        rmSync(root, { recursive: true, force: true });
+    }
+});
+
+test('update plan marks purge and lists E2 mutation kinds; journal omits hooks', () => {
+    const { root, managedRoot, packageRoot } = sandbox();
+    try {
+        const manifestFilePath = join(managedRoot, '.claude-dev-env-manifest.json');
+        writeFileSync(manifestFilePath, JSON.stringify({ files: ['a'], skills: [] }) + '\n');
+        writeFileSync(join(managedRoot, 'settings.json'), '{}\n');
+        const plan = buildInstallPlan(planInput(packageRoot, managedRoot, {
+            manifestFilePath,
+            targetIdentity: 'profile-a',
+            isUpdateRefresh: true,
+        }));
+        assert.equal(plan.shouldPurgeBeforeReinstall, true);
+        const allMutations = describeInstallMutations(plan);
+        assert.ok(allMutations.includes('purge_managed_installation'));
+        assert.ok(allMutations.includes('merge_hooks_settings'));
+        assert.ok(allMutations.includes('write_manifest'));
+        assert.ok(Object.isFrozen(allMutations));
+        const journalMutations = describeInstallMutations(
+            buildInstallPlan(planInput(packageRoot, managedRoot, { selectedGroups: ['journal'] })),
+        );
+        assert.ok(!journalMutations.includes('merge_hooks_settings'));
+        assert.ok(journalMutations.includes('copy_content_trees'));
+    } finally {
+        rmSync(root, { recursive: true, force: true });
+    }
+});

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

@@ -0,0 +1,154 @@
+/**
+ * Install-root resolver contract tests (control-plane A2 / P-11).
+ */
+
+import { test } from 'node:test';
+import { strict as assert } from 'node:assert';
+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 {
+    resolveInstallRoot,
+    isPathWithinManagedRoot,
+    isAllowedInstallDestination,
+    parseExplicitTargetFromArgv,
+    CLAUDE_CONFIG_DIR_ENVIRONMENT_VARIABLE,
+    DEFAULT_CLAUDE_DIRECTORY_NAME,
+} from './resolve-install-root.mjs';
+
+const BIN_DIRECTORY = fileURLToPath(new URL('.', import.meta.url));
+const INSTALL_MODULE_PATH = join(BIN_DIRECTORY, 'install.mjs');
+
+test('default target remains join(homeDirectory, .claude)', () => {
+    const homeDirectory = resolve(join(tmpdir(), 'a2-home-default'));
+    const resolution = resolveInstallRoot({
+        homeDirectory,
+        environment: {},
+        explicitTarget: null,
+    });
+    assert.equal(resolution.managedRoot, resolve(join(homeDirectory, DEFAULT_CLAUDE_DIRECTORY_NAME)));
+    assert.equal(resolution.source, 'default-home');
+});
+
+test('CLAUDE_CONFIG_DIR selects the profile root over the home default', () => {
+    const homeDirectory = resolve(join(tmpdir(), 'a2-home-config'));
+    const profileRoot = resolve(join(tmpdir(), 'a2-profile-a'));
+    const resolution = resolveInstallRoot({
+        homeDirectory,
+        environment: { [CLAUDE_CONFIG_DIR_ENVIRONMENT_VARIABLE]: profileRoot },
+        explicitTarget: null,
+    });
+    assert.equal(resolution.managedRoot, profileRoot);
+    assert.equal(resolution.source, 'claude-config-dir');
+    assert.notEqual(
+        resolution.managedRoot,
+        resolve(join(homeDirectory, DEFAULT_CLAUDE_DIRECTORY_NAME)),
+    );
+});
+
+test('explicit target has precedence over CLAUDE_CONFIG_DIR and the home default', () => {
+    const homeDirectory = resolve(join(tmpdir(), 'a2-home-explicit'));
+    const profileRoot = resolve(join(tmpdir(), 'a2-profile-b'));
+    const explicitTarget = resolve(join(tmpdir(), 'a2-explicit-target'));
+    const resolution = resolveInstallRoot({
+        homeDirectory,
+        environment: { [CLAUDE_CONFIG_DIR_ENVIRONMENT_VARIABLE]: profileRoot },
+        explicitTarget,
+    });
+    assert.equal(resolution.managedRoot, explicitTarget);
+    assert.equal(resolution.source, 'explicit-target');
+});
+
+test('isPathWithinManagedRoot requires a separator boundary', () => {
+    const managedRoot = resolve(join(tmpdir(), 'containment-root', '.claude'));
+    const insideFile = join(managedRoot, 'rules', 'plain-language.md');
+    const evilSibling = `${managedRoot}-evil`;
+    const evilChild = join(`${managedRoot}-evil`, 'rules', 'x.md');
+
+    assert.equal(isPathWithinManagedRoot(managedRoot, managedRoot), true);
+    assert.equal(isPathWithinManagedRoot(insideFile, managedRoot), true);
+    assert.equal(isPathWithinManagedRoot(evilSibling, managedRoot), false);
+    assert.equal(isPathWithinManagedRoot(evilChild, managedRoot), false);
+});
+
+test('declared external mypy.ini is allowed; unrelated external paths are not', () => {
+    const homeDirectory = resolve(join(tmpdir(), 'a2-home-external'));
+    const resolution = resolveInstallRoot({
+        homeDirectory,
+        environment: {},
+    });
+    assert.equal(
+        isAllowedInstallDestination(resolution.mypyIniInstallPath, resolution),
+        true,
+    );
+    assert.equal(
+        isAllowedInstallDestination(join(homeDirectory, '.ssh', 'id_rsa'), resolution),
+        false,
+    );
+    assert.equal(
+        isAllowedInstallDestination(join(resolution.managedRoot, 'hooks', 'x.py'), resolution),
+        true,
+    );
+});
+
+test('parseExplicitTargetFromArgv reads --target and --target=', () => {
+    assert.equal(parseExplicitTargetFromArgv(['--only', 'core']), null);
+    assert.equal(parseExplicitTargetFromArgv(['--target', 'C:\\tmp\\root']), 'C:\\tmp\\root');
+    assert.equal(parseExplicitTargetFromArgv(['--target=C:\\tmp\\root2']), 'C:\\tmp\\root2');
+    assert.throws(
+        () => parseExplicitTargetFromArgv(['--target']),
+        /--target requires a path argument/,
+    );
+});
+
+test('installer destinations for disposable main, profile-a, and profile-b stay inside the managed root', () => {
+    const runRoot = mkdtempSync(join(tmpdir(), 'a2-disposable-'));
+    try {
+        for (const eachProfileId of ['main', 'profile-a', 'profile-b']) {
+            const profileRoot = join(runRoot, eachProfileId);
+            mkdirSync(profileRoot, { recursive: true });
+            const homeDirectory = join(runRoot, `${eachProfileId}-home`);
+            mkdirSync(homeDirectory, { recursive: true });
+
+            const resolution = resolveInstallRoot({
+                homeDirectory,
+                environment: { [CLAUDE_CONFIG_DIR_ENVIRONMENT_VARIABLE]: profileRoot },
+            });
+            assert.equal(resolution.managedRoot, resolve(profileRoot));
+            assert.equal(resolution.source, 'claude-config-dir');
+
+            const allManagedWritePaths = [
+                join(resolution.managedRoot, 'rules', 'sample.md'),
+                join(resolution.managedRoot, 'hooks', 'blocking', 'x.py'),
+                join(resolution.managedRoot, 'CLAUDE.md'),
+                resolution.manifestFilePath,
+            ];
+            for (const eachWritePath of allManagedWritePaths) {
+                assert.equal(
+                    isAllowedInstallDestination(eachWritePath, resolution),
+                    true,
+                    `${eachProfileId}: ${eachWritePath}`,
+                );
+            }
+            assert.equal(
+                isAllowedInstallDestination(resolution.mypyIniInstallPath, resolution),
+                true,
+            );
+        }
+    } finally {
+        rmSync(runRoot, { recursive: true, force: true });
+    }
+});
+
+test('install.mjs module resolves CLAUDE_HOME through the shared resolver (import smoke)', async () => {
+    // Guard: the install module must import resolve-install-root so destinations
+    // cannot bypass the resolver by re-hardcoding join(homedir(), '.claude').
+    const source = readFileSync(INSTALL_MODULE_PATH, 'utf8');
+    assert.match(source, /resolve-install-root\.mjs/);
+    assert.match(source, /resolveInstallRoot/);
+    assert.ok(
+        !/const CLAUDE_HOME = join\(homedir\(\), ['"]\.claude['"]\)/.test(source),
+        'install.mjs must not hardcode CLAUDE_HOME = join(homedir(), \'.claude\')',
+    );
+});

package/bin/install.profiles.test.mjs

@@ -0,0 +1,253 @@
+/**
+ * Profile target-selection and per-target manifest contract (control-plane A3 / P-12).
+ */
+
+import { test } from 'node:test';
+import { strict as assert } from 'node:assert';
+import { join, resolve } from 'node:path';
+import {
+    mkdtempSync,
+    rmSync,
+    mkdirSync,
+    writeFileSync,
+    readFileSync,
+    existsSync,
+} from 'node:fs';
+import { tmpdir } from 'node:os';
+import { fileURLToPath } from 'node:url';
+import { spawnSync } from 'node:child_process';
+import {
+    parseInstallTargetSelectionFromArgv,
+    resolveInstallTargets,
+    buildTargetManifestRecord,
+    stripTargetSelectionFlagsFromArgv,
+    resolveProfilesRootDirectory,
+    assertSafeProfileDirectoryName,
+    MAIN_DEFAULT_TARGET_IDENTITY,
+    DEFAULT_PROFILES_ROOT_DIRECTORY_NAME,
+} from './select-install-targets.mjs';
+import { MANIFEST_FILE_NAME } from './resolve-install-root.mjs';
+
+const BIN_DIRECTORY = fileURLToPath(new URL('.', import.meta.url));
+const INSTALL_MODULE_PATH = join(BIN_DIRECTORY, 'install.mjs');
+
+const DIRECTORY_NAME_BY_PROFILE_ID = {
+    editor: 'editor',
+    mel: 'mel',
+    ev: 'ev',
+    master: 'master',
+    kimi: 'kimi',
+};
+
+test('main-default selection resolves a single main target under home/.claude', () => {
+    const homeDirectory = resolve(join(tmpdir(), 'a3-home-main'));
+    const selection = parseInstallTargetSelectionFromArgv([]);
+    assert.equal(selection.mode, 'main-default');
+    const allTargets = resolveInstallTargets(selection, {
+        homeDirectory,
+        environment: {},
+        directoryNameByProfileId: DIRECTORY_NAME_BY_PROFILE_ID,
+    });
+    assert.equal(allTargets.length, 1);
+    assert.equal(allTargets[0].targetIdentity, MAIN_DEFAULT_TARGET_IDENTITY);
+    assert.equal(allTargets[0].managedRoot, resolve(join(homeDirectory, '.claude')));
+    assert.equal(allTargets[0].source, 'default-home');
+});
+
+test('explicit --target is single-path mode and rejects combined --profile', () => {
+    const selection = parseInstallTargetSelectionFromArgv(['--target', 'C:\\tmp\\a3-root']);
+    assert.equal(selection.mode, 'explicit-path');
+    assert.equal(selection.explicitTarget, 'C:\\tmp\\a3-root');
+    assert.throws(
+        () => parseInstallTargetSelectionFromArgv(['--target', 'C:\\tmp\\x', '--profile', 'editor']),
+        /ambiguous targets/,
+    );
+});
+
+test('selected multi-profile resolves one managed root per id under profiles root', () => {
+    const homeDirectory = resolve(join(tmpdir(), 'a3-home-multi'));
+    const profilesRoot = resolve(join(tmpdir(), 'a3-profiles-root'));
+    const selection = parseInstallTargetSelectionFromArgv(['--profiles', 'editor,mel']);
+    assert.equal(selection.mode, 'profiles');
+    assert.deepEqual(selection.allProfileIds, ['editor', 'mel']);
+    const allTargets = resolveInstallTargets(selection, {
+        homeDirectory,
+        environment: {},
+        profilesRoot,
+        directoryNameByProfileId: DIRECTORY_NAME_BY_PROFILE_ID,
+    });
+    assert.equal(allTargets.length, 2);
+    assert.equal(allTargets[0].targetIdentity, 'editor');
+    assert.equal(allTargets[0].managedRoot, resolve(join(profilesRoot, 'editor')));
+    assert.equal(allTargets[1].targetIdentity, 'mel');
+    assert.equal(allTargets[1].managedRoot, resolve(join(profilesRoot, 'mel')));
+});
+
+test('duplicate profile ids and unknown ids are rejected before mutation', () => {
+    assert.throws(
+        () => parseInstallTargetSelectionFromArgv(['--profiles', 'editor,editor']),
+        /duplicate profile id/,
+    );
+    const selection = parseInstallTargetSelectionFromArgv(['--profile', 'does-not-exist']);
+    assert.throws(
+        () => resolveInstallTargets(selection, {
+            homeDirectory: resolve(join(tmpdir(), 'a3-home-unknown')),
+            profilesRoot: resolve(join(tmpdir(), 'a3-pr')),
+            directoryNameByProfileId: DIRECTORY_NAME_BY_PROFILE_ID,
+        }),
+        /unknown profile id: does-not-exist/,
+    );
+});
+
+test('child hop with --target-identity rejects residual --profile flags', () => {
+    assert.throws(
+        () => parseInstallTargetSelectionFromArgv([
+            '--target', 'C:\\tmp\\child',
+            '--target-identity', 'editor',
+            '--profile', 'mel',
+        ]),
+        /child install hop rejects/,
+    );
+});
+
+test('profile directoryName rejects absolute paths and parent segments', () => {
+    assert.throws(
+        () => assertSafeProfileDirectoryName('C:\\evil'),
+        /must be relative/,
+    );
+    assert.throws(
+        () => assertSafeProfileDirectoryName('..\\escape'),
+        /parent segments/,
+    );
+    assert.equal(assertSafeProfileDirectoryName('editor'), 'editor');
+});
+
+test('buildTargetManifestRecord records package, version, identity, root, files, skills', () => {
+    const managedRoot = resolve(join(tmpdir(), 'a3-manifest-root'));
+    const manifest = buildTargetManifestRecord({
+        packageName: 'claude-dev-env',
+        packageVersion: '9.9.9-test',
+        targetIdentity: 'editor',
+        managedRoot,
+        files: [join(managedRoot, 'rules', 'x.md')],
+        skills: ['privacy-hygiene'],
+        installedAt: '2026-07-30T00:00:00.000Z',
+    });
+    assert.equal(manifest.package, 'claude-dev-env');
+    assert.equal(manifest.version, '9.9.9-test');
+    assert.equal(manifest.targetIdentity, 'editor');
+    assert.equal(manifest.managedRoot, managedRoot);
+    assert.deepEqual(manifest.files, [join(managedRoot, 'rules', 'x.md')]);
+    assert.deepEqual(manifest.skills, ['privacy-hygiene']);
+    assert.equal(manifest.installedAt, '2026-07-30T00:00:00.000Z');
+});
+
+test('stripTargetSelectionFlagsFromArgv leaves install groups flags', () => {
+    assert.deepEqual(
+        stripTargetSelectionFlagsFromArgv([
+            '--profiles', 'editor,mel',
+            '--only', 'core',
+            '--update',
+        ]),
+        ['--only', 'core', '--update'],
+    );
+});
+
+test('resolveProfilesRootDirectory prefers explicit then env then home default', () => {
+    const homeDirectory = resolve(join(tmpdir(), 'a3-home-pr'));
+    assert.equal(
+        resolveProfilesRootDirectory({ homeDirectory, environment: {} }),
+        resolve(join(homeDirectory, DEFAULT_PROFILES_ROOT_DIRECTORY_NAME)),
+    );
+    const fromEnv = resolve(join(tmpdir(), 'a3-env-profiles'));
+    assert.equal(
+        resolveProfilesRootDirectory({
+            homeDirectory,
+            environment: { LLM_SETTINGS_PROFILES_ROOT: fromEnv },
+        }),
+        fromEnv,
+    );
+});
+
+test('repeated and selected multi-profile dry runs write one ownership manifest per target', () => {
+    const runRoot = mkdtempSync(join(tmpdir(), 'a3-multi-run-'));
+    try {
+        const profilesRoot = join(runRoot, 'profiles');
+        const homeDirectory = join(runRoot, 'home');
+        mkdirSync(homeDirectory, { recursive: true });
+        const selection = parseInstallTargetSelectionFromArgv(['--profiles', 'editor,mel']);
+        const allTargets = resolveInstallTargets(selection, {
+            homeDirectory,
+            profilesRoot,
+            directoryNameByProfileId: DIRECTORY_NAME_BY_PROFILE_ID,
+        });
+        assert.equal(allTargets.length, 2);
+
+        for (const eachTarget of allTargets) {
+            mkdirSync(eachTarget.managedRoot, { recursive: true });
+            const sampleFile = join(eachTarget.managedRoot, 'CLAUDE.md');
+            writeFileSync(sampleFile, `# ${eachTarget.targetIdentity}\n`, 'utf8');
+            const manifest = buildTargetManifestRecord({
+                packageName: 'claude-dev-env',
+                packageVersion: '0.0.0-a3',
+                targetIdentity: eachTarget.targetIdentity,
+                managedRoot: eachTarget.managedRoot,
+                files: [sampleFile],
+                skills: ['privacy-hygiene'],
+            });
+            const manifestPath = join(eachTarget.managedRoot, MANIFEST_FILE_NAME);
+            writeFileSync(manifestPath, `${JSON.stringify(manifest, null, 2)}\n`, 'utf8');
+        }
+
+        // Second pass (repeat) overwrites each target's own manifest only.
+        for (const eachTarget of allTargets) {
+            const manifestPath = join(eachTarget.managedRoot, MANIFEST_FILE_NAME);
+            const prior = JSON.parse(readFileSync(manifestPath, 'utf8'));
+            assert.equal(prior.targetIdentity, eachTarget.targetIdentity);
+            const refreshed = buildTargetManifestRecord({
+                packageName: 'claude-dev-env',
+                packageVersion: '0.0.0-a3-repeat',
+                targetIdentity: eachTarget.targetIdentity,
+                managedRoot: eachTarget.managedRoot,
+                files: prior.files,
+                skills: prior.skills,
+            });
+            writeFileSync(manifestPath, `${JSON.stringify(refreshed, null, 2)}\n`, 'utf8');
+        }
+
+        const editorManifest = JSON.parse(
+            readFileSync(join(profilesRoot, 'editor', MANIFEST_FILE_NAME), 'utf8'),
+        );
+        const melManifest = JSON.parse(
+            readFileSync(join(profilesRoot, 'mel', MANIFEST_FILE_NAME), 'utf8'),
+        );
+        assert.equal(editorManifest.targetIdentity, 'editor');
+        assert.equal(melManifest.targetIdentity, 'mel');
+        assert.equal(editorManifest.version, '0.0.0-a3-repeat');
+        assert.equal(melManifest.version, '0.0.0-a3-repeat');
+        assert.ok(!existsSync(join(profilesRoot, 'ev', MANIFEST_FILE_NAME)));
+        assert.notEqual(editorManifest.managedRoot, melManifest.managedRoot);
+    } finally {
+        rmSync(runRoot, { recursive: true, force: true });
+    }
+});
+
+test('install.mjs --help documents profile target selection', () => {
+    const result = spawnSync(process.execPath, [INSTALL_MODULE_PATH, '--help'], {
+        encoding: 'utf8',
+        env: process.env,
+    });
+    assert.equal(result.status, 0, result.stderr);
+    assert.match(result.stdout, /--profile/);
+    assert.match(result.stdout, /--profiles/);
+    assert.match(result.stdout, /--target/);
+    assert.match(result.stdout, /targetIdentity|target identity|per target/i);
+});
+
+test('install.mjs wires select-install-targets for multi-profile entry', () => {
+    const source = readFileSync(INSTALL_MODULE_PATH, 'utf8');
+    assert.match(source, /select-install-targets\.mjs/);
+    assert.match(source, /parseInstallTargetSelectionFromArgv/);
+    assert.match(source, /resolveInstallTargets/);
+    assert.match(source, /buildTargetManifestRecord|targetIdentity/);
+});