claude-dev-env 2.14.1 → 2.15.1

package/scripts/profile-isolation-launchers/mcp-bundles.mjs

@@ -1,275 +0,0 @@
-/**
- * Profile MCP bundle validation and materialization.
- *
- * Bundles map to server inventories written through the supported activation
- * interface (profile CLAUDE_CONFIG_DIR mcp.json).
- */
-
-import { readFileSync, writeFileSync, mkdirSync, existsSync } from 'node:fs';
-import { dirname, join } from 'node:path';
-import { fileURLToPath } from 'node:url';
-import {
-  loadProfilesManifestDocument,
-  MCP_BUNDLE_FULL,
-  MCP_BUNDLE_LEAN,
-} from './config/profile-isolation-constants.mjs';
-import {
-  resolveProfileDefinition,
-  validateProfilesManifest,
-} from './lib/profile-manifest.mjs';
-
-const MODULE_DIRECTORY = dirname(fileURLToPath(import.meta.url));
-const MCP_BUNDLES_CONFIG_PATH = join(MODULE_DIRECTORY, 'config', 'mcp-bundles.json');
-const SUPPORTED_ACTIVATION_INTERFACE = 'claude-config-dir-mcp-json';
-const DEFAULT_MCP_CONFIG_FILE_NAME = 'mcp.json';
-
-/**
- * @typedef {{
- *   schemaVersion: number,
- *   supportedActivationInterface: string,
- *   mcpConfigFileName: string,
- *   bundles: Record<string, {id: string, allServerNames: string[]}>,
- *   serverByName: Record<string, {command: string, args: string[]}>,
- * }} McpBundlesDocument
- */
-
-/**
- * @returns {McpBundlesDocument}
- */
-export function loadMcpBundlesDocument() {
-  const raw = JSON.parse(readFileSync(MCP_BUNDLES_CONFIG_PATH, 'utf8'));
-  return validateMcpBundlesDocument(raw);
-}
-
-/**
- * @param {unknown} maybeDocument
- * @returns {McpBundlesDocument}
- */
-export function validateMcpBundlesDocument(maybeDocument) {
-  if (!maybeDocument || typeof maybeDocument !== 'object' || Array.isArray(maybeDocument)) {
-    throw new Error('mcp bundles document must be a JSON object');
-  }
-  const document = /** @type {Record<string, unknown>} */ (maybeDocument);
-  if (document.schemaVersion !== 1) {
-    throw new Error('mcp bundles schemaVersion must be 1');
-  }
-  if (document.supportedActivationInterface !== SUPPORTED_ACTIVATION_INTERFACE) {
-    throw new Error(
-      `supportedActivationInterface must be ${SUPPORTED_ACTIVATION_INTERFACE}`,
-    );
-  }
-  const mcpConfigFileName = document.mcpConfigFileName;
-  if (typeof mcpConfigFileName !== 'string' || mcpConfigFileName.length === 0) {
-    throw new Error('mcpConfigFileName must be a non-empty string');
-  }
-  if (
-    !document.bundles
-    || typeof document.bundles !== 'object'
-    || Array.isArray(document.bundles)
-  ) {
-    throw new Error('bundles must be an object');
-  }
-  if (
-    !document.serverByName
-    || typeof document.serverByName !== 'object'
-    || Array.isArray(document.serverByName)
-  ) {
-    throw new Error('serverByName must be an object');
-  }
-  /** @type {Record<string, {id: string, allServerNames: string[]}>} */
-  const bundles = {};
-  for (const [eachBundleId, eachBundleValue] of Object.entries(
-    /** @type {Record<string, unknown>} */ (document.bundles),
-  )) {
-    if (
-      !eachBundleValue
-      || typeof eachBundleValue !== 'object'
-      || Array.isArray(eachBundleValue)
-    ) {
-      throw new Error(`bundle ${eachBundleId} must be an object`);
-    }
-    const bundle = /** @type {Record<string, unknown>} */ (eachBundleValue);
-    if (bundle.id !== eachBundleId) {
-      throw new Error(`bundle id mismatch for ${eachBundleId}`);
-    }
-    if (!Array.isArray(bundle.allServerNames) || bundle.allServerNames.length === 0) {
-      throw new Error(`bundle ${eachBundleId} requires allServerNames`);
-    }
-    bundles[eachBundleId] = {
-      id: eachBundleId,
-      allServerNames: bundle.allServerNames.map(String),
-    };
-  }
-  if (!(MCP_BUNDLE_LEAN in bundles) || !(MCP_BUNDLE_FULL in bundles)) {
-    throw new Error('bundles must define lean and full');
-  }
-  const leanServerNames = new Set(bundles[MCP_BUNDLE_LEAN].allServerNames);
-  for (const eachLeanServerName of leanServerNames) {
-    if (!bundles[MCP_BUNDLE_FULL].allServerNames.includes(eachLeanServerName)) {
-      throw new Error(
-        `lean server ${eachLeanServerName} must also appear in full`,
-      );
-    }
-  }
-  /** @type {Record<string, {command: string, args: string[]}>} */
-  const serverByName = {};
-  for (const [eachServerName, eachServerValue] of Object.entries(
-    /** @type {Record<string, unknown>} */ (document.serverByName),
-  )) {
-    if (
-      !eachServerValue
-      || typeof eachServerValue !== 'object'
-      || Array.isArray(eachServerValue)
-    ) {
-      throw new Error(`server ${eachServerName} must be an object`);
-    }
-    const server = /** @type {Record<string, unknown>} */ (eachServerValue);
-    if (typeof server.command !== 'string' || server.command.length === 0) {
-      throw new Error(`server ${eachServerName} requires command`);
-    }
-    if (!Array.isArray(server.args)) {
-      throw new Error(`server ${eachServerName} requires args array`);
-    }
-    serverByName[eachServerName] = {
-      command: server.command,
-      args: server.args.map(String),
-    };
-  }
-  for (const eachBundle of Object.values(bundles)) {
-    for (const eachServerName of eachBundle.allServerNames) {
-      if (!(eachServerName in serverByName)) {
-        throw new Error(
-          `bundle ${eachBundle.id} references unknown server ${eachServerName}`,
-        );
-      }
-    }
-  }
-  return {
-    schemaVersion: 1,
-    supportedActivationInterface: SUPPORTED_ACTIVATION_INTERFACE,
-    mcpConfigFileName: String(mcpConfigFileName),
-    bundles,
-    serverByName,
-  };
-}
-
-/**
- * Resolve the mcp bundle id for a profile from the profiles manifest.
- *
- * @param {string} profileId
- * @returns {string}
- */
-export function resolveProfileMcpBundleId(profileId) {
-  const manifest = validateProfilesManifest(loadProfilesManifestDocument());
-  try {
-    return resolveProfileDefinition(manifest, profileId).mcpBundle;
-  } catch (errorValue) {
-    if (
-      errorValue instanceof Error
-      && errorValue.message.startsWith('Unknown profile id or alias:')
-    ) {
-      throw new Error(`unknown profile id for mcp bundle: ${profileId}`);
-    }
-    throw errorValue;
-  }
-}
-
-/**
- * Build the effective MCP server inventory for a bundle id.
- *
- * @param {string} bundleId
- * @param {McpBundlesDocument} [bundlesDocument]
- * @returns {string[]}
- */
-export function listServerNamesForBundle(bundleId, bundlesDocument = loadMcpBundlesDocument()) {
-  const bundle = bundlesDocument.bundles[bundleId];
-  if (!bundle) {
-    throw new Error(`unknown mcp bundle id: ${bundleId}`);
-  }
-  return [...bundle.allServerNames];
-}
-
-/**
- * Materialize mcp.json for a profile under CLAUDE_CONFIG_DIR.
- *
- * @param {{
- *   profileId: string,
- *   claudeConfigDir: string,
- *   profileRootPlaceholderValue?: string,
- *   bundlesDocument?: McpBundlesDocument,
- * }} parameters
- * @returns {{
- *   activationInterface: string,
- *   mcpConfigPath: string,
- *   bundleId: string,
- *   allServerNames: string[],
- * }}
- */
-export function materializeProfileMcpConfig(parameters) {
-  const bundlesDocument = parameters.bundlesDocument ?? loadMcpBundlesDocument();
-  if (!parameters.claudeConfigDir || typeof parameters.claudeConfigDir !== 'string') {
-    throw new Error('claudeConfigDir is required');
-  }
-  if (!existsSync(parameters.claudeConfigDir)) {
-    mkdirSync(parameters.claudeConfigDir, { recursive: true });
-  }
-  const bundleId = resolveProfileMcpBundleId(parameters.profileId);
-  const allServerNames = listServerNamesForBundle(bundleId, bundlesDocument);
-  const profileRootValue = parameters.profileRootPlaceholderValue ?? parameters.claudeConfigDir;
-  /** @type {Record<string, {command: string, args: string[]}>} */
-  const mcpServers = {};
-  for (const eachServerName of allServerNames) {
-    const definition = bundlesDocument.serverByName[eachServerName];
-    mcpServers[eachServerName] = {
-      command: definition.command,
-      args: definition.args.map((eachArg) => eachArg.replaceAll('${PROFILE_ROOT}', profileRootValue)),
-    };
-  }
-  const mcpConfigPath = join(parameters.claudeConfigDir, bundlesDocument.mcpConfigFileName);
-  writeFileSync(
-    mcpConfigPath,
-    `${JSON.stringify({ mcpServers }, null, 2)}\n`,
-    'utf8',
-  );
-  return {
-    activationInterface: bundlesDocument.supportedActivationInterface,
-    mcpConfigPath,
-    bundleId,
-    allServerNames,
-  };
-}
-
-/**
- * Read back the effective server inventory from a materialized mcp.json.
- *
- * @param {string} mcpConfigPath
- * @returns {string[]}
- */
-export function readEffectiveMcpServerInventory(mcpConfigPath) {
-  if (!existsSync(mcpConfigPath)) {
-    throw new Error(`mcp config missing: ${mcpConfigPath}`);
-  }
-  let document;
-  try {
-    document = JSON.parse(readFileSync(mcpConfigPath, 'utf8'));
-  } catch {
-    throw new Error(`mcp config malformed: ${mcpConfigPath}`);
-  }
-  if (
-    !document
-    || typeof document !== 'object'
-    || Array.isArray(document)
-    || !document.mcpServers
-    || typeof document.mcpServers !== 'object'
-    || Array.isArray(document.mcpServers)
-  ) {
-    throw new Error(`mcp config malformed: ${mcpConfigPath}`);
-  }
-  return Object.keys(document.mcpServers).sort();
-}
-
-export {
-  SUPPORTED_ACTIVATION_INTERFACE,
-  DEFAULT_MCP_CONFIG_FILE_NAME,
-  MCP_BUNDLES_CONFIG_PATH,
-};

package/scripts/profile-isolation-launchers/profile-isolation-contract.test.mjs

@@ -1,221 +0,0 @@
-import { test } from 'node:test';
-import { strict as assert } from 'node:assert';
-import { execFileSync } from 'node:child_process';
-import { existsSync, readdirSync, readFileSync, statSync } from 'node:fs';
-import { dirname, join, relative, sep } from 'node:path';
-import { fileURLToPath } from 'node:url';
-
-import {
-  CLAUDE_CONFIG_DIR_ENVIRONMENT_VARIABLE,
-  CLAUDE_HOME_ENVIRONMENT_VARIABLE,
-  INSTALL_DESTINATION_ROOT_RELATIVE_PATH,
-  LAUNCHER_SCHEMA_VERSION,
-  LIVE_DEPLOYMENT_RESERVED_FOR,
-  loadProfilesManifestDocument,
-  loadSharedAllowlistDocument,
-  PACKAGE_FILES_WHITELIST_SCRIPTS_ENTRY,
-  PROFILE_ISOLATION_CONTRACT_OWNER,
-} from './config/profile-isolation-constants.mjs';
-import {
-  loadAndValidateProfilesManifest,
-  loadAndValidateSharedAllowlist,
-  resolveProfileDefinition,
-  resolveProfileRootDirectoryPath,
-  validateProfilesManifest,
-  validateSharedAllowlist,
-} from './lib/profile-manifest.mjs';
-
-const CONTRACT_ROOT_DIRECTORY_PATH = dirname(fileURLToPath(import.meta.url));
-const PACKAGE_ROOT_DIRECTORY_PATH = join(CONTRACT_ROOT_DIRECTORY_PATH, '..', '..');
-const REPOSITORY_ROOT_DIRECTORY_PATH = join(PACKAGE_ROOT_DIRECTORY_PATH, '..', '..');
-
-const ALL_REQUIRED_CONTRACT_SOURCE_RELATIVE_PATHS = Object.freeze([
-  'config/profile-isolation-constants.mjs',
-  'config/profiles.manifest.json',
-  'config/shared-allowlist.json',
-  'lib/profile-manifest.mjs',
-]);
-
-/** J1 MCP activation and K1 version-preflight sources allowed beside the A1a contract surface. */
-const ALL_ALLOWED_MCP_ACTIVATION_RELATIVE_PATHS = Object.freeze([
-  'config/mcp-bundles.json',
-  'mcp-bundles.mjs',
-  'launcher-runtime.mjs',
-  'version-compatibility.mjs',
-  'tests/mcp-bundles.test.mjs',
-  'tests/launcher-runtime.test.mjs',
-  'tests/version-compatibility.test.mjs',
-]);
-
-const ALL_N1_SHORTCUT_SOURCE_RELATIVE_PATHS = Object.freeze([
-  'tests/shortcut-contract.test.ps1',
-  'windows/shortcut-inventory.ps1',
-  'windows/shortcut-manifest.json',
-  'windows/shortcut-reconcile.ps1',
-]);
-
-test('profiles manifest schemaVersion is 1 and every migrationOrder id resolves', () => {
-  const validatedManifest = loadAndValidateProfilesManifest();
-  assert.equal(validatedManifest.schemaVersion, 1);
-  assert.equal(LAUNCHER_SCHEMA_VERSION, 1);
-  for (const eachProfileId of validatedManifest.migrationOrder) {
-    assert.equal(resolveProfileDefinition(validatedManifest, eachProfileId).id, eachProfileId);
-  }
-});
-
-test('resolveProfileDefinition accepts id, alias, and launcher names', () => {
-  const validatedManifest = loadAndValidateProfilesManifest();
-  assert.equal(resolveProfileDefinition(validatedManifest, 'master').id, 'master');
-  assert.equal(resolveProfileDefinition(validatedManifest, 'default').id, 'master');
-  assert.equal(resolveProfileDefinition(validatedManifest, 'claude').id, 'master');
-  assert.equal(resolveProfileDefinition(validatedManifest, 'claude-full').id, 'master');
-  assert.equal(resolveProfileDefinition(validatedManifest, 'profile-c').id, 'profile-c');
-  assert.equal(resolveProfileDefinition(validatedManifest, 'claude-profile-c').id, 'profile-c');
-  assert.equal(resolveProfileDefinition(validatedManifest, 'claude-profile-b-full').id, 'profile-b');
-  assert.equal(resolveProfileDefinition(validatedManifest, 'Master').id, 'master');
-  assert.equal(resolveProfileDefinition(validatedManifest, ' CLAUDE-PROFILE-C ').id, 'profile-c');
-  assert.throws(
-    () => resolveProfileDefinition(validatedManifest, 'not-a-profile'),
-    /Unknown profile id or alias/,
-  );
-  assert.throws(
-    () => resolveProfileDefinition(validatedManifest, /** @type {string} */ (/** @type {unknown} */ (42))),
-    /Unknown profile id or alias/,
-  );
-});
-
-test('shared allowlist names shared paths, always-local paths, and desktop exclusions', () => {
-  const validatedAllowlist = loadAndValidateSharedAllowlist();
-  assert.equal(validatedAllowlist.schemaVersion, 1);
-  assert.ok(validatedAllowlist.allSharedRelativePaths.includes('scripts'));
-  assert.ok(validatedAllowlist.allSharedRelativePaths.includes('hooks'));
-  assert.ok(validatedAllowlist.allAlwaysLocalRelativePaths.includes('settings.json'));
-  assert.ok(validatedAllowlist.allAlwaysLocalRelativePaths.includes('credentials'));
-  assert.ok(
-    validatedAllowlist.allDesktopExcludedPathFragments.some((eachFragment) =>
-      eachFragment.toLowerCase().includes('desktop'),
-    ),
-  );
-});
-
-test('validators reject bad schemaVersion and non-object allowlist', () => {
-  const rawManifest = loadProfilesManifestDocument();
-  assert.throws(
-    () => validateProfilesManifest({ ...rawManifest, schemaVersion: 0 }),
-    /schemaVersion must be 1/,
-  );
-  assert.throws(() => validateSharedAllowlist(null), /shared allowlist must be a JSON object/);
-  assert.equal(typeof loadSharedAllowlistDocument(), 'object');
-});
-
-test('validators reject duplicate launcher identities across profiles', () => {
-  const rawManifest = loadProfilesManifestDocument();
-  const profiles = {
-    .../** @type {Record<string, object>} */ (rawManifest.profiles),
-  };
-  const masterProfile = { ...profiles.master, launcherNames: ['claude', 'claude-profile-c'] };
-  const profileC = { ...profiles['profile-c'] };
-  assert.throws(
-    () =>
-      validateProfilesManifest({
-        ...rawManifest,
-        profiles: { ...profiles, master: masterProfile, 'profile-c': profileC },
-      }),
-    /duplicate profile identity/,
-  );
-});
-
-test('CLAUDE_CONFIG_DIR is the sole authoritative profile-root variable name', () => {
-  assert.equal(CLAUDE_CONFIG_DIR_ENVIRONMENT_VARIABLE, 'CLAUDE_CONFIG_DIR');
-  assert.equal(CLAUDE_HOME_ENVIRONMENT_VARIABLE, 'CLAUDE_HOME');
-  assert.notEqual(CLAUDE_CONFIG_DIR_ENVIRONMENT_VARIABLE, CLAUDE_HOME_ENVIRONMENT_VARIABLE);
-  const constantsSource = readFileSync(
-    join(CONTRACT_ROOT_DIRECTORY_PATH, 'config', 'profile-isolation-constants.mjs'),
-    'utf8',
-  );
-  assert.match(constantsSource, /Sole authoritative profile-root environment variable/);
-  assert.match(constantsSource, /CLAUDE_HOME is never honored as a profile root/);
-});
-
-test('resolveProfileRootDirectoryPath joins profiles root with directoryName', () => {
-  const validatedManifest = loadAndValidateProfilesManifest();
-  const profileC = resolveProfileDefinition(validatedManifest, 'profile-c');
-  assert.equal(
-    resolveProfileRootDirectoryPath('/profiles', profileC),
-    join('/profiles', 'profile-c'),
-  );
-});
-
-test('package ships contract under scripts/, reserves live deploy for L1, and holds only A1a+N1 files', () => {
-  const packageJson = JSON.parse(
-    readFileSync(join(PACKAGE_ROOT_DIRECTORY_PATH, 'package.json'), 'utf8'),
-  );
-  assert.ok(packageJson.files.includes(PACKAGE_FILES_WHITELIST_SCRIPTS_ENTRY));
-  assert.equal(INSTALL_DESTINATION_ROOT_RELATIVE_PATH, 'scripts/profile-isolation-launchers');
-  assert.equal(LIVE_DEPLOYMENT_RESERVED_FOR, 'L1');
-  assert.equal(PROFILE_ISOLATION_CONTRACT_OWNER, 'profile-isolation-contract');
-
-  /** @type {string[]} */
-  const allRelativePaths = [];
-  /**
-   * @param {string} currentDirectoryPath
-   */
-  function walk(currentDirectoryPath) {
-    for (const eachEntry of readdirSync(currentDirectoryPath, { withFileTypes: true })) {
-      const eachAbsolutePath = join(currentDirectoryPath, eachEntry.name);
-      if (eachEntry.isDirectory()) {
-        walk(eachAbsolutePath);
-        continue;
-      }
-      if (eachEntry.isFile()) {
-        allRelativePaths.push(
-          relative(CONTRACT_ROOT_DIRECTORY_PATH, eachAbsolutePath).split(sep).join('/'),
-        );
-      }
-    }
-  }
-  walk(CONTRACT_ROOT_DIRECTORY_PATH);
-  const allExpectedPaths = new Set([
-    ...ALL_REQUIRED_CONTRACT_SOURCE_RELATIVE_PATHS,
-    ...ALL_ALLOWED_MCP_ACTIVATION_RELATIVE_PATHS,
-    ...ALL_N1_SHORTCUT_SOURCE_RELATIVE_PATHS,
-    'profile-isolation-contract.test.mjs',
-  ]);
-  for (const eachRelativePath of allRelativePaths) {
-    assert.ok(allExpectedPaths.has(eachRelativePath), `unexpected package file: ${eachRelativePath}`);
-  }
-  for (const eachRequiredPath of [
-    ...ALL_REQUIRED_CONTRACT_SOURCE_RELATIVE_PATHS,
-    ...ALL_ALLOWED_MCP_ACTIVATION_RELATIVE_PATHS,
-    ...ALL_N1_SHORTCUT_SOURCE_RELATIVE_PATHS,
-  ]) {
-    const absolutePath = join(CONTRACT_ROOT_DIRECTORY_PATH, ...eachRequiredPath.split('/'));
-    assert.ok(existsSync(absolutePath) && statSync(absolutePath).isFile());
-  }
-});
-
-test('committed contract sources are tracked by git (not dirty-worktree-only)', () => {
-  for (const eachRelativePath of [
-    ...ALL_REQUIRED_CONTRACT_SOURCE_RELATIVE_PATHS,
-    ...ALL_N1_SHORTCUT_SOURCE_RELATIVE_PATHS,
-  ]) {
-    const repositoryRelativePath =
-      `packages/claude-dev-env/scripts/profile-isolation-launchers/${eachRelativePath}`;
-    const lsFilesOutput = execFileSync(
-      'git',
-      ['ls-files', '--', repositoryRelativePath],
-      { cwd: REPOSITORY_ROOT_DIRECTORY_PATH, encoding: 'utf8' },
-    ).trim();
-    assert.ok(lsFilesOutput.length > 0, `expected git-tracked source for ${eachRelativePath}`);
-    const porcelain = execFileSync(
-      'git',
-      ['status', '--porcelain', '--', repositoryRelativePath],
-      { cwd: REPOSITORY_ROOT_DIRECTORY_PATH, encoding: 'utf8' },
-    ).trim();
-    assert.equal(
-      porcelain,
-      '',
-      `launcher file must be clean committed source: ${eachRelativePath} status=${porcelain}`,
-    );
-  }
-});

package/scripts/profile-isolation-launchers/tests/launcher-runtime.test.mjs

@@ -1,108 +0,0 @@
-import { test } from 'node:test';
-import { strict as assert } from 'node:assert';
-import { mkdtempSync, rmSync, existsSync } from 'node:fs';
-import { join } from 'node:path';
-import { tmpdir } from 'node:os';
-import { fileURLToPath } from 'node:url';
-import { dirname } from 'node:path';
-import {
-  activateLauncherMcpBundle,
-  activateProfileMcpBundle,
-  describeLeanServerBoundary,
-  formatProfileMcpActivationFailure,
-  listMcpActivationPackageRelativePaths,
-  resolveProfileIdForLauncherName,
-  SUPPORTED_ACTIVATION_INTERFACE,
-} from '../launcher-runtime.mjs';
-import { readEffectiveMcpServerInventory } from '../mcp-bundles.mjs';
-import { CLAUDE_CONFIG_DIR_ENVIRONMENT_VARIABLE } from '../config/profile-isolation-constants.mjs';
-
-const PACKAGE_ROOT = join(
-  dirname(fileURLToPath(import.meta.url)),
-  '..',
-  '..',
-  '..',
-);
-
-test('claude-profile-a and claude-profile-b resolve to profile-a and profile-b profiles', () => {
-  assert.equal(resolveProfileIdForLauncherName('claude-profile-a'), 'profile-a');
-  assert.equal(resolveProfileIdForLauncherName('claude-profile-b'), 'profile-b');
-});
-
-test('activateLauncherMcpBundle materializes lean inventory for profile-a and profile-b', () => {
-  const profileADir = mkdtempSync(join(tmpdir(), 'launcher-profile-a-'));
-  const profileBDir = mkdtempSync(join(tmpdir(), 'launcher-profile-b-'));
-  try {
-    const profileA = activateLauncherMcpBundle({
-      launcherName: 'claude-profile-a',
-      claudeConfigDir: profileADir,
-    });
-    const profileB = activateLauncherMcpBundle({
-      launcherName: 'claude-profile-b',
-      claudeConfigDir: profileBDir,
-    });
-    assert.equal(profileA.activationInterface, SUPPORTED_ACTIVATION_INTERFACE);
-    assert.equal(profileB.activationInterface, SUPPORTED_ACTIVATION_INTERFACE);
-    assert.equal(profileA.bundleId, 'lean');
-    assert.equal(profileB.bundleId, 'lean');
-    assert.equal(
-      profileA.environment[CLAUDE_CONFIG_DIR_ENVIRONMENT_VARIABLE],
-      profileADir,
-    );
-    assert.deepEqual(
-      readEffectiveMcpServerInventory(profileA.mcpConfigPath),
-      profileA.expectedInventory,
-    );
-    assert.deepEqual(
-      readEffectiveMcpServerInventory(profileB.mcpConfigPath),
-      profileB.expectedInventory,
-    );
-  } finally {
-    rmSync(profileADir, { recursive: true, force: true });
-    rmSync(profileBDir, { recursive: true, force: true });
-  }
-});
-
-test('lean aliases expose only lean servers', () => {
-  const boundary = describeLeanServerBoundary();
-  assert.ok(boundary.leanServers.length >= 1);
-  assert.ok(boundary.fullServers.length >= boundary.leanServers.length);
-  for (const eachLeanServer of boundary.leanServers) {
-    assert.ok(boundary.fullServers.includes(eachLeanServer));
-  }
-  assert.ok(boundary.fullOnlyServers.every((eachName) => !boundary.leanServers.includes(eachName)));
-
-  const claudeConfigDir = mkdtempSync(join(tmpdir(), 'launcher-lean-'));
-  try {
-    const activation = activateProfileMcpBundle({
-      profileId: 'profile-a',
-      claudeConfigDir,
-    });
-    assert.deepEqual(activation.expectedInventory, boundary.leanServers);
-    for (const eachFullOnly of boundary.fullOnlyServers) {
-      assert.ok(!activation.expectedInventory.includes(eachFullOnly));
-    }
-  } finally {
-    rmSync(claudeConfigDir, { recursive: true, force: true });
-  }
-});
-
-test('unknown launcher name fails with an actionable message', () => {
-  assert.throws(
-    () => resolveProfileIdForLauncherName('claude-does-not-exist'),
-    /no profile owns launcher name/,
-  );
-  const message = formatProfileMcpActivationFailure(
-    'profile-a',
-    new Error('bundle missing'),
-  );
-  assert.match(message, /profile profile-a mcp activation failed/);
-  assert.match(message, /bundle missing/);
-});
-
-test('package-relative MCP activation paths exist for pack verification', () => {
-  const allPaths = listMcpActivationPackageRelativePaths(PACKAGE_ROOT);
-  for (const eachPath of allPaths) {
-    assert.ok(existsSync(eachPath), `missing pack path: ${eachPath}`);
-  }
-});